| 1 |
from urllib.parse import urlsplit, urlunsplit |
| 2 |
|
| 3 |
from django.conf import settings |
| 4 |
|
| 5 |
# Avoid shadowing the login() and logout() views below. |
| 6 |
from django.contrib.auth import REDIRECT_FIELD_NAME, get_user_model |
| 7 |
from django.contrib.auth import login as auth_login |
| 8 |
from django.contrib.auth import logout as auth_logout |
| 9 |
from django.contrib.auth import update_session_auth_hash |
| 10 |
from django.contrib.auth.decorators import login_not_required, login_required |
| 11 |
from django.contrib.auth.forms import ( |
| 12 |
AuthenticationForm, |
| 13 |
PasswordChangeForm, |
| 14 |
PasswordResetForm, |
| 15 |
SetPasswordForm, |
| 16 |
) |
| 17 |
from django.contrib.auth.tokens import default_token_generator |
| 18 |
from django.contrib.sites.shortcuts import get_current_site |
| 19 |
from django.core.exceptions import ImproperlyConfigured, ValidationError |
| 20 |
from django.http import HttpResponseRedirect, QueryDict |
| 21 |
from django.shortcuts import resolve_url |
| 22 |
from django.urls import reverse_lazy |
| 23 |
from django.utils.decorators import method_decorator |
| 24 |
from django.utils.http import url_has_allowed_host_and_scheme, urlsafe_base64_decode |
| 25 |
from django.utils.translation import gettext_lazy as _ |
| 26 |
from django.views.decorators.cache import never_cache |
| 27 |
from django.views.decorators.csrf import csrf_protect |
| 28 |
from django.views.decorators.debug import sensitive_post_parameters |
| 29 |
from django.views.generic.base import TemplateView |
| 30 |
from django.views.generic.edit import FormView |
| 31 |
|
| 32 |
UserModel = get_user_model() |
| 33 |
|
| 34 |
|
| 35 |
class RedirectURLMixin: |
| 36 |
next_page = None |
| 37 |
redirect_field_name = REDIRECT_FIELD_NAME |
| 38 |
success_url_allowed_hosts = set() |
| 39 |
|
| 40 |
def get_success_url(self): |
| 41 |
return self.get_redirect_url() or self.get_default_redirect_url() |
| 42 |
|
| 43 |
def get_redirect_url(self): |
| 44 |
"""Return the user-originating redirect URL if it's safe.""" |
| 45 |
redirect_to = self.request.POST.get( |
| 46 |
self.redirect_field_name, self.request.GET.get(self.redirect_field_name) |
| 47 |
) |
| 48 |
url_is_safe = url_has_allowed_host_and_scheme( |
| 49 |
url=redirect_to, |
| 50 |
allowed_hosts=self.get_success_url_allowed_hosts(), |
| 51 |
require_https=self.request.is_secure(), |
| 52 |
) |
| 53 |
return redirect_to if url_is_safe else "" |
| 54 |
|
| 55 |
def get_success_url_allowed_hosts(self): |
| 56 |
return {self.request.get_host(), *self.success_url_allowed_hosts} |
| 57 |
|
| 58 |
def get_default_redirect_url(self): |
| 59 |
"""Return the default redirect URL.""" |
| 60 |
if self.next_page: |
| 61 |
return resolve_url(self.next_page) |
| 62 |
raise ImproperlyConfigured("No URL to redirect to. Provide a next_page.") |
| 63 |
|
| 64 |
|
| 65 |
@method_decorator(login_not_required, name="dispatch") |
| 66 |
class LoginView(RedirectURLMixin, FormView): |
| 67 |
""" |
| 68 |
Display the login form and handle the login action. |
| 69 |
""" |
| 70 |
|
| 71 |
form_class = AuthenticationForm |
| 72 |
authentication_form = None |
| 73 |
template_name = "registration/login.html" |
| 74 |
redirect_authenticated_user = False |
| 75 |
extra_context = None |
| 76 |
|
| 77 |
@method_decorator(sensitive_post_parameters()) |
| 78 |
@method_decorator(csrf_protect) |
| 79 |
@method_decorator(never_cache) |
| 80 |
def dispatch(self, request, *args, **kwargs): |
| 81 |
if self.redirect_authenticated_user and self.request.user.is_authenticated: |
| 82 |
redirect_to = self.get_success_url() |
| 83 |
if redirect_to == self.request.path: |
| 84 |
raise ValueError( |
| 85 |
"Redirection loop for authenticated user detected. Check that " |
| 86 |
"your LOGIN_REDIRECT_URL doesn't point to a login page." |
| 87 |
) |
| 88 |
return HttpResponseRedirect(redirect_to) |
| 89 |
return super().dispatch(request, *args, **kwargs) |
| 90 |
|
| 91 |
def get_default_redirect_url(self): |
| 92 |
"""Return the default redirect URL.""" |
| 93 |
if self.next_page: |
| 94 |
return resolve_url(self.next_page) |
| 95 |
else: |
| 96 |
return resolve_url(settings.LOGIN_REDIRECT_URL) |
| 97 |
|
| 98 |
def get_form_class(self): |
| 99 |
return self.authentication_form or self.form_class |
| 100 |
|
| 101 |
def get_form_kwargs(self): |
| 102 |
kwargs = super().get_form_kwargs() |
| 103 |
kwargs["request"] = self.request |
| 104 |
return kwargs |
| 105 |
|
| 106 |
def form_valid(self, form): |
| 107 |
"""Security check complete. Log the user in.""" |
| 108 |
auth_login(self.request, form.get_user()) |
| 109 |
return HttpResponseRedirect(self.get_success_url()) |
| 110 |
|
| 111 |
def get_context_data(self, **kwargs): |
| 112 |
context = super().get_context_data(**kwargs) |
| 113 |
current_site = get_current_site(self.request) |
| 114 |
context.update( |
| 115 |
{ |
| 116 |
self.redirect_field_name: self.get_redirect_url(), |
| 117 |
"site": current_site, |
| 118 |
"site_name": current_site.name, |
| 119 |
**(self.extra_context or {}), |
| 120 |
} |
| 121 |
) |
| 122 |
return context |
| 123 |
|
| 124 |
|
| 125 |
class LogoutView(RedirectURLMixin, TemplateView): |
| 126 |
""" |
| 127 |
Log out the user and display the 'You are logged out' message. |
| 128 |
""" |
| 129 |
|
| 130 |
http_method_names = ["post", "options"] |
| 131 |
template_name = "registration/logged_out.html" |
| 132 |
extra_context = None |
| 133 |
|
| 134 |
@method_decorator(csrf_protect) |
| 135 |
@method_decorator(never_cache) |
| 136 |
def dispatch(self, request, *args, **kwargs): |
| 137 |
return super().dispatch(request, *args, **kwargs) |
| 138 |
|
| 139 |
def post(self, request, *args, **kwargs): |
| 140 |
"""Logout may be done via POST.""" |
| 141 |
auth_logout(request) |
| 142 |
redirect_to = self.get_success_url() |
| 143 |
if redirect_to != request.get_full_path(): |
| 144 |
# Redirect to target page once the session has been cleared. |
| 145 |
return HttpResponseRedirect(redirect_to) |
| 146 |
return super().get(request, *args, **kwargs) |
| 147 |
|
| 148 |
def get_default_redirect_url(self): |
| 149 |
"""Return the default redirect URL.""" |
| 150 |
if self.next_page: |
| 151 |
return resolve_url(self.next_page) |
| 152 |
elif settings.LOGOUT_REDIRECT_URL: |
| 153 |
return resolve_url(settings.LOGOUT_REDIRECT_URL) |
| 154 |
else: |
| 155 |
return self.request.path |
| 156 |
|
| 157 |
def get_context_data(self, **kwargs): |
| 158 |
context = super().get_context_data(**kwargs) |
| 159 |
current_site = get_current_site(self.request) |
| 160 |
context.update( |
| 161 |
{ |
| 162 |
"site": current_site, |
| 163 |
"site_name": current_site.name, |
| 164 |
"title": _("Logged out"), |
| 165 |
"subtitle": None, |
| 166 |
**(self.extra_context or {}), |
| 167 |
} |
| 168 |
) |
| 169 |
return context |
| 170 |
|
| 171 |
|
| 172 |
def logout_then_login(request, login_url=None): |
| 173 |
""" |
| 174 |
Log out the user if they are logged in. Then redirect to the login page. |
| 175 |
""" |
| 176 |
login_url = resolve_url(login_url or settings.LOGIN_URL) |
| 177 |
return LogoutView.as_view(next_page=login_url)(request) |
| 178 |
|
| 179 |
|
| 180 |
def redirect_to_login(next, login_url=None, redirect_field_name=REDIRECT_FIELD_NAME): |
| 181 |
""" |
| 182 |
Redirect the user to the login page, passing the given 'next' page. |
| 183 |
""" |
| 184 |
resolved_url = resolve_url(login_url or settings.LOGIN_URL) |
| 185 |
|
| 186 |
login_url_parts = list(urlsplit(resolved_url)) |
| 187 |
if redirect_field_name: |
| 188 |
querystring = QueryDict(login_url_parts[3], mutable=True) |
| 189 |
querystring[redirect_field_name] = next |
| 190 |
login_url_parts[3] = querystring.urlencode(safe="/") |
| 191 |
|
| 192 |
return HttpResponseRedirect(urlunsplit(login_url_parts)) |
| 193 |
|
| 194 |
|
| 195 |
# Class-based password reset views |
| 196 |
# - PasswordResetView sends the mail |
| 197 |
# - PasswordResetDoneView shows a success message for the above |
| 198 |
# - PasswordResetConfirmView checks the link the user clicked and |
| 199 |
# prompts for a new password |
| 200 |
# - PasswordResetCompleteView shows a success message for the above |
| 201 |
|
| 202 |
|
| 203 |
class PasswordContextMixin: |
| 204 |
extra_context = None |
| 205 |
|
| 206 |
def get_context_data(self, **kwargs): |
| 207 |
context = super().get_context_data(**kwargs) |
| 208 |
context.update( |
| 209 |
{"title": self.title, "subtitle": None, **(self.extra_context or {})} |
| 210 |
) |
| 211 |
return context |
| 212 |
|
| 213 |
|
| 214 |
@method_decorator(login_not_required, name="dispatch") |
| 215 |
class PasswordResetView(PasswordContextMixin, FormView): |
| 216 |
email_template_name = "registration/password_reset_email.html" |
| 217 |
extra_email_context = None |
| 218 |
form_class = PasswordResetForm |
| 219 |
from_email = None |
| 220 |
html_email_template_name = None |
| 221 |
subject_template_name = "registration/password_reset_subject.txt" |
| 222 |
success_url = reverse_lazy("password_reset_done") |
| 223 |
template_name = "registration/password_reset_form.html" |
| 224 |
title = _("Password reset") |
| 225 |
token_generator = default_token_generator |
| 226 |
|
| 227 |
@method_decorator(csrf_protect) |
| 228 |
def dispatch(self, *args, **kwargs): |
| 229 |
return super().dispatch(*args, **kwargs) |
| 230 |
|
| 231 |
def form_valid(self, form): |
| 232 |
opts = { |
| 233 |
"use_https": self.request.is_secure(), |
| 234 |
"token_generator": self.token_generator, |
| 235 |
"from_email": self.from_email, |
| 236 |
"email_template_name": self.email_template_name, |
| 237 |
"subject_template_name": self.subject_template_name, |
| 238 |
"request": self.request, |
| 239 |
"html_email_template_name": self.html_email_template_name, |
| 240 |
"extra_email_context": self.extra_email_context, |
| 241 |
} |
| 242 |
form.save(**opts) |
| 243 |
return super().form_valid(form) |
| 244 |
|
| 245 |
|
| 246 |
INTERNAL_RESET_SESSION_TOKEN = "_password_reset_token" |
| 247 |
|
| 248 |
|
| 249 |
@method_decorator(login_not_required, name="dispatch") |
| 250 |
class PasswordResetDoneView(PasswordContextMixin, TemplateView): |
| 251 |
template_name = "registration/password_reset_done.html" |
| 252 |
title = _("Password reset sent") |
| 253 |
|
| 254 |
|
| 255 |
@method_decorator(login_not_required, name="dispatch") |
| 256 |
class PasswordResetConfirmView(PasswordContextMixin, FormView): |
| 257 |
form_class = SetPasswordForm |
| 258 |
post_reset_login = False |
| 259 |
post_reset_login_backend = None |
| 260 |
reset_url_token = "set-password" |
| 261 |
success_url = reverse_lazy("password_reset_complete") |
| 262 |
template_name = "registration/password_reset_confirm.html" |
| 263 |
title = _("Enter new password") |
| 264 |
token_generator = default_token_generator |
| 265 |
|
| 266 |
@method_decorator(sensitive_post_parameters()) |
| 267 |
@method_decorator(never_cache) |
| 268 |
def dispatch(self, *args, **kwargs): |
| 269 |
if "uidb64" not in kwargs or "token" not in kwargs: |
| 270 |
raise ImproperlyConfigured( |
| 271 |
"The URL path must contain 'uidb64' and 'token' parameters." |
| 272 |
) |
| 273 |
|
| 274 |
self.validlink = False |
| 275 |
self.user = self.get_user(kwargs["uidb64"]) |
| 276 |
|
| 277 |
if self.user is not None: |
| 278 |
token = kwargs["token"] |
| 279 |
if token == self.reset_url_token: |
| 280 |
session_token = self.request.session.get(INTERNAL_RESET_SESSION_TOKEN) |
| 281 |
if self.token_generator.check_token(self.user, session_token): |
| 282 |
# If the token is valid, display the password reset form. |
| 283 |
self.validlink = True |
| 284 |
return super().dispatch(*args, **kwargs) |
| 285 |
else: |
| 286 |
if self.token_generator.check_token(self.user, token): |
| 287 |
# Store the token in the session and redirect to the |
| 288 |
# password reset form at a URL without the token. That |
| 289 |
# avoids the possibility of leaking the token in the |
| 290 |
# HTTP Referer header. |
| 291 |
self.request.session[INTERNAL_RESET_SESSION_TOKEN] = token |
| 292 |
redirect_url = self.request.path.replace( |
| 293 |
token, self.reset_url_token |
| 294 |
) |
| 295 |
return HttpResponseRedirect(redirect_url) |
| 296 |
|
| 297 |
# Display the "Password reset unsuccessful" page. |
| 298 |
return self.render_to_response(self.get_context_data()) |
| 299 |
|
| 300 |
def get_user(self, uidb64): |
| 301 |
try: |
| 302 |
# urlsafe_base64_decode() decodes to bytestring |
| 303 |
uid = urlsafe_base64_decode(uidb64).decode() |
| 304 |
pk = UserModel._meta.pk.to_python(uid) |
| 305 |
user = UserModel._default_manager.get(pk=pk) |
| 306 |
except ( |
| 307 |
TypeError, |
| 308 |
ValueError, |
| 309 |
OverflowError, |
| 310 |
UserModel.DoesNotExist, |
| 311 |
ValidationError, |
| 312 |
): |
| 313 |
user = None |
| 314 |
return user |
| 315 |
|
| 316 |
def get_form_kwargs(self): |
| 317 |
kwargs = super().get_form_kwargs() |
| 318 |
kwargs["user"] = self.user |
| 319 |
return kwargs |
| 320 |
|
| 321 |
def form_valid(self, form): |
| 322 |
user = form.save() |
| 323 |
del self.request.session[INTERNAL_RESET_SESSION_TOKEN] |
| 324 |
if self.post_reset_login: |
| 325 |
auth_login(self.request, user, self.post_reset_login_backend) |
| 326 |
return super().form_valid(form) |
| 327 |
|
| 328 |
def get_context_data(self, **kwargs): |
| 329 |
context = super().get_context_data(**kwargs) |
| 330 |
if self.validlink: |
| 331 |
context["validlink"] = True |
| 332 |
else: |
| 333 |
context.update( |
| 334 |
{ |
| 335 |
"form": None, |
| 336 |
"title": _("Password reset unsuccessful"), |
| 337 |
"validlink": False, |
| 338 |
} |
| 339 |
) |
| 340 |
return context |
| 341 |
|
| 342 |
|
| 343 |
@method_decorator(login_not_required, name="dispatch") |
| 344 |
class PasswordResetCompleteView(PasswordContextMixin, TemplateView): |
| 345 |
template_name = "registration/password_reset_complete.html" |
| 346 |
title = _("Password reset complete") |
| 347 |
|
| 348 |
def get_context_data(self, **kwargs): |
| 349 |
context = super().get_context_data(**kwargs) |
| 350 |
context["login_url"] = resolve_url(settings.LOGIN_URL) |
| 351 |
return context |
| 352 |
|
| 353 |
|
| 354 |
class PasswordChangeView(PasswordContextMixin, FormView): |
| 355 |
form_class = PasswordChangeForm |
| 356 |
success_url = reverse_lazy("password_change_done") |
| 357 |
template_name = "registration/password_change_form.html" |
| 358 |
title = _("Password change") |
| 359 |
|
| 360 |
@method_decorator(sensitive_post_parameters()) |
| 361 |
@method_decorator(csrf_protect) |
| 362 |
@method_decorator(login_required) |
| 363 |
def dispatch(self, *args, **kwargs): |
| 364 |
return super().dispatch(*args, **kwargs) |
| 365 |
|
| 366 |
def get_form_kwargs(self): |
| 367 |
kwargs = super().get_form_kwargs() |
| 368 |
kwargs["user"] = self.request.user |
| 369 |
return kwargs |
| 370 |
|
| 371 |
def form_valid(self, form): |
| 372 |
form.save() |
| 373 |
# Updating the password logs out all other sessions for the user |
| 374 |
# except the current one. |
| 375 |
update_session_auth_hash(self.request, form.user) |
| 376 |
return super().form_valid(form) |
| 377 |
|
| 378 |
|
| 379 |
class PasswordChangeDoneView(PasswordContextMixin, TemplateView): |
| 380 |
template_name = "registration/password_change_done.html" |
| 381 |
title = _("Password change successful") |
| 382 |
|
| 383 |
@method_decorator(login_required) |
| 384 |
def dispatch(self, *args, **kwargs): |
| 385 |
return super().dispatch(*args, **kwargs) |