ccbv.co.uk

class PasswordChangeDoneView

from django.contrib.auth.views import PasswordChangeDoneView
Hierarchy diagram Documentation Source code 
A view that renders a template.  This view will also pass into the context
any keyword arguments passed by the URLconf.

Ancestors (MRO)

  1. PasswordChangeDoneView
  2. PasswordContextMixin
  3. TemplateView
  4. TemplateResponseMixin
  5. ContextMixin
  6. View

Attributes

  Defined in
content_type = None TemplateResponseMixin
extra_context = None PasswordContextMixin
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
template_engine = None TemplateResponseMixin
template_name = 'registration/password_change_done.html' PasswordChangeDoneView
template_name = None TemplateResponseMixin
title = ugettext_lazy('Password change successful') PasswordChangeDoneView
Expand Collapse

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 _allowed_methods(self): View 

106
107
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
75
@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("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)
    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, *args, **kwargs):

PasswordChangeDoneView

 
629
630
631
@method_decorator(login_required)
def dispatch(self, *args, **kwargs):
    return super(PasswordChangeDoneView, self).dispatch(*args, **kwargs)

View

 
80
81
82
83
84
85
86
87
88
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 get(self, request, *args, **kwargs): TemplateView 

154
155
156
def get(self, request, *args, **kwargs):
    context = self.get_context_data(**kwargs)
    return self.render_to_response(context)

def get_context_data(self, **kwargs):

PasswordContextMixin

 
417
418
419
420
421
422
def get_context_data(self, **kwargs):
    context = super(PasswordContextMixin, self).get_context_data(**kwargs)
    context['title'] = self.title
    if self.extra_context is not None:
        context.update(self.extra_context)
    return context

ContextMixin

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

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.
136
137
138
139
140
141
142
143
144
145
146
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 

90
91
92
93
94
95
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 http.HttpResponseNotAllowed(self._allowed_methods())

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

Handles responding to requests for the OPTIONS HTTP verb.
 97
 98
 99
100
101
102
103
104
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 render_to_response(self, context, **response_kwargs): TemplateResponseMixin 

Returns a response, using the `response_class` for this
view, with a template rendered with the given context.

If any keyword arguments are provided, they will be
passed to the constructor of the response class.
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
def render_to_response(self, context, **response_kwargs):
    """
    Returns a response, using the `response_class` for this
    view, with a template rendered with the given context.
    If any keyword arguments are provided, they will be
    passed 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
    )