1. Introduction au problème

De nombreuses applications préfèrent utiliser les emails plutôt que des noms d'utilisateur car cela simplifie l'authentification et garantit l'unicité des comptes. L'email est plus facile à mémoriser, évite les conflits de noms d'utilisateur, centralise les communications (comme les réinitialisations de mot de passe), et facilite l'intégration avec des systèmes modernes comme le single sign-on (SSO). Cela rend l'inscription et la connexion plus fluides et sécurisées.

2. Création du projet Django

    2.1. Créer un nouveau projet Django 

Ouvre ton terminal et exécute la commande suivante pour démarrer un projet :  django-admin startproject myproject  

    2.2. Se déplacer dans le répertoire du projet 

   Accède au répertoire du projet créé : cd myproject

    2.3. Créer une nouvelle application Django 

   Crée une application nommée `users` qui gérera l'authentification des utilisateurs : python manage.py startapp users

3. Personnalisation du modèle utilisateur

Dans `models.py`, crée un modèle utilisateur personnalisé basé sur l'email :

from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin

from django.db import models

class UserManager(BaseUserManager):

    def create_user(self, email, password=None, extra_fields):

        if not email:

            raise ValueError('The Email field must be set')

        email = self.normalize_email(email)

        user = self.model(email=email, extra_fields)

        user.set_password(password)

        user.save(using=self._db)

        return user

    def create_superuser(self, email, password=None, extra_fields):

        extra_fields.setdefault('is_staff', True)

        extra_fields.setdefault('is_superuser', True)

        return self.create_user(email, password, extra_fields)

class User(AbstractBaseUser, PermissionsMixin):

    email = models.EmailField(unique=True)

    is_active = models.BooleanField(default=True)

    is_staff = models.BooleanField(default=False)

    objects = UserManager()

    USERNAME_FIELD = 'email'

    REQUIRED_FIELDS = []

    def __str__(self):

        return self.email

4. Configuration du modèle dans Django

Ensuite, indique à Django d'utiliser ce modèle personnalisé dans `settings.py` :

AUTH_USER_MODEL = 'users.User'

5. Formulaires d'inscription et de connexion

Dans `forms.py`, personnalise les formulaires pour l'inscription et la connexion avec l'email comme champ principal :

from django.contrib.auth.forms import UserCreationForm, AuthenticationForm

from .models import User

class CustomUserCreationForm(UserCreationForm):

    class Meta:

        model = User

        fields = ('email',)

class CustomAuthenticationForm(AuthenticationForm):

    class Meta:

        model = User

        fields = ('email', 'password')

6. Mise à jour des vues

Mets à jour les vues pour utiliser les nouveaux formulaires :

from django.urls import reverse_lazy

from django.views.generic.edit import CreateView

from .forms import CustomUserCreationForm

class SignUpView(CreateView):

    form_class = CustomUserCreationForm

    success_url = reverse_lazy('login')

    template_name = 'registration/signup.html'

7. Tests et démonstration

from django.test import TestCase

from django.contrib.auth import get_user_model

from django.urls import reverse

class UserTests(TestCase):

    def setUp(self):

        self.email = 'testuser@example.com'

        self.password = 'Testpass123'

        self.user = get_user_model().objects.create_user(

            email=self.email,

            password=self.password

        )

    def test_create_user_with_email(self):

        """Vérifie qu'un utilisateur peut être créé avec une adresse email"""

        user = get_user_model().objects.get(email=self.email)

        self.assertEqual(user.email, self.email)

        self.assertTrue(user.check_password(self.password))

    def test_user_login(self):

        """Teste la connexion de l'utilisateur avec l'email et le mot de passe"""

        login = self.client.login(email=self.email, password=self.password)

        self.assertTrue(login)

    def test_signup_view(self):

        """Teste l'affichage de la page d'inscription et la création d'un utilisateur"""

        response = self.client.get(reverse('users:signup'))

        self.assertEqual(response.status_code, 200)

        self.assertTemplateUsed(response, 'registration/signup.html')

        new_user_email = 'newuser@example.com'

        response = self.client.post(reverse('users:signup'), {

            'email': new_user_email,

            'password1': 'Newpass123',

            'password2': 'Newpass123'

        })

        self.assertEqual(response.status_code, 302)  # Redirection après inscription

        new_user = get_user_model().objects.get(email=new_user_email)

        self.assertEqual(new_user.email, new_user_email)

8. Conclusion

Utiliser des emails pour l'authentification simplifie la gestion des comptes et améliore l'expérience utilisateur. Cette approche peut également être étendue à d'autres méthodes, comme l'authentification par numéro de téléphone ou les connexions via des réseaux sociaux. Dans l'aticle suivant, nous verrons ensemble comment integrer une verification de l'email specifier par l'utilisateur lors de l'inscription.

Cliquer ici pour accéder au dépôt github qui donne le code complet realiser dans cet article.