Question

The scenario:

I have models like this:

class A(models.Model):
    ...

class B(models.Model):
    a = models.ForeignKey(A)
    ...

In the admin I have something like this:

class AInlinde(admin.StackedInline):
    ...
    model = A
    ...

class BAdmin(admin.ModelAdmin):
     ...
     inlines = [AInline]
     ...

Now I need to record in a log when a user deletes some model in the inline, but I can’t follow the code, until now, I know Badmin have a method: save_formset, which is this:

def save_formset(self, request, form, formset, change):
    """
    Given an inline formset save it to the database.
    """
    formset.save()

but I think that formset is generated through the method modelformset_factory, so I can’t know when I can override the delete behavior of that formset

Answer 1

The best way for override how the formset saves or deletes the objects, is make a class that inherits from BaseInlineFormSet and override the methods save and save_existing_objects:

class NoDeleteFormset(BaseInlineFormSet):
    def save(self, commit=True, request=None):
        """Saves model instances for every form, adding and changing instances
        as necessary, and returns the list of instances.
        """
        if not commit:
            self.saved_forms = []
            def save_m2m():
                for form in self.saved_forms:
                    form.save_m2m()
            self.save_m2m = save_m2m
        return self.save_existing_objects(commit) + self.save_new_objects(commit)

    def save_existing_objects(self, commit=True, request=None):
        self.changed_objects = []
        self.deleted_objects = []
        if not self.initial_forms:
            return []

        saved_instances = []
        for form in self.initial_forms:
            pk_name = self._pk_field.name
            raw_pk_value = form._raw_value(pk_name)

            # clean() for different types of PK fields can sometimes return
            # the model instance, and sometimes the PK. Handle either.
            pk_value = form.fields[pk_name].clean(raw_pk_value)
            pk_value = getattr(pk_value, 'pk', pk_value)

            obj = self._existing_object(pk_value)
            if self.can_delete and self._should_delete_form(form):
                self.deleted_objects.append(obj)
                obj.deleted_at = datetime.now()
                obj.save()

                # log there your user deleting the object!

                continue
            if form.has_changed():
                self.changed_objects.append((obj, form.changed_data))
                saved_instances.append(self.save_existing(form, obj, commit=commit))
                if not commit:
                    self.saved_forms.append(form)
        return saved_instances

Then construct a class than inherits from StackedInline:

class MetaInline(StackedInline):
    formset = NoDeleteFormset
    ...