Gestion des utilisateurs Django – Real Python

By | juillet 1, 2020

Formation Python

Si vous avez terminé la première partie de cette série, vous avez peut-être déjà beaucoup d'idées pour vos propres applications Django. À un moment donné, vous pourriez décider de les étendre avec des comptes d'utilisateurs. Dans ce didacticiel pas à pas, vous apprendrez à utiliser la gestion des utilisateurs Django et à l'ajouter à votre programme.

À la fin de ce didacticiel, vous serez en mesure de:

  • Créez une application où les utilisateurs peuvent S'inscrire, s'identifier, et réinitialiser et changer les mots de passe par eux-même
  • Modifier la valeur par défaut Modèles Django responsable de gestion des utilisateurs
  • Envoyer des e-mails de réinitialisation de mot de passe aux adresses e-mail réelles
  • Authentifier en utilisant un service externe

Commençons!

Configurer un projet Django

Ce didacticiel utilise Django 3.0 et Python 3.6. Il se concentre sur la gestion des utilisateurs, de sorte que vous n'utiliserez aucun style avancé ou réactif. Il ne traite pas non plus des groupes et des autorisations, mais uniquement de la création et de la gestion des comptes d'utilisateurs.

C'est une bonne idée d'utiliser un environnement virtuel lorsque vous travaillez avec des projets Python. De cette façon, vous pouvez toujours être sûr que le python commande pointe vers la bonne version de Python et que les modules requis par votre projet ont des versions correctes. Pour en savoir plus, consultez Python Virtual Environments: A Primer.

Pour configurer un environnement virtuel sur Linux et macOS, exécutez ces commandes:

$ python3 -m venv venv
$ la source venv / bin / activate
(venv) $ python -m pip install --upgrade pip
(venv) $ python -m pip install django

Pour activer un environnement virtuel sur Windows, exécutez cette commande:

C: > venv  Scripts  activate

Maintenant que l'environnement est prêt, vous pouvez créer un nouveau projet et une application pour stocker tout votre code de gestion des utilisateurs:

(venv) $ django-admin startproject awesome_website
(venv) $ CD awesome_website
(venv) $ utilisateurs de startapp python manage.py

Dans cet exemple, votre application est appelée utilisateurs. N'oubliez pas que vous devez l'installer en l'ajoutant à INSTALLED_APPS:

# awesome_website / settings.py

INSTALLED_APPS = [[[[
    "utilisateurs",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

Ensuite, appliquez les migrations et exécutez le serveur:

(venv) $ migration de python manage.py
(venv) $ python manage.py runserver

Cela créera tous les modèles liés à l'utilisateur dans la base de données et démarrera votre application à http: // localhost: 8000 /.

Il y a encore une chose que vous devez faire pour cette configuration. Par défaut, Django applique des mots de passe forts pour rendre les comptes d'utilisateurs moins sujets aux attaques. Mais vous allez changer de mot de passe très souvent au cours de ce didacticiel, et trouver un mot de passe fort à chaque fois serait très gênant.

Vous pouvez résoudre ce problème en désactivant les validateurs de mot de passe dans les paramètres. Il suffit de les commenter, en laissant une liste vide:

# awesome_website / settings.py

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",
    #,
]

Maintenant, Django vous permettra de définir des mots de passe comme mot de passe ou même passer, ce qui rend votre travail avec le système de gestion des utilisateurs beaucoup plus facile. N'oubliez pas d'activer les validateurs dans votre application actuelle!

Pour ce didacticiel, il serait également utile d'avoir accès au panneau d'administration afin de pouvoir suivre les utilisateurs nouvellement créés et leurs mots de passe. Allez-y et créez un utilisateur administrateur:

(venv) $ python manage.py crée un superutilisateur
Nom d'utilisateur (laissez vide pour utiliser 'pawel'): admin
Adresse e-mail: admin@example.com
Mot de passe:
Mot de passe (à nouveau):
Le superutilisateur a été créé avec succès.

Avec les validateurs de mot de passe désactivés, vous pouvez utiliser n'importe quel mot de passe que vous aimez.

Créer une vue de tableau de bord

La plupart des systèmes de gestion des utilisateurs ont une sorte de page principale, généralement appelée tableau de bord. Vous allez créer un tableau de bord dans cette section, mais comme ce ne sera pas la seule page de votre application, vous créerez également un modèle de base pour conserver la cohérence du site Web.

Vous n'utiliserez aucune des fonctionnalités avancées du modèle de Django, mais si vous avez besoin d'un rafraîchissement de la syntaxe du modèle, vous voudrez peut-être consulter la documentation du modèle de Django.

Créez un modèle de base appelé base.html avec le contenu suivant:



<h1>Bienvenue sur Awesome Website</h1>

% bloquer contenu %
% bloc d'extrémité %

Le modèle de base ne fait pas grand-chose. Il montre le message Bienvenue sur Awesome Website et définit un bloc appelé contenu. Le bloc est vide pour l'instant, et d'autres modèles vont l'utiliser pour inclure leur propre contenu.

Vous pouvez maintenant créer un modèle pour le tableau de bord. Il faut l'appeler users / dashboard.html et devrait ressembler à ceci:



% étend 'base.html' %

% bloquer contenu %
Bonjour,  user.username!
% bloc d'extrémité %

Cela n'ajoute pas encore grand-chose au modèle de base. Il affiche simplement le message de bienvenue avec le nom d'utilisateur de l'utilisateur actuel. Si l'utilisateur n'est pas connecté, Django définira toujours le utilisateur variable à l'aide d'un Utilisateur anonyme objet. Un utilisateur anonyme a toujours un nom d'utilisateur vide, donc le tableau de bord affichera Bonjour, invité!

Pour que votre modèle fonctionne, vous devez créer une vue qui le rend et une URL qui utilise la vue:

# users / views.py

de django.shortcuts importer rendre

def tableau de bord(demande):
    revenir rendre(demande, "users / dashboard.html")

Créez maintenant un users / urls.py fichier et ajouter un chemin d'accès pour le tableau de bord vue:

# users / urls.py

de django.conf.urls importer url
de users.views importer tableau de bord

urlpatterns = [[[[
    url(r"^ tableau de bord /", tableau de bord, Nom="tableau de bord"),
]

N'oubliez pas d'ajouter les URL de votre application aux URL de votre projet:

# awesome_website / urls.py

de django.conf.urls importer comprendre, url
de django.contrib importer administrateur

urlpatterns = [[[[
    url(r"^", comprendre("users.urls")),
    url(r"^ admin /", administrateur.site.urls),
]

Vous pouvez maintenant tester la vue du tableau de bord. Ouvert http: // localhost: 8000 / dashboard / dans votre navigateur. Vous devriez voir un écran similaire à celui-ci:

Tableau de bord pour les invités

Ouvrez maintenant le panneau d'administration à http: // localhost: 8000 / admin / et connectez-vous en tant qu'utilisateur administrateur. Votre tableau de bord devrait maintenant être un peu différent:

Tableau de bord pour les utilisateurs connectés

Comme vous pouvez le voir, votre nouveau modèle affiche correctement le nom de l'utilisateur actuellement connecté.

Travailler avec Django User Management

Un site Web complet a besoin d'un peu plus qu'un simple tableau de bord. Heureusement, Django possède de nombreuses ressources liées à la gestion des utilisateurs qui s'occupent de presque tout, y compris la connexion, la déconnexion, le changement de mot de passe et la réinitialisation du mot de passe. Cependant, les modèles ne font pas partie de ces ressources. Vous devez les créer vous-même.

Commencez par ajouter les URL fournies par le système d'authentification Django dans votre application:

# users / urls.py

de django.conf.urls importer comprendre, url
de users.views importer tableau de bord

urlpatterns = [[[[
    url(r"^ comptes /", comprendre("django.contrib.auth.urls")),
    url(r"^ tableau de bord /", tableau de bord, Nom="tableau de bord"),
]

Cela vous donnera accès à toutes les URL suivantes:

  • comptes / connexion / est utilisé pour connecter un utilisateur à votre application. Référez-vous-y par son nom "s'identifier".

  • comptes / déconnexion / est utilisé pour déconnecter un utilisateur de votre application. Référez-vous-y par son nom "Se déconnecter".

  • comptes / changement de mot de passe / est utilisé pour changer un mot de passe. Référez-vous-y par son nom "changement de mot de passe".

  • comptes / changement de mot de passe / terminé / est utilisé pour afficher une confirmation qu'un mot de passe a été modifié. Référez-vous-y par son nom "password_change_done".

  • comptes / password_reset / est utilisé pour demander un e-mail avec un lien de réinitialisation de mot de passe. Référez-vous-y par son nom "Réinitialisation du mot de passe".

  • comptes / password_reset / done / est utilisé pour afficher une confirmation qu'un e-mail de réinitialisation du mot de passe a été envoyé. Référez-vous-y par son nom "password_reset_done".

  • comptes / réinitialiser /// est utilisé pour définir un nouveau mot de passe à l'aide d'un lien de réinitialisation de mot de passe. Référez-vous-y par son nom "password_reset_confirm".

  • comptes / réinitialiser / terminé / est utilisé pour afficher une confirmation qu'un mot de passe a été réinitialisé. Référez-vous-y par son nom "password_reset_complete".

Cela peut sembler un peu écrasant, mais ne vous inquiétez pas. Dans les sections suivantes, vous apprendrez ce que fait chacune de ces URL et comment les ajouter à votre application.

Créer une page de connexion

Pour la page de connexion, Django essaiera d'utiliser un modèle appelé registration / login.html. Allez-y et créez-le:



% étend 'base.html' %

% bloquer contenu %
<H2>S'identifier</H2>

<forme méthode="Publier">
    % csrf_token %
     form.as_p 
    <contribution type="soumettre" valeur="S'identifier">
</forme>

<une href="% url 'tableau de bord' %">Retour au tableau de bord</une>
% bloc d'extrémité %

Cela affichera un S'identifier en-tête, suivi d'un formulaire de connexion. Django utilise un dictionnaire, également appelé le contexte, pour transmettre des données à un modèle lors du rendu. Dans ce cas, une variable appelée forme sera déjà inclus dans le contexte – il vous suffit de l'afficher. En utilisant form.as_p rendra le formulaire sous la forme d'une série de paragraphes HTML, ce qui le rendra un peu plus agréable que juste forme .

le % csrf_token% La ligne insère un jeton de falsification de requête intersite (CSRF), qui est requis par chaque formulaire Django. Il existe également un bouton pour envoyer le formulaire et, à la fin du modèle, un lien qui ramènera vos utilisateurs vers le tableau de bord.

Vous pouvez encore améliorer l'apparence du formulaire en ajoutant un petit script CSS au modèle de base:



<style>
    étiquette, contribution 
        afficher: bloquer;
    
    envergure.Texte d'aide 
        afficher: aucun;
    
</style>

<h1>Bienvenue sur Awesome Website</h1>

% bloquer contenu %
% bloc d'extrémité %

En ajoutant le code ci-dessus au modèle de base, vous améliorerez l'apparence de tous vos formulaires, pas seulement celui du tableau de bord.

Vous pouvez maintenant ouvrir http: // localhost: 8000 / accounts / login / dans votre navigateur, et vous devriez voir quelque chose comme ceci:

Page de connexion

Utilisez les informations d'identification de votre administrateur et appuyez sur S'identifier. Ne vous inquiétez pas si vous voyez un écran d'erreur:

URL de profil utilisateur manquante dans Django

Selon le message d'erreur, Django ne trouve pas de chemin pour comptes / profil /, qui est la destination par défaut de vos utilisateurs après une connexion réussie. Au lieu de créer une nouvelle vue, il serait plus logique de réutiliser la vue du tableau de bord ici.

Heureusement, Django facilite le changement de la redirection par défaut. Il vous suffit d'ajouter une ligne à la fin du fichier de paramètres:

# awesome_website / settings.py

LOGIN_REDIRECT_URL = "tableau de bord"

Essayez de vous reconnecter. Cette fois, vous devez être redirigé vers le tableau de bord sans aucune erreur.

Créer une page de déconnexion

Vos utilisateurs peuvent désormais se connecter, mais ils devraient également pouvoir se déconnecter. Ce processus est plus simple car il n'y a pas de formulaire: il suffit de cliquer sur un lien. Après cela, Django redirigera vos utilisateurs vers comptes / déconnexion et essaiera d'utiliser un modèle appelé registration / connected_out.html.

Cependant, comme précédemment, vous pouvez modifier la redirection. Par exemple, il serait judicieux de rediriger vos utilisateurs vers le tableau de bord. Pour ce faire, vous devez ajouter une ligne à la fin du fichier de paramètres:

# awesome_website / settings.py

LOGOUT_REDIRECT_URL = "tableau de bord"

Maintenant que la connexion et la déconnexion fonctionnent, ce serait une bonne idée d'ajouter des liens appropriés à votre tableau de bord:



% étend 'base.html' %

% bloquer contenu %
Bonjour,  user.username!

<div>
    % si user.is_authenticated %
        <une href="% url 'Se déconnecter' %">Se déconnecter</une>
    % autre %
        <une href="% url 's'identifier' %">S'identifier</une>
    % fin si %
</div>
% bloc d'extrémité %

Si un utilisateur est connecté, alors user.is_authenticated reviendra Vrai et le tableau de bord affichera la Se déconnecter lien. Si un utilisateur n'est pas connecté, alors utilisateur variable sera définie sur Utilisateur anonyme, et user.is_authenticated reviendra Faux. Dans ce cas, le S'identifier le lien sera affiché.

Le tableau de bord mis à jour devrait ressembler à ceci pour les utilisateurs non authentifiés:

Tableau de bord avec un lien de connexion

Si vous vous connectez, vous devriez voir cet écran:

Tableau de bord avec un lien de déconnexion

Toutes nos félicitations! Vous venez de terminer la partie la plus importante du système de gestion des utilisateurs: la connexion et la déconnexion des utilisateurs à l'application. Mais il vous reste encore quelques pas.

Changer les mots de passe

À un moment donné, vos utilisateurs pourraient vouloir changer leurs mots de passe. Au lieu de leur demander à l'administrateur de le faire pour eux, vous pouvez ajouter un formulaire de changement de mot de passe à votre application. Django a besoin de deux modèles pour que cela fonctionne:

  1. registration / password_change_form.html pour afficher le formulaire de changement de mot de passe

  2. registration / password_change_done.html pour afficher une confirmation que le mot de passe a bien été modifié

Commencer avec registration / password_change_form.html:



% étend 'base.html' %

% bloquer contenu %
<H2>Changer le mot de passe</H2>

<forme méthode="Publier">
    % csrf_token %
     form.as_p 
    <contribution type="soumettre" valeur="Changement">
</forme>

<une href="% url 'tableau de bord' %">Retour au tableau de bord</une>
% bloc d'extrémité %

Ce modèle ressemble presque au modèle de connexion que vous avez créé précédemment. Mais cette fois, Django mettra un formulaire de changement de mot de passe ici, pas un formulaire de connexion, donc le navigateur l'affichera différemment.

L'autre modèle que vous devez créer est registration / password_change_done.html:



% étend 'base.html' %

% bloquer contenu %
<H2>Mot de passe changé</H2>

<une href="% url 'tableau de bord' %">Retour au tableau de bord</une>
% bloc d'extrémité %

Cela rassurera vos utilisateurs que le changement de mot de passe a réussi et les laissera revenir au tableau de bord.

Le tableau de bord serait un endroit parfait pour inclure un lien vers votre formulaire de changement de mot de passe nouvellement créé. Vous devez simplement vous assurer qu'il ne s'affiche qu'aux utilisateurs connectés:



% étend 'base.html' %

% bloquer contenu %
Bonjour,  user.username!

<div>
    % si user.is_authenticated %
        <une href="% url 'Se déconnecter' %">Se déconnecter</une>
        <une href="% url 'changement de mot de passe' %">Changer le mot de passe</une>
    % autre %
        <une href="% url 's'identifier' %">S'identifier</une>
    % fin si %
</div>
% bloc d'extrémité %

Si vous suivez le lien dans votre navigateur, vous devriez voir le formulaire suivant:

Formulaire de changement de mot de passe

Allez-y et testez-le. Modifiez le mot de passe, déconnectez-vous et reconnectez-vous. Vous pouvez également essayer d'accéder à la page de changement de mot de passe sans vous connecter en accédant à l'URL http: // localhost: 8000 / accounts / password_change / directement dans votre navigateur. Django est suffisamment intelligent pour détecter que vous devez d'abord vous connecter et vous redirigera automatiquement vers la page de connexion.

Réinitialiser les mots de passe

Chaque e-mail de réinitialisation de mot de passe envoyé par Django contient un lien qui peut être utilisé pour réinitialiser le mot de passe. Pour gérer ce lien correctement, Django a besoin de deux modèles supplémentaires:

  1. inscription / password_reset_confirm.html pour afficher le formulaire de réinitialisation du mot de passe réel

  2. registration / password_reset_complete.html pour afficher une confirmation qu'un mot de passe a été réinitialisé

Ceux-ci ressembleront beaucoup aux modèles de changement de mot de passe. Commencez avec le formulaire:



% étend 'base.html' %

% bloquer contenu %
<H2>Confirmer la réinitialisation du mot de passe</H2>

<forme méthode="Publier">
    % csrf_token %
     form.as_p 
    <contribution type="soumettre" valeur="Confirmer">
</forme>
% bloc d'extrémité %

Comme auparavant, Django fournira automatiquement un formulaire, mais cette fois, ce sera un formulaire de réinitialisation de mot de passe. Vous devez également ajouter un modèle de confirmation:



% étend 'base.html' %

% bloquer contenu %
<H2>Réinitialisation du mot de passe terminée</H2>

<une href="% url 's'identifier' %">Retour connexion</une>
% bloc d'extrémité %

Maintenant, si vous suivez le lien de réinitialisation du mot de passe de l'un des e-mails, vous devriez voir un formulaire comme celui-ci dans votre navigateur:

Confirmation de réinitialisation du mot de passe

Vous pouvez maintenant vérifier si cela fonctionne. Insérez un nouveau mot de passe dans le formulaire, cliquez sur Confirmer, déconnectez-vous et connectez-vous en utilisant le nouveau mot de passe.

Modifier les modèles d'e-mail

Vous pouvez modifier les modèles par défaut des e-mails Django comme tout autre modèle lié à la gestion des utilisateurs:

  • registration / password_reset_email.html détermine le corps de l'e-mail
  • registration / password_reset_subject.txt détermine l'objet de l'e-mail

Django fournit de nombreuses variables dans le contexte du modèle d'e-mail que vous pouvez utiliser pour composer vos propres messages:









Quelqu'un a demandé la réinitialisation du mot de passe pour le courrier électronique  email .
Suivez le lien ci-dessous:
 protocole: // domaine  % url 'password_reset_confirm' uidb64=uid jeton=jeton %

Vous pouvez également changer le sujet en quelque chose de plus court, comme Réinitialiser le mot de passe. Si vous implémentez ces modifications et envoyez à nouveau un e-mail de réinitialisation de mot de passe, vous devriez voir ce message:

---------- LE MESSAGE SUIT ----------
b'Content-Type: text / plain; charset = "utf-8" '
b'MIME-Version: 1.0 '
b'Content-Transfer-Encoding: 7bit '
b'Subject: réinitialiser le mot de passe '
b'From: webmaster @ localhost '
b'To: admin@example.com '
b'Date: mer.22 avr.2020 20:36:36 -0000 '
b'Message-ID: <20200422203636.28625.36970@pawel-laptop>"
b'X-Peer: 127.0.0.1 '
b ''
b'Someone a demandé la réinitialisation du mot de passe pour l'e-mail admin@example.com. '
b'Suivez le lien ci-dessous: '
b'http: // localhost: 8000 / accounts / reset / MQ / 5fv-f18a25af38f3550a8ca5 / '
------------ FIN DU MESSAGE ------------

Comme vous pouvez le voir, l'objet et le contenu de l'e-mail ont changé.

Enregistrer de nouveaux utilisateurs

Votre application peut désormais gérer toutes les URL liées à la gestion des utilisateurs Django. Mais une fonctionnalité ne fonctionne pas encore.

Vous avez peut-être remarqué qu'il n'y a pas d'option pour créer un nouvel utilisateur. Malheureusement, Django ne fournit pas d’enregistrement d’utilisateur prêt à l’emploi. Vous pouvez cependant l'ajouter vous-même.

Django propose de nombreux formulaires que vous pouvez utiliser dans vos projets. L'un d'eux est UserCreationForm. Il contient tous les champs nécessaires pour créer un nouvel utilisateur. Cependant, il ne comprend pas de champ de messagerie.

Dans de nombreuses applications, ce n'est peut-être pas un problème, mais vous avez déjà implémenté une fonction de réinitialisation de mot de passe. Vos utilisateurs doivent configurer une adresse e-mail, sinon ils ne pourront pas recevoir d'e-mails de réinitialisation de mot de passe.

Pour résoudre ce problème, vous devez ajouter votre propre formulaire de création d'utilisateur. Ne vous inquiétez pas, vous pouvez réutiliser la quasi-totalité UserCreationForm. Il vous suffit d'ajouter le email champ.

Créez un nouveau fichier Python appelé users / forms.py et ajoutez-y un formulaire personnalisé:

# users / forms.py

de django.contrib.auth.forms importer UserCreationForm

classe CustomUserCreationForm(UserCreationForm):
    classe Meta(UserCreationForm.Meta):
        des champs = UserCreationForm.Meta.des champs + ("email",)

Comme vous pouvez le voir, votre CustomUserCreationForm étend Django UserCreationForm. La classe intérieure Meta conserve des informations supplémentaires sur le formulaire et dans ce cas étend UserCreationForm.Meta, donc presque tout ce qui se trouve dans le formulaire de Django sera réutilisé.

La principale différence est la des champs attribut, qui détermine les champs qui seront inclus dans le formulaire. Votre formulaire personnalisé utilisera tous les champs de UserCreationForm et ajoutera le email champ.

Maintenant que le formulaire est prêt, créez une nouvelle vue appelée S'inscrire:

    1 # users / views.py
    2 
    3 de django.contrib.auth importer s'identifier
    4 de django.shortcuts importer réorienter, rendre
    5 de django.urls importer inverser
    6 de users.forms importer CustomUserCreationForm
    7 
    8 def tableau de bord(demande):
    9     revenir rendre(demande, "users / dashboard.html")
dix 
11 def S'inscrire(demande):
12     si demande.méthode == "AVOIR":
13         revenir rendre(
14             demande, "users / register.html",
15             "forme": CustomUserCreationForm
16         )
17     elif demande.méthode == "PUBLIER":
18         forme = CustomUserCreationForm(demande.PUBLIER)
19         si forme.est valable():
20             utilisateur = forme.enregistrer()
21             s'identifier(demande, utilisateur)
22             revenir réorienter(inverser("tableau de bord"))

Voici une ventilation des S'inscrire() vue:

  • Lignes 12 à 16: Si la vue est affichée par un navigateur, elle sera accessible par un AVOIR méthode. Dans ce cas, un modèle appelé utilisateurs / register.html sera rendu. Le dernier argument de .rendre() est un contexte, qui dans ce cas contient votre formulaire de création d'utilisateur personnalisé.

  • Lignes 17 à 18: Si le formulaire est soumis, la vue sera accessible par un PUBLIER méthode. Dans ce cas, Django tentera de créer un utilisateur. Un nouveau CustomUserCreationForm est créé en utilisant les valeurs soumises au formulaire, qui sont contenues dans le request.POST objet.

  • Lignes 19 à 22: Si le formulaire est valide, un nouvel utilisateur est créé sur ligne 20 en utilisant form.save (). Ensuite, l'utilisateur est connecté ligne 21 en utilisant s'identifier(). Finalement, ligne 22 redirige l'utilisateur vers le tableau de bord.

Le modèle lui-même devrait ressembler à ceci:



% étend 'base.html' %

% bloquer contenu %
<H2>S'inscrire</H2>

<forme méthode="Publier">
    % csrf_token %
    forme
    <contribution type="soumettre" valeur="S'inscrire">
</forme>

<une href="% url 's'identifier' %">Retour connexion</une>
% bloc d'extrémité %

Ceci est très similaire aux modèles précédents. Tout comme avant, il prend la forme du contexte et la restitue. La seule différence est que cette fois, vous avez dû ajouter le formulaire au contexte par vous-même au lieu de laisser Django le faire.

N'oubliez pas d'ajouter une URL pour la vue d'inscription:

# users / urls.py

de django.conf.urls importer comprendre, url
de users.views importer tableau de bord, S'inscrire

urlpatterns = [[[[
    url(r"^ comptes /", comprendre("django.contrib.auth.urls")),
    url(r"^ tableau de bord /", tableau de bord, Nom="tableau de bord"),
    url(r"^ s'inscrire /", S'inscrire, Nom="S'inscrire"),
]

C'est aussi une bonne idée d'ajouter un lien vers le formulaire d'inscription sur la page de connexion:



% étend 'base.html' %

% bloquer contenu %
<H2>S'identifier</H2>

<forme méthode="Publier">
    % csrf_token %
     form.as_p 
    <contribution type="soumettre" valeur="S'identifier">
</forme>

<une href="% url 'tableau de bord' %">Retour au tableau de bord</une>
<une href="% url 'Réinitialisation du mot de passe' %">Réinitialiser le mot de passe</une>
<une href="% url 'S'inscrire' %">S'inscrire</une>
% bloc d'extrémité %

Votre formulaire nouvellement créé devrait ressembler à ceci:

Formulaire d'inscription utilisateur

N'oubliez pas qu'il ne s'agit que d'un exemple de formulaire d'inscription. Dans le monde réel, vous enverriez probablement des e-mails avec des liens de confirmation après que quelqu'un a créé un compte d'utilisateur, et vous afficheriez également des messages d'erreur appropriés si quelqu'un tentait d'enregistrer un compte qui existe déjà.

Envoyer des e-mails au monde extérieur

Pour le moment, votre application peut envoyer des e-mails au serveur SMTP local afin que vous puissiez les lire dans la ligne de commande. Il serait beaucoup plus utile d'envoyer des e-mails à des adresses e-mail réelles. Pour ce faire, vous pouvez utiliser Mailgun.

Pour cette étape, vous aurez besoin d'un compte Mailgun. La version de base est gratuite et vous permettra d'envoyer des e-mails à partir d'un domaine plutôt obscur, mais cela fonctionnera dans le cadre de ce tutoriel.

Après avoir créé votre compte, accédez à la page Tableau de bord et faites défiler vers le bas jusqu'à ce que vous atteigniez «Envoi de domaines». Vous y trouverez votre domaine sandbox:

Tableau de bord de Mailgun

Cliquez sur le domaine. Vous serez redirigé vers une page où vous pourrez sélectionner la manière dont vous souhaitez envoyer des e-mails. Choisir SMTP:

Paramètres SMTP de Mailgun

Faites défiler vers le bas jusqu'à ce que vous atteigniez les informations d'identification de votre compte:

Informations d'identification du pistolet

Vous devriez trouver les valeurs suivantes:

  • Nom d'hôte SMTP
  • Port
  • Nom d'utilisateur
  • Mot de passe par défaut

Il vous suffit d'ajouter ces valeurs au fichier de paramètres. Gardez à l'esprit que vous ne devez jamais inclure d'informations d'identification directement dans votre code. Au lieu de cela, ajoutez-les en tant que variables d'environnement et lisez leurs valeurs en Python.

Sous Linux et macOS, vous pouvez ajouter une variable d'environnement dans le terminal comme ceci:

(venv) $ exportation EMAIL_HOST_USER=your_email_host_user

Sous Windows, vous pouvez exécuter cette commande dans l'invite de commandes:

C: > ensemble EMAIL_HOST_USER=your_email_host_user

Répétez le même processus pour EMAIL_HOST_PASSWORD, et n'oubliez pas d'exporter les variables dans la même fenêtre de terminal où vous exécutez le serveur Django. Une fois les deux variables ajoutées, mettez à jour les paramètres:

# awesome_website / settings.py

EMAIL_HOST = "smtp.mailgun.org"
EMAIL_PORT = 587
EMAIL_HOST_USER = os.environ.avoir("EMAIL_HOST_USER")
EMAIL_HOST_PASSWORD = os.environ.avoir("EMAIL_HOST_PASSWORD")
EMAIL_USE_TSL = Vrai

Les valeurs de EMAIL_HOST et EMAIL_PORT devrait être le même pour tous les domaines sandbox, mais vous devez utiliser votre propre nom d'utilisateur et mot de passe. Il existe également une valeur supplémentaire appelée EMAIL_USE_TSL que vous devez définir Vrai.

Pour vérifier si cela fonctionne, vous devez créer un nouvel utilisateur avec votre propre adresse e-mail. Aller à http: // localhost: 8000 / admin / et connectez-vous en tant qu'utilisateur administrateur. Accédez à Utilisateurs et cliquez sur AJOUTER UN UTILISATEUR. Sélectionnez le nom d'utilisateur et le mot de passe que vous aimez et cliquez sur Enregistrez et continuez l'édition. Insérez ensuite la même adresse e-mail que vous avez utilisée pour votre compte de boîte aux lettres dans le champ d'adresse e-mail et enregistrez l'utilisateur.

Après avoir créé l'utilisateur, accédez à http: // localhost: 8000 / accounts / password_reset /. Saisissez votre adresse e-mail et appuyez sur Envoyer. L'envoi d'un e-mail prendra un peu plus de temps qu'avec le serveur local. Après quelques instants, l'e-mail de réinitialisation du mot de passe devrait arriver dans votre boîte de réception. Il peut également se trouver dans votre dossier spam, alors n'oubliez pas de le vérifier également.

Le domaine sandbox ne fonctionnera qu'avec l'adresse e-mail que vous avez utilisée pour créer votre compte Mailgun. Pour envoyer des e-mails à d'autres destinataires, vous devez ajouter un domaine personnalisé.

Connectez-vous avec GitHub

De nombreux sites Web modernes offrent une option d'authentification à l'aide de comptes de médias sociaux. Un tel exemple est la connexion Google, mais dans ce didacticiel, vous apprendrez à vous intégrer à GitHub.

Heureusement, il existe un module Python très utile qui prend en charge cette tâche. C'est appelé social-auth-app-django. Ce tutoriel montre juste la configuration de base du module, mais vous pouvez en apprendre plus à ce sujet dans sa documentation, en particulier la partie dédiée à la configuration de Django.

Configurer l'authentification sociale

Commencez par installer le module:

(venv) $ python -m pip installe social-auth-app-django

Comme toute autre application Django, vous devez l'ajouter à INSTALLED_APPS. Notez que, dans ce cas, le nom de l'application Django est différent du nom du module Python:

# awesome_website / settings.py

INSTALLED_APPS = [[[[
    "utilisateurs",
    "social_django",
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

Ensuite, ajoutez deux processeurs de contexte à awesome_website / settings.py:

# awesome_website / settings.py

MODÈLES = [[[[
    
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [],
        "APP_DIRS": Vrai,
        "OPTIONS": 
            "context_processors": [[[[
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
                "social_django.context_processors.backends",
                "social_django.context_processors.login_redirect",
            ],
        ,
    ,
]

Après cela, appliquez les migrations:

(venv) $ migration de python manage.py

Vous devez également inclure les URL d'authentification sociale dans votre application, tout comme vous l'avez fait avec celles fournies par Django:

# users / urls.py

de django.conf.urls importer comprendre, url
de users.views importer tableau de bord, S'inscrire

urlpatterns = [[[[
    url(r"^ comptes /", comprendre("django.contrib.auth.urls")),
    url(r"^ tableau de bord /", tableau de bord, Nom="tableau de bord"),
    url(r"^ oauth /", comprendre("social_django.urls")),
    url(r"^ s'inscrire /", S'inscrire, Nom="S'inscrire"),
]

Tout cela était une configuration générale pour Django. Pour utiliser l'authentification sociale spécifiquement avec GitHub, vous devez ajouter un backend d'authentification dédié.

Par défaut, les paramètres Django ne spécifient pas les backends d'authentification, et le backend par défaut utilisé par Django est django.contrib.auth.backends.ModelBackend. Donc, pour utiliser l'authentification sociale, vous devez créer une nouvelle valeur dans les paramètres:

# awesome_website / settings.py

AUTHENTICATION_BACKENDS = [[[[
    "django.contrib.auth.backends.ModelBackend",
    "social_core.backends.github.GithubOAuth2",
]

The first backend on the list is the default one used by Django. If you don’t include it here, then Django won’t be able to log in standard users. The second backend is used for GitHub logins.

The last thing to do is to add a link to the GitHub login on your login page:



% extends 'base.html' %

% block contenu %
<h2>S'identifier</h2>

<form method="post">
    % csrf_token %
     form.as_p 
    <input type="submit" valeur="Login">
</form>

<une href="% url 'dashboard' %">Back to dashboard</une>
<une href="% url 'social:begin' 'github' %">Login with GitHub</une>
<une href="% url 'password_reset' %">Reset password</une>
<une href="% url 'register' %">S'inscrire</une>
% endblock %

You might notice that the new URL uses the namespace social. Namespaces are Django’s way of organizing URLs in more complex projects.

Using a unique namespace ensures that there will be no conflicts between your application’s URLs and the URLS of other applications. The social authentication application uses the namespace social, so every URL you want to use has to start with social:.

Create a GitHub Application

To use GitHub authentication with Django user management, you first have to create an application. Log in to your GitHub account, go to GitHub’s page for registering a new OAuth application, and fill in the form:

Creating a new GitHub application

The most important part is the Authorization callback URL. It has to point back to your application.

After you register the application, you’ll be redirected to a page with credentials:

The credentials of a newly created GitHub application

Add the values of Client ID et Client Secret to settings the same way you added Mailgun email credentials:

# awesome_website/settings.py

SOCIAL_AUTH_GITHUB_KEY = os.environ.avoir("SOCIAL_AUTH_GITHUB_KEY")
SOCIAL_AUTH_GITHUB_SECRET = os.environ.avoir("SOCIAL_AUTH_GITHUB_SECRET")

You can now check if this works. Go to your application’s login page and select the option to log in with GitHub. Assuming you’ve logged out after creating the application in the previous step, you should be redirected to GitHub’s login page:

GitHub application login page

In the next step you’ll be asked to authorize the GitHub application:

Authorizing a GitHub application

If you confirm, then you’ll be redirected back to your application. You can now find a new user in the admin panel :

GitHub user created automatically in the Django application

The newly created user has the same username as your GitHub handle and doesn’t have a password.

Select Authentication Backend

There’s one problem with the example above: by enabling GitHub login, you accidentally broke the normal user creation process.

That happened because Django previously had only one authentication backend to choose from, and now it has two. Django doesn’t know which one to use when creating new users, so you’ll have to help it decide. To do that, replace the line user = form.save() in your registration view:

# users/views.py

de django.contrib.auth import s'identifier
de django.shortcuts import redirect, render
de django.urls import reverse
de users.forms import CustomUserCreationForm

def dashboard(request):
    return render(request, "users/dashboard.html")

def S'inscrire(request):
    si request.method == "GET":
        return render(
            request, "users/register.html", "form": CustomUserCreationForm
        )
    elif request.method == "POST":
        form = CustomUserCreationForm(request.PUBLIER)
        si form.is_valid():
            utilisateur = form.save(commit=False)
            utilisateur.backend = "django.contrib.auth.backends.ModelBackend"
            utilisateur.save()
            s'identifier(request, utilisateur)
            return redirect(reverse("dashboard"))

A user is created from the form like before, but this time it’s not immediately saved thanks to commit=False. In the next line, a backend is associated with the user, and only then is the user saved to the database. This way, you can use both normal user creation and social media authentication in the same Django user management system.

Conclusion

Django is a versatile framework, and it does its best to help you with every possible task, including user management. It provides a lot of ready-to-use resources, but sometimes you need to extend them just a bit.

In this tutorial, you’ve learned how to:

  • Extend your Django application with a full set of user management fonctionnalités
  • Adjust the default Django templates to better suit your needs
  • Use Mailgun to send password reset emails
  • Add an option to log in with GitHub

This should provide you with a good starting point for your own amazing ideas. If you think that something’s missing, or if you have any questions, then please don’t hesitate to let me know!