Added normalise_function to provide control on how values are stored in dirty fields dict

Author: harel

docs/index.rst

@@ -191,6 +191,30 @@ You can now define how you want to compare 2 values by passing a function on Dir
 
 Have a look at ``dirtyfields.compare`` module to get some examples.
 
+Custom value normalisation function
+----------------------------
+By default, ``dirtyfields`` reports on the dirty fields as is. If a date field was changed
+the result of ``get_dirty_fields`` will return the current and saved datetime object.
+In some cases it is useful to normalise those values, e.g., when wanting ot save the diff data as a json dataset in a database.
+The default behaviour of using values as is can be changed by providing a ``normalise_function``
+in your model. That function can evaluate the value's type and rewrite it accordingly.
+
+::
+
+    import datetime
+    from django.db import models
+    from dirtyfields import DirtyFieldsMixin
+
+    def your_normalise_function(value):
+        if isinstance(value, (datetime.datetime, datetime.date)):
+            return value.isoformat()
+        else:
+            return value
+
+    class TestModel(DirtyFieldsMixin, models.Model):
+        normalise_function = (your_normalise_function, {'extra_kwargs': 1})
+
+
 Why would you want this?
 ========================
 

src/dirtyfields/compare.py

@@ -5,7 +5,7 @@
 from django.utils import timezone
 
 
-def compare_states(new_state, original_state, compare_function):
+def compare_states(new_state, original_state, compare_function, normalise_function):
     modified_field = {}
 
     for key, value in new_state.items():
@@ -21,7 +21,10 @@ def compare_states(new_state, original_state, compare_function):
         if is_identical:
             continue
 
-        modified_field[key] = {'saved': original_value, 'current': value}
+        modified_field[key] = {
+            'saved': normalise_function[0](original_value, **normalise_function[1]),
+            'current': normalise_function[0](value, **normalise_function[1])
+        }
 
     return modified_field
 
@@ -56,3 +59,13 @@ def timezone_support_compare(new_value, old_value, timezone_to_set=pytz.UTC):
         old_value = timezone.make_aware(old_value, pytz.utc).astimezone(timezone_to_set)
 
     return raw_compare(new_value, old_value)
+
+
+def normalise_value(value):
+    """
+    Default normalisation of value simply returns the value as is.
+    Custom implementations can normalise the value for various storage schemes.
+    For example, converting datetime objects to iso datetime strings in order to
+    comply with JSON standard.
+    """
+    return value

src/dirtyfields/dirtyfields.py

@@ -6,12 +6,13 @@
 from django.db.models.expressions import Combinable
 from django.db.models.signals import post_save, m2m_changed
 
-from .compare import raw_compare, compare_states
+from .compare import raw_compare, compare_states, normalise_value
 from .compat import is_buffer, get_m2m_with_model, remote_field
 
 
 class DirtyFieldsMixin(object):
     compare_function = (raw_compare, {})
+    normalise_function = (normalise_value, {})
 
     # This mode has been introduced to handle some situations like this one:
     # https://github.com/romgar/django-dirtyfields/issues/73
@@ -101,7 +102,7 @@ def get_dirty_fields(self, check_relationship=False, check_m2m=None, verbose=Fal
             pk_specified = self.pk is not None
             initial_dict = self._as_dict(check_relationship, include_primary_key=pk_specified)
             if verbose:
-                initial_dict = {key: {'saved': None, 'current': value}
+                initial_dict = {key: {'saved': None, 'current': self.normalise_function[0](value)}
                                 for key, value in initial_dict.items()}
             return initial_dict
 
@@ -110,17 +111,19 @@ def get_dirty_fields(self, check_relationship=False, check_m2m=None, verbose=Fal
 
         modified_fields = compare_states(self._as_dict(check_relationship),
                                          self._original_state,
-                                         self.compare_function)
+                                         self.compare_function,
+                                         self.normalise_function)
 
         if check_m2m:
             modified_m2m_fields = compare_states(check_m2m,
                                                  self._original_m2m_state,
-                                                 self.compare_function)
+                                                 self.compare_function,
+                                                 self.normalise_function)
             modified_fields.update(modified_m2m_fields)
 
         if not verbose:
             # Keeps backward compatibility with previous function return
-            modified_fields = {key: value['saved'] for key, value in modified_fields.items()}
+            modified_fields = {key: self.normalise_function[0](value['saved']) for key, value in modified_fields.items()}
 
         return modified_fields