from django.views.generic import FormView
A view for displaying a form and rendering a template response.
Предки (MRO)
- FormView
- TemplateResponseMixin
- BaseFormView
- FormMixin
- ContextMixin
- ProcessFormView
- View
Потомки
- LoginView
- PasswordChangeView
- PasswordResetConfirmView
- PasswordResetView
Атрибуты
Определено в | |
---|---|
content_type = None | TemplateResponseMixin |
extra_context = None | ContextMixin |
form_class = None | FormMixin |
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] | View |
initial = {} | FormMixin |
prefix = None | FormMixin |
response_class = <class 'django.template.response.TemplateResponse'> | TemplateResponseMixin |
success_url = None | FormMixin |
template_engine = None | TemplateResponseMixin |
template_name = None | TemplateResponseMixin |
Методы
def _allowed_methods(self): return [m.upper() for m in self.http_method_names if hasattr(self, m)]
Main entry point for a request-response process.
@classonlymethoddef 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 # 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): # 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)
If the form is invalid, render the invalid form.
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))
If the form is valid, redirect to the supplied URL.
def form_valid(self, form): """If the form is valid, redirect to the supplied URL.""" return HttpResponseRedirect(self.get_success_url())
Handle GET requests: instantiate a blank version of the form.
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())
FormMixin
Insert the form into the context dict.
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)
ContextMixin
def get_context_data(self, **kwargs): kwargs.setdefault('view', self) if self.extra_context is not None: kwargs.update(self.extra_context) return kwargs
Return an instance of the form to be used in this view.
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())
Return the form class to use.
def get_form_class(self): """Return the form class to use.""" return self.form_class
Return the keyword arguments for instantiating the form.
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
Return the initial data to use for forms on this view.
def get_initial(self): """Return the initial data to use for forms on this view.""" return self.initial.copy()
Return the prefix to use for forms.
def get_prefix(self): """Return the prefix to use for forms.""" return self.prefix
Return the URL to redirect to after processing a valid form.
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
Return a list of template names to be used for the request. Must returna list. May not be called if render_to_response() is overridden.
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): logger.warning( 'Method Not Allowed (%s): %s', request.method, request.path, extra={'status_code': 405, 'request': request} ) return HttpResponseNotAllowed(self._allowed_methods())
Constructor. Called in the URLconf; can contain helpful extrakeyword arguments, and other things.
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)
Handle responding to requests for the OPTIONS HTTP verb.
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' return response
Handle POST requests: instantiate a form instance with the passedPOST variables and then check if it's valid.
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): return self.post(*args, **kwargs)
Return a response, using the `response_class` for this view, with atemplate rendered with the given context.Pass response_kwargs to the constructor of the response class.
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 )
Initialize attributes shared by all view methods.
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