Debian Codegraph @

django/contrib/auth/views.py

raw
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)