Form handling with class-based views

• Initial GET (blank or prepopulated form)
• POST with invalid data (typically redisplay form with errors)
• POST with valid data (process the data and typically redirect)
  Implementing this yourself often results in a lot of repeated boilerplate code(see Using a form in a view). To help avoidthis, Django provides a collection of generic class-based views for formprocessing.

Given a simple contact form:

forms.py

The view can be constructed using a :

views.py

from myapp.forms import ContactForm
from django.views.generic.edit import FormView
 
class ContactView(FormView):
    template_name = 'contact.html'
    form_class = ContactForm
    success_url = '/thanks/'
 
    def form_valid(self, form):
        # This method is called when valid form data has been POSTed.
        # It should return an HttpResponse.
        form.send_email()
        return super().form_valid(form)

注意：

• FormView inherits sotemplate_namecan be used here.
• The default implementation for simplyredirects to the success_url.

Generic views really shine when working with models. These genericviews will automatically create a , so long asthey can work out which model class to use:

• If the model attribute isgiven, that model class will be used.
• If returns an object, the class of that object will be used.
• If a queryset isgiven, the model for that queryset will be used.
  Model form views provide a implementationthat saves the model automatically. You can override this if you have anyspecial requirements; see below for examples.

You don't even need to provide a success_url forCreateView or - they will useget_absolute_url() on the model object if available.

If you want to use a custom (for instance toadd extra validation) simply setform_class on your view.

注解

First we need to add to ourAuthor class:

models.py

Then we can use and friends to do the actualwork. Notice how we're just configuring the generic class-based viewshere; we don't have to write any logic ourselves:

views.py

from django.urls import reverse_lazy
from myapp.models import Author
 
class AuthorCreate(CreateView):
    model = Author
    fields = ['name']
 
class AuthorUpdate(UpdateView):
    model = Author
    fields = ['name']
 
class AuthorDelete(DeleteView):
    model = Author
    success_url = reverse_lazy('author-list')

注解

We have to use here, not justreverse() as the urls are not loaded when the file is imported.

The fields attribute works the same way as the fields attribute on theinner Meta class on ModelForm. Unless you define theform class in another way, the attribute is required and the view will raisean exception if it's not.

If you specify both the fieldsand attributes, anImproperlyConfigured exception will be raised.

Finally, we hook these new views into the URLconf:

注解

These views inheritwhich usesto construct thebased on the model.

In this example:

• CreateView and use myapp/author_form.html
• DeleteView uses myapp/author_confirm_delete.html
  If you wish to have separate templates for andUpdateView, you can set either ortemplate_name_suffixon your view class.

To track the user that created an object using a ,you can use a custom ModelForm to do this. First, addthe foreign key relation to the model:

models.py

from django.contrib.auth.models import User
from django.db import models
 
class Author(models.Model):
    name = models.CharField(max_length=200)
    created_by = models.ForeignKey(User, on_delete=models.CASCADE)
 
    # ...

In the view, ensure that you don't include created_by in the list of fieldsto edit, and overrideform_valid() to add the user:

views.py

LoginRequiredMixin prevents users whoaren't logged in from accessing the form. If you omit that, you'll need tohandle unauthorized users in .

Here is a simple example showing how you might go about implementing a form thatworks for AJAX requests as well as 'normal' form POSTs:

from django.http import JsonResponse
from django.views.generic.edit import CreateView
from myapp.models import Author
class AjaxableResponseMixin:
    """
    Mixin to add AJAX support to a form.
    Must be used with an object-based FormView (e.g. CreateView)
    """
    def form_invalid(self, form):
        response = super().form_invalid(form)
        if self.request.is_ajax():
            return JsonResponse(form.errors, status=400)
        else:
            return response
 
    def form_valid(self, form):
        # We make sure to call the parent's form_valid() method because
        # it might do some processing (in the case of CreateView, it will
        # call form.save() for example).
        response = super().form_valid(form)
        if self.request.is_ajax():
            data = {
                'pk': self.object.pk,
            }
            return JsonResponse(data)
        else:
            return response
 
class AuthorCreate(AjaxableResponseMixin, CreateView):
    fields = ['name']