tag - Modelo de Django: eliminar() no activado

django templates examples

Question

Tengo un modelo:

class MyModel(models.Model):
 ...
    def save(self):
        print "saving"
        ...
    def delete(self):
        print "deleting"
        ...

El método save () - se activa, pero el delete () no. Utilizo la versión svn más reciente (Django versión 1.2 pre-alpha SVN-11593), y con respecto a la documentación en http://www.djangoproject.com/documentation/models/save_delete_hooks/ esto debería funcionar. ¿Algunas ideas?

Answer 1

Creo que probablemente estés usando la función de eliminación masiva del administrador y te encuentras con que el método de eliminación masiva del administrador no llama a delete() (mira el ticket relacionado).

Ya resolví esto en el pasado escribiendo una acción de administrador personalizada para eliminar modelos.

Si no está utilizando el método de eliminación masiva del administrador (por ejemplo, está haciendo clic en el botón Eliminar en la página de edición del objeto), entonces está sucediendo algo más.

Vea la advertencia here :

La acción "eliminar objetos seleccionados" utiliza QuerySet.delete() por razones de eficiencia, lo que tiene una advertencia importante: no se QuerySet.delete() método delete() su modelo.

Si desea anular este comportamiento, simplemente escriba una acción personalizada que realice la eliminación de la manera que prefiera; por ejemplo, llamando a Model.delete() para cada uno de los elementos seleccionados.

Para obtener más información acerca de la eliminación masiva, consulte la documentación sobre eliminación de objetos .

Mi modelo de administrador personalizado se ve así:

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)

Answer 2

El problema principal es que la eliminación masiva del administrador de Django usa SQL, no instance.delete (), como se indica en otra parte. Para una solución solo de administrador, la siguiente solución preserva el intersitial del administrador de Django "¿realmente quieres eliminar estos?". La solución de vdboor es la más general, sin embargo.

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):
    ...

Answer 3

La acción masiva de las llamadas de administrador queryset.delete() .

Puede anular el método .delete() del conjunto de preguntas, por lo que siempre elimina los objetos 1 por 1. Por ejemplo:

en managers.py :

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)

En models.py :

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()

Answer 4

Sé que esta pregunta es antigua, pero me encontré con esto de nuevo y quería agregar que siempre puedes mover tu código a una señal pre_delete o post_delete como esta:

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"

Funciona con la acción de eliminación masiva del administrador (al menos desde 1.3.1).