Imported Marty Alchin's initial implementation from the Pro Django book.

Author: q

LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright (c) 2008, Marty Alchin
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of the author nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

simple_history/__init__.py

@@ -0,0 +1,58 @@
+from django.db import models
+
+class HistoryDescriptor(object):
+    def __init__(self, model):
+        self.model = model
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return HistoryManager(self.model)
+        return HistoryManager(self.model, instance)
+
+class HistoryManager(models.Manager):
+    def __init__(self, model, instance=None):
+        super(HistoryManager, self).__init__()
+        self.model = model
+        self.instance = instance
+
+    def get_query_set(self):
+        if self.instance is None:
+            return super(HistoryManager, self).get_query_set()
+
+        filter = {self.instance._meta.pk.name: self.instance.pk}
+        return super(HistoryManager, self).get_query_set().filter(**filter)
+
+    def most_recent(self):
+        """
+        Returns the most recent copy of the instance available in the history.
+        """
+        if not self.instance:
+            raise TypeError("Can't use most_recent() without a %s instance." % \
+                            self.instance._meta.object_name)
+        fields = (field.name for field in self.instance._meta.fields)
+        try:
+            values = self.values_list(*fields)[0]
+        except IndexError:
+            raise self.instance.DoesNotExist("%s has no historical record." % \
+                                             self.instance._meta.object_name)
+        return self.instance.__class__(*values)
+
+    def as_of(self, date):
+        """
+        Returns an instance of the original model with all the attributes set
+        according to what was present on the object on the date provided.
+        """
+        if not self.instance:
+            raise TypeError("Can't use as_of() without a %s instance." % \
+                            self.instance._meta.object_name)
+        fields = (field.name for field in self.instance._meta.fields)
+        qs = self.filter(history_date__lte=date)
+        try:
+            values = qs.values_list('history_type', *fields)[0]
+        except IndexError:
+            raise self.instance.DoesNotExist("%s had not yet been created." % \
+                                             self.instance._meta.object_name)
+        if values[0] == '-':
+            raise self.instance.DoesNotExist("%s had already been deleted." % \
+                                             self.instance._meta.object_name)
+        return self.instance.__class__(*values[1:])

simple_history/manager.py

@@ -0,0 +1,112 @@
+import copy
+import datetime
+
+from django.db import models
+
+from chapter11.current_user import models as current_user
+from chapter11.history import manager
+
+class HistoricalRecords(object):
+    def contribute_to_class(self, cls, name):
+        self.manager_name = name
+        models.signals.class_prepared.connect(self.finalize, sender=cls)
+
+    def finalize(self, sender, **kwargs):
+        history_model = self.create_history_model(sender)
+
+        # The HistoricalRecords object will be discarded,
+        # so the signal handlers can't use weak references.
+        models.signals.post_save.connect(self.post_save, sender=sender,
+                                         weak=False)
+        models.signals.post_delete.connect(self.post_delete, sender=sender,
+                                           weak=False)
+
+        descriptor = manager.HistoryDescriptor(history_model)
+        setattr(sender, self.manager_name, descriptor)
+
+    def create_history_model(self, model):
+        """
+        Creates a historical model to associate with the model provided.
+        """
+        attrs = self.copy_fields(model)
+        attrs.update(self.get_extra_fields(model))
+        attrs.update(Meta=type('Meta', (), self.get_meta_options(model)))
+        name = 'Historical%s' % model._meta.object_name
+        return type(name, (models.Model,), attrs)
+
+    def copy_fields(self, model):
+        """
+        Creates copies of the model's original fields, returning
+        a dictionary mapping field name to copied field object.
+        """
+        # Though not strictly a field, this attribute
+        # is required for a model to function properly.
+        fields = {'__module__': model.__module__}
+
+        for field in model._meta.fields:
+            field = copy.copy(field)
+
+            if isinstance(field, models.AutoField):
+                # The historical model gets its own AutoField, so any
+                # existing one must be replaced with an IntegerField.
+                field.__class__ = models.IntegerField
+
+            if field.primary_key or field.unique:
+                # Unique fields can no longer be guaranteed unique,
+                # but they should still be indexed for faster lookups.
+                field.primary_key = False
+                field._unique = False
+                field.db_index = True
+            fields[field.name] = field
+
+        return fields
+
+    def get_extra_fields(self, model):
+        """
+        Returns a dictionary of fields that will be added to the historical
+        record model, in addition to the ones returned by copy_fields below.
+        """
+        rel_nm = '_%s_history' % model._meta.object_name.lower()
+        return {
+            'history_id': models.AutoField(primary_key=True),
+            'history_date': models.DateTimeField(default=datetime.datetime.now),
+            'history_user': current_user.CurrentUserField(related_name=rel_nm),
+            'history_type': models.CharField(max_length=1, choices=(
+                ('+', 'Created'),
+                ('~', 'Changed'),
+                ('-', 'Deleted'),
+            )),
+            'history_object': HistoricalObjectDescriptor(model),
+            '__unicode__': lambda self: u'%s as of %s' % (self.history_object,
+                                                          self.history_date)
+        }
+
+    def get_meta_options(self, model):
+        """
+        Returns a dictionary of fields that will be added to
+        the Meta inner class of the historical record model.
+        """
+        return {
+            'ordering': ('-history_date',),
+        }
+
+    def post_save(self, instance, created, **kwargs):
+        self.create_historical_record(instance, created and '+' or '~')
+
+    def post_delete(self, instance, **kwargs):
+        self.create_historical_record(instance, '-')
+
+    def create_historical_record(self, instance, type):
+        manager = getattr(instance, self.manager_name)
+        attrs = {}
+        for field in instance._meta.fields:
+            attrs[field.attname] = getattr(instance, field.attname)
+        manager.create(history_type=type, **attrs)
+
+class HistoricalObjectDescriptor(object):
+    def __init__(self, model):
+        self.model = model
+
+    def __get__(self, instance, owner):
+        values = (getattr(instance, f.attname) for f in self.model._meta.fields)
+        return self.model(*values)