Django model: delete() not triggered
I have a model:
class MyModel(models.Model): ... def save(self): print "saving" ... def delete(self): print "deleting" ...
The save()-Method is triggered, but the delete() is not. I use the latest svn-Version (Django version 1.2 pre-alpha SVN-11593), and concerning the documentation at http://www.djangoproject.com/documentation/models/save_delete_hooks/ this should work. Any ideas?
I think you're probably using the admin's bulk delete feature, and are running into the fact that the admin's bulk delete method doesn't call delete() (see the related ticket).
I've got round this in the past by writing a custom admin action for deleting models.
If you're not using the admin's bulk delete method (e.g. you're clicking the delete button on the object's edit page) then something else is going on.
See the warning here:
The “delete selected objects” action uses QuerySet.delete() for efficiency reasons, which has an important caveat: your model’s delete() method will not be called.
If you wish to override this behavior, simply write a custom action which accomplishes deletion in your preferred manner – for example, by calling Model.delete() for each of the selected items.
For more background on bulk deletion, see the documentation on object deletion.
My custom admin model looks like this:
from photoblog.models import PhotoBlogEntry from django.contrib import admin class PhotoBlogEntryAdmin(admin.ModelAdmin): actions=['really_delete_selected'] def get_actions(self, request): actions = super(PhotoBlogEntryAdmin, self).get_actions(request) del actions['delete_selected'] return actions def really_delete_selected(self, request, queryset): for obj in queryset: obj.delete() if queryset.count() == 1: message_bit = "1 photoblog entry was" else: message_bit = "%s photoblog entries were" % queryset.count() self.message_user(request, "%s successfully deleted." % message_bit) really_delete_selected.short_description = "Delete selected entries" admin.site.register(PhotoBlogEntry, PhotoBlogEntryAdmin)
I know this question is ancient, but I just ran into this again and wanted to add that you can always move your code to a pre_delete or post_delete signal like so:
from django.db.models.signals import pre_delete from django.dispatch.dispatcher import receiver @receiver(pre_delete, sender=MyModel) def _mymodel_delete(sender, instance, **kwargs): print "deleting"
It works with the admin's bulk delete action (at least as of 1.3.1).
The bulk action of the admin calls queryset.delete().
You could override the .delete() method of the queryset, so it always does a 1-by-1 deletion of objects. For example:
from django.db import models from django.db.models.query import QuerySet class PhotoQueryMixin(object): """ Methods that appear both in the manager and queryset. """ def delete(self): # Use individual queries to the attachment is removed. for photo in self.all(): photo.delete() class PhotoQuerySet(PhotoQueryMixin, QuerySet): pass class PhotoManager(PhotoQueryMixin, models.Manager): def get_query_set(self): return PhotoQuerySet(self.model, using=self._db)
from django.db import models class Photo(models.Model): image = models.ImageField(upload_to='images') objects = PhotoManager() def delete(self, *args, **kwargs): # Note this is a simple example. it only handles delete(), # and not replacing images in .save() super(Photo, self).delete(*args, **kwargs) self.image.delete()
The main issue is that the Django admin's bulk delete uses SQL, not instance.delete(), as noted elsewhere. For an admin-only solution, the following solution preserves the Django admin's "do you really want to delete these" interstitial. vdboor's solution is the most general, however.
from django.contrib.admin.actions import delete_selected class BulkDeleteMixin(object): class SafeDeleteQuerysetWrapper(object): def __init__(self, wrapped_queryset): self.wrapped_queryset = wrapped_queryset def _safe_delete(self): for obj in self.wrapped_queryset: obj.delete() def __getattr__(self, attr): if attr == 'delete': return self._safe_delete else: return getattr(self.wrapped_queryset, attr) def __iter__(self): for obj in self.wrapped_queryset: yield obj def __getitem__(self, index): return self.wrapped_queryset[index] def __len__(self): return len(self.wrapped_queryset) def get_actions(self, request): actions = super(BulkDeleteMixin, self).get_actions(request) actions['delete_selected'] = (BulkDeleteMixin.action_safe_bulk_delete, 'delete_selected', ugettext_lazy("Delete selected %(verbose_name_plural)s")) return actions def action_safe_bulk_delete(self, request, queryset): wrapped_queryset = BulkDeleteMixin.SafeDeleteQuerysetWrapper(queryset) return delete_selected(self, request, wrapped_queryset) class SomeAdmin(BulkDeleteMixin, ModelAdmin): ...