如何使用django-simple-history跟踪ForeignKey关联对象变更并同步至主模型历史记录？

Absolutely, you can make this happen! django-simple-history doesn’t automatically track changes to related objects out of the box, but with Django’s signal system, you can easily sync Item updates to the Collection’s history log. Here’s a practical implementation:

1. Add Signal Receivers for the Item Model #

We’ll listen to post_save and post_delete signals from the Item model. Whenever an Item is created, updated, or deleted, we’ll manually generate a history record for its linked Collection.

First, create or update your app’s signals.py file with these imports and handlers:

from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from .models import Item, Collection

@receiver(post_save, sender=Item)
def update_collection_history_on_item_save(sender, instance, created, **kwargs):
    # Fetch the associated Collection
    collection = instance.collection
    
    # Define history type and change context
    history_type = '+' if created else '~'
    change_reason = f"Item {'created' if created else 'updated'}: ID {instance.id}"
    
    # Create a new history snapshot for the Collection
    collection.history.create(
        history_type=history_type,
        history_change_reason=change_reason,
        # Copy all current Collection field values to the history record
        **{field.name: getattr(collection, field.name) for field in Collection._meta.fields}
    )

@receiver(post_delete, sender=Item)
def update_collection_history_on_item_delete(sender, instance, **kwargs):
    collection = instance.collection
    
    # Log the Item deletion in the Collection's history
    collection.history.create(
        history_type='-',
        history_change_reason=f"Item deleted: ID {instance.id}",
        **{field.name: getattr(collection, field.name) for field in Collection._meta.fields}
    )

2. Connect the Signals to Your App #

Ensure Django recognizes your signals by updating your app’s apps.py:

from django.apps import AppConfig

class YourAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'your_app_name'

    def ready(self):
        import your_app_name.signals

Then reference this config in your settings.py:

INSTALLED_APPS = [
    # ... other apps
    'your_app_name.apps.YourAppConfig',
]

3. (Optional) Clean Up with a Collection Method #

For better code organization, wrap the history creation logic in a method on the Collection model:

class Collection(models.Model):
    description = models.TextField()
    # ... other fields
    history = simple_history.HistoricalRecords()

    def record_item_change(self, item, change_type):
        """Log an Item-related change to the Collection's history."""
        reason_map = {
            'create': f"Added Item: ID {item.id}",
            'update': f"Updated Item: ID {item.id}",
            'delete': f"Removed Item: ID {item.id}"
        }
        history_type_map = {
            'create': '+',
            'update': '~',
            'delete': '-'
        }

        self.history.create(
            history_type=history_type_map[change_type],
            history_change_reason=reason_map[change_type],
            **{field.name: getattr(self, field.name) for field in self._meta.fields}
        )

Now simplify your signal handlers:

@receiver(post_save, sender=Item)
def on_item_save(sender, instance, created, **kwargs):
    change_type = 'create' if created else 'update'
    instance.collection.record_item_change(instance, change_type)

@receiver(post_delete, sender=Item)
def on_item_delete(sender, instance, **kwargs):
    instance.collection.record_item_change(instance, 'delete')

How It Works #

• When you run c.items.add(item) (which saves the Item with its new Collection association), the post_save signal triggers, and a new entry appears in c.history explaining the Item addition.
• The history record captures a full snapshot of the Collection’s current state, just like when you modify the Collection’s own fields like description.
• You’ll see these Item-related entries alongside your existing Collection field change logs when accessing c.history.

Key Notes #

• Batch Operations: Django signals don’t fire for bulk actions like bulk_create() or bulk_update(). If you use these, you’ll need to manually trigger Collection history updates after the batch completes.
• Metadata: django-simple-history automatically populates history_date and history_user (if you’ve set up user tracking) for all new history records, so you don’t need to handle these manually.

内容的提问来源于stack exchange，提问作者Blub