Comment envoyer un e-mail avec Django

Dans ce tutoriel, nous allons vous guider pas à pas sur la façon de ​​envoyer des e-mails à l’aide de Django. Nous allons aborder comment configurer les connexions SMTP de Django, comment mettre en place un mot de passe d’application pour votre fournisseur d’e-mails, et comment envoyer des e-mails via l’interpréteur de commandes Django. Nous examinerons également comment configurer un formulaire de contact pour votre application Django, ce qui permettra à vos clients de vous contacter.

La plupart des applications web utilisent les e-mails pour gérer des opérations cruciales, telles que la réinitialisation des mots de passe, l’activation des comptes, la réception de retours clients, l’envoi de newsletters et de campagnes marketing. La plupart de ces tâches nécessitent un service dédié comme SendGrid ou Mailgun. Mais si vous ne prévoyez pas que votre site recevra une quantité massive de visiteurs, vous pouvez réaliser beaucoup de choses à travers votre fournisseur d’e-mails personnel.

L’envoi d’e-mails avec votre adresse e-mail personnelle est une option raisonnable pour les petits projets ou les projets de test, nous allons donc adopter cette approche ici pour simplifier les choses. Cependant, ce n’est pas une bonne idée d’utiliser votre service d’e-mails personnel pour votre site de production. Vous pouvez en savoir plus sur les restrictions d’envoi Gmail, ou consulter les limitations de votre fournisseur d’e-mails.

Note : le code complet de ce tutoriel est disponible sur GitHub.

Comprendre SMTP

SMTP (ou le Simple Mail Transfer Protocol) est un ensemble de règles déterminant comment les courriels sont transférés des expéditeurs aux destinataires. Les serveurs SMTP utilisent ce protocole pour envoyer et relayer les courriels sortants. (Notez que d’autres protocoles régissent la manière dont les courriels sont reçus.)

Un serveur SMTP possède toujours une adresse unique et un port spécifique pour envoyer des messages, qui est généralement 587. Nous verrons en quoi le port est pertinent lors de l’envoi d’e-mails avec Django.

Puisque nous utiliserons Gmail, l’adresse avec laquelle nous travaillerons est smtp.gmail.com, et le port sera 587.

Voyons maintenant comment nous pouvons envoyer des courriels avec Django.

Création d’un Projet Django

Chaque projet Django devrait avoir un environnement virtuel, car nous ne voulons pas perturber les dépendances du projet. Pour en créer un, exécutez ce qui suit:

python -m venv .venv

Remarque : si vous n’êtes pas familier avec les environnements virtuels, assurez-vous de consulter notre guide sur les environnements virtuels Python.

La commande ci-dessus crée un environnement virtuel avec le nom .venv. Pour activer cet environnement virtuel, vous pouvez utiliser ce qui suit:

source .venv/bin/activate

Puisque Django est un package tiers, vous devez l’installer avec pip:

pip install django

Cela installera la dernière version de Django, que vous pouvez vérifier avec pip freeze.

Pour créer un projet Django, vous appelez l’utilitaire de ligne de commande django-admin:

django-admin startproject EmailProject

Avec la commande ci-dessus, vous créez un projet Django avec le nom EmailProject, mais vous pouvez créer le projet avec le nom de votre choix.

Maintenant, entrez dans le répertoire du projet et exécutez le serveur:

cd EmailProject
python manage.py runserver

Après avoir démarré le serveur Django, visitez http://localhost:8000 dans votre navigateur. Vous verrez une page générée automatiquement avec les dernières notes de version de Django.

Modification des Paramètres

Vous devrez modifier le fichier des paramètres avant d’envoyer des emails, alors localisons ce fichier avec la commande tree:

Note : pour simplifier, nous utiliserons uniquement des commandes système UNIX (macOS ou Linux).

tree

La commande tree affiche la structure des fichiers d’un répertoire. Dans ce cas, puisque nous ne lui donnons pas un chemin de répertoire spécifique, nous obtiendrons quelque chose de similaire à ce qui suit si nous sommes dans le dossier racine du projet:

├── EmailProject
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 6 files

Le fichier que nous modifierons constamment tout au long de ce tutoriel est le settings.py à l’intérieur du dossier EmailProject.

settings.py contient toutes les configurations du projet dont vous aurez besoin et vous permet de définir des variables personnalisées. Comme le disent les documents Django, « Un fichier de paramètres est simplement un module Python avec des variables au niveau du module ».

Examinons les paramètres nécessaires pour envoyer un courriel avec Django. Ouvrez le fichier EmailProject/settings.py et collez les paramètres suivants en bas du fichier :

# EmailProject/settings.py

# Bas du fichier
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = ''
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = ''
EMAIL_HOST_PASSWORD = ''

Décomposons le code ci-dessus en analysant chacun de ces paramètres.

Backend de courriel

Le paramètre EMAIL_BACKEND déclare l’interface de programmation (API) que notre projet Django utilisera pour se connecter au serveur SMTP.

Cette variable pointe vers la classe smtp.EmailBackend qui reçoit tous les paramètres nécessaires pour envoyer un courriel. Je vous suggère fortement de consulter le constructeur de la classe directement dans le code source de Django. Vous serez surpris de voir à quel point ce code est lisible.

Remarque : bien que cette classe soit le EMAIL_BACKEND par défaut, il est considéré comme une bonne pratique d’être explicite dans les paramètres Django.

Tous les autres paramètres de courriel seront basés sur le constructeur de cette classe EmailBackend.

Hôte de courriel

Le paramètre EMAIL_HOST fait référence au domaine du serveur SMTP que vous utiliserez. Cela dépend de votre fournisseur de messagerie. Voici un tableau avec le serveur SMTP correspondant à trois fournisseurs courants :

Email provider	SMTP server host
Gmail	smtp.gmail.com
Outlook/Hotmail	smtp-mail.outlook.com
Yahoo	smtp.mail.yahoo.com

Nous laissons ce paramètre vide pour l’instant car nous utiliserons un fichier .env plus tard pour éviter les clés sensibles codées en dur ou les configurations spécifiques au site. Vous ne devriez jamais définir les informations d’identification directement dans le code.

Nous utiliserons Django Environ pour résoudre ce problème.

Port de l’Email

Le paramètre EMAIL_PORT doit être défini sur 587 car c’est le port par défaut pour la plupart des serveurs SMTP. Cela reste vrai pour les fournisseurs de messagerie personnels.

Ce port est utilisé avec le chiffrement TLS pour garantir la sécurité de l’envoi d’e-mails.

Utilisation de TLS pour Email

Transport Layer Security (TLS) est un protocole de sécurité utilisé sur le Web pour chiffrer la communication entre les applications Web (Django) et les serveurs (serveur SMTP).

À l’origine, nous avons défini la variable EMAIL_USE_TLS sur True. Cela signifie que Django utilisera la Sécurité de la Couche de Transport pour se connecter au serveur SMTP et envoyer des e-mails. (C’est obligatoire pour les fournisseurs de messagerie personnels.)

Utilisateur du Serveur de l’Email

Le paramètre EMAIL_HOST_USER est votre adresse e-mail personnelle. Laissez-le vide pour l’instant, car nous utiliserons django-environ pour configurer toutes ces informations d’identification.

Mot de passe du Serveur de l’Email

Le paramètre EMAIL_HOST_PASSWORD est le mot de passe d’application que vous obtiendrez de votre compte e-mail — le processus que nous allons faire juste après cette section.

Même histoire : laissez ce paramètre vide, car nous utiliserons des variables d’environnement plus tard.

Configurer un Mot de Passe d’Application dans Gmail

Pour utiliser le paramètre EMAIL_HOST_PASSWORD, vous devez activer l’accès aux applications moins sécurisées et avoir un mot de passe d’application de votre adresse e-mail personnelle.

Si vous n’activez pas l’accès aux applications moins sécurisées, vous obtiendrez probablement une erreur SMTPAuthenticationError, car Django n’a aucun moyen de respecter les protocoles de sécurité de Google.

Vous pouvez choisir d’utiliser votre mot de passe normal, mais cela serait encore plus risqué que d’utiliser un mot de passe d’application. Mon conseil est de créer un nouveau compte Gmail ou d’utiliser une adresse e-mail « de test ».

Tenant compte de cela, vous pouvez obtenir un mot de passe d’application Gmail avec les étapes ci-dessous. Notez que si vous utilisez un compte existant et avez activé la vérification en deux étapes, vous pouvez sauter les étapes 2 et 3 :

1. Créez ou connectez-vous à un compte Gmail
2. Allez sur myaccount.google.com/lesssecureapps et activez l’option des applications moins sécurisées.
   
3. Activer l’authentification à deux facteurs, car elle est nécessaire pour obtenir un mot de passe d’application.
   
4. Maintenant que vous avez activé l’authentification à deux facteurs, il est temps d’obtenir un mot de passe d’application. Vous pouvez le faire en vous rendant dans la section de sécurité de votre compte Google, en faisant défiler jusqu’à la section Connexion à Google, et en cliquant sur Mot de passe d’application.
   

Vous devrez réintroduire votre mot de passe (mot de passe du compte), avant d’être redirigé vers la page des mots de passe d’application.

Une fois que vous y êtes, cliquez sur sélectionner l’application, où vous choisirez un nom personnalisé pour ce mot de passe d’application — tel que “Django Send Email” — puis cliquez sur GÉNÉRER.

A new window will show up with a sixteen-character password. Copy it, because we’ll need it to configure our Django project.

Si vous utilisez d’autres fournisseurs de messagerie, assurez-vous de lire les guides suivants:

• Mot de passe d’application Yahoo
• Mot de passe d’application Outlook ou Hotmail

Utilisation de Django Environ pour cacher les clés sensibles

Même si vous envoyez simplement des emails en développement, vous ne devriez pas écrire les mots de passe directement dans le code source. Cela devient encore plus important lorsque vous utilisez un système de contrôle de version avec GitHub pour héberger votre projet. Vous ne voulez pas que les gens accèdent à vos données.

Voyons comment nous pouvons empêcher cela en utilisant Django-environ.

Créez un fichier .env à l’intérieur du répertoire EmailProject (où se trouve le fichier settings.py) avec la commande ci-dessous:

cd EmailProject/
ls

settings.py # Le fichier des paramètres doit être ici

touch .env

Maintenant, ouvrez ce fichier .env et entrez les paires clé-valeur suivantes:

EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=YourEmail@address
EMAIL_HOST_PASSWORD=YourAppPassword
RECIPIENT_ADDRESS=TheRecieverOfTheMails

Décomposons le contenu de ce fichier:

• EMAIL_HOST: l’adresse du serveur SMTP de votre fournisseur de messagerie. Consultez le tableau des fournisseurs de messagerie ci-dessus pour un guide rapide. Dans ce cas, j’utilise smtp.gmail.com, l’adresse SMTP de Gmail.
• EMAIL_HOST_USER: votre adresse email.
• EMAIL_HOST_PASSWORD: le mot de passe de l’application que vous venez de générer. Gardez à l’esprit qu’il ne contient aucun espace.
• RECIPIENT_ADDRESS: l’adresse email à laquelle vous recevrez les messages. Il s’agit d’un paramètre personnalisé que nous créerons plus tard pour envoyer tous les emails au même destinataire.

Pour utiliser ces variables d’environnement, nous devons installer Django-environ:

pip install django-environ

Remarque : assurez-vous que votre environnement virtuel est activé.

Maintenant, ouvrez le settings.py situé dans le répertoire EmailProject et utilisez le code ci-dessous:

# EmailProject/settings.py
# Ceci devrait être au début du fichier
import environ

env = environ.Env()
environ.Env.read_env()

# Paramètres précédents ...
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = env('EMAIL_HOST')
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = env('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = env('EMAIL_HOST_PASSWORD')

# Paramètre personnalisé. Pour les emails
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Tout d’abord, nous importons le package environ au début du fichier de paramètres. N’oubliez pas que toutes les importations doivent être au début.

Ensuite, nous créons une variable env qui contiendra tous les paires clé-valeur disponibles sur le .env.

L’instruction env('KEY') signifie que nous recherchons la valeur de cette clé. Assurez-vous d’avoir configuré votre fichier .env avant de procéder, car vous obtiendrez une erreur Django ImproperlyConfigured en cas de variable d’environnement non définie.

Notez que RECIPIENT_ADDRESS est un paramètre personnalisé que nous utiliserons pour envoyer les emails à une adresse que nous pouvons accéder.

N’oubliez pas d’inclure le fichier .env dans votre .gitignore si vous utilisez Git et GitHub. Vous pouvez le faire en l’ouvrant et en ajoutant simplement la ligne suivante :

.env

1. Envoyer des emails avec l’interpréteur de commandes Django

Enfin, nous arrivons à la partie savoureuse de l’article ! Il est temps d’envoyer votre premier email à Django.

Ouvrez un terminal, activez l’environnement virtuel, et exécutez :

python manage.py shell

Cela créera un interpréteur de commandes avec toutes les configurations Django déjà préparées pour nous. À l’intérieur de cet interpréteur de commandes tout neuf, collez le code suivant :

>>> from django.core.mail import send_mail
>>> from django.conf import settings
>>> send_mail(
...     subject='A cool subject',
...     message='A stunning message',
...     from_email=settings.EMAIL_HOST_USER,
...     recipient_list=[settings.RECIPIENT_ADDRESS])
1

Nous pouvons également faire une ligne sans spécifier les arguments :

>>> send_mail('A cool subject', 'A stunning message', settings.EMAIL_HOST_USER, [settings.RECIPIENT_ADDRESS])
1

Décomposons le code ci-dessus :

• Nous importons la fonction Django send_mail.
• Ensuite, nous importons l’objet settings qui contient toutes les paramètres globaux et les paramètres par site (ceux situés dans le fichier settings.py).
• Enfin, nous passons tous les arguments nécessaires à la fonction send_mail. Cette fonction renvoie le nombre d’emails envoyés, dans ce cas, 1.

Notez comment nous utilisons l’objet settings pour obtenir le from_email (l’email avec lequel vous envoyez des emails) et la recipient_list (le paramètre personnalisé RECIPIENT_ADDRESS que nous avons défini dans le .env).

Maintenant, si je vérifie ma boîte de réception — comme j’ai défini la variable d’environnement RECIPIENT_ADDRESS à mon adresse email — je vais recevoir le message envoyé par Django.

2. Créer un formulaire de contact automatisé avec Django

Dans cette section, nous allons créer un formulaire de contact automatique avec les formulaires Django et la fonction intégrée send_mail. De plus, nous créerons une fonction personnalisée, send(), à l’intérieur du formulaire de contact pour faciliter son implémentation dans les vues.

Commençons par créer l’application de contact. Entrez dans le répertoire racine du projet — où se trouve manage.py — et exécutez :

python manage.py startapp contact

Ensuite, installez-la dans votre variable INSTALLED_APPS à l’intérieur du fichier EmailProject/settings.py :

# EmailProject/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    ...

    # Custom
    'contact',
]

Avant de continuer avec l’application contact, configurons les urlpatterns à l’intérieur du fichier EmailProject/urls.py. Pour ce faire, importez la fonction django.urls.include et incluez les URL de contact dans l’ensemble du projet. Ne vous inquiétez pas, nous configurerons les URL de contact plus tard :

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # Nouvel import

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Inclure les URL de Contact
]

Formulaire de Contact

Entrez dans le dossier de l’application contact et créez un fichier forms.py. Il est bon de pratique de définir tous vos formulaires à l’intérieur d’un fichier forms.py, mais ce n’est pas obligatoire. C’est pourquoi Django n’inclut pas ce fichier par défaut.

Vous pouvez créer le fichier des formulaires avec les commandes suivantes :

cd ../contact/
# Vous étiez à l'intérieur du dossier EmailProject
touch forms.py

Ouvrez le fichier que vous venez de créer et effectuez les importations suivantes :

# contact/forms.py
from django import forms
from django.conf import settings
from django.core.mail import send_mail

Le module form de Django nous fournit toutes les classes et champs nécessaires pour créer notre formulaire de contact. Encore une fois, nous importons l’objet settings et la fonction send_mail pour envoyer les e-mails.

Notre formulaire de contact comprendra plusieurs champs et utilisera deux méthodes personnalisées : get_info(), qui formate les informations fournies par l’utilisateur, et send(), qui enverra le message.

Voyons cela implémenté en code :

# contact/forms.py
class ContactForm(forms.Form):

    name = forms.CharField(max_length=120)
    email = forms.EmailField()
    inquiry = forms.CharField(max_length=70)
    message = forms.CharField(widget=forms.Textarea)

    def get_info(self):
        """
        Method that returns formatted information
        :return: subject, msg
        """
        # Données nettoyées
        cl_data = super().clean()

        name = cl_data.get('name').strip()
        from_email = cl_data.get('email')
        subject = cl_data.get('inquiry')

        msg = f'{name} with email {from_email} said:'
        msg += f'\n"{subject}"\n\n'
        msg += cl_data.get('message')

        return subject, msg

    def send(self):

        subject, msg = self.get_info()

        send_mail(
            subject=subject,
            message=msg,
            from_email=settings.EMAIL_HOST_USER,
            recipient_list=[settings.RECIPIENT_ADDRESS]
        )

C’est une classe très importante, donc décomposons ce que nous faisons dans chaque partie. Tout d’abord, nous définissons quatre champs qui seront requis pour envoyer le message :

• name et enquiry sont des CharFields qui représentent le nom et la raison du message de contact.
• email est un EmailField qui représente l’adresse e-mail de la personne qui essaie de vous contacter. Prenez en compte que l’e-mail ne sera pas envoyé depuis l’adresse e-mail de l’utilisateur, mais depuis l’adresse e-mail que vous avez définie pour envoyer les e-mails dans le projet Django.
• message est un autre CharField avec l’exception que nous utilisons le widget Textarea. Cela signifie que, lors de la mise en forme du formulaire, il affichera une balise <textarea> au lieu d’une simple <input>.

En abordant les méthodes personnalisées, nous utilisons uniquement la méthode get_info pour formater les informations fournies par l’utilisateur et renvoyer deux variables : subject, qui n’est autre que le champ inquiry, et le message, qui sera le message réel envoyé par Django.

D’un autre côté, la méthode send() n’obtient que les informations formatées de get_info et envoie le message avec la fonction send_mail.

Bien que cette section soit assez large, vous verrez comment nous avons simplifié les vues de contact en implémentant toute la logique d’envoi dans le ContactForm lui-même.

Vues de Contact

Ouvrez le fichier contact/views.py et ajoutez les importations suivantes:

# contact/views.py
from django.views.generic import FormView, TemplateView
from .forms import ContactForm
from django.urls import reverse_lazy

Comme vous pouvez le voir, nous allons utiliser vues génériques Django, ce qui nous permet de gagner beaucoup de temps lors de la réalisation de tâches simples — par exemple, lors de la configuration d’un formulaire avec FormView ou la création d’une vue qui n’affiche qu’un modèle avec TemplateView.

De plus, nous importons le ContactForm que nous avons construit dans la section précédente et la fonction reverse_lazy utilisée lors de la manipulation des vues basées sur des classes.

En continuant avec les vues, écrivons le ContactView:

# contact/views.py

class ContactView(FormView):
    template_name = 'contact/contact.html'
    form_class = ContactForm
    success_url = reverse_lazy('contact:success')

    def form_valid(self, form):
        # Appelle la méthode personnalisée send
        form.send()
        return super().form_valid(form)

Comme vous pouvez le constater, nous construisons une simple FormView en utilisant le ContactForm que nous avons créé. Nous configurons également le template_name et le success_url. Nous écrirons le modèle HTML et configurerons les URLs plus tard.

La méthode form_valid nous permet d’envoyer l’e-mail en utilisant la méthode ContactForm.send() uniquement si tous les champs du formulaire sont valides. Cela signifie que si l’utilisateur saisit une entrée invalide, comme une adresse e-mail mal formatée, le message ne sera pas envoyé.

La mise en œuvre de la méthode form_valid ci-dessus serait équivalente à ce qui suit dans une vue basée sur une fonction :

# Vue de contact basée sur une fonction précédente ...

if request.method == 'POST':
    form = ContactForm(request.POST)
    if form.is_valid():
        form.send()
        return redirect('contact:success')
else:
    form = ContactForm())

Fin de cette section, nous allons écrire un ContactSucessView, qui affichera un message de succès à l’utilisateur. Puisque nous avons déjà importé la classe TemplateView, nous avons seulement besoin de l’hériter et de définir l’attribut template_name :

# contact/views.py
class ContactSuccessView(TemplateView):
    template_name = 'contact/success.html'

Vous pouvez consulter le fichier views.py sur le dépôt GitHub au cas où vous auriez des préoccupations.

URLs de contact

Il est temps de créer les modèles d’URL de l’application contact. Puisque Django ne nous fournit pas le fichier urls.py par défaut, nous devons le créer avec la commande suivante (assurez-vous d’être à l’intérieur du dossier de l’application contact) :

pwd
# /path/to/project/EmailProject/contact
touch urls.py

Ouvrez ce fichier et configurez les variables app_name et urlpatterns :

from django.urls import path
from .views import ContactView, ContactSuccessView

app_name = 'contact'

urlpatterns = [
    path('', ContactView.as_view(), name="contact"),
    path('success/', ContactSuccessView.as_view(), name="success"),
]

Nous utilisons path pour inclure la route et sa vue correspondante dans la configuration des URL de l’application. Lorsque nous définissons la variable app_name sur 'contact', cela signifie que l’espace de noms des URL de l’application ressemblera à ceci :

contact:name_of_path
# Pour ContactView
contact:contact
# Pour ContactSuccessView
contact:success

Remarque : un espace de noms est ce que nous appelons dynamiquement les URL dans les modèles Django et les vues.

Vous pouvez en savoir plus sur le dispatcher de URL Django dans la documentation officielle.

Écriture de modèles

Les modèles Django sont la manière préférée de présenter des données dynamiquement, en utilisant HTML et des balises spéciales que le Langage de Modèles Django nous fournit.

Pour cette application spécifique, nous utiliserons trois modèles :

• base.html: tous les autres modèles en hériteront. Il contiendra tout le squelette HTML que tous les modèles doivent avoir, ainsi que les liens vers Bootstrap.
• contact.html: affiche le formulaire de contact.
• success.html: affiche un message de succès.

Commençons par créer la structure de modèle de l’application de contact (assurez-vous d’être à l’intérieur du dossier de l’application de contact) :

mkdir -p templates/contact/
cd templates/contact
touch base.html contact.html success.html

Les commandes ci-dessus créent la structure de modèle typique d’une application Django réutilisable — appname/templates/appname — et les fichiers de modèle arborescents que j’ai mentionnés précédemment.

Voici à quoi devrait ressembler maintenant la structure de fichiers de l’application :

.
├── admin.py
├── apps.py
├── forms.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── templates
│   └── contact
│       ├── base.html
│       ├── contact.html
│       └── success.html
├── tests.py
├── urls.py
└── views.py

Passons au contenu du modèle base.html :

<!-- contact/templates/contact/base.html -->

<!DOCTYPE html>
<html lang="en">

  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Django Email Send</title>
    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
      integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous" />
  </head>

  <body>
    {% block body %}

    {% endblock %}
    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
      integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous">
    </script>
  </body>

</html>

Comme vous pouvez le constater, c’est le squelette simple d’un fichier HTML qui inclut des liens vers Bootstrap 5. Cela nous permet de styliser notre application de contact sans utiliser de fichiers CSS.

Le tag {% block name-of-block %} nous permet de mettre en place un espace réservé que les « templates enfants » utiliseront. L’utilisation de ce tag rend l’héritage des templates une tâche facile.

Avant d’aborder les formulaires, vous devrez installer le package Django crispy forms, qui nous permet de les styliser facilement:

pip install django-crispy-forms

Encore une fois, crispy_forms est une application Django, et nous devons l’inclure dans la liste INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # applications tierces
    'crispy_forms',

    # applications personnalisées
    'contact',
]

# Indique le framework frontend utilisé par django crispy forms
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Nous utilisons le pack de templates de Bootstrap 4, car les classes de formulaire Bootstrap sont compatibles entre les versions 4 et 5 (au moment de la rédaction).

Maintenant, travaillons sur le template contact.html:

<!-- contact/templates/contact/contact.html -->

{% extends 'contact/base.html' %}
{% load crispy_forms_tags %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1>Contact Us</h1>
</div>
<div class="container">
    <form action="" method="post">
        {% csrf_token %}
        {{ form | crispy }}
    <button class="btn btn-success my-3" type="submit">Send message</button>
    </form>
</div>
{% endblock %}

Notez comment nous avons étendu le modèle de base et utilisé le placeholder de bloc. C’est ce qui rend le Langage de Template Django si efficace, car il nous permet d’éviter beaucoup de copier-coller HTML.

En parlant du formulaire, nous utilisons la méthode "post", ce qui signifie que notre ContactView traitera les données fournies par l’utilisateur et enverra le courriel si le formulaire est valide.

Le {% csrf_token %} est obligatoire dans chaque formulaire pour des raisons de sécurité. La documentation de Django a une page dédiée sur les jetons CSRF et les raisons d’utiliser les jetons CSRF lors de la création de formulaires.

Nous allons rendre le formulaire avec l’étiquette de modèle crispy, c’est pourquoi nous avons chargé les balises crispy avec {% load crispy_forms_tags %}.

Enfin, écrivons le modèle success.html:

{% extends 'contact/base.html' %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1 class="fw-bolder text-success">We sent your message</h1>
    <p class="my-5">You can send another in the <a href="{% url 'contact:contact' %}">contact page</a></p>
</div>
{% endblock %}

Comme vous pouvez le constater, c’est une simple annonce de succès qui inclut un lien vers le formulaire de contact au cas où l’utilisateur voudrait envoyer un autre message.

Exécutons à nouveau le serveur et visitons http://localhost:8000 (assurez-vous d’avoir activé le .venv et d’être à l’intérieur du dossier racine du projet) :

python manage.py runserver

L’image ci-dessous montre à quoi ressemble le formulaire de contact final.

Et voici une image du message de succès.

Et voici une image du courriel dans la boîte de réception.

Pour conclure

Félicitations ! Vous avez appris à envoyer des e-mails avec Django et à créer un formulaire de contact Django également.

Il existe de nombreuses façons d’envoyer des e-mails avec Django. Dans ce tutoriel, vous l’avez fait avec votre adresse e-mail personnelle, mais je vous encourage à explorer d’autres outils et à les intégrer dans vos projets.

Dans ce tutoriel, nous avons abordé les points suivants:

• comment configurer les paramètres Django pour servir les e-mails
• comment utiliser un compte e-mail personnel pour envoyer des e-mails dans un petit projet
• comment utiliser les fichiers .env pour utiliser des données sensibles dans un projet Django
• comment créer un formulaire de contact automatisé

Pour en savoir plus sur Django, consultez « Créer une application de partage de photos avec Django ».

FAQ sur comment envoyer un e-mail avec Django