Allez plus loin avec le framework Django

Ajoutez une page d’inscription

Notre site dispose maintenant de toutes les fonctionnalités nécessaires pour authentifier des utilisateurs. Pour continuer, nous pouvons ajouter une page d’inscription.

Tous les formulaires utilisés dans les vues d’authentification basées sur des classes sont également disponibles seuls. Cela vous permet de les utiliser lorsque vous implémentez vos propres vues de connexion. Bien que Django ne donne pas de vue basée sur une classe pour l’inscription, il fournit un formulaire de création d’utilisateur,UserCreationForm  .

Vous pouvez importer tous les formulaires du packageauth  depuisdjango.contrib.auth.forms   .

Utilisons  UserCreationForm  pour implémenter une vue d’inscription. Découvrez ci-dessous la marche à suivre en vidéo :

Implémentez une vue d’inscription avec

Étape 1 : Spécialisez UserCreationForm

UserCreationForm  est un   ModelForm   qui possède trois champs :username ,password1,et password2. Comme nous demandons également d’autres champs à l’utilisateur, nous allons devoir spécialiser ce formulaire.

Premièrement, héritez du formulaire et ajoutez vos champs.

# authentication/forms.py
from django.contrib.auth import get_user_model
from django.contrib.auth.forms import UserCreationForm


class SignupForm(UserCreationForm):
    class Meta(UserCreationForm.Meta):
        model = get_user_model()
        fields = ('username', 'email', 'first_name', 'last_name', 'role')

Étant donné que nous héritons d’unModelForm, la meilleure pratique est d’hériter également de sa classe interneMeta.

Nous utilisons également la méthode utilitaire  get_user_model, qui vous permet d’obtenir le modèle  User sans l’importer directement. C’est particulièrement important si vous construisez une application conçue pour être réutilisée dans différents projets.

Étape 2 : Ajoutez une vue d’inscription

Maintenant que nous avons le formulaire, il nous faut simplement nous occuper de l’ajout de la vue, de l’écriture du gabarit, et de son inclusion dans les modèles d’URL !

Premièrement, la vue :

# authentication/views.py
from django.conf import settings
from django.contrib.auth import login
from django.shortcuts import redirect, render

from . import forms


def signup_page(request):
    form = forms.SignupForm()
    if request.method == 'POST':
        form = forms.SignupForm(request.POST)
        if form.is_valid():
            user = form.save()
            # auto-login user
            login(request, user)
            return redirect(settings.LOGIN_REDIRECT_URL)
return render(request, 'authentication/signup.html', context={'form': form})

La meilleure façon d’accéder aux paramètres généraux est d’importerdjango.conf.settings. Cela vous permet d’accéder à  LOGIN_REDIRECT_URL, que vous utiliserez pour la redirection après une inscription réussie. Vous avez aussi utilisé la fonction  login  pour connecter l’utilisateur automatiquement.

Étape 3 : Configurez les gabarits

Deuxièmement, le gabarit :

# authentication/templates/authentication/signup.html
{% extends 'base.html' %}
{% block content %}
    <h2>Inscription</h2>
    {% if form.errors %}
        {{ form.errors }}
    {% endif %}
    <form method="post">
        {{ form.as_p }}
        {% csrf_token %}
        <button type="submit" >S’inscrire</button>
    </form>
{% endblock content %}

Ajoutons également un lien d’inscription sur la page de connexion.

# authentication/templates/authentication/login.html
{% extends 'base.html' %}
{% block content %}
    <form method="post">
        {{ form.as_p }}
        {% csrf_token %}
        <button type="submit" >Se connecter</button>
    </form>
    <p>Pas encore membre ? <a href="{% url 'signup' %}">Inscrivez-vous maintenant !</a></p>
{% endblock content %}

Étape 4 : Ajoutez le modèle d’URL

Et maintenant, mettez à jour les modèles d’URL.

# fotoblog/urls.py
urlpatterns = [
    ...
    path('signup/', authentication.views.signup_page, name='signup'),
]

Voyons si ça a marché. Voici à quoi devrait maintenant ressembler votre page :

Beau travail ! Essayez d’inscrire vous-même un utilisateur.

Vous verrez toutes les restrictions sur le mot de passe. Il s’agit des validateurs de mot de passe par défaut de Django, mais vous pouvez les configurer pour qu’ils soient aussi forts ou aussi faibles que vous le souhaitez. Voyons comment nous y prendre.

Personnalisez la validation de mot de passe

Vous devez utiliser des validateurs pour personnaliser la validation de mot de passe. Les validateurs sont des classes utilisées pour valider les données entrantes d’un champ. Le module  auth  fournit quatre validateurs de mots de passe différents, qui se trouvent dans  django.contrib.auth.password_validation  .  

Les validateurs par défaut sont les suivants :

• UserAttributeSimilarityValidator  : invalide le mot de passe s’il est trop similaire aux informations utilisateur.

• MinimumLengthValidator  : invalide le mot de passe en dessous d’une longueur minimale.

• CommonPasswordValidator  : invalide le mot de passe s’il se trouve dans une liste de mots de passe courants.

• NumericPasswordValidator   : invalide le mot de passe s’il est entièrement numérique.

Tous ces validateurs sont activés par défaut, mais vous pouvez les configurer avec  AUTH_PASSWORD_VALIDATORS   dans les paramètres.

Voici la configuration par défaut.

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

Imaginons que les restrictions de mot de passe par défaut soient trop strictes. Vous voulez imposer les obligations suivantes pour le mot de passe :

• Il doit faire au moins huit caractères de long ;

• Il doit contenir des lettres ;

• Il doit contenir des chiffres.

Pour mettre ces conditions en œuvre, il vous faudra créer des validateurs sur mesure. Voyons comment en vidéo :

Étape 1 : Créez les validateurs

Tout d’abord, créez un nouveau fichier nommé   validators.py   qui contiendra vos validateurs.

Un validateur est une classe qui n’a besoin que de deux méthodes : une méthode  validate  et une méthode  get_help_text .

Construisons un validateur vérifiant que le mot de passe contient une lettre.

# authentication/validators.py
from django.core.exceptions import ValidationError


class ContainsLetterValidator:
    def validate(self, password, user=None):
        if not any(char.isalpha() for char in password):
            raise ValidationError(
                'Le mot de passe doit contenir une lettre', code='password_no_letters')
                
    def get_help_text(self):
        return 'Votre mot de passe doit contenir au moins une lettre majuscule ou minuscule.'

La méthode  validate  vérifie le mot de passe et provoque une  ValidationError  si le mot de passe ne remplit pas le critère. La méthode  get_help_text  guide l’utilisateur final pour qu’il sache comment passer la validation.

Étape 2 : Configurez les paramètres pour utiliser le validateur personnalisé

Maintenant que le validateur est construit, ajoutons-le aux paramètres. Nous utiliserons également le  MinimumLengthValidator, que nous pouvons configurer à l’aide de la clé  OPTIONS.

# fotoblog/settings.py  
AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
        'OPTIONS': {
            'min_length': 8,
        }
    },
    {
        'NAME': 'authentication.validators.ContainsLetterValidator',
    },
]

Allez voir maintenant la page d’inscription.

On dirait que ça a marché ! Essayez de tester la fonctionnalité de mot de passe.

Ces validateurs fonctionnent très bien pour les mots de passe, mais vous pouvez aussi les utiliser pour d’autres champs.

Si vous voulez vérifier par exemple qu’un code postal est valide, vous pouvez définir un  PostCodeValidator  dans votre fichier de validateurs, puis le spécifier dans le formulaire.

from . import validators


class PostCodeForm(forms.Form):
    post_code = forms.CharField(max_length=10, validators=[validators.PostCodeValidator])

Vous pouvez maintenant valider des informations entrantes pour vous assurer que les données contenues dans votre base de données sont cohérentes.

C'est à vous ! Créez votre propre validateur de mot de passe

Vous savez comment vérifier si les mots de passe utilisateur contiennent au moins une lettre. Maintenant, vérifiez s’ils contiennent au moins un chiffre.

Essayez de créer un validateur qui vérifiera le mot de passe pour voir s’il contient un chiffre en utilisant  if not  any(character.is_digit() for character in password).

Vous devrez :

• Créer le   ContainsNumberValidator  dans   authentication/validators.py .

• Configurer   AUTH_PASSWORD_VALIDATORS  dans les paramètres pour utiliser le validateur.

Une fois que vous aurez terminé, vérifiez votre implémentation par rapport à la solution dans le dépôt GitHub.

Trouvez et utilisez des packages Django tiers

Vous avez construit une application d’ authentication   (authentification)  qui peut gérer l’inscription et la connexion d’utilisateurs. Néanmoins, nous pourrions ajouter beaucoup plus de fonctionnalités d’authentification. Par exemple :

• La vérification par email.

• L’intégration de la connexion unique avec les comptes sur les réseaux sociaux.

• Des emails de réinitialisation de mot de passe.

La construction de toutes ces fonctionnalités serait un gros travail. Et pourtant, ces tâches sont communes à un grand nombre de sites.

Non, ce n’est pas nécessaire.

Une grande communauté de développeurs soutient Django. Nombre d’entre eux créent et publient des packages réutilisables dont la communauté peut se servir.

Retrouvez-les sur Django Packages (ressource en anglais) !

Suivez le screencast pour explorer les packages Django. Vous découvrirez comment trouver un package permettant de configurer l’authentification plus rapidement et plus facilement.

Il y a plusieurs considérations à prendre en compte lorsqu’on choisit un package :

• Il est activement maintenu. Un projet non maintenu ne recevra pas de mises à jour pour être compatible avec les nouvelles versions de Django, et les bugs ne seront pas corrigés. Vous pouvez regarder la date de la dernière mise à jour du dépôt sur GitHub. 

• Il est populaire. Les projets à forte popularité sont moins susceptibles de contenir des bugs, mais aussi plus susceptibles d’avoir une communauté de développeurs qui ouvriront activement des pull requests pour réparer les bugs. Une bonne manière d’évaluer la popularité d’un dépôt est de voir son nombre d’étoiles sur GitHub.

• Il est compatible avec votre version de Python.

• Il est compatible avec votre version de Django.

• Beta ou Production. En règle générale, préférez un package en Production. Il existe tout de même des packages Django robustes en phase Beta. Si tous les autres critères sont remplis et que le package est en Beta, vous pouvez probablement l’utiliser sans problèmes.

Si vous travaillez avec un package et que vous trouvez un bug, signalez-le sur GitHub avec une issue. Si vous vous en sentez le courage, dupliquez le dépôt (créez un fork), corrigez-le vous-même, puis ouvrez une pull request. Félicitations, vous êtes maintenant un contributeur open-source !

Une dernière chose à garder en tête : de nombreux packages sont faits par amour de l’art. Ils sont maintenus par des personnes qui prennent sur leur temps libre, de façon complètement bénévole. Les questions et les propositions d’aide seront souvent bien reçues, mais les demandes trop pressantes risquent de ne pas être accueillies chaleureusement !

En résumé 

• Vous pouvez utiliser des formulaires d’authentification Django génériques dans votre projet pour gagner du temps.

• Vous pouvez spécifier des validateurs de mot de passe avec le paramètre   AUTH_PASSWORD_VALIDATORS.

• Utilisez Django Packages pour trouver des packages tiers à intégrer à votre site.

Vous avez réussi à construire une application d’authentification. Maintenant, il est temps de répondre à un quiz sur ce que vous avez appris !