Django-Modell: delete () nicht ausgelöst

Habe ich ein Modell:

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

Save()-Methode ausgelöst, aber der delete() nicht. Ich benutze die aktuelle svn-Version (Django-version 1.2 pre-alpha-SVN-11593), und im Hinblick auf die Dokumentation bei http://www.djangoproject.com/documentation/models/save_delete_hooks/ das funktionieren sollte.
Irgendwelche Ideen?

InformationsquelleAutor der Frage schneck | 2009-09-24

django django-models

70

Denke ich bist du wohl mit dem admin-bulk-delete-Funktion, und die Tatsache, dass der admin-bulk-delete-Methode aufrufen nicht delete() (siehe auch die Verwandte ticket).

Ich habe diese Runde in der Vergangenheit durch schreiben eines benutzerdefinierten admin-Aktion für das löschen von Modellen.

Wenn du nicht mit dem admin-bulk-delete-Methode (z.B. Sie klicken auf die Schaltfläche "löschen" auf das Objekt "Seite Bearbeiten"), dann ist etwas anderes passiert.

Sehen, die Warnung hier:

Den "ausgewählten Objekte löschen" - Aktion
verwendet QuerySet.delete() für Effizienz
Gründe, die eine wichtige
Nachteil: Ihr Modell ist delete() Methode
nicht aufgerufen werden.

Wenn Sie möchten, um dieses Verhalten zu überschreiben,
schreiben Sie einfach eine benutzerdefinierte Aktion, die
führt das löschen in Ihrer
bevorzugter Weise – zum Beispiel durch
Aufruf Model.delete() für jede der
ausgewählte Elemente.

Weitere Hintergrundinformationen über bulk-Löschung,
finden Sie in der Dokumentation auf Objekt
löschen.

Meine benutzerdefinierte admin-Modell sieht wie folgt aus:
```
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)
```
InformationsquelleAutor der Antwort Dominic Rodger
30

Ich weiß, diese Frage ist uralt, aber ich lief einfach in diesen wieder und wollte noch hinzufügen, können Sie immer bewegen Sie Ihren code, um eine pre_delete oder post_delete signal etwa 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"
```
Klappt es mit dem admin-bulk-delete-Aktion (zumindest ab 1.3.1).

InformationsquelleAutor der Antwort David Bennett

Die bulk-Aktion des admin-Anrufe queryset.delete().

Könnte man das überschreiben der .delete() Methode der queryset,
so ist es immer ein 1-by-1 löschen von Objekten. Zum Beispiel:

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

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

InformationsquelleAutor der Antwort vdboor

Das Hauptproblem ist, dass der Django-admin-bulk-delete-verwendet SQL-Instanz nicht.löschen(), wie anderswo. Für eine admin-only-Lösung, die folgende Lösung bewahrt die Django-admin "wollen Sie wirklich löschen" interstitial. vdboor die Lösung ist die Allgemeine, jedoch.

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

InformationsquelleAutor der Antwort Scott A

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.