class ModelFormMixin

from django.views.generic.edit import ModelFormMixin
Provide a way to show and handle a ModelForm in a request.

Attributes

  Defined in
context_object_name = None SingleObjectMixin
extra_context = None ContextMixin
fields = None ModelFormMixin
form_class = None FormMixin
initial = {} FormMixin
model = None SingleObjectMixin
pk_url_kwarg = 'pk' SingleObjectMixin
prefix = None FormMixin
query_pk_and_slug = False SingleObjectMixin
queryset = None SingleObjectMixin
slug_field = 'slug' SingleObjectMixin
slug_url_kwarg = 'slug' SingleObjectMixin
success_url = None FormMixin
Expand Collapse

Methods

def form_invalid(self, form): FormMixin

If the form is invalid, render the invalid form.
67
68
69
def form_invalid(self, form):
    """If the form is invalid, render the invalid form."""
    return self.render_to_response(self.get_context_data(form=form))

def form_valid(self, form):

ModelFormMixin

If the form is valid, save the associated model.
133
134
135
136
def form_valid(self, form):
    """If the form is valid, save the associated model."""
    self.object = form.save()
    return super().form_valid(form)

FormMixin

If the form is valid, redirect to the supplied URL.
63
64
65
def form_valid(self, form):
    """If the form is valid, redirect to the supplied URL."""
    return HttpResponseRedirect(self.get_success_url())

def get_context_data(self, **kwargs):

FormMixin

Insert the form into the context dict.
71
72
73
74
75
def get_context_data(self, **kwargs):
    """Insert the form into the context dict."""
    if "form" not in kwargs:
        kwargs["form"] = self.get_form()
    return super().get_context_data(**kwargs)

SingleObjectMixin

Insert the single object into the context dict.
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def get_context_data(self, **kwargs):
    """Insert the single object into the context dict."""
    context = {}
    if self.object:
        context["object"] = self.object
        context_object_name = self.get_context_object_name(self.object)
        if context_object_name:
            context[context_object_name] = self.object
    context.update(kwargs)
    return super().get_context_data(**context)

ContextMixin

28
29
30
31
32
def get_context_data(self, **kwargs):
    kwargs.setdefault("view", self)
    if self.extra_context is not None:
        kwargs.update(self.extra_context)
    return kwargs

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
83
84
85
86
87
88
89
90
def get_context_object_name(self, obj):
    """Get the name to use for the object."""
    if self.context_object_name:
        return self.context_object_name
    elif isinstance(obj, models.Model):
        return obj._meta.model_name
    else:
        return None

def get_form(self, form_class=None): FormMixin

Return an instance of the form to be used in this view.
35
36
37
38
39
def get_form(self, form_class=None):
    """Return an instance of the form to be used in this view."""
    if form_class is None:
        form_class = self.get_form_class()
    return form_class(**self.get_form_kwargs())

def get_form_class(self):

ModelFormMixin

Return the form class to use in this view.
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
def get_form_class(self):
    """Return the form class to use in this view."""
    if self.fields is not None and self.form_class:
        raise ImproperlyConfigured(
            "Specifying both 'fields' and 'form_class' is not permitted."
        )
    if self.form_class:
        return self.form_class
    else:
        if self.model is not None:
            # If a model has been explicitly provided, use it
            model = self.model
        elif getattr(self, "object", None) is not None:
            # If this view is operating on a single object, use
            # the class of that object
            model = self.object.__class__
        else:
            # Try to get a queryset and extract the model class
            # from that
            model = self.get_queryset().model
        if self.fields is None:
            raise ImproperlyConfigured(
                "Using ModelFormMixin (base class of %s) without "
                "the 'fields' attribute is prohibited." % self.__class__.__name__
            )
        return model_forms.modelform_factory(model, fields=self.fields)

FormMixin

Return the form class to use.
31
32
33
def get_form_class(self):
    """Return the form class to use."""
    return self.form_class

def get_form_kwargs(self):

ModelFormMixin

Return the keyword arguments for instantiating the form.
112
113
114
115
116
117
def get_form_kwargs(self):
    """Return the keyword arguments for instantiating the form."""
    kwargs = super().get_form_kwargs()
    if hasattr(self, "object"):
        kwargs.update({"instance": self.object})
    return kwargs

FormMixin

Return the keyword arguments for instantiating the form.
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def get_form_kwargs(self):
    """Return the keyword arguments for instantiating the form."""
    kwargs = {
        "initial": self.get_initial(),
        "prefix": self.get_prefix(),
    }
    if self.request.method in ("POST", "PUT"):
        kwargs.update(
            {
                "data": self.request.POST,
                "files": self.request.FILES,
            }
        )
    return kwargs

def get_initial(self): FormMixin

Return the initial data to use for forms on this view.
23
24
25
def get_initial(self):
    """Return the initial data to use for forms on this view."""
    return self.initial.copy()

def get_object(self, queryset=None): SingleObjectMixin

Return the object the view is displaying.

Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
Subclasses can override this to return any object.
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def get_object(self, queryset=None):
    """
    Return the object the view is displaying.
    Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
    Subclasses can override this to return any object.
    """
    # Use a custom queryset if provided; this is required for subclasses
    # like DateDetailView
    if queryset is None:
        queryset = self.get_queryset()
    # Next, try looking up by primary key.
    pk = self.kwargs.get(self.pk_url_kwarg)
    slug = self.kwargs.get(self.slug_url_kwarg)
    if pk is not None:
        queryset = queryset.filter(pk=pk)
    # Next, try looking up by slug.
    if slug is not None and (pk is None or self.query_pk_and_slug):
        slug_field = self.get_slug_field()
        queryset = queryset.filter(**{slug_field: slug})
    # If none of those are defined, it's an error.
    if pk is None and slug is None:
        raise AttributeError(
            "Generic detail view %s must be called with either an object "
            "pk or a slug in the URLconf." % self.__class__.__name__
        )
    try:
        # Get the single item from the filtered queryset
        obj = queryset.get()
    except queryset.model.DoesNotExist:
        raise Http404(
            _("No %(verbose_name)s found matching the query")
            % {"verbose_name": queryset.model._meta.verbose_name}
        )
    return obj

def get_prefix(self): FormMixin

Return the prefix to use for forms.
27
28
29
def get_prefix(self):
    """Return the prefix to use for forms."""
    return self.prefix

def get_queryset(self): SingleObjectMixin

Return the `QuerySet` that will be used to look up the object.

This method is called by the default implementation of get_object() and
may not be called if get_object() is overridden.
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
def get_queryset(self):
    """
    Return the `QuerySet` that will be used to look up the object.
    This method is called by the default implementation of get_object() and
    may not be called if get_object() is overridden.
    """
    if self.queryset is None:
        if self.model:
            return self.model._default_manager.all()
        else:
            raise ImproperlyConfigured(
                "%(cls)s is missing a QuerySet. Define "
                "%(cls)s.model, %(cls)s.queryset, or override "
                "%(cls)s.get_queryset()." % {"cls": self.__class__.__name__}
            )
    return self.queryset.all()

def get_slug_field(self): SingleObjectMixin

Get the name of a slug field to be used to look up by slug.
79
80
81
def get_slug_field(self):
    """Get the name of a slug field to be used to look up by slug."""
    return self.slug_field

def get_success_url(self):

ModelFormMixin

Return the URL to redirect to after processing a valid form.
119
120
121
122
123
124
125
126
127
128
129
130
131
def get_success_url(self):
    """Return the URL to redirect to after processing a valid form."""
    if self.success_url:
        url = self.success_url.format(**self.object.__dict__)
    else:
        try:
            url = self.object.get_absolute_url()
        except AttributeError:
            raise ImproperlyConfigured(
                "No URL to redirect to.  Either provide a url or define"
                " a get_absolute_url method on the Model."
            )
    return url

FormMixin

Return the URL to redirect to after processing a valid form.
57
58
59
60
61
def get_success_url(self):
    """Return the URL to redirect to after processing a valid form."""
    if not self.success_url:
        raise ImproperlyConfigured("No URL to redirect to. Provide a success_url.")
    return str(self.success_url)  # success_url may be lazy