Addressing Concurrent Editing in Django Admin

Your problem with concurrent editing in Django Admin is a common challenge when multiple users work on the same objects. While your approach using Redis is creative, there are some issues with the implementation and potentially simpler solutions available.

Issues with the Proposed Solution

1. Overriding get_object(): This method is used to retrieve the object for display, not for saving. Returning cached data here won't affect how Django saves the object.

2. Using update_fields: While update_fields can help with partial updates, it won't solve the concurrent editing problem as described.

3. Redis Serialization: Storing Django model instances in Redis requires proper serialization/deserialization, which isn't addressed in your example.

Alternative Approaches

1. Using Django's Built-in Optimistic Concurrency Control

Django has a built-in mechanism for handling concurrent edits through the ModelAdmin.save_model() method:

PYTHONCopied
from django.db import transaction
from django.db.models import F

class ConcurrentModelAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        if change:
            # Get the current state from the database
            current_obj = self.model.objects.get(pk=obj.pk)
            
            # Update only the fields that were changed in the form
            for field_name in form.changed_data:
                setattr(current_obj, field_name, getattr(obj, field_name))
            
            # Save the updated object
            current_obj.save()
        else:
            super().save_model(request, obj, form, change)

2. Using Django's Version Control

For more complex scenarios, you might consider using a version control package like django-reversion:

PYTHONCopied
from reversion.admin import VersionAdmin

class MyModelAdmin(VersionAdmin):
    # Your customizations here
    pass

3. Using Form Timestamps

Another approach is to add a hidden timestamp field to your form and check if the object has been modified since the form was loaded:

PYTHONCopied
from django import forms
from django.contrib import admin
from django.core.exceptions import ValidationError
from django.utils import timezone

class TimestampedModelAdminForm(forms.ModelForm):
    last_modified = forms.DateTimeField(widget=forms.HiddenInput(), required=False)
    
    def clean(self):
        cleaned_data = super().clean()
        last_modified = cleaned_data.get('last_modified')
        
        if self.instance.pk and last_modified:
            current_modified = self.instance.__class__.objects.get(pk=self.instance.pk).last_modified
            if current_modified and current_modified > last_modified:
                raise ValidationError("This object has been modified since you started editing it.")
        
        return cleaned_data

class ConcurrentModelAdmin(admin.ModelAdmin):
    form = TimestampedModelAdminForm
    
    def get_form(self, request, obj=None, **kwargs):
        form = super().get_form(request, obj, **kwargs)
        if obj:
            form.base_fields['last_modified'].initial = obj.last_modified
        return form

Recommendation

I recommend starting with the first approach as it's simpler and doesn't require additional dependencies. It addresses your specific use case by ensuring that only the fields changed by the current user are updated, while preserving changes made by other users.

If you need more advanced features like version history or the ability to revert changes, consider using django-reversion or a similar package.

Remember that any solution should be thoroughly tested with your specific models and use cases to ensure it works as expected.