Authentication – django rest framework
Auth needs to be pluggable.
— Jacob Kaplan-Moss, “REST worst practices”
Authentication is the mechanism of associating an incoming request with a set of identifying credentials, such as the user the request came from, or the token that it was signed with. The permission and throttling policies can then use those credentials to determine if the request should be permitted.
REST framework provides several authentication schemes out of the box, and also allows you to implement custom schemes.
Authentication always runs at the very start of the view, before the permission and throttling checks occur, and before any other code is allowed to proceed.
The request.user
property will typically be set to an instance of the contrib.auth
package’s User
class.
The request.auth
property is used for any additional authentication information, for example, it may be used to represent an authentication token that the request was signed with.
Note: Don’t forget that authentication by itself won’t allow or disallow an incoming request, it simply identifies the credentials that the request was made with.
For information on how to set up the permission policies for your API please see the permissions documentation.
The authentication schemes are always defined as a list of classes. REST framework will attempt to authenticate with each class in the list, and will set request.user
and request.auth
using the return value of the first class that successfully authenticates.
If no class authenticates, request.user
will be set to an instance of django.contrib.auth.models.AnonymousUser
, and request.auth
will be set to None
.
The value of request.user
and request.auth
for unauthenticated requests can be modified using the UNAUTHENTICATED_USER
and UNAUTHENTICATED_TOKEN
settings.
The default authentication schemes may be set globally, using the DEFAULT_AUTHENTICATION_CLASSES
setting. For example.
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.BasicAuthentication',
'rest_framework.authentication.SessionAuthentication',
]
}
You can also set the authentication scheme on a per-view or per-viewset basis,
using the APIView
class-based views.
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView
class ExampleView(APIView):
authentication_classes = [SessionAuthentication, BasicAuthentication]
permission_classes = [IsAuthenticated]
def get(self, request, format=None):
content = {
'user': str(request.user), # `django.contrib.auth.User` instance.
'auth': str(request.auth), # None
}
return Response(content)
Or, if you’re using the @api_view
decorator with function based views.
@api_view(['GET'])
@authentication_classes([SessionAuthentication, BasicAuthentication])
@permission_classes([IsAuthenticated])
def example_view(request, format=None):
content = {
'user': str(request.user), # `django.contrib.auth.User` instance.
'auth': str(request.auth), # None
}
return Response(content)
When an unauthenticated request is denied permission there are two different error codes that may be appropriate.
HTTP 401 responses must always include a WWW-Authenticate
header, that instructs the client how to authenticate. HTTP 403 responses do not include the WWW-Authenticate
header.
The kind of response that will be used depends on the authentication scheme. Although multiple authentication schemes may be in use, only one scheme may be used to determine the type of response. The first authentication class set on the view is used when determining the type of response.
Note that when a request may successfully authenticate, but still be denied permission to perform the request, in which case a 403 Permission Denied
response will always be used, regardless of the authentication scheme.
Note that if deploying to Apache using mod_wsgi, the authorization header is not passed through to a WSGI application by default, as it is assumed that authentication will be handled by Apache, rather than at an application level.
If you are deploying to Apache, and using any non-session based authentication, you will need to explicitly configure mod_wsgi to pass the required headers through to the application. This can be done by specifying the WSGIPassAuthorization
directive in the appropriate context and setting it to 'On'
.
# this can go in either server config, virtual host, directory or .htaccess
WSGIPassAuthorization On
This authentication scheme uses HTTP Basic Authentication, signed against a user’s username and password. Basic authentication is generally only appropriate for testing.
If successfully authenticated, BasicAuthentication
provides the following credentials.
Unauthenticated responses that are denied permission will result in an HTTP 401 Unauthorized
response with an appropriate WWW-Authenticate header. For example:
WWW-Authenticate: Basic realm="api"
Note: If you use BasicAuthentication
in production you must ensure that your API is only available over https
. You should also ensure that your API clients will always re-request the username and password at login, and will never store those details to persistent storage.
Note: The token authentication provided by Django REST framework is a fairly simple implementation.
For an implementation which allows more than one token per user, has some tighter security implementation details, and supports token expiry, please see the Django REST Knox third party package.
This authentication scheme uses a simple token-based HTTP Authentication scheme. Token authentication is appropriate for client-server setups, such as native desktop and mobile clients.
To use the TokenAuthentication
scheme you’ll need to configure the authentication classes to include TokenAuthentication
, and additionally include rest_framework.authtoken
in your INSTALLED_APPS
setting:
INSTALLED_APPS = [
...
'rest_framework.authtoken'
]
Make sure to run manage.py migrate
after changing your settings.
The rest_framework.authtoken
app provides Django database migrations.
You’ll also need to create tokens for your users.
from rest_framework.authtoken.models import Token
token = Token.objects.create(user=...)
print(token.key)
For clients to authenticate, the token key should be included in the Authorization
HTTP header. The key should be prefixed by the string literal “Token”, with whitespace separating the two strings. For example:
Authorization: Token 9944b09199c62bcf9418ad846dd0e4bbdfc6ee4b
If you want to use a different keyword in the header, such as Bearer
, simply subclass TokenAuthentication
and set the keyword
class variable.
If successfully authenticated, TokenAuthentication
provides the following credentials.
Unauthenticated responses that are denied permission will result in an HTTP 401 Unauthorized
response with an appropriate WWW-Authenticate header. For example:
WWW-Authenticate: Token
The curl
command line tool may be useful for testing token authenticated APIs. For example:
curl -X GET http://127.0.0.1:8000/api/example/ -H 'Authorization: Token 9944b09199c62bcf9418ad846dd0e4bbdfc6ee4b'
Note: If you use TokenAuthentication
in production you must ensure that your API is only available over https
.
If you want every user to have an automatically generated Token, you can simply catch the User’s post_save
signal.
from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token
@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
if created:
Token.objects.create(user=instance)
Note that you’ll want to ensure you place this code snippet in an installed models.py
module, or some other location that will be imported by Django on startup.
If you’ve already created some users, you can generate tokens for all existing users like this:
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
for user in User.objects.all():
Token.objects.get_or_create(user=user)
When using TokenAuthentication
, you may want to provide a mechanism for clients to obtain a token given the username and password. REST framework provides a built-in view to provide this behaviour. To use it, add the obtain_auth_token
view to your URLconf:
from rest_framework.authtoken import views
urlpatterns = [
path('api-token-auth/', views.obtain_auth_token)
]
Note that the URL part of the pattern can be whatever you want to use.
The obtain_auth_token
view will return a JSON response when valid username
and password
fields are POSTed to the view using form data or JSON:
{ 'token' : '9944b09199c62bcf9418ad846dd0e4bbdfc6ee4b' }
Note that the default obtain_auth_token
view explicitly uses JSON requests and responses, rather than using default renderer and parser classes in your settings.
By default, there are no permissions or throttling applied to the obtain_auth_token
view. If you do wish to apply to throttle you’ll need to override the view class,
and include them using the throttle_classes
attribute.
If you need a customized version of the obtain_auth_token
view, you can do so by subclassing the ObtainAuthToken
view class, and using that in your url conf instead.
For example, you may return additional user information beyond the token
value:
from rest_framework.authtoken.views import ObtainAuthToken
from rest_framework.authtoken.models import Token
from rest_framework.response import Response
class CustomAuthToken(ObtainAuthToken):
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
user = serializer.validated_data['user']
token, created = Token.objects.get_or_create(user=user)
return Response({
'token': token.key,
'user_id': user.pk,
'email': user.email
})
And in your urls.py
:
urlpatterns = [
path('api-token-auth/', CustomAuthToken.as_view())
]
It is also possible to create Tokens manually through the admin interface. In case you are using a large user base, we recommend that you monkey patch the TokenAdmin
class customize it to your needs, more specifically by declaring the user
field as raw_field
.
your_app/admin.py
:
from rest_framework.authtoken.admin import TokenAdmin
TokenAdmin.raw_id_fields = ['user']
Since version 3.6.4 it’s possible to generate a user token using the following command:
./manage.py drf_create_token <username>
this command will return the API token for the given user, creating it if it doesn’t exist:
Generated token 9944b09199c62bcf9418ad846dd0e4bbdfc6ee4b for user user1
In case you want to regenerate the token (for example if it has been compromised or leaked) you can pass an additional parameter:
./manage.py drf_create_token -r <username>
This authentication scheme uses Django’s default session backend for authentication. Session authentication is appropriate for AJAX clients that are running in the same session context as your website.
If successfully authenticated, SessionAuthentication
provides the following credentials.
Unauthenticated responses that are denied permission will result in an HTTP 403 Forbidden
response.
If you’re using an AJAX-style API with SessionAuthentication, you’ll need to make sure you include a valid CSRF token for any “unsafe” HTTP method calls, such as PUT
, PATCH
, POST
or DELETE
requests. See the Django CSRF documentation for more details.
Warning: Always use Django’s standard login view when creating login pages. This will ensure your login views are properly protected.
CSRF validation in REST framework works slightly differently from standard Django due to the need to support both session and non-session based authentication to the same views. This means that only authenticated requests require CSRF tokens, and anonymous requests may be sent without CSRF tokens. This behaviour is not suitable for login views, which should always have CSRF validation applied.
This authentication scheme allows you to delegate authentication to your web server, which sets the REMOTE_USER
environment variable.
To use it, you must have django.contrib.auth.backends.RemoteUserBackend
(or a subclass) in your
AUTHENTICATION_BACKENDS
setting. By default, RemoteUserBackend
creates User
objects for usernames that don’t
already exist. To change this and other behaviour, consult the
Django documentation.
If successfully authenticated, RemoteUserAuthentication
provides the following credentials:
Consult your web server’s documentation for information about configuring an authentication method, e.g.:
To implement a custom authentication scheme, subclass BaseAuthentication
and override the .authenticate(self, request)
method. The method should return a two-tuple of (user, auth)
if authentication succeeds, or None
otherwise.
In some circumstances instead of returning None
, you may want to raise an AuthenticationFailed
exception from the .authenticate()
method.
Typically the approach you should take is:
- If authentication is not attempted, return
None
. Any other authentication schemes also in use will still be checked. - If authentication is attempted but fails, raise an
AuthenticationFailed
exception. An error response will be returned immediately, regardless of any permissions checks, and without checking any other authentication schemes.
You may also override the .authenticate_header(self, request)
method. If implemented, it should return a string that will be used as the value of the WWW-Authenticate
header in a HTTP 401 Unauthorized
response.
If the .authenticate_header()
method is not overridden, the authentication scheme will return HTTP 403 Forbidden
responses when an unauthenticated request is denied access.
Note: When your custom authenticator is invoked by the request object’s .user
or .auth
properties, you may see an AttributeError
re-raised as a WrappedAttributeError
. This is necessary to prevent the original exception from being suppressed by the outer property access. Python will not recognize that the AttributeError
originates from your custom authenticator and will instead assume that the request object does not have a .user
or .auth
property. These errors should be fixed or otherwise handled by your authenticator.
The following example will authenticate any incoming request as the user given by the username in a custom request header named ‘X-USERNAME’.
from django.contrib.auth.models import User
from rest_framework import authentication
from rest_framework import exceptions
class ExampleAuthentication(authentication.BaseAuthentication):
def authenticate(self, request):
username = request.META.get('HTTP_X_USERNAME')
if not username:
return None
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise exceptions.AuthenticationFailed('No such user')
return (user, None)
The following third-party packages are also available.
Django-rest-knox library provides models and views to handle token-based authentication in a more secure and extensible way than the built-in TokenAuthentication scheme – with Single Page Applications and Mobile clients in mind. It provides per-client tokens, and views to generate them when provided some other authentication (usually basic authentication), to delete the token (providing a server enforced logout) and to delete all tokens (logs out all clients that a user is logged into).
The Django OAuth Toolkit package provides OAuth 2.0 support and works with Python 3.4 . The package is maintained by jazzband and uses the excellent OAuthLib. The package is well documented, and well supported and is currently our recommended package for OAuth 2.0 support.
Install using pip
.
pip install django-oauth-toolkit
Add the package to your INSTALLED_APPS
and modify your REST framework settings.
INSTALLED_APPS = [
...
'oauth2_provider',
]
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'oauth2_provider.contrib.rest_framework.OAuth2Authentication',
]
}
For more details see the Django REST framework – Getting started documentation.
The Django REST framework OAuth package provides both OAuth1 and OAuth2 support for REST framework.
This package was previously included directly in the REST framework but is now supported and maintained as a third-party package.
Install the package using pip
.
pip install djangorestframework-oauth
For details on configuration and usage see the Django REST framework OAuth documentation for authentication and permissions.
JSON Web Token is a fairly new standard which can be used for token-based authentication. Unlike the built-in TokenAuthentication scheme, JWT Authentication doesn’t need to use a database to validate a token. A package for JWT authentication is djangorestframework-simplejwt which provides some features as well as a pluggable token blacklist app.
The HawkREST library builds on the Mohawk library to let you work with Hawk signed requests and responses in your API. Hawk lets two parties securely communicate with each other using messages signed by a shared key. It is based on HTTP MAC access authentication (which was based on parts of OAuth 1.0).
HTTP Signature (currently a IETF draft) provides a way to achieve origin authentication and message integrity for HTTP messages. Similar to Amazon’s HTTP Signature scheme, used by many of its services, it permits stateless, per-request authentication. Elvio Toccalino maintains the djangorestframework-httpsignature (outdated) package which provides an easy to use HTTP Signature Authentication mechanism. You can use the updated fork version of djangorestframework-httpsignature, which is drf-httpsig.
Djoser library provides a set of views to handle basic actions such as registration, login, logout, password reset and account activation. The package works with a custom user model and uses token-based authentication. This is ready to use REST implementation of the Django authentication system.
This library provides a set of REST API endpoints for registration, authentication (including social media authentication), password reset, retrieve and update user details, etc. By having these API endpoints, your client apps such as AngularJS, iOS, Android, and others can communicate to your Django backend site independently via REST APIs for user management.
There are currently two forks of this project.
Drf-social-oauth2 is a framework that helps you authenticate with major social oauth2 vendors, such as Facebook, Google, Twitter, Orcid, etc. It generates tokens in a JWTed way with an easy setup.
drfpasswordless adds (Medium, Square Cash inspired) passwordless support to Django REST Framework’s TokenAuthentication scheme. Users log in and sign up with a token sent to a contact point like an email address or a mobile number.
django-rest-authemail provides a RESTful API interface for user signup and authentication. Email addresses are used for authentication, rather than usernames. API endpoints are available for signup, signup email verification, login, logout, password reset, password reset verification, email change, email change verification, password change, and user detail. A fully functional example project and detailed instructions are included.
Django-Rest-Durin is built with the idea to have one library that does token auth for multiple Web/CLI/Mobile API clients via one interface but allows different token configuration for each API Client that consumes the API. It provides support for multiple tokens per user via custom models, views, permissions that work with Django-Rest-Framework. The token expiration time can be different per API client and is customizable via the Django Admin Interface.
More information can be found in the Documentation.
Декоратор login_required¶
login_required
(redirect_field_name=‘next’, login_url=None)[исходныйкод]¶В качестве сокращения можно использовать удобный декоратор
login_required()
:login_required()
делает следующее:По умолчанию путь, на который пользователь должен быть перенаправлен после успешной аутентификации, хранится в параметре строки запроса под названием
"next"
. Если вы предпочитаете использовать другое имя для этого параметра,login_required()
принимает необязательный параметрredirect_field_name
:Обратите внимание, что если вы зададите значение
redirect_field_name
, то, скорее всего, вам также придется настроить шаблон входа в систему, так как контекстная переменная шаблона, хранящая путь перенаправления, будет использовать в качестве ключа значениеredirect_field_name
, а не"next"
(по умолчанию).login_required()
также принимает необязательный параметрlogin_url
. Пример:Обратите внимание, что если вы не указываете параметр
login_url
, вам нужно убедиться, что параметрsettings.LOGIN_URL
и ваше представление входа правильно связаны. Например, используя значения по умолчанию, добавьте следующие строки в URLconf:settings.LOGIN_URL
также принимает имена функций представления и named URL patterns. Это позволяет вам свободно переназначать представление входа в URLconf без необходимости обновлять настройки.
Использование представлений¶
Существуют различные методы реализации этих представлений в вашем проекте. Самый простой способ – включить предоставленный URLconf в django.contrib.auth.urls в ваш собственный URLconf, например:
Это будет включать следующие шаблоны URL:
Представления предоставляют имя URL для более удобного использования. Подробнее об использовании именованных шаблонов URL см. в the URL documentation.
Если вы хотите получить больший контроль над своими URL-адресами, вы можете сослаться на определенное представление в URLconf:
Представления имеют необязательные аргументы, которые можно использовать для изменения поведения представления. Например, если вы хотите изменить имя шаблона, которое использует представление, вы можете указать аргумент template_name. Для этого в URLconf можно указать аргументы в виде ключевых слов, которые будут переданы представлению. Например:
Все представления являются class-based, что позволяет легко настраивать их с помощью подклассов.
Миксин permissionrequiredmixin¶
Чтобы применить проверку разрешений к class-based views, вы можете использовать PermissionRequiredMixin:
- class
PermissionRequiredMixin
¶ Этот миксин, как и декоратор
permission_required
, проверяет, имеет ли пользователь, обращающийся к представлению, все заданные разрешения. Вы должны указать разрешение (или итерацию разрешений) с помощью параметраpermission_required
:Вы можете установить любой из параметров
AccessMixin
, чтобы настроить обработку неавторизованных пользователей.Вы также можете переопределить эти методы:
get_permission_required
()¶Возвращает итерабель имен разрешений, используемых данным микшином. По умолчанию используется атрибут
permission_required
, при необходимости преобразуется в кортеж.
has_permission
()¶Возвращает булево значение, обозначающее, имеет ли текущий пользователь разрешение на выполнение декорированного представления. По умолчанию возвращается результат вызова
has_perms()
со списком разрешений, возвращаемымget_permission_required()
.
Ограничение доступа для вошедших в систему пользователей¶
Декоратор login_required
¶
login_required
(redirect_field_name=‘next’, login_url=None)[исходныйкод]¶В качестве сокращения можно использовать удобный декоратор
login_required()
:login_required()
делает следующее:По умолчанию путь, на который пользователь должен быть перенаправлен после успешной аутентификации, хранится в параметре строки запроса под названием
"next"
. Если вы предпочитаете использовать другое имя для этого параметра,login_required()
принимает необязательный параметрredirect_field_name
:Обратите внимание, что если вы зададите значение
redirect_field_name
, то, скорее всего, вам также придется настроить шаблон входа в систему, так как контекстная переменная шаблона, хранящая путь перенаправления, будет использовать в качестве ключа значениеredirect_field_name
, а не"next"
(по умолчанию).login_required()
также принимает необязательный параметрlogin_url
. Пример:Обратите внимание, что если вы не указываете параметр
login_url
, вам нужно убедиться, что параметрsettings.LOGIN_URL
и ваше представление входа правильно связаны. Например, используя значения по умолчанию, добавьте следующие строки в URLconf:settings.LOGIN_URL
также принимает имена функций представления и named URL patterns. Это позволяет вам свободно переназначать представление входа в URLconf без необходимости обновлять настройки.
Ограничение доступа для вошедших в систему пользователей, которые прошли тест¶
Чтобы ограничить доступ на основе определенных разрешений или какого-либо другого теста, вы сделаете практически то же самое, что описано в предыдущем разделе.
Вы можете запустить свой тест на request.user
непосредственно в представлении. Например, это представление проверяет, есть ли у пользователя email в нужном домене, и если нет, перенаправляет на страницу входа:
user_passes_test
(test_func, login_url=None, redirect_field_name=‘next’)[исходныйкод]¶В качестве сокращения можно использовать удобный декоратор
user_passes_test
, который выполняет перенаправление, когда вызываемый объект возвращаетFalse
:user_passes_test()
принимает обязательный аргумент: вызываемый объект, который принимает объектUser
и возвращаетTrue
, если пользователю разрешено просматривать страницу. Обратите внимание, чтоuser_passes_test()
не проверяет автоматически, чтоUser
не является анонимным.user_passes_test()
принимает два необязательных аргумента:login_url
- Позволяет указать URL, на который будут перенаправлены пользователи, не прошедшие тест. Это может быть страница входа в систему и по умолчанию имеет значение
settings.LOGIN_URL
, если вы его не укажете. redirect_field_name
- То же самое, что и для
login_required()
. Установка значенияNone
удаляет его из URL, что может понадобиться, если вы перенаправляете пользователей, не прошедших тест, на страницу без входа в систему, где нет «следующей страницы».
Например:
- class
UserPassesTestMixin
¶ При использовании class-based views, вы можете использовать
UserPassesTestMixin
для этого.test_func
()¶Вы должны переопределить метод
test_func()
класса, чтобы указать выполняемый тест. Кроме того, вы можете установить любой из параметровAccessMixin
для настройки обработки неавторизованных пользователей:
get_test_func
()¶Вы также можете переопределить метод
get_test_func()
, чтобы миксин использовал для своих проверок функцию с другим именем (вместоtest_func()
).
Декоратор permission_required
¶
permission_required
(perm, login_url=None, raise_exception=False)[исходныйкод]¶Это довольно распространенная задача – проверить, есть ли у пользователя определенное разрешение. По этой причине Django предоставляет ярлык для этого случая: декоратор
permission_required()
.:Как и в методе
has_perm()
, имена разрешений принимают форму"<applabel>.<permissioncodename>"
(например,polls.add_choice
для разрешения на модель в приложенииpolls
).Декоратор также может принимать итерацию разрешений, в этом случае пользователь должен иметь все разрешения, чтобы получить доступ к представлению.
Обратите внимание, что
permission_required()
также принимает необязательный параметрlogin_url
:Как и в декораторе
login_required()
,login_url
по умолчанию равенsettings.LOGIN_URL
.Если задан параметр
raise_exception
, декоратор подниметPermissionDenied
, предлагая the 403 (HTTP Forbidden) view вместо перенаправления на страницу входа.Если вы хотите использовать
raise_exception
, но при этом дать пользователям возможность сначала войти в систему, вы можете добавить декораторlogin_required()
:Это также позволяет избежать цикла перенаправления, когда
LoginView
становитсяredirect_authenticated_user=True
, а у вошедшего пользователя нет всех необходимых прав.
Миксин PermissionRequiredMixin
¶
Чтобы применить проверку разрешений к class-based views, вы можете использовать PermissionRequiredMixin
:
- class
PermissionRequiredMixin
¶ Этот миксин, как и декоратор
permission_required
, проверяет, имеет ли пользователь, обращающийся к представлению, все заданные разрешения. Вы должны указать разрешение (или итерацию разрешений) с помощью параметраpermission_required
:Вы можете установить любой из параметров
AccessMixin
, чтобы настроить обработку неавторизованных пользователей.Вы также можете переопределить эти методы:
get_permission_required
()¶Возвращает итерабель имен разрешений, используемых данным микшином. По умолчанию используется атрибут
permission_required
, при необходимости преобразуется в кортеж.
has_permission
()¶Возвращает булево значение, обозначающее, имеет ли текущий пользователь разрешение на выполнение декорированного представления. По умолчанию возвращается результат вызова
has_perms()
со списком разрешений, возвращаемымget_permission_required()
.
Представления аутентификации¶
Django предоставляет несколько представлений, которые вы можете использовать для обработки входа, выхода и управления паролями. В них используется stock auth forms, но вы можете передавать и свои собственные формы.
Django не предоставляет шаблонов по умолчанию для представлений аутентификации. Вы должны создать свои собственные шаблоны для представлений, которые вы хотите использовать. Контекст шаблона документирован в каждом представлении, см. Все виды аутентификации.
Использование представлений¶
Существуют различные методы реализации этих представлений в вашем проекте. Самый простой способ – включить предоставленный URLconf в django.contrib.auth.urls
в ваш собственный URLconf, например:
Это будет включать следующие шаблоны URL:
Представления предоставляют имя URL для более удобного использования. Подробнее об использовании именованных шаблонов URL см. в the URL documentation.
Если вы хотите получить больший контроль над своими URL-адресами, вы можете сослаться на определенное представление в URLconf:
Представления имеют необязательные аргументы, которые можно использовать для изменения поведения представления. Например, если вы хотите изменить имя шаблона, которое использует представление, вы можете указать аргумент template_name
. Для этого в URLconf можно указать аргументы в виде ключевых слов, которые будут переданы представлению. Например:
Все представления являются class-based, что позволяет легко настраивать их с помощью подклассов.
Все виды аутентификации¶
Это список со всеми представлениями, которые предоставляет django.contrib.auth
. Подробности реализации смотрите в Использование представлений.
- class
LoginView
¶ Имя URL:
login
Подробнее об использовании именованных шаблонов URL см. в разделе the URL documentation.
Методы и атрибуты
template_name
¶Имя шаблона, отображаемого для представления, используемого для входа пользователя в систему. По умолчанию имеет значение
registration/login.html
.
next_page
¶URL для перенаправления после входа в систему. По умолчанию
LOGIN_REDIRECT_URL
.
redirect_field_name
¶Имя поля
GET
, содержащего URL для перенаправления после входа в систему. По умолчанию используетсяnext
. Переопределяет URLget_default_redirect_url()
, если передан заданный параметрGET
.
authentication_form
¶Вызываемый объект (обычно класс формы), который будет использоваться для аутентификации. По умолчанию
AuthenticationForm
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
redirect_authenticated_user
¶Булево значение, определяющее, будут ли аутентифицированные пользователи, зашедшие на страницу входа, перенаправлены так, как будто они только что успешно вошли в систему. По умолчанию имеет значение
False
.
success_url_allowed_hosts
¶set
хостов, в дополнение кrequest.get_host()
, которые безопасны для перенаправления после входа в систему. По умолчанию используется пустойset
.
get_default_redirect_url
()¶Возвращает URL для перенаправления после входа в систему. Реализация по умолчанию разрешает и возвращает
next_page
, если установлен, илиLOGIN_REDIRECT_URL
в противном случае.
Вот что делает
LoginView
:Вы обязаны предоставить html для шаблона входа в систему, который по умолчанию называется
registration/login.html
. Этому шаблону передаются четыре контекстные переменные шаблона:Если вы предпочитаете не вызывать шаблон
registration/login.html
, вы можете передать параметрtemplate_name
через дополнительные аргументы методуas_view
в вашем URLconf. Например, эта строка URLconf будет использоватьmyapp/login.html
вместо:Вы также можете указать имя поля
GET
, которое содержит URL-адрес для перенаправления на него после входа в систему с помощьюredirect_field_name
. По умолчанию поле называетсяnext
.Вот пример шаблона
registration/login.html
, который вы можете использовать в качестве отправной точки. Он предполагает, что у вас есть шаблонbase.html
, определяющий блокcontent
:Если вы настроили аутентификацию (см. Customizing Authentication), вы можете использовать пользовательскую форму аутентификации, установив атрибут
authentication_form
. Эта форма должна принимать аргумент с ключевым словомrequest
в своем методе__init__()
и предоставлять методget_user()
, который возвращает объект аутентифицированного пользователя (этот метод вызывается только после успешной проверки формы).
- class
LogoutView
¶ Выход пользователя из системы.
Имя URL:
logout
Атрибуты:
next_page
¶URL для перенаправления после выхода из системы. По умолчанию
LOGOUT_REDIRECT_URL
.
template_name
¶Полное имя шаблона для отображения после выхода пользователя из системы. По умолчанию имеет значение
registration/logged_out.html
.
redirect_field_name
¶Имя поля
GET
, содержащего URL для перенаправления после выхода из системы. По умолчанию используется значение'next'
. Переопределяет URLnext_page
, если передан заданный параметрGET
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
success_url_allowed_hosts
¶set
хостов, в дополнение кrequest.get_host()
, которые безопасны для перенаправления после выхода из системы. По умолчанию используется пустое значениеset
.
Контекст шаблона:
logout_then_login
(request, login_url=None)¶Выводит пользователя из системы, а затем перенаправляет на страницу входа в систему.
Имя URL: URL по умолчанию не предоставляется
Дополнительные аргументы:
- class
PasswordChangeView
¶ Имя URL:
password_change
Позволяет пользователю изменить свой пароль.
Атрибуты:
success_url
¶URL для перенаправления после успешной смены пароля. По умолчанию
'password_change_done'
.
form_class
¶Пользовательская форма «Смена пароля», которая должна принимать аргумент в виде ключевого слова
user
. Форма отвечает за фактическое изменение пароля пользователя. По умолчанию используетсяPasswordChangeForm
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
Контекст шаблона:
- class
PasswordChangeDoneView
¶ Имя URL:
password_change_done
Страница, отображаемая после того, как пользователь изменил свой пароль.
Атрибуты:
template_name
¶Полное имя шаблона для использования. По умолчанию
registration/password_change_done.html
, если не указано.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
- class
PasswordResetView
¶ Имя URL:
password_reset
Позволяет пользователю сбросить пароль путем генерации ссылки одноразового использования, которая может быть использована для сброса пароля, и отправки этой ссылки на зарегистрированный адрес электронной почты пользователя.
Если указанный адрес электронной почты не существует в системе, это представление не отправит письмо, но пользователь также не получит никакого сообщения об ошибке. Это предотвращает утечку информации к потенциальным злоумышленникам. Если вы хотите предоставить сообщение об ошибке в этом случае, вы можете подклассифицировать
PasswordResetForm
и использовать атрибутform_class
.Пользователям, отмеченным непригодным паролем (см.
set_unusable_password()
), не разрешается запрашивать сброс пароля, чтобы предотвратить злоупотребления при использовании внешнего источника аутентификации, например LDAP. Обратите внимание, что они не получат никакого сообщения об ошибке, поскольку это раскрыло бы существование их учетной записи, но и почта не будет отправлена.Атрибуты:
template_name
¶Полное имя шаблона, который будет использоваться для отображения формы сброса пароля. По умолчанию имеет значение
registration/password_reset_form.html
, если не указано.
form_class
¶Форма, которая будет использоваться для получения email пользователя для сброса пароля. По умолчанию имеет значение
PasswordResetForm
.
email_template_name
¶Полное имя шаблона, который будет использоваться для создания письма со ссылкой на сброс пароля. По умолчанию имеет значение
registration/password_reset_email.html
, если не указано.
subject_template_name
¶Полное имя шаблона, который будет использоваться для темы письма со ссылкой на сброс пароля. По умолчанию имеет значение
registration/password_reset_subject.txt
, если не указано.
token_generator
¶Экземпляр класса для проверки одноразовой ссылки. По умолчанию это будет
default_token_generator
, это экземплярdjango.contrib.auth.tokens.PasswordResetTokenGenerator
.
success_url
¶URL для перенаправления после успешного запроса на сброс пароля. По умолчанию
'password_reset_done'
.
from_email
¶Действительный адрес электронной почты. По умолчанию Django использует
DEFAULT_FROM_EMAIL
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
html_email_template_name
¶Полное имя шаблона, используемого для генерации многокомпонентного письма text/html со ссылкой для сброса пароля. По умолчанию письмо в формате HTML не отправляется.
extra_email_context
¶Словарь контекстных данных, которые будут доступны в шаблоне письма. Его можно использовать для переопределения значений контекста шаблона по умолчанию, перечисленных ниже, например
domain
.
Контекст шаблона:
Контекст шаблона электронной почты:
Образец
registration/password_reset_email.html
(шаблон тела письма):Тот же контекст шаблона используется для шаблона темы. Тема должна быть однострочной строкой обычного текста.
- class
PasswordResetDoneView
¶ Имя URL:
password_reset_done
Страница, отображаемая после того, как пользователь получил по электронной почте ссылку для сброса пароля. Это представление вызывается по умолчанию, если для
PasswordResetView
не задан явный URLsuccess_url
.Атрибуты:
template_name
¶Полное имя шаблона для использования. По умолчанию
registration/password_reset_done.html
, если не указано.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
- class
PasswordResetConfirmView
¶ Имя URL:
password_reset_confirm
Представляет форму для ввода нового пароля.
Ключевые аргументы из URL:.
Атрибуты:
template_name
¶Полное имя шаблона для отображения представления подтверждения пароля. Значение по умолчанию –
registration/password_reset_confirm.html
.
token_generator
¶Экземпляр класса для проверки пароля. По умолчанию это будет
default_token_generator
, это экземплярdjango.contrib.auth.tokens.PasswordResetTokenGenerator
.
post_reset_login
¶Булево значение, указывающее, следует ли автоматически аутентифицировать пользователя после успешного сброса пароля. По умолчанию имеет значение
False
.
post_reset_login_backend
¶Пунктирный путь к бэкенду аутентификации, который будет использоваться при аутентификации пользователя, если
post_reset_login
являетсяTrue
. Требуется, только если у вас настроено несколькоAUTHENTICATION_BACKENDS
. По умолчанию используетсяNone
.
form_class
¶Форма, которая будет использоваться для установки пароля. По умолчанию имеет значение
SetPasswordForm
.
success_url
¶URL для перенаправления после сброса пароля. По умолчанию
'password_reset_complete'
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
reset_url_token
¶Параметр токена, отображаемый как компонент URL-адресов сброса пароля. По умолчанию имеет значение
'set-password'
.
Контекст шаблона:
- class
PasswordResetCompleteView
¶ Имя URL:
password_reset_complete
Представляет представление, которое информирует пользователя о том, что пароль был успешно изменен.
Атрибуты:
template_name
¶Полное имя шаблона для отображения представления. По умолчанию имеет значение
registration/password_reset_complete.html
.
extra_context
¶Словарь контекстных данных, которые будут добавлены к контекстным данным по умолчанию, переданным в шаблон.
Разрешения по умолчанию¶
Когда django.contrib.auth указано в настройках INSTALLED_APPS, это гарантирует, что четыре разрешения по умолчанию – добавление, изменение, удаление и просмотр – будут созданы для каждой модели Django, определенной в одном из ваших установленных приложений.
Эти разрешения будут созданы при запуске manage.pymigrate; при первом запуске migrate после добавления django.contrib.auth к INSTALLED_APPS разрешения по умолчанию будут созданы для всех ранее установленных моделей, а также для любых новых моделей, устанавливаемых в это время.
После этого он будет создавать разрешения по умолчанию для новых моделей каждый раз, когда вы запускаете manage.pymigrate (функция, создающая разрешения, связана с сигналом post_migrate).
Предположим, что у вас есть приложение с app_labelfoo и моделью с именем Bar, для проверки основных разрешений вы должны использовать:
К модели Permission редко обращаются напрямую.