class BaseFormView

from django.views.generic.edit import BaseFormView
A base view for displaying a form

Descendants

Attributes

  Defined in
form_class = None FormMixin
http_method_names = [u'get', u'post', u'put', u'patch', u'delete', u'head', u'options', u'trace'] View
initial = {} FormMixin
prefix = None FormMixin
success_url = None FormMixin
Expand Collapse

Methods

def _allowed_methods(self): View

107
108
def _allowed_methods(self):
    return [m.upper() for m in self.http_method_names if hasattr(self, m)]

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@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("You tried to pass in the %s method name as a "
                            "keyword argument to %s(). Don't do that."
                            % (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)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        self.request = request
        self.args = args
        self.kwargs = kwargs
        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

79
80
81
82
83
84
85
86
87
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

If the form is invalid, re-render the context data with the
data-filled form and errors.
80
81
82
83
84
85
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): FormMixin

If the form is valid, redirect to the supplied URL.
74
75
76
77
78
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): ProcessFormView

Handles GET requests and instantiates a blank version of the form.
155
156
157
158
159
160
161
def get(self, request, *args, **kwargs):
    """
    Handles GET requests and instantiates a blank version of the form.
    """
    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): ContextMixin

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

def get_form(self, form_class): FormMixin

Returns an instance of the form to be used in this view.
40
41
42
43
44
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
34
35
36
37
38
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 instantiating the form.
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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.
22
23
24
25
26
def get_initial(self):
    """
    Returns the initial data to use for forms on this view.
    """
    return self.initial.copy()

def get_prefix(self): FormMixin

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

def get_success_url(self): FormMixin

Returns the supplied success URL.
62
63
64
65
66
67
68
69
70
71
72
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

def http_method_not_allowed(self, request, *args, **kwargs): View

89
90
91
92
93
94
95
96
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': self.request
        }
    )
    return http.HttpResponseNotAllowed(self._allowed_methods())

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
36
37
38
39
40
41
42
43
44
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 six.iteritems(kwargs):
        setattr(self, key, value)

def options(self, request, *args, **kwargs): View

Handles responding to requests for the OPTIONS HTTP verb.
 98
 99
100
101
102
103
104
105
def options(self, request, *args, **kwargs):
    """
    Handles responding to requests for the OPTIONS HTTP verb.
    """
    response = http.HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

def post(self, request, *args, **kwargs): ProcessFormView

Handles POST requests, instantiating a form instance with the passed
POST variables and then checked for validity.
163
164
165
166
167
168
169
170
171
172
173
def post(self, request, *args, **kwargs):
    """
    Handles POST requests, instantiating a form instance with the passed
    POST variables and then checked for validity.
    """
    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

177
178
def put(self, *args, **kwargs):
    return self.post(*args, **kwargs)