553 lines
20 KiB
Python
553 lines
20 KiB
Python
import functools
|
|
import warnings
|
|
|
|
from django.conf import settings
|
|
# Avoid shadowing the login() and logout() views below.
|
|
from django.contrib.auth import (
|
|
REDIRECT_FIELD_NAME, get_user_model, login as auth_login,
|
|
logout as auth_logout, update_session_auth_hash,
|
|
)
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth.forms import (
|
|
AuthenticationForm, PasswordChangeForm, PasswordResetForm, SetPasswordForm,
|
|
)
|
|
from django.contrib.auth.tokens import default_token_generator
|
|
from django.contrib.sites.shortcuts import get_current_site
|
|
from django.http import HttpResponseRedirect, QueryDict
|
|
from django.shortcuts import resolve_url
|
|
from django.template.response import TemplateResponse
|
|
from django.urls import reverse, reverse_lazy
|
|
from django.utils.decorators import method_decorator
|
|
from django.utils.deprecation import (
|
|
RemovedInDjango20Warning, RemovedInDjango21Warning,
|
|
)
|
|
from django.utils.encoding import force_text
|
|
from django.utils.http import is_safe_url, urlsafe_base64_decode
|
|
from django.utils.six.moves.urllib.parse import urlparse, urlunparse
|
|
from django.utils.translation import ugettext_lazy as _
|
|
from django.views.decorators.cache import never_cache
|
|
from django.views.decorators.csrf import csrf_protect
|
|
from django.views.decorators.debug import sensitive_post_parameters
|
|
from django.views.generic.base import TemplateView
|
|
from django.views.generic.edit import FormView
|
|
|
|
|
|
def deprecate_current_app(func):
|
|
"""
|
|
Handle deprecation of the current_app parameter of the views.
|
|
"""
|
|
@functools.wraps(func)
|
|
def inner(*args, **kwargs):
|
|
if 'current_app' in kwargs:
|
|
warnings.warn(
|
|
"Passing `current_app` as a keyword argument is deprecated. "
|
|
"Instead the caller of `{0}` should set "
|
|
"`request.current_app`.".format(func.__name__),
|
|
RemovedInDjango20Warning
|
|
)
|
|
current_app = kwargs.pop('current_app')
|
|
request = kwargs.get('request', None)
|
|
if request and current_app is not None:
|
|
request.current_app = current_app
|
|
return func(*args, **kwargs)
|
|
return inner
|
|
|
|
|
|
class LoginView(FormView):
|
|
"""
|
|
Displays the login form and handles the login action.
|
|
"""
|
|
form_class = AuthenticationForm
|
|
authentication_form = None
|
|
redirect_field_name = REDIRECT_FIELD_NAME
|
|
template_name = 'registration/login.html'
|
|
redirect_authenticated_user = False
|
|
extra_context = None
|
|
|
|
@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(LoginView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_success_url(self):
|
|
"""Ensure the user-originating redirection URL is safe."""
|
|
redirect_to = self.request.POST.get(
|
|
self.redirect_field_name,
|
|
self.request.GET.get(self.redirect_field_name, '')
|
|
)
|
|
if not is_safe_url(url=redirect_to, host=self.request.get_host()):
|
|
return resolve_url(settings.LOGIN_REDIRECT_URL)
|
|
return redirect_to
|
|
|
|
def get_form_class(self):
|
|
return self.authentication_form or self.form_class
|
|
|
|
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())
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(LoginView, self).get_context_data(**kwargs)
|
|
current_site = get_current_site(self.request)
|
|
context.update({
|
|
self.redirect_field_name: self.get_success_url(),
|
|
'site': current_site,
|
|
'site_name': current_site.name,
|
|
})
|
|
if self.extra_context is not None:
|
|
context.update(self.extra_context)
|
|
return context
|
|
|
|
|
|
@deprecate_current_app
|
|
def login(request, *args, **kwargs):
|
|
warnings.warn(
|
|
'The login() view is superseded by the class-based LoginView().',
|
|
RemovedInDjango21Warning, stacklevel=2
|
|
)
|
|
return LoginView.as_view(**kwargs)(request, *args, **kwargs)
|
|
|
|
|
|
class LogoutView(TemplateView):
|
|
"""
|
|
Logs out the user and displays 'You are logged out' message.
|
|
"""
|
|
next_page = None
|
|
redirect_field_name = REDIRECT_FIELD_NAME
|
|
template_name = 'registration/logged_out.html'
|
|
extra_context = None
|
|
|
|
@method_decorator(never_cache)
|
|
def dispatch(self, request, *args, **kwargs):
|
|
auth_logout(request)
|
|
next_page = self.get_next_page()
|
|
if next_page:
|
|
# Redirect to this page until the session has been cleared.
|
|
return HttpResponseRedirect(next_page)
|
|
return super(LogoutView, self).dispatch(request, *args, **kwargs)
|
|
|
|
def get_next_page(self):
|
|
if self.next_page is not None:
|
|
next_page = resolve_url(self.next_page)
|
|
elif settings.LOGOUT_REDIRECT_URL:
|
|
next_page = resolve_url(settings.LOGOUT_REDIRECT_URL)
|
|
else:
|
|
next_page = self.next_page
|
|
|
|
if (self.redirect_field_name in self.request.POST or
|
|
self.redirect_field_name in self.request.GET):
|
|
next_page = self.request.POST.get(
|
|
self.redirect_field_name,
|
|
self.request.GET.get(self.redirect_field_name)
|
|
)
|
|
# Security check -- don't allow redirection to a different host.
|
|
if not is_safe_url(url=next_page, host=self.request.get_host()):
|
|
next_page = self.request.path
|
|
return next_page
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(LogoutView, self).get_context_data(**kwargs)
|
|
current_site = get_current_site(self.request)
|
|
context.update({
|
|
'site': current_site,
|
|
'site_name': current_site.name,
|
|
'title': _('Logged out'),
|
|
})
|
|
if self.extra_context is not None:
|
|
context.update(self.extra_context)
|
|
return context
|
|
|
|
|
|
@deprecate_current_app
|
|
def logout(request, *args, **kwargs):
|
|
warnings.warn(
|
|
'The logout() view is superseded by the class-based LogoutView().',
|
|
RemovedInDjango21Warning, stacklevel=2
|
|
)
|
|
return LogoutView.as_view(**kwargs)(request, *args, **kwargs)
|
|
|
|
|
|
_sentinel = object()
|
|
|
|
|
|
@deprecate_current_app
|
|
def logout_then_login(request, login_url=None, extra_context=_sentinel):
|
|
"""
|
|
Logs out the user if they are logged in. Then redirects to the log-in page.
|
|
"""
|
|
if extra_context is not _sentinel:
|
|
warnings.warn(
|
|
"The unused `extra_context` parameter to `logout_then_login` "
|
|
"is deprecated.", RemovedInDjango21Warning
|
|
)
|
|
|
|
if not login_url:
|
|
login_url = settings.LOGIN_URL
|
|
login_url = resolve_url(login_url)
|
|
return LogoutView.as_view(next_page=login_url)(request)
|
|
|
|
|
|
def redirect_to_login(next, login_url=None,
|
|
redirect_field_name=REDIRECT_FIELD_NAME):
|
|
"""
|
|
Redirects the user to the login page, passing the given 'next' page
|
|
"""
|
|
resolved_url = resolve_url(login_url or settings.LOGIN_URL)
|
|
|
|
login_url_parts = list(urlparse(resolved_url))
|
|
if redirect_field_name:
|
|
querystring = QueryDict(login_url_parts[4], mutable=True)
|
|
querystring[redirect_field_name] = next
|
|
login_url_parts[4] = querystring.urlencode(safe='/')
|
|
|
|
return HttpResponseRedirect(urlunparse(login_url_parts))
|
|
|
|
|
|
# 4 views for password reset:
|
|
# - password_reset sends the mail
|
|
# - password_reset_done shows a success message for the above
|
|
# - password_reset_confirm checks the link the user clicked and
|
|
# prompts for a new password
|
|
# - password_reset_complete shows a success message for the above
|
|
|
|
@deprecate_current_app
|
|
@csrf_protect
|
|
def password_reset(request,
|
|
template_name='registration/password_reset_form.html',
|
|
email_template_name='registration/password_reset_email.html',
|
|
subject_template_name='registration/password_reset_subject.txt',
|
|
password_reset_form=PasswordResetForm,
|
|
token_generator=default_token_generator,
|
|
post_reset_redirect=None,
|
|
from_email=None,
|
|
extra_context=None,
|
|
html_email_template_name=None,
|
|
extra_email_context=None):
|
|
warnings.warn("The password_reset() view is superseded by the "
|
|
"class-based PasswordResetView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
if post_reset_redirect is None:
|
|
post_reset_redirect = reverse('password_reset_done')
|
|
else:
|
|
post_reset_redirect = resolve_url(post_reset_redirect)
|
|
if request.method == "POST":
|
|
form = password_reset_form(request.POST)
|
|
if form.is_valid():
|
|
opts = {
|
|
'use_https': request.is_secure(),
|
|
'token_generator': token_generator,
|
|
'from_email': from_email,
|
|
'email_template_name': email_template_name,
|
|
'subject_template_name': subject_template_name,
|
|
'request': request,
|
|
'html_email_template_name': html_email_template_name,
|
|
'extra_email_context': extra_email_context,
|
|
}
|
|
form.save(**opts)
|
|
return HttpResponseRedirect(post_reset_redirect)
|
|
else:
|
|
form = password_reset_form()
|
|
context = {
|
|
'form': form,
|
|
'title': _('Password reset'),
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
@deprecate_current_app
|
|
def password_reset_done(request,
|
|
template_name='registration/password_reset_done.html',
|
|
extra_context=None):
|
|
warnings.warn("The password_reset_done() view is superseded by the "
|
|
"class-based PasswordResetDoneView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
context = {
|
|
'title': _('Password reset sent'),
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
# Doesn't need csrf_protect since no-one can guess the URL
|
|
@sensitive_post_parameters()
|
|
@never_cache
|
|
@deprecate_current_app
|
|
def password_reset_confirm(request, uidb64=None, token=None,
|
|
template_name='registration/password_reset_confirm.html',
|
|
token_generator=default_token_generator,
|
|
set_password_form=SetPasswordForm,
|
|
post_reset_redirect=None,
|
|
extra_context=None):
|
|
"""
|
|
View that checks the hash in a password reset link and presents a
|
|
form for entering a new password.
|
|
"""
|
|
warnings.warn("The password_reset_confirm() view is superseded by the "
|
|
"class-based PasswordResetConfirmView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
UserModel = get_user_model()
|
|
assert uidb64 is not None and token is not None # checked by URLconf
|
|
if post_reset_redirect is None:
|
|
post_reset_redirect = reverse('password_reset_complete')
|
|
else:
|
|
post_reset_redirect = resolve_url(post_reset_redirect)
|
|
try:
|
|
# urlsafe_base64_decode() decodes to bytestring on Python 3
|
|
uid = force_text(urlsafe_base64_decode(uidb64))
|
|
user = UserModel._default_manager.get(pk=uid)
|
|
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
|
|
user = None
|
|
|
|
if user is not None and token_generator.check_token(user, token):
|
|
validlink = True
|
|
title = _('Enter new password')
|
|
if request.method == 'POST':
|
|
form = set_password_form(user, request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
return HttpResponseRedirect(post_reset_redirect)
|
|
else:
|
|
form = set_password_form(user)
|
|
else:
|
|
validlink = False
|
|
form = None
|
|
title = _('Password reset unsuccessful')
|
|
context = {
|
|
'form': form,
|
|
'title': title,
|
|
'validlink': validlink,
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
@deprecate_current_app
|
|
def password_reset_complete(request,
|
|
template_name='registration/password_reset_complete.html',
|
|
extra_context=None):
|
|
warnings.warn("The password_reset_complete() view is superseded by the "
|
|
"class-based PasswordResetCompleteView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
context = {
|
|
'login_url': resolve_url(settings.LOGIN_URL),
|
|
'title': _('Password reset complete'),
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
# Class-based password reset views
|
|
# - PasswordResetView sends the mail
|
|
# - PasswordResetDoneView shows a success message for the above
|
|
# - PasswordResetConfirmView checks the link the user clicked and
|
|
# prompts for a new password
|
|
# - PasswordResetCompleteView shows a success message for the above
|
|
|
|
class PasswordContextMixin(object):
|
|
extra_context = None
|
|
|
|
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
|
|
|
|
|
|
class PasswordResetView(PasswordContextMixin, FormView):
|
|
email_template_name = 'registration/password_reset_email.html'
|
|
extra_email_context = None
|
|
form_class = PasswordResetForm
|
|
from_email = None
|
|
html_email_template_name = None
|
|
subject_template_name = 'registration/password_reset_subject.txt'
|
|
success_url = reverse_lazy('password_reset_done')
|
|
template_name = 'registration/password_reset_form.html'
|
|
title = _('Password reset')
|
|
token_generator = default_token_generator
|
|
|
|
@method_decorator(csrf_protect)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(PasswordResetView, self).dispatch(*args, **kwargs)
|
|
|
|
def form_valid(self, form):
|
|
opts = {
|
|
'use_https': self.request.is_secure(),
|
|
'token_generator': self.token_generator,
|
|
'from_email': self.from_email,
|
|
'email_template_name': self.email_template_name,
|
|
'subject_template_name': self.subject_template_name,
|
|
'request': self.request,
|
|
'html_email_template_name': self.html_email_template_name,
|
|
'extra_email_context': self.extra_email_context,
|
|
}
|
|
form.save(**opts)
|
|
return super(PasswordResetView, self).form_valid(form)
|
|
|
|
|
|
class PasswordResetDoneView(PasswordContextMixin, TemplateView):
|
|
template_name = 'registration/password_reset_done.html'
|
|
title = _('Password reset sent')
|
|
|
|
|
|
class PasswordResetConfirmView(PasswordContextMixin, FormView):
|
|
form_class = SetPasswordForm
|
|
success_url = reverse_lazy('password_reset_complete')
|
|
template_name = 'registration/password_reset_confirm.html'
|
|
title = _('Enter new password')
|
|
token_generator = default_token_generator
|
|
|
|
@method_decorator(sensitive_post_parameters())
|
|
@method_decorator(never_cache)
|
|
def dispatch(self, *args, **kwargs):
|
|
assert 'uidb64' in kwargs and 'token' in kwargs
|
|
return super(PasswordResetConfirmView, self).dispatch(*args, **kwargs)
|
|
|
|
def get_user(self, uidb64):
|
|
UserModel = get_user_model()
|
|
try:
|
|
# urlsafe_base64_decode() decodes to bytestring on Python 3
|
|
uid = force_text(urlsafe_base64_decode(uidb64))
|
|
user = UserModel._default_manager.get(pk=uid)
|
|
except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
|
|
user = None
|
|
return user
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(PasswordResetConfirmView, self).get_form_kwargs()
|
|
kwargs['user'] = self.get_user(self.kwargs['uidb64'])
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
form.save()
|
|
return super(PasswordResetConfirmView, self).form_valid(form)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(PasswordResetConfirmView, self).get_context_data(**kwargs)
|
|
user = context['form'].user
|
|
if user is not None and self.token_generator.check_token(user, self.kwargs['token']):
|
|
context['validlink'] = True
|
|
else:
|
|
context.update({
|
|
'form': None,
|
|
'title': _('Password reset unsuccessful'),
|
|
'validlink': False,
|
|
})
|
|
return context
|
|
|
|
|
|
class PasswordResetCompleteView(PasswordContextMixin, TemplateView):
|
|
template_name = 'registration/password_reset_complete.html'
|
|
title = _('Password reset complete')
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super(PasswordResetCompleteView, self).get_context_data(**kwargs)
|
|
context['login_url'] = resolve_url(settings.LOGIN_URL)
|
|
return context
|
|
|
|
|
|
@sensitive_post_parameters()
|
|
@csrf_protect
|
|
@login_required
|
|
@deprecate_current_app
|
|
def password_change(request,
|
|
template_name='registration/password_change_form.html',
|
|
post_change_redirect=None,
|
|
password_change_form=PasswordChangeForm,
|
|
extra_context=None):
|
|
warnings.warn("The password_change() view is superseded by the "
|
|
"class-based PasswordChangeView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
if post_change_redirect is None:
|
|
post_change_redirect = reverse('password_change_done')
|
|
else:
|
|
post_change_redirect = resolve_url(post_change_redirect)
|
|
if request.method == "POST":
|
|
form = password_change_form(user=request.user, data=request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
# Updating the password logs out all other sessions for the user
|
|
# except the current one.
|
|
update_session_auth_hash(request, form.user)
|
|
return HttpResponseRedirect(post_change_redirect)
|
|
else:
|
|
form = password_change_form(user=request.user)
|
|
context = {
|
|
'form': form,
|
|
'title': _('Password change'),
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
@login_required
|
|
@deprecate_current_app
|
|
def password_change_done(request,
|
|
template_name='registration/password_change_done.html',
|
|
extra_context=None):
|
|
warnings.warn("The password_change_done() view is superseded by the "
|
|
"class-based PasswordChangeDoneView().",
|
|
RemovedInDjango21Warning, stacklevel=2)
|
|
context = {
|
|
'title': _('Password change successful'),
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context)
|
|
|
|
|
|
class PasswordChangeView(PasswordContextMixin, FormView):
|
|
form_class = PasswordChangeForm
|
|
success_url = reverse_lazy('password_change_done')
|
|
template_name = 'registration/password_change_form.html'
|
|
title = _('Password change')
|
|
|
|
@method_decorator(sensitive_post_parameters())
|
|
@method_decorator(csrf_protect)
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(PasswordChangeView, self).dispatch(*args, **kwargs)
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super(PasswordChangeView, self).get_form_kwargs()
|
|
kwargs['user'] = self.request.user
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
form.save()
|
|
# Updating the password logs out all other sessions for the user
|
|
# except the current one.
|
|
update_session_auth_hash(self.request, form.user)
|
|
return super(PasswordChangeView, self).form_valid(form)
|
|
|
|
|
|
class PasswordChangeDoneView(PasswordContextMixin, TemplateView):
|
|
template_name = 'registration/password_change_done.html'
|
|
title = _('Password change successful')
|
|
|
|
@method_decorator(login_required)
|
|
def dispatch(self, *args, **kwargs):
|
|
return super(PasswordChangeDoneView, self).dispatch(*args, **kwargs)
|