class LoginView

from django.contrib.auth.views import LoginView
Display the login form and handle the login action.

Attributes

  Defined in
authentication_form = None LoginView
content_type = None TemplateResponseMixin
extra_context = None ContextMixin
form_class = <class 'django.contrib.auth.forms.AuthenticationForm'> LoginView
form_class = None FormMixin
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
initial = {} FormMixin
prefix = None FormMixin
redirect_authenticated_user = False LoginView
redirect_field_name = 'next' LoginView
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
success_url = None FormMixin
success_url_allowed_hosts = set() SuccessURLAllowedHostsMixin
template_engine = None TemplateResponseMixin
template_name = 'registration/login.html' LoginView
template_name = None TemplateResponseMixin
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
38
39
40
41
42
43
44
45
46
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

114
115
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.
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
76
77
@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
    # 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):

LoginView

51
52
53
54
55
56
57
58
59
60
61
62
63
@method_decorator(sensitive_post_parameters())
@method_decorator(csrf_protect)
@method_decorator(never_cache)
def dispatch(self, request, *args, **kwargs):
    if self.redirect_authenticated_user and self.request.user.is_authenticated:
        redirect_to = self.get_success_url()
        if redirect_to == self.request.path:
            raise ValueError(
                "Redirection loop for authenticated user detected. Check that "
                "your LOGIN_REDIRECT_URL doesn't point to a login page."
            )
        return HttpResponseRedirect(redirect_to)
    return super().dispatch(request, *args, **kwargs)

View

90
91
92
93
94
95
96
97
98
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, render the invalid form.
59
60
61
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):

LoginView

Security check complete. Log the user in.
90
91
92
93
def form_valid(self, form):
    """Security check complete. Log the user in."""
    auth_login(self.request, form.get_user())
    return HttpResponseRedirect(self.get_success_url())

FormMixin

If the form is valid, redirect to the supplied URL.
55
56
57
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

Handle GET requests: instantiate a blank version of the form.
131
132
133
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):

LoginView

Insert the form into the context dict.
 95
 96
 97
 98
 99
100
101
102
103
104
def get_context_data(self, **kwargs):
    context = super().get_context_data(**kwargs)
    current_site = get_current_site(self.request)
    context.update({
        self.redirect_field_name: self.get_redirect_url(),
        'site': current_site,
        'site_name': current_site.name,
        **(self.extra_context or {})
    })
    return context

FormMixin

Insert the form into the context dict.
63
64
65
66
67
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

23
24
25
26
27
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_form(self, form_class=None): FormMixin

Return an instance of the form to be used in this view.
29
30
31
32
33
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):

LoginView

Return the form class to use.
82
83
def get_form_class(self):
    return self.authentication_form or self.form_class

FormMixin

Return the form class to use.
25
26
27
def get_form_class(self):
    """Return the form class to use."""
    return self.form_class

def get_form_kwargs(self):

LoginView

Return the keyword arguments for instantiating the form.
85
86
87
88
def get_form_kwargs(self):
    kwargs = super().get_form_kwargs()
    kwargs['request'] = self.request
    return kwargs

FormMixin

Return the keyword arguments for instantiating the form.
35
36
37
38
39
40
41
42
43
44
45
46
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

Return the initial data to use for forms on this view.
17
18
19
def get_initial(self):
    """Return the initial data to use for forms on this view."""
    return self.initial.copy()

def get_prefix(self): FormMixin

Return the prefix to use for forms.
21
22
23
def get_prefix(self):
    """Return the prefix to use for forms."""
    return self.prefix

def get_redirect_url(self): LoginView

Return the user-originating redirect URL if it's safe.
69
70
71
72
73
74
75
76
77
78
79
80
def get_redirect_url(self):
    """Return the user-originating redirect URL if it's safe."""
    redirect_to = self.request.POST.get(
        self.redirect_field_name,
        self.request.GET.get(self.redirect_field_name, '')
    )
    url_is_safe = url_has_allowed_host_and_scheme(
        url=redirect_to,
        allowed_hosts=self.get_success_url_allowed_hosts(),
        require_https=self.request.is_secure(),
    )
    return redirect_to if url_is_safe else ''

def get_success_url(self):

LoginView

Return the URL to redirect to after processing a valid form.
65
66
67
def get_success_url(self):
    url = self.get_redirect_url()
    return url or resolve_url(settings.LOGIN_REDIRECT_URL)

FormMixin

Return the URL to redirect to after processing a valid form.
49
50
51
52
53
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_success_url_allowed_hosts(self): SuccessURLAllowedHostsMixin

36
37
def get_success_url_allowed_hosts(self):
    return {self.request.get_host(), *self.success_url_allowed_hosts}

def get_template_names(self): 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.
141
142
143
144
145
146
147
148
149
150
151
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

100
101
102
103
104
105
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

Handle responding to requests for the OPTIONS HTTP verb.
107
108
109
110
111
112
def options(self, request, *args, **kwargs):
    """Handle responding to requests for the OPTIONS HTTP verb."""
    response = HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

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

Handle POST requests: instantiate a form instance with the passed
POST variables and then check if it's valid.
135
136
137
138
139
140
141
142
143
144
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

148
149
def put(self, *args, **kwargs):
    return self.post(*args, **kwargs)

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.
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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

Initialize attributes shared by all view methods.
82
83
84
85
86
87
88
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