ccbv.co.uk

class ModelFormMixin

from django.views.generic.edit import ModelFormMixin
Hierarchy diagram Documentation Source code 
A mixin that provides a way to show and handle a modelform in a request.

Ancestors (MRO)

  1. ModelFormMixin
  2. FormMixin
  3. SingleObjectMixin
  4. ContextMixin

Attributes

  Defined in
context_object_name = None SingleObjectMixin
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, re-render the context data with the
data-filled form and errors.
81
82
83
84
85
86
def form_invalid(self, form):
    """
    If the form is invalid, re-render the context data with the
    data-filled form and errors.
    """
    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.
158
159
160
161
162
163
def form_valid(self, form):
    """
    If the form is valid, save the associated model.
    """
    self.object = form.save()
    return super(ModelFormMixin, self).form_valid(form)

FormMixin

 
If the form is valid, redirect to the supplied URL.
75
76
77
78
79
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.
88
89
90
91
92
93
94
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(FormMixin, self).get_context_data(**kwargs)

SingleObjectMixin

 
Insert the single object into the context dict.
 96
 97
 98
 99
100
101
102
103
104
105
106
107
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(SingleObjectMixin, self).get_context_data(**context)

ContextMixin

 
22
23
24
25
def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    return kwargs

def get_context_object_name(self, obj): SingleObjectMixin 

Get the name to use for the object.
85
86
87
88
89
90
91
92
93
94
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 

Returns an instance of the form to be used in this view.
39
40
41
42
43
44
45
def get_form(self, form_class=None):
    """
    Returns 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

 
Returns the form class to use in this view.
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
def get_form_class(self):
    """
    Returns 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 hasattr(self, 'object') and self.object 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

 
Returns the form class to use in this view
33
34
35
36
37
def get_form_class(self):
    """
    Returns the form class to use in this view
    """
    return self.form_class

def get_form_kwargs(self):

ModelFormMixin

 
Returns the keyword arguments for instantiating the form.
134
135
136
137
138
139
140
141
def get_form_kwargs(self):
    """
    Returns the keyword arguments for instantiating the form.
    """
    kwargs = super(ModelFormMixin, self).get_form_kwargs()
    if hasattr(self, 'object'):
        kwargs.update({'instance': self.object})
    return kwargs

FormMixin

 
Returns the keyword arguments for instantiating the form.
47
48
49
50
51
52
53
54
55
56
57
58
59
60
def get_form_kwargs(self):
    """
    Returns 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 

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

def get_object(self, queryset=None): SingleObjectMixin 

Returns the object the view is displaying.

By default this requires `self.queryset` and a `pk` or `slug` argument
in the URLconf, but subclasses can override this to return any object.
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
def get_object(self, queryset=None):
    """
    Returns the object the view is displaying.
    By default this requires `self.queryset` and a `pk` or `slug` argument
    in the URLconf, but 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."
                             % 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 

Returns the prefix to use for forms on this view
27
28
29
30
31
def get_prefix(self):
    """
    Returns the prefix to use for forms on this view
    """
    return self.prefix

def get_queryset(self): SingleObjectMixin 

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

Note that this method is called by the default implementation of
`get_object` and may not be called if `get_object` is overridden.
59
60
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.
    Note that 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
82
83
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

 
Returns the supplied URL.
143
144
145
146
147
148
149
150
151
152
153
154
155
156
def get_success_url(self):
    """
    Returns the supplied URL.
    """
    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

 
Returns the supplied success URL.
63
64
65
66
67
68
69
70
71
72
73
def get_success_url(self):
    """
    Returns the supplied success URL.
    """
    if self.success_url:
        # Forcing possible reverse_lazy evaluation
        url = force_text(self.success_url)
    else:
        raise ImproperlyConfigured(
            "No URL to redirect to. Provide a success_url.")
    return url