Is there a built-in way to get all of the changed/updated fields in a Doctrine 2 entity

You can use DoctrineORMEntityManager#getUnitOfWork to get a DoctrineORMUnitOfWork.

Then just trigger changeset computation (works only on managed entities) via DoctrineORMUnitOfWork#computeChangeSets().

You can use also similar methods like DoctrineORMUnitOfWork#recomputeSingleEntityChangeSet(DoctrineORMClassMetadata $meta, $entity) if you know exactly what you want to check without iterating over the entire object graph.

After that you can use DoctrineORMUnitOfWork#getEntityChangeSet($entity) to retrieve all changes to your object.

Putting it together:

$entity = $em->find('MyEntity', 1);
$entity->setTitle('Changed Title!');
$uow = $em->getUnitOfWork();
$uow->computeChangeSets(); // do not compute changes if inside a listener
$changeset = $uow->getEntityChangeSet($entity);

Note. If trying to get the updated fields inside a preUpdate listener, don't recompute change set, as it has already been done. Simply call the getEntityChangeSet to get all of the changes made to the entity.

Warning: As explained in the comments, this solution should not be used outside of Doctrine event listeners. This will break Doctrine's behavior.

Well there it is: it's not possible.

In the last year I've been working on an alternative ACL system that would allow to filter directly in database queries.

My company recently agreed to open source it, so here it is: http://myclabs.github.io/ACL/

So, all my searching didn't yield a short solution. The answer to the question seems to be: no, there is no buit-in way to get the current date (or datetime) as a variable in the template.

In case others are searching for this topic, I'll try to give a summary of the possible workarounds that I can up with and that were suggested by other users.

1. I could pass a context variable to the template from my view. In class-based views that could look like this (it is even an example in the docs):

   # file 'my_app/views.py'
   from django.utils import timezone as tz
   from django.views.generic import ListView
   
   class MyView(ListView)
       ...
   
       def get_context_data(self, **kwargs):
           ctx = super().get_context_data(**kwargs)
   
           now = tz.now()
           ctx['now'] = now
           ctx['today'] = tz.localtime(now).date()
   
           return ctx
   

2. I could create a custom context processor that loads that variable to every template. In class-based views that could look like this:

   # file 'context_processors.py'
   from django.utils import timezone as tz
   
   def now_and_today(request):
       now = tz.now()
       return {
           'now': now,
           'today': tz.localtime(now).date(),
       }
   
   # file 'settings.py'
   ...
   TEMPLATES = [
       {
           ...
           'OPTIONS': {
               'context_processors': [
                   ...
                   'context_processors.today_and_now',
               ],
           },
       },
   ]
   ...
   

3. I could create a custom template tag, like this:

   # file 'my_app/custom_template_tags/custom_time_tags.py'
   from django.utils import timezone as tz
   from django import template
   register = template.Library()
   
   @register.simple_tag
   def get_now(request):
       return tz.now()
   
   @register.simple_tag
   def get_today(request):
       return tz.localtime(tz.now()).date()
   

   To be used like this:

   {% load 'custom_time_tags' %}
   
   {% get_today as today %}
   {% for per in person_list %}
       {% if per.brith_date > today %}
           <p>{{ per.name }} is from the future!!<p>
       {% endif %}
   {% endfor %}
   

4. I could also add a property (or even a cached_property) to the model:

   # file 'models.py'
   from django.db import models
   from django.utils import timezone as tz
   from django.utils.functional import cached_property
   
   class Person(models.Model):
       ...
   
       @cached_property
       def is_from_future(self):
           # careful: for long-lived instances do not use 'cached_property' as
           # the time of 'now' might not be right later
           if self.birth_date > tz.localtime(tz.now()).date():
               return True
   
           return False
   

5. And last but not least, I could just do the processing in the view and add a property to the elements:

   # file 'my_app/views.py'
   from django.utils import timezone as tz
   
   def person_list(request):
       today = tz.localtime(tz.now()).date()
   
       person_list = []
       for p in Person.objects.all():
           p.is_from_future = self.birth_date > today
           person_list.append(p)
   
       return render(request, 'some_template.html', {'person_list': person_list})