Usando o sistema de autenticação DjangoLink para este cabeçalho#

Selecting the authentication backendLink para este cabeçalho#

When a user logs in, the user’s ID and the backend that was used for authentication are saved in the user’s session. This allows the same authentication backend to fetch the user’s details on a future request. The authentication backend to save in the session is 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 allows pairing authenticate() and login(): authenticate() sets the user.backend attribute on the User object it returns.

3. Use the backend in AUTHENTICATION_BACKENDS, if there is only one.

4. Caso contrário, gera uma exceção.

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

The raw wayLink para este cabeçalho#

The simple, raw way to limit access to pages is to check request.user.is_authenticated() and either redirect to a login page:

from django.conf import settings
from django.shortcuts import redirect

def my_view(request):
    if not request.user.is_authenticated():
        return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
    # ...

…or display an error message:

from django.shortcuts import render

def my_view(request):
    if not request.user.is_authenticated():
        return render(request, 'myapp/login_error.html')
    # ...

O login_required decoratorLink para este cabeçalho#

login_required(redirect_field_name='next', login_url=None)Link para esta definição#

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

Code

from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    ...

login_required() does the following:

• If the user isn’t logged in, redirect to settings.LOGIN_URL, passing the current absolute path in the query string. Example: /accounts/login/?next=/polls/3/.

• If the user is logged in, execute the view normally. The view code is free to assume the user is logged in.

By default, the path that the user should be redirected to upon successful 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 an optional redirect_field_name parameter:

Code

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 most likely need to customize your login template as well, since the template context variable which stores the redirect path will use the value of redirect_field_name as its key rather than "next" (the default).

login_required() also takes an optional login_url parameter. Example:

Code

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 to ensure that the settings.LOGIN_URL and your login view are properly associated. For example, using the defaults, add the following lines to your URLconf:

Code

from django.contrib.auth import views as auth_views

url(r'^accounts/login/$', auth_views.login),

The settings.LOGIN_URL also accepts view function names and named URL patterns. This allows you to freely remap your login view within your URLconf without having to update the setting.

O LoginRequired mixinLink para este cabeçalho#

When using class-based views, you can achieve the same behavior as with login_required by using the LoginRequiredMixin. This mixin should be at the leftmost position in the inheritance list.

class LoginRequiredMixinLink para esta definição#

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

You can set any of the parameters of AccessMixin to customize the handling of unauthorized users:

Code

from django.contrib.auth.mixins import LoginRequiredMixin

class MyView(LoginRequiredMixin, View):
    login_url = '/login/'
    redirect_field_name = 'redirect_to'

Limiting access to logged-in users that pass a testLink para este cabeçalho#

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

The simple way is to run your test on request.user in the view directly. For example, this view checks to make sure the user has an email in the desired domain and if not, redirects to the login page:

from django.shortcuts import redirect

def 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')Link para esta definição#

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

Code

from django.contrib.auth.decorators import user_passes_test

def email_check(user):
    return user.email.endswith('@example.com')

@user_passes_test(email_check)
def my_view(request):
    ...

user_passes_test() takes a required argument: a callable that takes a User object and returns True if the user is allowed to view the page. Note that user_passes_test() does not automatically check that the User is not anonymous.

user_passes_test() takes two optional arguments:

login_url

Lets you specify the URL that users who don’t pass the test will be redirected to. It may be a login page and defaults to settings.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 do if you are redirecting users that don’t pass the test to a non-login page where there’s no “next page”.

Por exemplo:

Code

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

class UserPassesTestMixinLink para esta definição#

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

test_func()Link para esta definição#

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

Code

from django.contrib.auth.mixins import UserPassesTestMixin

class MyView(UserPassesTestMixin, View):

    def test_func(self):
        return self.request.user.email.endswith('@example.com')

get_test_func()Link para esta definição#

You can also override the get_test_func() method to have the mixin use a differently named function for its checks (instead of test_func()).

O permission_required decoratorLink para este cabeçalho#

permission_required(perm, login_url=None, raise_exception=False)Link para esta definição#

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

Code

from django.contrib.auth.decorators import permission_required

@permission_required('polls.can_vote')
def my_view(request):
    ...

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

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

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

Code

from django.contrib.auth.decorators import permission_required

@permission_required('polls.can_vote', 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 raise PermissionDenied, prompting the 403 (HTTP Forbidden) view instead of redirecting to the login page.

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

Code

from django.contrib.auth.decorators import login_required, permission_required

@login_required
@permission_required('polls.can_vote', raise_exception=True)
def my_view(request):
    ...

O PermissionRequiredMixin mixinLink para este cabeçalho#

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

class PermissionRequiredMixinLink para esta definição#

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

Code

from django.contrib.auth.mixins import PermissionRequiredMixin

class MyView(PermissionRequiredMixin, View):
    permission_required = 'polls.can_vote'
    # Or multiple of permissions:
    permission_required = ('polls.can_open', 'polls.can_edit')

You can set any of the parameters of AccessMixin to customize the handling of unauthorized users.

You may also override these methods:

get_permission_required()Link para esta definição#

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

has_permission()Link para esta definição#

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

Session invalidation on password changeLink para este cabeçalho#

If your AUTH_USER_MODEL inherits from AbstractBaseUser or implements its own get_session_auth_hash() method, authenticated sessions will include the hash returned by this function. In the AbstractBaseUser case, this is an HMAC of the password field. If the SessionAuthenticationMiddleware is enabled, Django verifies that the hash sent along with each request matches the one that’s computed server-side. This allows a user to log out all of their sessions by changing their password.

The default password change views included with Django, django.contrib.auth.views.password_change() and the user_change_password view in the django.contrib.auth admin, update the session with the new password hash so that a user changing their own password won’t log themselves out. If you have a custom password change view and wish to have similar behavior, use this function:

update_session_auth_hash(request, user)Link para esta definição#

This function takes the current request and the updated user object from which the new session hash will be derived and updates the session hash appropriately. Example usage:

Code

from django.contrib.auth import update_session_auth_hash

def 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:
        ...

If you are upgrading an existing site and wish to enable this middleware without requiring all your users to re-login afterward, you should first upgrade to Django 1.7 and run it for a while so that as sessions are naturally recreated as users login, they include the session hash as described above. Once you start running your site with SessionAuthenticationMiddleware, any users who have not logged in and had their session updated with the verification hash will have their existing session invalidated and be required to login.

Using the viewsLink para este cabeçalho#

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

urlpatterns = [
    url('^', include('django.contrib.auth.urls')),
]

This will include the following URL patterns:

^login/$ [name='login']
^logout/$ [name='logout']
^password_change/$ [name='password_change']
^password_change/done/$ [name='password_change_done']
^password_reset/$ [name='password_reset']
^password_reset/done/$ [name='password_reset_done']
^reset/(?P<uidb64>[0-9A-Za-z_\-]+)/(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$ [name='password_reset_confirm']
^reset/done/$ [name='password_reset_complete']

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

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

from django.contrib.auth import views as auth_views

urlpatterns = [
    url('^change-password/$', auth_views.password_change),
]

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

urlpatterns = [
    url(
        '^change-password/$',
        auth_views.password_change,
        {'template_name': 'change-password.html'}
    ),
]

All views return a TemplateResponse instance, which allows you to easily customize the response data before rendering. A way to do this is to wrap a view in your own view:

from django.contrib.auth import views

def change_password(request):
    template_response = views.password_change(request)
    # Do something with `template_response`
    return template_response

For more details, see the TemplateResponse documentation.

All authentication viewsLink para este cabeçalho#

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

login(request, template_name=`registration/login.html`, redirect_field_name='next', authentication_form=AuthenticationForm, current_app=None, extra_context=None)Link para esta definição#

URL name: login

See the URL documentation for details on using named URL patterns.

Optional arguments:

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

• redirect_field_name: The name of a GET field containing the URL to redirect to after login. Defaults to next.

• authentication_form: A callable (typically just a form class) to use for authentication. Defaults to AuthenticationForm.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Here’s what django.contrib.auth.views.login does:

• If called via GET, it displays a login form that POSTs to the same URL. More on this in a bit.

• If called via POST with user submitted credentials, it tries to log the user in. If login is successful, the view redirects to the URL specified in next. If next isn’t provided, it redirects to settings.LOGIN_REDIRECT_URL (which defaults to /accounts/profile/). If login isn’t successful, it redisplays the login form.

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

• form: A Form object representing the AuthenticationForm.

• next: The URL to redirect to after successful login. This may contain a query string, too.

• site: The current Site, according to the SITE_ID setting. If you don’t have the site framework installed, this will be set to an instance of RequestSite, which derives the site name and domain from the current HttpRequest.

• site_name: An alias for site.name. If you don’t have the site framework installed, this will be set to the value of request.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 to the view in your URLconf. For example, this URLconf line would use myapp/login.html instead:

Code

url(r'^accounts/login/$', auth_views.login, {'template_name': 'myapp/login.html'}),

You can also specify the name of the GET field which contains the URL to redirect to after login by passing redirect_field_name to the view. By default, the field is called next.

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

Django template

{% 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 setup 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 pass a custom authentication form to the login view via the authentication_form parameter. This form must accept a request keyword argument in its __init__ method, and provide a get_user() method which returns the authenticated user object (this method is only ever called after successful form validation).

logout(request, next_page=None, template_name='registration/logged_out.html', redirect_field_name='next', current_app=None, extra_context=None)Link para esta definição#

Logs a user out.

URL name: logout

Optional arguments:

• next_page: The URL to redirect to after logout.

• template_name: The full name of a template to display after logging the user out. Defaults to registration/logged_out.html if no argument is supplied.

• redirect_field_name: The name of a GET field containing the URL to redirect to after log out. Defaults to next. Overrides the next_page URL if the given GET parameter is passed.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Template context:

• title: The string “Logged out”, localized.

• site: The current Site, according to the SITE_ID setting. If you don’t have the site framework installed, this will be set to an instance of RequestSite, which derives the site name and domain from the current HttpRequest.

• site_name: An alias for site.name. If you don’t have the site framework installed, this will be set to the value of request.META['SERVER_NAME']. For more on sites, see The “sites” framework.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

logout_then_login(request, login_url=None, current_app=None, extra_context=None)Link para esta definição#

Logs a user out, 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.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

password_change(request, template_name='registration/password_change_form.html', post_change_redirect=None, password_change_form=PasswordChangeForm, current_app=None, extra_context=None)Link para esta definição#

Allows a user to change their password.

URL name: password_change

Optional arguments:

• template_name: The full name of a template to use for displaying the password change form. Defaults to registration/password_change_form.html if not supplied.

• post_change_redirect: The URL to redirect to after a successful password change.

• password_change_form: A custom “change password” form which must accept a user keyword argument. The form is responsible for actually changing the user’s password. Defaults to PasswordChangeForm.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Template context:

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

password_change_done(request, template_name='registration/password_change_done.html', current_app=None, extra_context=None)Link para esta definição#

The page shown after a user has changed their password.

URL name: password_change_done

Optional arguments:

• template_name: The full name of a template to use. Defaults to registration/password_change_done.html if not supplied.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

password_reset(request, is_admin_site=False, 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, current_app=None, extra_context=None, html_email_template_name=None, extra_email_context=None)Link para esta definição#

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

If the email address provided does not exist in the system, this view won’t send an email, but the user won’t receive any error message either. This prevents information leaking to potential attackers. If you want to provide an error message in this case, you can subclass PasswordResetForm and use the password_reset_form argument.

Users flagged with an unusable password (see set_unusable_password() aren’t allowed to request a password reset to prevent misuse when using an external authentication source like LDAP. Note that they won’t receive any error message since this would expose their account’s existence but no mail will be sent either.

URL name: password_reset

Optional arguments:

• template_name: The full name of a template to use for displaying the password reset form. Defaults to registration/password_reset_form.html if not supplied.

• email_template_name: The full name of a template to use for generating the email with the reset password link. Defaults to registration/password_reset_email.html if not supplied.

• subject_template_name: The full name of a template to use for the subject of the email with the reset password link. Defaults to registration/password_reset_subject.txt if not supplied.

• password_reset_form: Form that will be used to get the email of the user to reset the password for. Defaults to PasswordResetForm.

• token_generator: Instance of the class to check the one time link. This will default to default_token_generator, it’s an instance of django.contrib.auth.tokens.PasswordResetTokenGenerator.

• post_reset_redirect: The URL to redirect to after a successful password reset request.

• from_email: A valid email address. By default Django uses the DEFAULT_FROM_EMAIL.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

• html_email_template_name: The full name of a template to use for generating a text/html multipart email with the password reset link. By default, HTML email is not sent.

• extra_email_context: A dictionary of context data that will available in the email template.

Template context:

• form: The form (see password_reset_form above) for resetting the user’s password.

Email template context:

• email: An alias for user.email

• user: The current User, according to the email form field. Only active users are able to reset their passwords (User.is_active is True).

• site_name: An alias for site.name. If you don’t have the site framework installed, this will be set to the value of request.META['SERVER_NAME']. For more on sites, see The “sites” framework.

• domain: An alias for site.domain. If you don’t have the site framework installed, this will be set to the value of request.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):

Django 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 be single line plain text string.

password_reset_done(request, template_name='registration/password_reset_done.html', current_app=None, extra_context=None)Link para esta definição#

The page shown after a user has been emailed a link to reset their password. This view is called by default if the password_reset() view doesn’t have an explicit post_reset_redirect URL set.

URL name: password_reset_done

Optional arguments:

• template_name: The full name of a template to use. Defaults to registration/password_reset_done.html if not supplied.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

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, current_app=None, extra_context=None)Link para esta definição#

Presents a form for entering a new password.

URL name: password_reset_confirm

Optional arguments:

• uidb64: The user’s id encoded in base 64. Defaults to None.

• token: Token to check that the password is valid. Defaults to None.

• 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 to default_token_generator, it’s an instance of django.contrib.auth.tokens.PasswordResetTokenGenerator.

• set_password_form: Form that will be used to set the password. Defaults to SetPasswordForm

• post_reset_redirect: URL to redirect after the password reset done. Defaults to None.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

Template context:

• form: The form (see set_password_form above) for setting the new user’s password.

• validlink: Boolean, True if the link (combination of uidb64 and token) is valid or unused yet.

password_reset_complete(request, template_name='registration/password_reset_complete.html', current_app=None, extra_context=None)Link para esta definição#

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

URL name: password_reset_complete

Optional arguments:

• template_name: The full name of a template to display the view. Defaults to registration/password_reset_complete.html.

• current_app: A hint indicating which application contains the current view. See the namespaced URL resolution strategy for more information.

• extra_context: A dictionary of context data that will be added to the default context data passed to the template.

UsuáriosLink para este cabeçalho#

When rendering a template RequestContext, the currently logged-in user, either a User instance or an AnonymousUser instance, is stored 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 not being used.

PermissõesLink para este cabeçalho#

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

In the {{ perms }} object, single-attribute lookup is a proxy to User.has_module_perms. This example would display True if the logged-in user had any permissions in the foo app:

{{ perms.foo }}

Two-level-attribute lookup is a proxy to User.has_perm. This example would display True if the logged-in user had the permission foo.can_vote:

{{ perms.foo.can_vote }}

Thus, you can check permissions in template {% if %} statements:

{% if perms.foo %}
    <p>You have permission to do something in the foo app.</p>
    {% if perms.foo.can_vote %}
        <p>You can vote!</p>
    {% endif %}
    {% if perms.foo.can_drive %}
        <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.can_vote' in perms %}
        <p>In lookup works, too.</p>
    {% endif %}
{% endif %}