Fixing Multi-Database Deletion in Django Admin

The issue you're experiencing with Django Admin attempting to delete objects from the default database instead of the members database is likely related to how related objects are being handled during deletion. The error message indicates that Django is looking for a login_history relation in the default database when it should be looking in the members database.

The Problem

When deleting a User object with related LoginHistoryRecord objects, Django is trying to cascade the deletion to the related objects but is looking in the wrong database. This happens because the inline relationship isn't properly configured to use the correct database during deletion operations.

Solution

You need to override a few additional methods to ensure that all operations, including cascading deletions, use the correct database. Here are the key changes needed:

1. Update the LoginHistoryInline class

PYTHONCopied
class LoginHistoryInline(MultiDBTabularInline):
    model = LoginHistoryRecord
    readonly_fields = [
        "id",
        "device",
        "login_date",
        "device_type",
    ]
    can_delete = False
    verbose_name = "Login history"
    verbose_name_plural = "Login history"
    
    def get_formset(self, request, obj=None, **kwargs):
        formset = super().get_formset(request, obj, **kwargs)
        if obj:
            # Ensure the parent instance has the correct database
            obj._state.db = self.using
        return formset

2. Enhance the MultiDBModelAdmin class

PYTHONCopied
class MultiDBModelAdmin(admin.ModelAdmin):
    using = "members"
    
    def save_model(self, request, obj, form, change):
        # Tell Django to save objects to the 'members' database.
        obj.save(using=self.using)
    
    def delete_model(self, request, obj):
        # Tell Django to delete objects from the 'members' database
        obj._state.db = self.using
        obj.delete(using=self.using)
    
    def delete_queryset(self, request, queryset):
        # Ensure the queryset is using the correct database
        queryset.using(self.using).delete()
    
    def get_queryset(self, request):
        # Tell Django to look for objects on the 'members' database.
        return super().get_queryset(request).using(self.using)
    
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        # Tell Django to populate ForeignKey widgets using a query
        # on the 'members' database.
        return super().formfield_for_foreignkey(
            db_field, request, using=self.using, **kwargs
        )
    
    def formfield_for_manytomany(self, db_field, request, **kwargs):
        # Tell Django to populate ManyToMany widgets using a query
        # on the 'members' database.
        return super().formfield_for_manytomany(
            db_field, request, using=self.using, **kwargs
        )
    
    def _save_related(self, request, form, formsets, change):
        """Ensure related objects are saved in the correct database."""
        for formset in formsets:
            formset.instance._state.db = self.using  # Force the database
            # Also set the database for each form in the formset
            for form in formset.forms:
                if form.instance:
                    form.instance._state.db = self.using
        super()._save_related(request, form, formsets, change)
    
    def get_object(self, request, object_id, from_field=None):
        """Ensure the retrieved object has the correct database set."""
        obj = super().get_object(request, object_id, from_field)
        if obj:
            obj._state.db = self.using
        return obj
    
    def has_delete_permission(self, request, obj=None):
        """Ensure obj has the correct database before checking permissions."""
        if obj:
            obj._state.db = self.using
        return super().has_delete_permission(request, obj)

3. Update the MemberAdmin class to include the inline

PYTHONCopied
@admin.register(User)
class MemberAdmin(MultiDBModelAdmin):
    list_display = [
        "id",
    ]
    inlines = [LoginHistoryInline]
    
    def get_deleted_objects(self, objs, request):
        """Override to ensure related objects are found in the correct database."""
        for obj in objs:
            obj._state.db = self.using
        return super().get_deleted_objects(objs, request)

Additional Considerations

1. Database Routers: Make sure your database router is correctly configured to handle related objects. You might need to implement a custom router that directs all operations on LoginHistoryRecord to the members database.

2. Collector Customization: For complex cases, you might need to override the get_deleted_objects method to use a custom collector that explicitly uses the correct database.

3. Consistent Database State: Ensure that all objects have their _state.db attribute set to the correct database before any operation.

By implementing these changes, you should be able to ensure that Django Admin correctly deletes objects from the members database and properly handles related objects during deletion.