Formation Python
- Épisode # 317 Python à la commission électorale fédérale américaine
- 12+ meilleurs add-ons de générateur de pages WPBakery
- Démolition du site Web d'une petite entreprise 150k 2019 • WPShout
- API REST Python avec Flask, Connexion et SQLAlchemy – Partie 3 – Real Python
- Utilisation de datetime Python pour travailler avec des dates et des heures – Real 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 /
.
Remarque: Dans ce didacticiel, vous allez utiliser le modèle utilisateur intégré de Django. En pratique, vous créeriez plus probablement un modèle utilisateur personnalisé, étendant les fonctionnalités offertes par Django. Vous pouvez en savoir plus sur la personnalisation du modèle utilisateur par défaut dans la documentation de Django.
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.
Remarque: Tous les modèles utilisés dans ce didacticiel doivent être placés dans le utilisateurs / modèles
annuaire. Si le didacticiel mentionne un fichier modèle users / dashboard.html
, le chemin de fichier réel est utilisateurs / modèles / utilisateurs / tableau de bord.html
. Pour base.html
, le chemin réel est utilisateurs / modèles / base.html
, etc.
le utilisateurs / modèles
n’existe pas par défaut, vous devez donc le créer d’abord. La structure de votre projet ressemblera à ceci:
awesome_website /
│
├── awesome_website /
│ ├── __init__.py
│ ├── asgi.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
├── utilisateurs /
│ │
│ ├── migrations /
│ │ └── __init__.py
│ │
│ ├── modèles /
│ │ │
│ │ ├── inscription / ← Modèles utilisés par la gestion des utilisateurs Django
│ │ │
│ │ ├── utilisateurs / ← Autres modèles de votre application
│ │ │
│ │ └── base.html ← Le modèle de base de votre application
│ │
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
│
├── db.sqlite3
└── manage.py
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:
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:
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:
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:
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:
Si vous vous connectez, vous devriez voir cet écran:
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:
-
registration / password_change_form.html
pour afficher le formulaire de changement de mot de passe -
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:
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.
Envoyer des liens de réinitialisation de mot de passe
Des erreurs arrivent aux meilleurs d'entre nous, et de temps en temps, quelqu'un peut oublier un mot de passe. Votre système de gestion des utilisateurs Django devrait également gérer cette situation. Cette fonctionnalité est un peu plus compliquée car, pour fournir des liens de réinitialisation de mot de passe, votre application doit envoyer des e-mails.
Ne vous inquiétez pas, vous n'avez pas besoin de configurer votre propre serveur de messagerie. Pour ce didacticiel, il vous suffit d'un serveur de test local pour confirmer l'envoi des e-mails. Ouvrez votre terminal et exécutez cette commande:
(venv) $ python -m smtpd -n -c DebuggingServer localhost: 1025
Cela démarrera un simple serveur SMTP à http: // localhost: 1025
. Il n'enverra aucun e-mail à des adresses e-mail réelles. Au lieu de cela, il affichera le contenu des messages dans la ligne de commande.
Il ne vous reste plus qu'à informer Django que vous allez l'utiliser. Ajoutez ces deux lignes à la fin du fichier de paramètres:
# awesome_website / settings.py
EMAIL_HOST = "localhost"
EMAIL_PORT = 1025
Django a besoin de deux modèles pour envoyer des liens de réinitialisation de mot de passe:
-
registration / password_reset_form.html
pour afficher le formulaire utilisé pour demander un e-mail de réinitialisation de mot de passe -
registration / password_reset_done.html
pour afficher la confirmation qu'un e-mail de réinitialisation du mot de passe a été envoyé
Ils seront très similaires aux modèles de changement de mot de passe que vous avez créés précédemment. Commencez avec le formulaire:
% étend 'base.html' %
% bloquer contenu %
<H2>Envoyer le lien de réinitialisation du mot de passe</H2>
<forme méthode="Publier">
% csrf_token %
form.as_p
<contribution type="soumettre" valeur="Réinitialiser">
</forme>
<une href="% url 'tableau de bord' %">Retour au tableau de bord</une>
% bloc d'extrémité %
Ajoutez maintenant 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é %
Ce serait également une bonne idée d'inclure un lien vers le formulaire de réinitialisation du mot de passe 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>
% bloc d'extrémité %
Votre nouveau formulaire de réinitialisation de mot de passe devrait ressembler à ceci:
Saisissez l'adresse e-mail de votre administrateur (admin@example.com
) et appuyez sur Réinitialiser. Vous devriez voir le message suivant dans le terminal exécutant le serveur de messagerie:
---------- LE MESSAGE SUIT ----------
b'Content-Type: text / plain; charset = "utf-8" '
b'MIME-Version: 1.0 '
b'Content-Transfer-Encoding: 7bit '
b'Subject: réinitialisation du mot de passe sur l'hôte local: 8000 '
b'From: webmaster @ localhost '
b'To: admin@example.com '
date: mer.22 avr.2020 20:32:39 -0000 '
b'Message-ID: <20200422203239.28625.15187@pawel-laptop>"
b'X-Peer: 127.0.0.1 '
b ''
b ''
b "Vous recevez cet e-mail car vous avez demandé une réinitialisation du mot de passe pour votre
compte utilisateur sur localhost: 8000. "
b ''
b'Veuillez vous rendre sur la page suivante et choisir un nouveau mot de passe: '
b ''
b'http: // localhost: 8000 / accounts / reset / MQ / 5fv-f18a25af38f3550a8ca5 / '
b ''
b "Votre nom d'utilisateur, au cas où vous auriez oublié: admin"
b ''
b'Merci d'utiliser notre site! '
b ''
b'The localhost: 8000 team '
b ''
------------ FIN DU MESSAGE ------------
Il s'agit du contenu d'un e-mail qui serait envoyé à votre administrateur. Il contient des informations sur l'application qui l'a envoyée ainsi qu'un lien de réinitialisation du mot de passe.
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:
-
inscription / password_reset_confirm.html
pour afficher le formulaire de réinitialisation du mot de passe réel -
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:
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-mailregistration / 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 nouveauCustomUserCreationForm
est créé en utilisant les valeurs soumises au formulaire, qui sont contenues dans lerequest.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 utilisants'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:
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:
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:
Faites défiler vers le bas jusqu'à ce que vous atteigniez les informations d'identification de votre compte:
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:
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:
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:
In the next step you’ll be asked to authorize the 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 :
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!
[ad_2]