Implémentation de la fonction d'authentification du modèle utilisateur personnalisé dans Django REST Framework à l'aide de djoser
Qu'est-ce que Djoser
djoser est une bibliothèque qui prend en charge l'authentification et l'enregistrement des utilisateurs de base sur le Django REST Framework. Il peut également être utilisé pour des modèles personnalisés et est conçu pour une architecture qui s'adapte mieux à l'application à page unique (SPA) plutôt que de réutiliser le code Django.
Cette fois, j'écrirai sur l'implémentation de la fonction d'authentification la plus simple de djoser. Notez que cette authentification ne doit pas être réellement utilisée pour des raisons de sécurité, et il existe des paramètres de sécurité plus forts tels que l'authentification JWT ci-dessous. Je vais l'introduire comme une simple certification jusqu'au dernier.
Le code source est ici
Tous les éléments suivants peuvent être utilisés comme points de terminaison après l'installation.
/users/ /users/me/ /users/confirm/ /users/resend_activation/ /users/set_password/ /users/reset_password/ /users/reset_password_confirm/ /users/set_username/ /users/reset_username/ /users/reset_username_confirm/ /token/login/ (Token Based Authentication) /token/logout/ (Token Based Authentication) /jwt/create/ (JSON Web Token Authentication) /jwt/refresh/ (JSON Web Token Authentication) /jwt/verify/ (JSON Web Token Authentication) Getting started
J'ai écrit d'autres articles liés à djoser.
- Implémentation de la fonction d'authentification dans Django REST Framework à l'aide de djoser
- Implémentation de la fonction d'authentification JWT dans Django REST Framework à l'aide de djoser
Cette fois, nous implémenterons l'authentification des utilisateurs à l'aide de l'authentification JWT.
Comment utiliser
Le flux jusqu'au milieu est le même que l'heure d'authentification JWT, et les principaux changements sont l'écriture de models.py par vous-même et l'augmentation de certains paramètres.py.
$ pip install -U djoser
Puisque l'authentification JWT est utilisée, simple_jwt doit également être utilisé.
$ pip install -U djangorestframework_simplejwt
Tout d'abord, faites un projet
$ django-admin startproject djoser_customuser
Entrez dans le projet
$ cd djoser_customuser
Créez une application.
$ django-admin startapp accounts
Ensuite, nous allons configurer Django.
setings.py
from datetime import timedelta # add
.........
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework', # add
'djoser', # add
'accounts' # add
]
# add
SIMPLE_JWT = {
#Définir le jeton sur JWT
'AUTH_HEADER_TYPES':('JWT'),
#Définition de la durée du jeton
'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60)
}
# add
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework_simplejwt.authentication.JWTAuthentication',
),
}
# add
AUTH_USER_MODEL = 'user.accounts'
urls.py
from django.contrib import admin
from django.urls import path,include #add
urlpatterns = [
path('admin/', admin.site.urls),
path('api/auth/',include('djoser.urls')), #add
path('api/auth/',include('djoser.urls.jwt')), #add
]
À partir de là, j'écrirai un modèle d'utilisateur personnalisé pour la pièce qui est très différente de l'article de certification JWT. En ce qui concerne la raison pour laquelle nous utilisons un modèle utilisateur personnalisé au lieu du modèle par défaut, en général, le modèle utilisateur fourni par défaut n'est pas suffisant lors de la création de l'application Web que nous voulons, et le développement a progressé. Puisqu'il est difficile de modifier le modèle utilisateur ultérieurement, il est souhaitable de concevoir un modèle utilisateur personnalisé qui répond aux exigences à l'avance.
De plus, Django est livré avec deux classes, la classe "AbstractUser" et la "AbstractBaseUser", qui sont incluses par défaut.
- AbstractUser
Comme il est similaire à la classe User, il est facile à utiliser car il nécessite moins de codage. Par conséquent, il est souvent utilisé lors de l'ajout d'attributs uniquement.
- AbstractBaseUser
Il nécessite plus de codage car vous devez écrire le nom d'utilisateur et d'autres attributs, mais il est plus flexible que AbstractUser.
Généralement, il présente les caractéristiques ci-dessus. Cette fois, nous utiliserons "AbstactBaseUser".
models.py
from django.db import models
# add
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.utils.translation import gettext_lazy as _
from django.contrib.auth.validators import UnicodeUsernameValidator
from django.utils import timezone
from django.core.mail import send_mail
from django.contrib.auth.base_user import BaseUserManager
# add
class UserManager(BaseUserManager):
use_in_migrations = True
def _create_user(self, username, email, password, **extra_fields):
"""
Create and save a user with the given username, email, and password.
"""
if not username:
raise ValueError('The given username must be set')
email = self.normalize_email(email)
username = self.model.normalize_username(username)
user = self.model(username=username, email=email, **extra_fields)
user.set_password(password)
user.save(using=self._db)
return user
def create_user(self, username, email=None, password=None, **extra_fields):
extra_fields.setdefault('is_staff', False)
extra_fields.setdefault('is_superuser', False)
return self._create_user(username, email, password, **extra_fields)
def create_superuser(self, username, email, password, **extra_fields):
extra_fields.setdefault('is_staff', True)
extra_fields.setdefault('is_superuser', True)
if extra_fields.get('is_staff') is not True:
raise ValueError('Superuser must have is_staff=True.')
if extra_fields.get('is_superuser') is not True:
raise ValueError('Superuser must have is_superuser=True.')
return self._create_user(username, email, password, **extra_fields)
class User(AbstractBaseUser, PermissionsMixin):
"""
An abstract base class implementing a fully featured User model with
admin-compliant permissions.
Username and password are required. Other fields are optional.
"""
username_validator = UnicodeUsernameValidator()
username = models.CharField(
_('username'),
max_length=150,
unique=True,
help_text=_('Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.'),
validators=[username_validator],
error_messages={
'unique': _("A user with that username already exists."),
},
)
first_name = models.CharField(_('first name'), max_length=30, blank=True)
last_name = models.CharField(_('last name'), max_length=150, blank=True)
email = models.EmailField(_('email address'), blank=True,unique=True)
profile = models.CharField(_('profile'), max_length=255, blank=True) # add
is_staff = models.BooleanField(
_('staff status'),
default=False,
help_text=_('Designates whether the user can log into this admin site.'),
)
is_active = models.BooleanField(
_('active'),
default=True,
help_text=_(
'Designates whether this user should be treated as active. '
'Unselect this instead of deleting accounts.'
),
)
date_joined = models.DateTimeField(_('date joined'), default=timezone.now)
objects = UserManager()
EMAIL_FIELD = 'email' # fix
USERNAME_FIELD = 'email' # fix
REQUIRED_FIELDS = ['username'] # fix
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
def clean(self):
super().clean()
self.email = self.__class__.objects.normalize_email(self.email)
def get_full_name(self):
"""
Return the first_name plus the last_name, with a space in between.
"""
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
"""Return the short name for the user."""
return self.first_name
def email_user(self, subject, message, from_email=None, **kwargs):
"""Send an email to this user."""
send_mail(subject, message, from_email, [self.email], **kwargs)
Après cela, le flux est exactement le même que celui de l'article JWT. Cependant, il y a une différence, d'abord dans models.py
models.py
EMAIL_FIELD = 'email' # fix
USERNAME_FIELD = 'email' # fix
REQUIRED_FIELDS = ['username'] # fix
Jusqu'à présent, le nom d'utilisateur était un élément obligatoire lors de la création d'un utilisateur, mais cette fois, l'e-mail est un élément obligatoire. Lors de l'utilisation d'un service Web, le courrier électronique doit être un élément obligatoire plutôt qu'un nom d'utilisateur. Ce sont également les avantages de l'utilisation d'utilisateurs personnalisés.
Migrez et créez un super utilisateur.
$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py createsuperuser
Email address: [email protected]
Username: Admin
Password:***********
Commencez sur l'hôte local et spécifiez http://localhost:8000/api/auth Accéder.
$ python manage.py runserver
Et http://localhost:8000/api/auth/users/ Lorsque vous accédez
Les informations utilisateur ne peuvent pas être obtenues car elles ne sont toujours pas authentifiées. Alors, comme la dernière fois, pour obtenir un jeton http://localhost:8000/api/auth/jwt/create/ Accédez, entrez la valeur du super utilisateur que vous avez enregistré précédemment et appuyez sur POST en bas à droite.
Ensuite, le jeton suivant sera émis et le jeton d'accès en bas sera copié.
Obtenons réellement les informations utilisateur en utilisant la commande curl.
curl -LX GET http://127.0.0.1:8000/api/auth/users/me/ -H 'Authorization: JWT xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
(Entrez le jeton dans xxxx)
Puis
{"username":"Admin","id":1,"email":"[email protected]"}
Les informations utilisateur que vous avez enregistrées précédemment seront renvoyées.
Recommended Posts