Beispiel für Django-Klassen-basierte DeleteView

Habe ich im Grunde untergeordnetes einige der Generischen Class-Based-Views, genau das zu tun. Der wesentliche Unterschied ist, ich habe einfach herausgefiltert, die querysets. Ich kann nicht verbürgen für, ob diese Methode ist besser oder schlechter, aber es machte mehr Sinn für mich.

Fühlen Sie sich frei, zu ignorieren, die "MessageMixin" - das ist einfach da, einfach präsent-Nachrichten über das Messaging-Framework Django w/eine variable angegeben, die für jede Ansicht. Hier ist der code, den ich geschrieben habe für unsere Website:

Ansichten

from django.views.generic import CreateView, UpdateView, \
        DeleteView, ListView, DetailView

from myproject.core.views import MessageMixin

class RequestCreateView(MessageMixin, CreateView):
    """ 
    Sub-class of the CreateView to automatically pass the Request to the Form. 
    """
    success_message = "Created Successfully"

    def get_form_kwargs(self):
        """ Add the Request object to the Form's Keyword Arguments. """
        kwargs = super(RequestCreateView, self).get_form_kwargs()
        kwargs.update({'request': self.request})
        return kwargs

class RequestUpdateView(MessageMixin, UpdateView):
    """
    Sub-class the UpdateView to pass the request to the form and limit the
    queryset to the requesting user.        
    """
    success_message = "Updated Successfully"

    def get_form_kwargs(self):
        """ Add the Request object to the form's keyword arguments. """
        kwargs = super(RequestUpdateView, self).get_form_kwargs()
        kwargs.update({'request': self.request})
        return kwargs

    def get_queryset(self):
        """ Limit a User to only modifying their own data. """
        qs = super(RequestUpdateView, self).get_queryset()
        return qs.filter(owner=self.request.user)

class RequestDeleteView(MessageMixin, DeleteView):
    """
    Sub-class the DeleteView to restrict a User from deleting other 
    user's data.
    """
    success_message = "Deleted Successfully"

    def get_queryset(self):
        qs = super(RequestDeleteView, self).get_queryset()
        return qs.filter(owner=self.request.user)

Nutzung

Dann können Sie einfach erstellen Sie Ihre eigenen Ansichten zu verwenden, diese Art von Funktionalität. Zum Beispiel, ich bin nur, indem Sie in meine urls.py:

from myproject.utils.views import RequestDeleteView

#...

url(r'^delete-photo/(?P<pk>[\w]+)/$', RequestDeleteView.as_view(
                   model=Photo,
                   success_url='/site/media/photos',
                   template_name='site/media-photos-delete.html',
                   success_message='Your Photo has been deleted successfully.'
                   ), name='fireflie-delete-photo-form'),

Formen

Wichtig zu beachten: ich überladen haben diese get_form_kwargs() Methoden, um meine Formulare mit einer Instanz von 'Anfrage'. Wenn Sie nicht möchten, dass das Request-Objekt, das an der Form, entfernen Sie einfach die überladenen Methoden. Wenn Sie Sie verwenden möchten, Folgen Sie diesem Beispiel:

from django.forms import ModelForm

class RequestModelForm(ModelForm):
    """
    Sub-class the ModelForm to provide an instance of 'request'.
    It also saves the object with the appropriate user.
    """
    def __init__(self, request, *args, **kwargs):
        """ Override init to grab the request object. """
        self.request = request
        super(RequestModelForm, self).__init__(*args, **kwargs)

    def save(self, commit=True):
        m = super(RequestModelForm, self).save(commit=False)
        m.owner = self.request.user
        if commit:
            m.save()
        return m

Dies ist ein bisschen mehr als Sie bat, -- aber es hilft zu wissen, wie zu tun die selben für die Erstellung und Aktualisierung von Ansichten als gut. Diese gleiche Allgemeine Methodik könnte auch angewendet werden, um ListView & Detailansicht.

MessageMixin

Nur für den Fall jemand will, dass MessageMixin ich verwenden.

class MessageMixin(object):
    """
    Make it easy to display notification messages when using Class Based Views.
    """
    def delete(self, request, *args, **kwargs):
        messages.success(self.request, self.success_message)
        return super(MessageMixin, self).delete(request, *args, **kwargs)

    def form_valid(self, form):
        messages.success(self.request, self.success_message)
        return super(MessageMixin, self).form_valid(form)

InformationsquelleAutor der Antwort Kurtis

Ich würde vorschlagen, dass die beste (und einfachste) Weg, dies zu tun wäre, um die UserPassesTestMixin die Ihnen eine sauberere Trennung von Bedenken.

Beispiel:

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import DeleteView


class MyDeleteView(LoginRequiredMixin, UserPassesTestMixin, DeleteView):
    def test_func(self):
        """ Only let the user access this page if they own the object being deleted"""
        return self.get_object().owner == self.request.user

InformationsquelleAutor der Antwort Inti