Form processing generally has 3 paths:
\nInitial 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\n(see Using a form in a view). To help avoid\nthis, Django provides a collection of generic class-based views for form\nprocessing.
\nGiven a simple contact form:
\nforms.pyfrom django import forms\n\nclass ContactForm(forms.Form):\n name = forms.CharField()\n message = forms.CharField(widget=forms.Textarea)\n\n def send_email(self):\n # send email using the self.cleaned_data dictionary\n pass\nThe view can be constructed using a FormView:
views.pyfrom myapp.forms import ContactForm\nfrom django.views.generic.edit import FormView\n\nclass ContactView(FormView):\n template_name = 'contact.html'\n form_class = ContactForm\n success_url = '/thanks/'\n\n def form_valid(self, form):\n # This method is called when valid form data has been POSTed.\n # It should return an HttpResponse.\n form.send_email()\n return super(ContactView, self).form_valid(form)\nNotas:
\nFormView inherits\nTemplateResponseMixin so\ntemplate_name\ncan be used here.
The default implementation for\nform_valid() simply\nredirects to the success_url.
Generic views really shine when working with models. These generic\nviews will automatically create a ModelForm, so long as\nthey can work out which model class to use:
If the model attribute is\ngiven, that model class will be used.
If get_object()\nreturns an object, the class of that object will be used.
If a queryset is\ngiven, the model for that queryset will be used.
Model form views provide a\nform_valid() implementation\nthat saves the model automatically. You can override this if you have any\nspecial requirements; see below for examples.
You don’t even need to provide a success_url for\nCreateView or\nUpdateView - they will use\nget_absolute_url() on the model object if available.
If you want to use a custom ModelForm (for instance to\nadd extra validation) simply set\nform_class on your view.
First we need to add get_absolute_url() to our\nAuthor class:
models.pyfrom django.urls import reverse\nfrom django.db import models\n\nclass Author(models.Model):\n name = models.CharField(max_length=200)\n\n def get_absolute_url(self):\n return reverse('author-detail', kwargs={'pk': self.pk})\nThen we can use CreateView and friends to do the actual\nwork. Notice how we’re just configuring the generic class-based views\nhere; we don’t have to write any logic ourselves:
views.pyfrom django.views.generic.edit import CreateView, UpdateView, DeleteView\nfrom django.urls import reverse_lazy\nfrom myapp.models import Author\n\nclass AuthorCreate(CreateView):\n model = Author\n fields = ['name']\n\nclass AuthorUpdate(UpdateView):\n model = Author\n fields = ['name']\n\nclass AuthorDelete(DeleteView):\n model = Author\n success_url = reverse_lazy('author-list')\nThe fields attribute works the same way as the fields attribute on the\ninner Meta class on ModelForm. Unless you define the\nform class in another way, the attribute is required and the view will raise\nan ImproperlyConfigured exception if it’s not.
If you specify both the fields\nand form_class attributes, an\nImproperlyConfigured exception will be raised.
Finally, we hook these new views into the URLconf:
\nurls.pyfrom django.conf.urls import url\nfrom myapp.views import AuthorCreate, AuthorUpdate, AuthorDelete\n\nurlpatterns = [\n # ...\n url(r'author/add/$', AuthorCreate.as_view(), name='author-add'),\n url(r'author/(?P<pk>[0-9]+)/$', AuthorUpdate.as_view(), name='author-update'),\n url(r'author/(?P<pk>[0-9]+)/delete/$', AuthorDelete.as_view(), name='author-delete'),\n]\nrequest.userLink para este cabeçalho#To track the user that created an object using a CreateView,\nyou can use a custom ModelForm to do this. First, add\nthe foreign key relation to the model:
models.pyfrom django.contrib.auth.models import User\nfrom django.db import models\n\nclass Author(models.Model):\n name = models.CharField(max_length=200)\n created_by = models.ForeignKey(User, on_delete=models.CASCADE)\n\n # ...\nIn the view, ensure that you don’t include created_by in the list of fields\nto edit, and override\nform_valid() to add the user:
views.pyfrom django.views.generic.edit import CreateView\nfrom myapp.models import Author\n\nclass AuthorCreate(CreateView):\n model = Author\n fields = ['name']\n\n def form_valid(self, form):\n form.instance.created_by = self.request.user\n return super(AuthorCreate, self).form_valid(form)\nNote that you’ll need to decorate this\nview using\nlogin_required(), or\nalternatively handle unauthorized users in the\nform_valid().
Here is a simple example showing how you might go about implementing a form that\nworks for AJAX requests as well as ‘normal’ form POSTs:
\nfrom django.http import JsonResponse\nfrom django.views.generic.edit import CreateView\nfrom myapp.models import Author\n\nclass AjaxableResponseMixin(object):\n """\n Mixin to add AJAX support to a form.\n Must be used with an object-based FormView (e.g. CreateView)\n """\n def form_invalid(self, form):\n response = super(AjaxableResponseMixin, self).form_invalid(form)\n if self.request.is_ajax():\n return JsonResponse(form.errors, status=400)\n else:\n return response\n\n def form_valid(self, form):\n # We make sure to call the parent's form_valid() method because\n # it might do some processing (in the case of CreateView, it will\n # call form.save() for example).\n response = super(AjaxableResponseMixin, self).form_valid(form)\n if self.request.is_ajax():\n data = {\n 'pk': self.object.pk,\n }\n return JsonResponse(data)\n else:\n return response\n\nclass AuthorCreate(AjaxableResponseMixin, CreateView):\n model = Author\n fields = ['name']\n