Update migration files for Django 5.1.4; remove obsolete merge migrations and adjust history tracking context in templates

history_tracking/models.py

@@ -1,18 +1,14 @@
-# history_tracking/models.py
 from django.db import models
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes.fields import GenericForeignKey
-from django.contrib.auth import get_user_model
-from simple_history.models import HistoricalRecords
-from .mixins import HistoricalChangeMixin
-from typing import Any, Type, TypeVar, cast
+from django.conf import settings
+from typing import Any, Dict, Optional
 from django.db.models import QuerySet
 
-T = TypeVar('T', bound=models.Model)
-
 class DiffMixin:
-    """Mixin to add diffing capabilities to pghistory events"""
-    def get_prev_record(self):
+    """Mixin to add diffing capabilities to models"""
+    
+    def get_prev_record(self) -> Optional[Any]:
         """Get the previous record for this instance"""
         try:
             return type(self).objects.filter(
@@ -22,73 +18,53 @@ class DiffMixin:
         except (AttributeError, TypeError):
             return None
 
-    def diff_against_previous(self):
+    def diff_against_previous(self) -> Dict:
         """Compare this record against the previous one"""
         prev_record = self.get_prev_record()
         if not prev_record:
             return {}
 
-        changes = {}
         skip_fields = {
             'pgh_id', 'pgh_created_at', 'pgh_label', 
-            'pgh_obj_id', 'pgh_context_id', '_state'
+            'pgh_obj_id', 'pgh_context_id', '_state',
+            'created_at', 'updated_at'
         }
 
-        for field in self.__dict__:
-            if field not in skip_fields and not field.startswith('_'):
-                try:
-                    old_value = getattr(prev_record, field)
-                    new_value = getattr(self, field)
-                    if old_value != new_value:
-                        changes[field] = {"old": str(old_value), "new": str(new_value)}
-                except AttributeError:
-                    continue
+        changes = {}
+        for field, value in self.__dict__.items():
+            # Skip internal fields and those we don't want to track
+            if field.startswith('_') or field in skip_fields or field.endswith('_id'):
+                continue
+
+            try:
+                old_value = getattr(prev_record, field)
+                new_value = value
+                if old_value != new_value:
+                    changes[field] = {
+                        "old": str(old_value) if old_value is not None else "None",
+                        "new": str(new_value) if new_value is not None else "None"
+                    }
+            except AttributeError:
+                continue
+
         return changes
 
-class HistoricalModel(models.Model):
-    """
-    Legacy abstract base class for models with history tracking.
-    Use TrackedModel for new implementations.
-    """
-    id = models.BigAutoField(primary_key=True)
-    history: HistoricalRecords = HistoricalRecords(
-        inherit=True,
-        bases=(HistoricalChangeMixin,)
-    )
-
-    class Meta:
-        abstract = True
-
-    @property
-    def _history_model(self) -> Type[T]:
-        """Get the history model class"""
-        return cast(Type[T], self.history.model)  # type: ignore
-
-    def get_history(self) -> QuerySet:
-        """Get all history records for this instance"""
-        model = self._history_model
-        return model.objects.filter(id=self.pk).order_by('-history_date')
-
 class TrackedModel(models.Model):
-    """Abstract base class for models with pghistory tracking.
-    The @pghistory.track() decorator should be applied to concrete models
-    that inherit from this class.
-    """
-    id = models.BigAutoField(primary_key=True)
+    """Abstract base class for models that need history tracking"""
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
 
     class Meta:
         abstract = True
 
     def get_history(self) -> QuerySet:
         """Get all history records for this instance in chronological order"""
-        history_model = self.get_history_model()
-        return history_model.objects.filter(
-            pgh_obj_id=self.pk
-        ).order_by('-pgh_created_at')
-
-    def get_history_model(self) -> Type[Any]:
-        """Get the pghistory model for this instance"""
-        return self.pgh_obj_event_model
+        event_model = self.events.model  # pghistory provides this automatically
+        if event_model:
+            return event_model.objects.filter(
+                pgh_obj_id=self.pk
+            ).order_by('-pgh_created_at')
+        return self.__class__.objects.none()
 
 class HistoricalSlug(models.Model):
     """Track historical slugs for models"""
@@ -97,6 +73,13 @@ class HistoricalSlug(models.Model):
     content_object = GenericForeignKey('content_type', 'object_id')
     slug = models.SlugField(max_length=255)
     created_at = models.DateTimeField(auto_now_add=True)
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name='historical_slugs'
+    )
 
     class Meta:
         unique_together = ('content_type', 'slug')