Django - Connexion avec l'email

Question

Je veux que django authentifie les utilisateurs par e-mail, et non par nom d'utilisateur. Une façon de faire est de fournir la valeur de l'email comme valeur du nom d'utilisateur, mais je ne veux pas cela. La raison en est que j'ai une url /profile/<username>/ donc je ne peux pas avoir d'url /profile/abcd@gmail.com/ .

Une autre raison est que tous les emails sont uniques, mais il arrive parfois que le nom d'utilisateur soit déjà pris. C'est pourquoi je crée automatiquement le nom d'utilisateur en tant que fullName_ID .

Comment puis-je changer le fait que Django s'authentifie avec l'email ?

Voici comment je crée un utilisateur.

username = `abcd28`
user_email = `abcd@gmail.com`
user = User.objects.create_user(username, user_email, user_pass)

C'est ainsi que je me connecte.

email = request.POST['email']
password = request.POST['password']
username = User.objects.get(email=email.lower()).username
user = authenticate(username=username, password=password)
login(request, user)

Existe-t-il un autre moyen de se connecter, à part obtenir le nom d'utilisateur en premier ?

Answer 1

Vous devez écrire un backend d'authentification personnalisé. Quelque chose comme ceci fonctionnera :

from django.contrib.auth import get_user_model
from django.contrib.auth.backends import ModelBackend

class EmailBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        UserModel = get_user_model()
        try:
            user = UserModel.objects.get(email=username)
        except UserModel.DoesNotExist:
            return None
        else:
            if user.check_password(password):
                return user
        return None

Ensuite, définissez ce backend comme votre backend d'authentification dans vos paramètres :

AUTHENTICATION_BACKENDS = ['path.to.auth.module.EmailBackend']

Mise à jour de . hérité de ModelBackend car il met en œuvre des méthodes comme get_user() déjà.

Voir les documents ici : https://docs.djangoproject.com/en/3.0/topics/auth/customizing/#writing-an-authentication-backend

Answer 2

Si vous démarrez un nouveau projet, django vous recommande vivement de mettre en place un modèle d'utilisateur personnalisé. (voir https://docs.djangoproject.com/en/dev/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project )

et si vous l'avez fait, ajoutez trois lignes à votre modèle d'utilisateur :

class MyUser(AbstractUser):
    USERNAME_FIELD = 'email'
    email = models.EmailField(_('email address'), unique=True) # changes email to unique and blank to false
    REQUIRED_FIELDS = [] # removes email from REQUIRED_FIELDS

Puis authenticate(email=email, password=password) fonctionne, tandis que authenticate(username=username, password=password) ne fonctionne plus.

Answer 3

Authentification par courriel pour Django 3.x

Pour utiliser l'email/le nom d'utilisateur et le mot de passe pour l'authentification au lieu de l'authentification par défaut par nom d'utilisateur et mot de passe, nous devons surcharger deux méthodes de la classe ModelBackend : authenticate() et get_user() :

La méthode get_user prend un user_id - qui peut être un nom d'utilisateur, un ID de base de données ou autre, mais doit être unique à votre objet utilisateur - et renvoie un objet utilisateur ou None. Si vous n'avez pas gardé l'email comme clé unique, vous devrez vous occuper des multiples résultats retournés pour le query_set. Dans le code ci-dessous, cela a été pris en charge en retournant le premier utilisateur de la liste retournée.

from django.contrib.auth.backends import ModelBackend, UserModel
from django.db.models import Q

class EmailBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try: #to allow authentication through phone number or any other field, modify the below statement
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            UserModel().set_password(password)
        except MultipleObjectsReturned:
            return User.objects.filter(email=username).order_by('id').first()
        else:
            if user.check_password(password) and self.user_can_authenticate(user):
                return user

    def get_user(self, user_id):
        try:
            user = UserModel.objects.get(pk=user_id)
        except UserModel.DoesNotExist:
            return None

        return user if self.user_can_authenticate(user) else None

Par défaut, AUTHENTICATION_BACKENDS est défini sur :

['django.contrib.auth.backends.ModelBackend']

Dans le fichier settings.py, ajoutez ce qui suit en bas de page pour remplacer la valeur par défaut :

AUTHENTICATION_BACKENDS = ('appname.filename.EmailBackend',)

Answer 4

J'ai eu une exigence similaire où le nom d'utilisateur et l'email doivent fonctionner pour le champ du nom d'utilisateur. Au cas où quelqu'un cherche le moyen d'authentification en backend pour faire cela, vérifiez le code suivant. Vous pouvez changer le queryset si vous souhaitez seulement l'email.

from django.contrib.auth import get_user_model  # gets the user_model django  default or your own custom
from django.contrib.auth.backends import ModelBackend
from django.db.models import Q

# Class to permit the athentication using email or username
class CustomBackend(ModelBackend):  # requires to define two functions authenticate and get_user

    def authenticate(self, username=None, password=None, **kwargs):
        UserModel = get_user_model()

        try:
            # below line gives query set,you can change the queryset as per your requirement
            user = UserModel.objects.filter(
                Q(username__iexact=username) |
                Q(email__iexact=username)
            ).distinct()

        except UserModel.DoesNotExist:
            return None

        if user.exists():
            ''' get the user object from the underlying query set,
            there will only be one object since username and email
            should be unique fields in your models.'''
            user_obj = user.first()
            if user_obj.check_password(password):
                return user_obj
            return None
        else:
            return None

    def get_user(self, user_id):
        UserModel = get_user_model()
        try:
            return UserModel.objects.get(pk=user_id)
        except UserModel.DoesNotExist:
            return None

Ajoutez également AUTHENTICATION_BACKENDS = ('path.to.CustomBackend', ) dans settings.py.

Answer 5

Django 2.x

Comme mentionné par Ganesh ci-dessus, pour django 2.x, la méthode authenticate requiert maintenant un paramètre de requête.

# backends.py
from django.contrib.auth import backends, get_user_model
from django.db.models import Q
UserModel = get_user_model()

class ModelBackend(backends.ModelBackend):

    def authenticate(self, request, username=None, password=None, **kwargs):
        if username is None:
            username = kwargs.get(UserModel.USERNAME_FIELD)
        try:
            # user = UserModel._default_manager.get_by_natural_key(username)
            # You can customise what the given username is checked against, here I compare to both username and email fields of the User model
            user = UserModel.objects.get(Q(username__iexact=username) | Q(email__iexact=username))
        except UserModel.DoesNotExist:
            # Run the default password hasher once to reduce the timing
            # difference between an existing and a nonexistent user (#20760).
            UserModel().set_password(password)
        else:
            if user.check_password(password) and self.user_can_authenticate(user):
                return user
        return super().authenticate(request, username, password, **kwargs)

ajoutez votre backend aux paramètres de votre projet

# settings.py
AUTHENTICATION_BACKENDS = ['path.to.ModelBackend']

Votre modèle d'utilisateur personnalisé devra faire en sorte que les courriels soient uniques pour les utilisateurs actifs et les utilisateurs validés :

from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    objects = UserManager()
    email = models.EmailField(_('email address'), unique=True)

    class Meta:
        verbose_name = _('user')
        verbose_name_plural = _('users')
        db_table = 'auth_user'
        swappable = 'AUTH_USER_MODEL'

Mais pour éviter que quelqu'un ne bloque l'utilisation de son adresse électronique par une autre personne, vous devriez plutôt ajouter la validation de l'adresse électronique et faire en sorte que votre processus d'enregistrement et de connexion tienne compte du fait que les adresses électroniques peuvent ne pas être uniques (et probablement empêcher les nouveaux utilisateurs d'utiliser une adresse électronique existante et validée).