Django (2024)

/

$ python manage.py createsuperuser --username=joe --email=joe@example.com

...\> py manage.py createsuperuser --username=joe --email=joe@example.com

myuser.groups.set([group_list])myuser.groups.add(group, group, ...)myuser.groups.remove(group, group, ...)myuser.groups.clear()myuser.user_permissions.set([permission_list])myuser.user_permissions.add(permission, permission, ...)myuser.user_permissions.remove(permission, permission, ...)myuser.user_permissions.clear()

Proxy models need their own content type

If you want to create permissions for a proxy model, pass for_concrete_model=False toContentTypeManager.get_for_model() to get the appropriateContentType:

content_type = ContentType.objects.get_for_model( BlogPostProxy, for_concrete_model=False)

if request.user.is_authenticated: # Do something for authenticated users. ...else: # Do something for anonymous users. ...

Selecting the authentication backend¶

When a user logs in, the user’s ID and the backend that was used forauthentication are saved in the user’s session. This allows the sameauthentication backend to fetch the user’sdetails on a future request. The authentication backend to save in the sessionis selected as follows:

1. Use the value of the optional backend argument, if provided.
2. Use the value of the user.backend attribute, if present. This allowspairing authenticate() andlogin():authenticate()sets the user.backend attribute on the user object it returns.
3. Use the backend in AUTHENTICATION_BACKENDS, if there is onlyone.
4. Otherwise, raise an exception.

In cases 1 and 2, the value of the backend argument or the user.backendattribute should be a dotted import path string (like that found inAUTHENTICATION_BACKENDS), not the actual backend class.

The raw way¶

The raw way to limit access to pages is to checkrequest.user.is_authenticated and either redirect to alogin page:

from django.conf import settingsfrom django.shortcuts import redirectdef my_view(request): if not request.user.is_authenticated: return redirect(f"{settings.LOGIN_URL}?next={request.path}") # ...

…or display an error message:

from django.shortcuts import renderdef my_view(request): if not request.user.is_authenticated: return render(request, "myapp/login_error.html") # ...

The login_required decorator¶

login_required(redirect_field_name='next', login_url=None)¶

As a shortcut, you can use the convenientlogin_required() decorator:

from django.contrib.auth.decorators import login_required@login_requireddef my_view(request): ...

login_required() does the following:

• If the user isn’t logged in, redirect tosettings.LOGIN_URL, passing the current absolutepath in the query string. Example: /accounts/login/?next=/polls/3/.
• If the user is logged in, execute the view normally. The view code isfree to assume the user is logged in.

By default, the path that the user should be redirected to uponsuccessful authentication is stored in a query string parameter called"next". If you would prefer to use a different name for this parameter,login_required() takes anoptional redirect_field_name parameter:

from django.contrib.auth.decorators import login_required@login_required(redirect_field_name="my_redirect_field")def my_view(request): ...

Note that if you provide a value to redirect_field_name, you will mostlikely need to customize your login template as well, since the templatecontext variable which stores the redirect path will use the value ofredirect_field_name as its key rather than "next" (the default).

login_required() also takes anoptional login_url parameter. Example:

from django.contrib.auth.decorators import login_required@login_required(login_url="/accounts/login/")def my_view(request): ...

Note that if you don’t specify the login_url parameter, you’ll need toensure that the settings.LOGIN_URL and your loginview are properly associated. For example, using the defaults, add thefollowing lines to your URLconf:

from django.contrib.auth import views as auth_viewspath("accounts/login/", auth_views.LoginView.as_view()),

The settings.LOGIN_URL also accepts view functionnames and named URL patterns. This allows youto freely remap your login view within your URLconf without having toupdate the setting.

The LoginRequiredMixin mixin¶

When using class-based views, you canachieve the same behavior as with login_required by using theLoginRequiredMixin. This mixin should be at the leftmost position in theinheritance list.

class LoginRequiredMixin¶

If a view is using this mixin, all requests by non-authenticated users willbe redirected to the login page or shown an HTTP 403 Forbidden error,depending on theraise_exception parameter.

You can set any of the parameters ofAccessMixin to customize the handlingof unauthorized users:

from django.contrib.auth.mixins import LoginRequiredMixinclass MyView(LoginRequiredMixin, View): login_url = "/login/" redirect_field_name = "redirect_to"

Limiting access to logged-in users that pass a test¶

To limit access based on certain permissions or some other test, you’d doessentially the same thing as described in the previous section.

You can run your test on request.user inthe view directly. For example, this view checks to make sure the user has anemail in the desired domain and if not, redirects to the login page:

from django.shortcuts import redirectdef my_view(request): if not request.user.email.endswith("@example.com"): return redirect("/login/?next=%s" % request.path) # ...

user_passes_test(test_func, login_url=None, redirect_field_name='next')¶

As a shortcut, you can use the convenient user_passes_test decoratorwhich performs a redirect when the callable returns False:

from django.contrib.auth.decorators import user_passes_testdef email_check(user): return user.email.endswith("@example.com")@user_passes_test(email_check)def my_view(request): ...

user_passes_test() takes a requiredargument: a callable that takes aUser object and returns True ifthe user is allowed to view the page. Note thatuser_passes_test() does notautomatically check that the User isnot anonymous.

user_passes_test() takes twooptional arguments:

login_url

Lets you specify the URL that users who don’t pass the test will beredirected to. It may be a login page and defaults tosettings.LOGIN_URL if you don’t specify one.

redirect_field_name

Same as for login_required().Setting it to None removes it from the URL, which you may want to doif you are redirecting users that don’t pass the test to a non-loginpage where there’s no “next page”.

For example:

@user_passes_test(email_check, login_url="/login/")def my_view(request): ...

class UserPassesTestMixin¶

When using class-based views, youcan use the UserPassesTestMixin to do this.

test_func()¶

You have to override the test_func() method of the class toprovide the test that is performed. Furthermore, you can set any of theparameters of AccessMixin tocustomize the handling of unauthorized users:

from django.contrib.auth.mixins import UserPassesTestMixinclass MyView(UserPassesTestMixin, View): def test_func(self): return self.request.user.email.endswith("@example.com")

get_test_func()¶

You can also override the get_test_func() method to have the mixinuse a differently named function for its checks (instead oftest_func()).

Stacking UserPassesTestMixin

Due to the way UserPassesTestMixin is implemented, you cannot stackthem in your inheritance list. The following does NOT work:

class TestMixin1(UserPassesTestMixin): def test_func(self): return self.request.user.email.endswith("@example.com")class TestMixin2(UserPassesTestMixin): def test_func(self): return self.request.user.username.startswith("django")class MyView(TestMixin1, TestMixin2, View): ...

If TestMixin1 would call super() and take that result intoaccount, TestMixin1 wouldn’t work standalone anymore.

The permission_required decorator¶

permission_required(perm, login_url=None, raise_exception=False)¶

It’s a relatively common task to check whether a user has a particularpermission. For that reason, Django provides a shortcut for that case: thepermission_required() decorator.:

from django.contrib.auth.decorators import permission_required@permission_required("polls.add_choice")def my_view(request): ...

Just like the has_perm() method,permission names take the form "<app label>.<permission codename>"(i.e. polls.add_choice for a permission on a model in the pollsapplication).

The decorator may also take an iterable of permissions, in which case theuser must have all of the permissions in order to access the view.

Note that permission_required()also takes an optional login_url parameter:

from django.contrib.auth.decorators import permission_required@permission_required("polls.add_choice", login_url="/loginpage/")def my_view(request): ...

As in the login_required() decorator,login_url defaults to settings.LOGIN_URL.

If the raise_exception parameter is given, the decorator will raisePermissionDenied, prompting the 403(HTTP Forbidden) view instead of redirecting to thelogin page.

If you want to use raise_exception but also give your users a chance tologin first, you can add thelogin_required() decorator:

from django.contrib.auth.decorators import login_required, permission_required@login_required@permission_required("polls.add_choice", raise_exception=True)def my_view(request): ...

This also avoids a redirect loop when LoginView’sredirect_authenticated_user=True and the logged-in user doesn’t haveall of the required permissions.

The PermissionRequiredMixin mixin¶

To apply permission checks to class-based views, you can use the PermissionRequiredMixin:

class PermissionRequiredMixin¶

This mixin, just like the permission_requireddecorator, checks whether the user accessing a view has all givenpermissions. You should specify the permission (or an iterable ofpermissions) using the permission_required parameter:

from django.contrib.auth.mixins import PermissionRequiredMixinclass MyView(PermissionRequiredMixin, View): permission_required = "polls.add_choice" # Or multiple of permissions: permission_required = ["polls.view_choice", "polls.change_choice"]

You can set any of the parameters ofAccessMixin to customize the handlingof unauthorized users.

You may also override these methods:

get_permission_required()¶

Returns an iterable of permission names used by the mixin. Defaults tothe permission_required attribute, converted to a tuple ifnecessary.

has_permission()¶

Returns a boolean denoting whether the current user has permission toexecute the decorated view. By default, this returns the result ofcalling has_perms() with thelist of permissions returned by get_permission_required().

Session invalidation on password change¶

If your AUTH_USER_MODEL inherits fromAbstractBaseUser or implements its ownget_session_auth_hash()method, authenticated sessions will include the hash returned by this function.In the AbstractBaseUser case, this is anHMAC of the password field. Django verifies that the hash in the session foreach request matches the one that’s computed during the request. This allows auser to log out all of their sessions by changing their password.

The default password change views included with Django,PasswordChangeView and theuser_change_password view in the django.contrib.auth admin, updatethe session with the new password hash so that a user changing their ownpassword won’t log themselves out. If you have a custom password change viewand wish to have similar behavior, use the update_session_auth_hash()function.

update_session_auth_hash(request, user)¶

This function takes the current request and the updated user object fromwhich the new session hash will be derived and updates the session hashappropriately. It also rotates the session key so that a stolen sessioncookie will be invalidated.

Example usage:

from django.contrib.auth import update_session_auth_hashdef password_change(request): if request.method == "POST": form = PasswordChangeForm(user=request.user, data=request.POST) if form.is_valid(): form.save() update_session_auth_hash(request, form.user) else: ...

Using the views¶

There are different methods to implement these views in your project. Theeasiest way is to include the provided URLconf in django.contrib.auth.urlsin your own URLconf, for example:

urlpatterns = [ path("accounts/", include("django.contrib.auth.urls")),]

This will include the following URL patterns:

accounts/login/ [name='login']accounts/logout/ [name='logout']accounts/password_change/ [name='password_change']accounts/password_change/done/ [name='password_change_done']accounts/password_reset/ [name='password_reset']accounts/password_reset/done/ [name='password_reset_done']accounts/reset/<uidb64>/<token>/ [name='password_reset_confirm']accounts/reset/done/ [name='password_reset_complete']

The views provide a URL name for easier reference. See the URLdocumentation for details on using named URL patterns.

If you want more control over your URLs, you can reference a specific view inyour URLconf:

from django.contrib.auth import views as auth_viewsurlpatterns = [ path("change-password/", auth_views.PasswordChangeView.as_view()),]

The views have optional arguments you can use to alter the behavior of theview. For example, if you want to change the template name a view uses, you canprovide the template_name argument. A way to do this is to provide keywordarguments in the URLconf, these will be passed on to the view. For example:

urlpatterns = [ path( "change-password/", auth_views.PasswordChangeView.as_view(template_name="change-password.html"), ),]

All views are class-based, which allowsyou to easily customize them by subclassing.

All authentication views¶

This is a list with all the views django.contrib.auth provides. Forimplementation details see Using the views.

class LoginView¶

URL name: login

See the URL documentation for details on usingnamed URL patterns.

Methods and Attributes

template_name¶

The name of a template to display for the view used to log the user in.Defaults to registration/login.html.

next_page¶

The URL to redirect to after login. Defaults toLOGIN_REDIRECT_URL.

redirect_field_name¶

The name of a GET field containing the URL to redirect to afterlogin. Defaults to next. Overrides theget_default_redirect_url() URL if the given GET parameter ispassed.

authentication_form¶

A callable (typically a form class) to use for authentication. Defaultsto AuthenticationForm.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

redirect_authenticated_user¶

A boolean that controls whether or not authenticated users accessingthe login page will be redirected as if they had just successfullylogged in. Defaults to False.

Warning

If you enable redirect_authenticated_user, other websites willbe able to determine if their visitors are authenticated on yoursite by requesting redirect URLs to image files on your website. Toavoid this “social media fingerprinting” informationleakage, host all images and your favicon on a separate domain.

Enabling redirect_authenticated_user can also result in aredirect loop when using the permission_required() decoratorunless the raise_exception parameter is used.

success_url_allowed_hosts¶

A set of hosts, in addition to request.get_host(), that are safe for redirectingafter login. Defaults to an empty set.

get_default_redirect_url()¶

Returns the URL to redirect to after login. The default implementationresolves and returns next_page if set, orLOGIN_REDIRECT_URL otherwise.

Here’s what LoginView does:

• If called via GET, it displays a login form that POSTs to thesame URL. More on this in a bit.
• If called via POST with user submitted credentials, it tries to logthe user in. If login is successful, the view redirects to the URLspecified in next. If next isn’t provided, it redirects tosettings.LOGIN_REDIRECT_URL (whichdefaults to /accounts/profile/). If login isn’t successful, itredisplays the login form.

It’s your responsibility to provide the html for the login template, called registration/login.html by default. This template gets passedfour template context variables:

• form: A Form object representing theAuthenticationForm.
• next: The URL to redirect to after successful login. This maycontain a query string, too.
• site: The current Site,according to the SITE_ID setting. If you don’t have thesite framework installed, this will be set to an instance ofRequestSite, which derives thesite name and domain from the currentHttpRequest.
• site_name: An alias for site.name. If you don’t have the siteframework installed, this will be set to the value ofrequest.META['SERVER_NAME'].For more on sites, see The “sites” framework.

If you’d prefer not to call the template registration/login.html,you can pass the template_name parameter via the extra arguments tothe as_view method in your URLconf. For example, this URLconf line woulduse myapp/login.html instead:

path("accounts/login/", auth_views.LoginView.as_view(template_name="myapp/login.html")),

You can also specify the name of the GET field which contains the URLto redirect to after login using redirect_field_name. By default, thefield is called next.

Here’s a sample registration/login.html template you can use as astarting point. It assumes you have a base.html template thatdefines a content block:

{% extends "base.html" %}{% block content %}{% if form.errors %}<p>Your username and password didn't match. Please try again.</p>{% endif %}{% if next %} {% if user.is_authenticated %} <p>Your account doesn't have access to this page. To proceed, please login with an account that has access.</p> {% else %} <p>Please login to see this page.</p> {% endif %}{% endif %}<form method="post" action="{% url 'login' %}">{% csrf_token %}<table><tr> <td>{{ form.username.label_tag }}</td> <td>{{ form.username }}</td></tr><tr> <td>{{ form.password.label_tag }}</td> <td>{{ form.password }}</td></tr></table><input type="submit" value="login"><input type="hidden" name="next" value="{{ next }}"></form>{# Assumes you set up the password_reset view in your URLconf #}<p><a href="{% url 'password_reset' %}">Lost password?</a></p>{% endblock %}

If you have customized authentication (see Customizing Authentication) you can use a custom authentication form bysetting the authentication_form attribute. This form must accept arequest keyword argument in its __init__() method and provide aget_user() method which returns the authenticated user object (thismethod is only ever called after successful form validation).

class LogoutView¶

Logs a user out on POST requests.

Deprecated since version 4.1: Support for logging out on GET requests is deprecated and will beremoved in Django 5.0.

URL name: logout

Attributes:

next_page¶

The URL to redirect to after logout. Defaults toLOGOUT_REDIRECT_URL.

template_name¶

The full name of a template to display after logging the user out.Defaults to registration/logged_out.html.

redirect_field_name¶

The name of a GET field containing the URL to redirect to after logout. Defaults to 'next'. Overrides thenext_page URL if the given GET parameter ispassed.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

success_url_allowed_hosts¶

A set of hosts, in addition to request.get_host(), that are safe for redirectingafter logout. Defaults to an empty set.

Template context:

• title: The string “Logged out”, localized.
• site: The current Site,according to the SITE_ID setting. If you don’t have thesite framework installed, this will be set to an instance ofRequestSite, which derives thesite name and domain from the currentHttpRequest.
• site_name: An alias for site.name. If you don’t have the siteframework installed, this will be set to the value ofrequest.META['SERVER_NAME'].For more on sites, see The “sites” framework.

logout_then_login(request, login_url=None)¶

Logs a user out on POST requests, then redirects to the login page.

URL name: No default URL provided

Optional arguments:

• login_url: The URL of the login page to redirect to.Defaults to settings.LOGIN_URL if not supplied.

Deprecated since version 4.1: Support for logging out on GET requests is deprecated and will beremoved in Django 5.0.

class PasswordChangeView¶

URL name: password_change

Allows a user to change their password.

Attributes:

template_name¶

The full name of a template to use for displaying the password changeform. Defaults to registration/password_change_form.html if notsupplied.

success_url¶

The URL to redirect to after a successful password change. Defaults to'password_change_done'.

form_class¶

A custom “change password” form which must accept a user keywordargument. The form is responsible for actually changing the user’spassword. Defaults toPasswordChangeForm.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

Template context:

• form: The password change form (see form_class above).

class PasswordChangeDoneView¶

URL name: password_change_done

The page shown after a user has changed their password.

Attributes:

template_name¶

The full name of a template to use. Defaults toregistration/password_change_done.html if not supplied.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

class PasswordResetView¶

URL name: password_reset

Allows a user to reset their password by generating a one-time use linkthat can be used to reset the password, and sending that link to theuser’s registered email address.

This view will send an email if the following conditions are met:

• The email address provided exists in the system.
• The requested user is active (User.is_active is True).
• The requested user has a usable password. Users flagged with an unusablepassword (seeset_unusable_password()) aren’tallowed to request a password reset to prevent misuse when using anexternal authentication source like LDAP.

If any of these conditions are not met, no email will be sent, but theuser won’t receive any error message either. This prevents informationleaking to potential attackers. If you want to provide an error message inthis case, you can subclassPasswordResetForm and use theform_class attribute.

Note

Be aware that sending an email costs extra time, hence you may bevulnerable to an email address enumeration timing attack due to adifference between the duration of a reset request for an existingemail address and the duration of a reset request for a nonexistentemail address. To reduce the overhead, you can use a 3rd party packagethat allows to send emails asynchronously, e.g. django-mailer.

Attributes:

template_name¶

The full name of a template to use for displaying the password resetform. Defaults to registration/password_reset_form.html if notsupplied.

form_class¶

Form that will be used to get the email of the user to reset thepassword for. Defaults toPasswordResetForm.

email_template_name¶

The full name of a template to use for generating the email with thereset password link. Defaults toregistration/password_reset_email.html if not supplied.

subject_template_name¶

The full name of a template to use for the subject of the email withthe reset password link. Defaults toregistration/password_reset_subject.txt if not supplied.

token_generator¶

Instance of the class to check the one time link. This will default todefault_token_generator, it’s an instance ofdjango.contrib.auth.tokens.PasswordResetTokenGenerator.

success_url¶

The URL to redirect to after a successful password reset request.Defaults to 'password_reset_done'.

from_email¶

A valid email address. By default Django uses theDEFAULT_FROM_EMAIL.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

html_email_template_name¶

The full name of a template to use for generating atext/html multipart email with the password reset link. Bydefault, HTML email is not sent.

extra_email_context¶

A dictionary of context data that will be available in the emailtemplate. It can be used to override default template context valueslisted below e.g. domain.

Template context:

• form: The form (see form_class above) for resetting the user’spassword.

Email template context:

• email: An alias for user.email
• user: The current User,according to the email form field. Only active users are able toreset their passwords (User.is_active is True).
• site_name: An alias for site.name. If you don’t have the siteframework installed, this will be set to the value ofrequest.META['SERVER_NAME'].For more on sites, see The “sites” framework.
• domain: An alias for site.domain. If you don’t have the siteframework installed, this will be set to the value ofrequest.get_host().
• protocol: http or https
• uid: The user’s primary key encoded in base 64.
• token: Token to check that the reset link is valid.

Sample registration/password_reset_email.html (email body template):

Someone asked for password reset for email {{ email }}. Follow the link below:{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}

The same template context is used for subject template. Subject must besingle line plain text string.

class PasswordResetDoneView¶

URL name: password_reset_done

The page shown after a user has been emailed a link to reset theirpassword. This view is called by default if the PasswordResetViewdoesn’t have an explicit success_url URL set.

Note

If the email address provided does not exist in the system, the user isinactive, or has an unusable password, the user will still beredirected to this view but no email will be sent.

Attributes:

template_name¶

The full name of a template to use. Defaults toregistration/password_reset_done.html if not supplied.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

class PasswordResetConfirmView¶

URL name: password_reset_confirm

Presents a form for entering a new password.

Keyword arguments from the URL:

• uidb64: The user’s id encoded in base 64.
• token: Token to check that the password is valid.

Attributes:

template_name¶

The full name of a template to display the confirm password view.Default value is registration/password_reset_confirm.html.

token_generator¶

Instance of the class to check the password. This will default todefault_token_generator, it’s an instance ofdjango.contrib.auth.tokens.PasswordResetTokenGenerator.

post_reset_login¶

A boolean indicating if the user should be automatically authenticatedafter a successful password reset. Defaults to False.

post_reset_login_backend¶

A dotted path to the authentication backend to use when authenticatinga user if post_reset_login is True. Required only if you havemultiple AUTHENTICATION_BACKENDS configured. Defaults toNone.

form_class¶

Form that will be used to set the password. Defaults toSetPasswordForm.

success_url¶

URL to redirect after the password reset done. Defaults to'password_reset_complete'.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

reset_url_token¶

Token parameter displayed as a component of password reset URLs.Defaults to 'set-password'.

Template context:

• form: The form (see form_class above) for setting the new user’spassword.
• validlink: Boolean, True if the link (combination of uidb64 andtoken) is valid or unused yet.

class PasswordResetCompleteView¶

URL name: password_reset_complete

Presents a view which informs the user that the password has beensuccessfully changed.

Attributes:

template_name¶

The full name of a template to display the view. Defaults toregistration/password_reset_complete.html.

extra_context¶

A dictionary of context data that will be added to the default contextdata passed to the template.

Note

The built-in authentication forms make certain assumptions about the usermodel that they are working with. If you’re using a custom user model, it may be necessary to define your own forms for theauthentication system. For more information, refer to the documentationabout using the built-in authentication forms with custom user models.

Technicality

Technically, these variables are only made available in the templatecontext if you use RequestContext and the'django.contrib.auth.context_processors.auth' context processor isenabled. It is in the default generated settings file. For more, see theRequestContext docs.

Users¶

When rendering a template RequestContext, thecurrently logged-in user, either a Userinstance or an AnonymousUser instance, isstored in the template variable {{ user }}:

{% if user.is_authenticated %} <p>Welcome, {{ user.username }}. Thanks for logging in.</p>{% else %} <p>Welcome, new user. Please log in.</p>{% endif %}

This template context variable is not available if a RequestContext is notbeing used.

Permissions¶

The currently logged-in user’s permissions are stored in the template variable{{ perms }}. This is an instance ofdjango.contrib.auth.context_processors.PermWrapper, which is atemplate-friendly proxy of permissions.

Evaluating a single-attribute lookup of {{ perms }} as a boolean is a proxyto User.has_module_perms(). For example, to check ifthe logged-in user has any permissions in the foo app:

{% if perms.foo %}

Evaluating a two-level-attribute lookup as a boolean is a proxy toUser.has_perm(). For example,to check if the logged-in user has the permission foo.add_vote:

{% if perms.foo.add_vote %}

Here’s a more complete example of checking permissions in a template:

{% if perms.foo %} <p>You have permission to do something in the foo app.</p> {% if perms.foo.add_vote %} <p>You can vote!</p> {% endif %} {% if perms.foo.add_driving %} <p>You can drive!</p> {% endif %}{% else %} <p>You don't have permission to do anything in the foo app.</p>{% endif %}

It is possible to also look permissions up by {% if in %} statements.For example:

{% if 'foo' in perms %} {% if 'foo.add_vote' in perms %} <p>In lookup works, too.</p> {% endif %}{% endif %}