class UpdateView
from django.views.generic import UpdateView
View for updating an object, with a response rendered by a template.
Ancestors (MRO)
Attributes
Defined in | |
---|---|
content_type = None
|
TemplateResponseMixin |
context_object_name = None
|
SingleObjectMixin |
extra_context = None
|
ContextMixin |
fields = None
|
ModelFormMixin |
form_class = None
|
FormMixin |
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']
|
View |
initial = {}
|
FormMixin |
model = None
|
SingleObjectMixin |
pk_url_kwarg = 'pk'
|
SingleObjectMixin |
prefix = None
|
FormMixin |
query_pk_and_slug = False
|
SingleObjectMixin |
queryset = None
|
SingleObjectMixin |
response_class = <class 'django.template.response.TemplateResponse'>
|
TemplateResponseMixin |
slug_field = 'slug'
|
SingleObjectMixin |
slug_url_kwarg = 'slug'
|
SingleObjectMixin |
success_url = None
|
FormMixin |
template_engine = None
|
TemplateResponseMixin |
template_name = None
|
TemplateResponseMixin |
template_name_field = None
|
SingleObjectTemplateResponseMixin |
template_name_suffix = '_detail'
|
SingleObjectTemplateResponseMixin |
template_name_suffix = '_form'
|
UpdateView |
view_is_async = False
|
View |
Methods
def
__init__(self, **kwargs):
View
¶
def
__init__(self, **kwargs):
View
¶
Constructor. Called in the URLconf; can contain helpful extra keyword arguments, and other things.
52 53 54 55 56 57 58 59 60 | def __init__(self, **kwargs):
"""
Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
"""
# Go through keyword arguments, and either save their values to our
# instance, or raise an error.
for key, value in kwargs.items():
setattr(self, key, value)
|
def
_allowed_methods(self):
View
¶
def
_allowed_methods(self):
View
¶
168 169 | def _allowed_methods(self):
return [m.upper() for m in self.http_method_names if hasattr(self, m)]
|
def
as_view(cls, **initkwargs):
View
¶
def
as_view(cls, **initkwargs):
View
¶
Main entry point for a request-response process.
79 80 81 82 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 109 110 111 112 113 114 115 116 117 | @classonlymethod
def as_view(cls, **initkwargs):
"""Main entry point for a request-response process."""
for key in initkwargs:
if key in cls.http_method_names:
raise TypeError(
"The method name %s is not accepted as a keyword argument "
"to %s()." % (key, cls.__name__)
)
if not hasattr(cls, key):
raise TypeError(
"%s() received an invalid keyword %r. as_view "
"only accepts arguments that are already "
"attributes of the class." % (cls.__name__, key)
)
def view(request, *args, **kwargs):
self = cls(**initkwargs)
self.setup(request, *args, **kwargs)
if not hasattr(self, "request"):
raise AttributeError(
"%s instance has no 'request' attribute. Did you override "
"setup() and forget to call super()?" % cls.__name__
)
return self.dispatch(request, *args, **kwargs)
view.view_class = cls
view.view_initkwargs = initkwargs
# __name__ and __qualname__ are intentionally left unchanged as
# view_class should be used to robustly determine the name of the view
# instead.
view.__doc__ = cls.__doc__
view.__module__ = cls.__module__
view.__annotations__ = cls.dispatch.__annotations__
# Copy possible attributes set by decorators, e.g. @csrf_exempt, from
# the dispatch method.
view.__dict__.update(cls.dispatch.__dict__)
# Mark the callback if the view class is async.
if cls.view_is_async:
view._is_coroutine = asyncio.coroutines._is_coroutine
return view
|
def
dispatch(self, request, *args, **kwargs):
View
¶
def
dispatch(self, request, *args, **kwargs):
View
¶
132 133 134 135 136 137 138 139 140 141 142 | def dispatch(self, request, *args, **kwargs):
# Try to dispatch to the right method; if a method doesn't exist,
# defer to the error handler. Also defer to the error handler if the
# request method isn't on the approved list.
if request.method.lower() in self.http_method_names:
handler = getattr(
self, request.method.lower(), self.http_method_not_allowed
)
else:
handler = self.http_method_not_allowed
return handler(request, *args, **kwargs)
|
def
form_invalid(self, form):
FormMixin
¶
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):
¶
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(self, request, *args, **kwargs):
¶
def
get(self, request, *args, **kwargs):
¶
BaseUpdateView
Handle GET requests: instantiate a blank version of the form.
202 203 204 | def get(self, request, *args, **kwargs):
self.object = self.get_object()
return super().get(request, *args, **kwargs)
|
ProcessFormView
Handle GET requests: instantiate a blank version of the form.
142 143 144 | def get(self, request, *args, **kwargs):
"""Handle GET requests: instantiate a blank version of the form."""
return self.render_to_response(self.get_context_data())
|
def
get_context_data(self, **kwargs):
¶
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
¶
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
¶
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):
¶
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):
¶
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
¶
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
¶
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
¶
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
¶
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
¶
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):
¶
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
|
def
get_template_names(self):
¶
def
get_template_names(self):
¶
SingleObjectTemplateResponseMixin
Return a list of template names to be used for the request. May not be called if render_to_response() is overridden. Return the following list: * the value of ``template_name`` on the view (if provided) * the contents of the ``template_name_field`` field on the object instance that the view is operating upon (if available) * ``<app_label>/<model_name><template_name_suffix>.html``
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | def get_template_names(self):
"""
Return a list of template names to be used for the request. May not be
called if render_to_response() is overridden. Return the following list:
* the value of ``template_name`` on the view (if provided)
* the contents of the ``template_name_field`` field on the
object instance that the view is operating upon (if available)
* ``<app_label>/<model_name><template_name_suffix>.html``
"""
try:
names = super().get_template_names()
except ImproperlyConfigured:
# If template_name isn't specified, it's not a problem --
# we just start with an empty list.
names = []
# If self.template_name_field is set, grab the value of the field
# of that name from the object; this is the most specific template
# name, if given.
if self.object and self.template_name_field:
name = getattr(self.object, self.template_name_field, None)
if name:
names.insert(0, name)
# The least-specific option is the default <app>/<model>_detail.html;
# only use this if the object in question is a model.
if isinstance(self.object, models.Model):
object_meta = self.object._meta
names.append(
"%s/%s%s.html"
% (
object_meta.app_label,
object_meta.model_name,
self.template_name_suffix,
)
)
elif getattr(self, "model", None) is not None and issubclass(
self.model, models.Model
):
names.append(
"%s/%s%s.html"
% (
self.model._meta.app_label,
self.model._meta.model_name,
self.template_name_suffix,
)
)
# If we still haven't managed to find any template names, we should
# re-raise the ImproperlyConfigured to alert the user.
if not names:
raise
return names
|
TemplateResponseMixin
Return a list of template names to be used for the request. Must return a list. May not be called if render_to_response() is overridden.
196 197 198 199 200 201 202 203 204 205 206 207 | def get_template_names(self):
"""
Return a list of template names to be used for the request. Must return
a list. May not be called if render_to_response() is overridden.
"""
if self.template_name is None:
raise ImproperlyConfigured(
"TemplateResponseMixin requires either a definition of "
"'template_name' or an implementation of 'get_template_names()'"
)
else:
return [self.template_name]
|
def
http_method_not_allowed(self, request, *args, **kwargs):
View
¶
def
http_method_not_allowed(self, request, *args, **kwargs):
View
¶
144 145 146 147 148 149 150 151 | def http_method_not_allowed(self, request, *args, **kwargs):
logger.warning(
"Method Not Allowed (%s): %s",
request.method,
request.path,
extra={"status_code": 405, "request": request},
)
return HttpResponseNotAllowed(self._allowed_methods())
|
def
options(self, request, *args, **kwargs):
View
¶
def
options(self, request, *args, **kwargs):
View
¶
Handle responding to requests for the OPTIONS HTTP verb.
153 154 155 156 157 158 159 160 161 162 163 | def options(self, request, *args, **kwargs):
"""Handle responding to requests for the OPTIONS HTTP verb."""
response = HttpResponse()
response.headers["Allow"] = ", ".join(self._allowed_methods())
response.headers["Content-Length"] = "0"
if self.view_is_async:
async def func():
return response
return func()
else:
return response
|
def
post(self, request, *args, **kwargs):
¶
def
post(self, request, *args, **kwargs):
¶
BaseUpdateView
Handle POST requests: instantiate a form instance with the passed POST variables and then check if it's valid.
206 207 208 | def post(self, request, *args, **kwargs):
self.object = self.get_object()
return super().post(request, *args, **kwargs)
|
ProcessFormView
Handle POST requests: instantiate a form instance with the passed POST variables and then check if it's valid.
146 147 148 149 150 151 152 153 154 155 | def post(self, request, *args, **kwargs):
"""
Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
"""
form = self.get_form()
if form.is_valid():
return self.form_valid(form)
else:
return self.form_invalid(form)
|
def
put(self, *args, **kwargs):
ProcessFormView
¶
def
put(self, *args, **kwargs):
ProcessFormView
¶
159 160 | def put(self, *args, **kwargs):
return self.post(*args, **kwargs)
|
def
render_to_response(self, context, **response_kwargs):
TemplateResponseMixin
¶
def
render_to_response(self, context, **response_kwargs):
TemplateResponseMixin
¶
Return a response, using the `response_class` for this view, with a template rendered with the given context. Pass response_kwargs to the constructor of the response class.
180 181 182 183 184 185 186 187 188 189 190 191 192 193 | def render_to_response(self, context, **response_kwargs):
"""
Return a response, using the `response_class` for this view, with a
template rendered with the given context.
Pass response_kwargs to the constructor of the response class.
"""
response_kwargs.setdefault("content_type", self.content_type)
return self.response_class(
request=self.request,
template=self.get_template_names(),
context=context,
using=self.template_engine,
**response_kwargs,
)
|
def
setup(self, request, *args, **kwargs):
View
¶
def
setup(self, request, *args, **kwargs):
View
¶
Initialize attributes shared by all view methods.
124 125 126 127 128 129 130 | def setup(self, request, *args, **kwargs):
"""Initialize attributes shared by all view methods."""
if hasattr(self, "get") and not hasattr(self, "head"):
self.head = self.get
self.request = request
self.args = args
self.kwargs = kwargs
|