class FormView
from django.views.generic import FormView
A view for displaying a form, and rendering a template response.
Expand
Collapse
Methods
def
__init__(self, **kwargs):
View
¶
Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
20
21
22
23
24
25
26
27
28 | 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.iteritems():
setattr(self, key, value)
|
def
as_view(cls, **initkwargs):
View
¶
Main entry point for a request-response process.
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52 | @classonlymethod
def as_view(cls, **initkwargs):
"""
Main entry point for a request-response process.
"""
# sanitize keyword arguments
for key in initkwargs:
if key in cls.http_method_names:
raise TypeError(u"You tried to pass in the %s method name as a "
u"keyword argument to %s(). Don't do that."
% (key, cls.__name__))
if not hasattr(cls, key):
raise TypeError(u"%s() received an invalid keyword %r" % (
cls.__name__, key))
def view(request, *args, **kwargs):
self = cls(**initkwargs)
return self.dispatch(request, *args, **kwargs)
# take name and docstring from class
update_wrapper(view, cls, updated=())
# and possible attributes set by decorators
# like csrf_exempt from dispatch
update_wrapper(view, cls.dispatch, assigned=())
return view
|
def
dispatch(self, request, *args, **kwargs):
View
¶
57
58
59
60
61
62
63
64
65
66
67
68 | 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
self.request = request
self.args = args
self.kwargs = kwargs
return handler(request, *args, **kwargs)
|
def
form_invalid(self, form):
FormMixin
¶
| def form_invalid(self, form):
return self.render_to_response(self.get_context_data(form=form))
|
def
form_valid(self, form):
FormMixin
¶
| def form_valid(self, form):
return HttpResponseRedirect(self.get_success_url())
|
def
get(self, request, *args, **kwargs):
ProcessFormView
¶
| def get(self, request, *args, **kwargs):
form_class = self.get_form_class()
form = self.get_form(form_class)
return self.render_to_response(self.get_context_data(form=form))
|
def
get_context_data(self, **kwargs):
FormMixin
¶
| def get_context_data(self, **kwargs):
return kwargs
|
def
get_form(self, form_class):
FormMixin
¶
Returns an instance of the form to be used in this view.
| def get_form(self, form_class):
"""
Returns an instance of the form to be used in this view.
"""
return form_class(**self.get_form_kwargs())
|
def
get_form_class(self):
FormMixin
¶
Returns the form class to use in this view
| def get_form_class(self):
"""
Returns the form class to use in this view
"""
return self.form_class
|
def
get_form_kwargs(self):
FormMixin
¶
Returns the keyword arguments for instanciating the form.
36
37
38
39
40
41
42
43
44
45
46 | def get_form_kwargs(self):
"""
Returns the keyword arguments for instanciating the form.
"""
kwargs = {'initial': self.get_initial()}
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.
| def get_initial(self):
"""
Returns the initial data to use for forms on this view.
"""
return self.initial
|
def
get_success_url(self):
FormMixin
¶
| def get_success_url(self):
if self.success_url:
url = self.success_url
else:
raise ImproperlyConfigured(
"No URL to redirect to. Provide a success_url.")
return url
|
def
get_template_names(self):
TemplateResponseMixin
¶
Returns 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.
99
100
101
102
103
104
105
106
107
108
109 | def get_template_names(self):
"""
Returns 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
¶
70
71
72
73
74
75
76
77
78 | def http_method_not_allowed(self, request, *args, **kwargs):
allowed_methods = [m for m in self.http_method_names if hasattr(self, m)]
logger.warning('Method Not Allowed (%s): %s' % (request.method, request.path),
extra={
'status_code': 405,
'request': self.request
}
)
return http.HttpResponseNotAllowed(allowed_methods)
|
def
post(self, request, *args, **kwargs):
ProcessFormView
¶
134
135
136
137
138
139
140 | def post(self, request, *args, **kwargs):
form_class = self.get_form_class()
form = self.get_form(form_class)
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):
return self.post(*args, **kwargs)
|
def
render_to_response(self, context, **response_kwargs):
TemplateResponseMixin
¶
Returns a response with a template rendered with the given context.
88
89
90
91
92
93
94
95
96
97 | def render_to_response(self, context, **response_kwargs):
"""
Returns a response with a template rendered with the given context.
"""
return self.response_class(
request = self.request,
template = self.get_template_names(),
context = context,
**response_kwargs
)
|