Wie man E-Mails mit Django sendet

In diesem Tutorial führen wir Sie durch den Prozess des Versands von E-Mails mit Django. Wir behandeln, wie man Django SMTP-Verbindungen konfiguriert, wie man ein App-Passwort für Ihren E-Mail-Anbieter einrichtet und wie man E-Mails über die Django-Shell sendet. Wir werden auch sehen, wie man ein Kontaktformular für Ihr Django-App einrichtet, das es Ihren Kunden ermöglicht, sich mit Ihnen in Verbindung zu setzen.

Die meisten Webanwendungen verwenden E-Mail, um wichtige Vorgänge zu verwalten, wie das Zurücksetzen von Kennwörtern, die Aktivierung von Konten, die Erfassung von Kundenfeedback, das Versenden von Newslettern und Marketingkampagnen. Die meisten dieser Aufgaben erfordern einen dedizierten Dienst wie SendGrid oder Mailgun. Aber wenn Sie nicht damit rechnen, dass Ihre Website eine große Anzahl von Besuchern erhält, können Sie tatsächlich viel mit Ihrem persönlichen E-Mail-Anbieter erreichen.

Das Senden von E-Mails mit Ihrer persönlichen E-Mail ist eine vernünftige Option für kleine oder Testprojekte, daher werden wir diesen Ansatz hier verfolgen, um die Dinge einfach zu halten. Es ist jedoch keine gute Idee, Ihren persönlichen E-Mail-Dienst für Ihre Produktionswebsite zu verwenden. Sie können mehr über Gmail-Sendebeschränkungen erfahren oder sich an die Beschränkungen Ihres E-Mail-Anbieters wenden.

Hinweis: Der vollständige Code für dieses Tutorial ist verfügbar auf GitHub.

SMTP verstehen

SMTP (oder das Simple Mail Transfer Protocol) ist eine Reihe von Regeln, die bestimmen, wie E-Mails von Absendern an Empfänger übermittelt werden. SMTP-Server verwenden dieses Protokoll, um ausgehende E-Mails zu senden und weiterzuleiten. (Beachten Sie, dass andere Protokolle Regeln zur Empfang von E-Mails festlegen.)

Ein SMTP-Server verfügt immer über eine eindeutige Adresse und einen spezifischen Port zum Senden von Nachrichten, der in den meisten Fällen 587 ist. Wir werden sehen, wie der Port bei der E-Mail-Versendung mit Django relevant ist.

Da wir Gmail verwenden werden, lautet die Adresse, mit der wir arbeiten werden, smtp.gmail.com, und der Port wird 587 sein.

Nun schauen wir uns an, wie wir mit Django E-Mails senden können.

Erstellen eines Django-Projekts

Jedes Django-Projekt sollte eine virtuelle Umgebung haben, da wir die Projektabhängigkeiten nicht durcheinanderbringen möchten. Um eine solche zu erstellen, führen Sie Folgendes aus:

python -m venv .venv

Hinweis: Wenn Sie mit virtuellen Umgebungen nicht vertraut sind, sehen Sie sich unbedingt unsere Anleitung zu Python-virtuellen Umgebungen an.

Der obige Befehl erstellt eine virtuelle Umgebung mit dem Namen .venv. Um diese virtuelle Umgebung zu aktivieren, können Sie Folgendes verwenden:

source .venv/bin/activate

Da Django eine Drittanbieter-Software ist, müssen Sie es mit pip installieren:

pip install django

Dies installiert die neueste Version von Django, die Sie mit pip freeze überprüfen können.

Um ein Django-Projekt zu erstellen, rufen Sie das Kommandozeilen-Tool django-admin:

django-admin startproject EmailProject

Mit dem obigen Befehl erstellen Sie ein Django-Projekt mit dem Namen EmailProject, Sie können das Projekt jedoch mit dem gewünschten Namen erstellen.

Gehen Sie nun in das Projektverzeichnis und starten Sie den Server:

cd EmailProject
python manage.py runserver

Nachdem Sie den Django-Server gestartet haben, besuchen Sie http://localhost:8000 in Ihrem Browser. Sie sehen eine automatisch generierte Seite mit den neuesten Django-Versionshinweisen.

Einstellungen ändern

Bevor Sie E-Mails senden, müssen Sie die Einstellungsdatei ändern. Suchen wir diese Datei mit dem Befehl tree:

Hinweis: Aus Gründen der Einfachheit verwenden wir nur UNIX-Systembefehle (macOS oder Linux).

tree

Der tree-Befehl gibt die Dateistruktur eines Verzeichnisses aus. In diesem Fall erhalten wir, da wir keinen bestimmten Verzeichnispfad angeben, etwas Ähnliches wie folgendes, wenn wir sich im Stammverzeichnis des Projekts befinden:

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

1 directory, 6 files

Die Datei, die wir in diesem Tutorial kontinuierlich ändern werden, ist die settings.py im EmailProject-Ordner.

settings.py enthält alle Projekteinstellungen, die Sie benötigen, und ermöglicht Ihnen das Setzen benutzerdefinierter Variablen. Wie die Django-Dokumentation sagt: „Eine Einstellungsdatei ist nur ein Python-Modul mit modulbaren Variablen“.

Schauen wir uns die Einstellungen an, die für das Senden einer E-Mail mit Django erforderlich sind. Öffnen Sie die Datei EmailProject/settings.py und fügen Sie die folgenden Einstellungen ganz unten in die Datei ein:

# EmailProject/settings.py

# Bottom of the file
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = ''
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = ''
EMAIL_HOST_PASSWORD = ''

Lassen Sie uns den obigen Code analysieren, indem wir jede dieser Einstellungen untersuchen.

E-Mail-Backend

Die Einstellung EMAIL_BACKEND gibt den Backend an, das unser Django-Projekt verwenden wird, um eine Verbindung mit dem SMTP-Server herzustellen.

Diese Variable zeigt auf die smtp.EmailBackend-Klasse, die alle erforderlichen Parameter zum Senden einer E-Mail empfängt. Ich empfehle Ihnen dringend, sich die Konstruktor der Klasse direkt im Django-Quellcode anzuschauen. Sie werden überrascht sein, wie lesbar dieser Code ist.

Hinweis: Obwohl diese Klasse die Standardeinstellung EMAIL_BACKEND ist, wird es als gute Praxis angesehen, in den Django-Einstellungen explizit zu sein.

Alle anderen E-Mail-Einstellungen basieren auf dem Konstruktor dieser EmailBackend-Klasse.

E-Mail-Host

Die EMAIL_HOST Einstellung bezieht sich auf die SMTP-Server-Domäne, die Sie verwenden werden. Dies hängt von Ihrem E-Mail-Anbieter ab. Folgend finden Sie eine Tabelle mit dem SMTP-Server-Host, der für drei gängige Anbieter entspricht:

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

Wir lassen diese Einstellung vorerst leer, da wir später eine .env Datei verwenden, um hartcodierten sensiblen Schlüsseln oder ortspezifischen Konfigurationen aus dem Weg zu gehen. Sie sollten niemals Anmeldeinformationen direkt in den Code setzen.

Wir werden Django Environ verwenden, um dieses Problem zu lösen.

E-Mail-Port

Die EMAIL_PORT Einstellung muss auf 587 gesetzt werden, da dies der Standardport für die meisten SMTP-Server ist. Dies gilt auch für persönliche E-Mail-Anbieter.

Dieser Port wird zusammen mit TLS-Verschlüsselung verwendet, um die Sicherheit des E-Mail-Versands zu gewährleisten.

E-Mail-TLS-Nutzung

Transport Layer Security (TLS) ist ein Sicherheitsprotokoll, das im gesamten Web zum Verschlüsseln der Kommunikation zwischen Web-Apps (Django) und Servern (SMTP-Server) verwendet wird.

Ursprünglich setzen wir die EMAIL_USE_TLS Variable auf True. Das bedeutet, Django wird Transport Layer Security verwenden, um eine Verbindung zum SMTP-Server herzustellen und E-Mails zu senden. (Dies ist für persönliche E-Mail-Anbieter obligatorisch.)

E-Mail-Host-Benutzer

Die EMAIL_HOST_USER Einstellung ist Ihre persönliche E-Mail-Adresse. Lassen Sie es vorerst leer, da wir django-environ verwenden werden, um all diese Anmeldeinformationen einzurichten.

E-Mail-Host-Passwort

Die Einstellung EMAIL_HOST_PASSWORD ist das App-Passwort, das Sie von Ihrem E-Mail-Konto erhalten – den Prozess, den wir direkt nach diesem Abschnitt durchführen werden.

Gleiches gilt hier: Lassen Sie diese Einstellung leer, da wir später Umgebungsvariablen verwenden werden.

Einrichten eines App-Passworts in Gmail

Um die Einstellung EMAIL_HOST_PASSWORD zu verwenden, müssen Sie den Zugriff für weniger sichere Apps aktivieren und ein App-Passwort von Ihrer persönlichen E-Mail-Adresse besitzen.

Wenn Sie den Zugriff für weniger sichere Apps nicht aktivieren, erhalten Sie wahrscheinlich einen SMTPAuthenticationError, da Django keine Möglichkeit hat, sich an die Sicherheitsrichtlinien von Google zu halten.

Sie können auch das normale Passwort verwenden, aber das wäre sogar risikoreicher als die Verwendung eines App-Passworts. Mein Rat ist, ein neues Gmail-Konto zu erstellen oder eine „Test“-E-Mail-Adresse zu verwenden.

Berücksichtigen Sie dies, können Sie mit den folgenden Schritten ein Gmail-App-Passwort erhalten. Beachten Sie, dass Sie bei einem vorhandenen Konto, für das 2-stufige Überprüfung aktiviert ist, die Schritte 2 und 3 überspringen können:

1. Erstellen oder Anmelden bei einem Gmail-Konto
2. Gehen Sie zu myaccount.google.com/lesssecureapps und aktivieren Sie die Option für weniger sichere Apps.
   
3. Aktivieren Sie Zwei-Faktor-Authentifizierung, da dies erforderlich ist, um ein App-Passwort zu erhalten.
   
4. Nachdem Sie nun die Zwei-Faktor-Authentifizierung aktiviert haben, ist es Zeit, ein App-Passwort zu erhalten. Sie können dies tun, indem Sie zur Sicherheit-Sektion Ihres Google-Kontos gehen, nach unten zum Abschnitt „Anmeldung bei Google“ scrollen und auf App-Passwörter klicken.
   

Sie müssen Ihr Passwort (Konto-Passwort) erneut eingeben, bevor Sie zur Seite „App-Passwörter“ weitergeleitet werden.

Sobald Sie sich dort befinden, klicken Sie auf App auswählen, wo Sie einen benutzerdefinierten Namen für dieses App-Passwort wählen können — wie zum Beispiel “Django Send Email” — und dann auf ERZEUGEN klicken.

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

Wenn Sie andere E-Mail-Anbieter verwenden, achten Sie bitte auf die folgenden Anleitungen:

• Yahoo App-Passwort
• Outlook oder Hotmail App-Passwort

Verwenden von Django Environ zur Versteckung sensibler Schlüssel

Auch wenn Sie nur E-Mails in der Entwicklung senden, sollten Sie keine Passwörter direkt in den Quellcode schreiben. Dies wird umso wichtiger, wenn Sie ein Versionskontrollsystem zusammen mit GitHub verwenden, um Ihr Projekt zu hosten. Sie wollen nicht, dass Leute auf Ihre Daten zugreifen.

Schauen wir uns an, wie wir dies verhindern können, indem wir Django-environ verwenden.

Erstellen Sie eine .env-Datei im EmailProject-Verzeichnis (wo sich die settings.py-Datei befindet) mit dem folgenden Befehl:

cd EmailProject/
ls

settings.py # Die Einstellungsdatei muss hier sein

touch .env

Öffnen Sie nun diese .env-Datei und geben Sie die folgenden Schlüssel-Wert-Paare ein:

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

Aufschlüsselung des Inhalts dieser Datei:

• EMAIL_HOST: Die SMTP-Serveradresse Ihres E-Mail-Anbieters. Sehen Sie sich die E-Mail-Host-Tabelle oben für eine schnelle Anleitung an. In diesem Fall verwende ich smtp.gmail.com, die Gmail SMTP-Adresse.
• EMAIL_HOST_USER: Ihre E-Mail-Adresse.
• EMAIL_HOST_PASSWORD: Das gerade generierte App-Passwort. Denken Sie daran, dass es keine Leerzeichen enthält.
• RECIPIENT_ADDRESS: Die E-Mail-Adresse, an die Sie die Nachrichten erhalten werden. Dies ist eine benutzerdefinierte Einstellung, die wir später erstellen, um alle E-Mails an denselben Empfänger zu senden.

Um diese Umgebungsvariablen zu nutzen, müssen wir Django-environ installieren:

pip install django-environ

Hinweis: Stellen Sie sicher, dass Ihre virtuelle Umgebung aktiviert ist.

Öffnen Sie nun die settings.py, die sich im Verzeichnis EmailProject befindet, und verwenden Sie den folgenden Code:

# EmailProject/settings.py
# Dies sollte am Anfang der Datei sein
import environ

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

# Vorherige Einstellungen ...
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')

# Benutzerdefinierte Einstellung. Zur E-Mail
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Zuerst importieren wir die environ-Paket am Anfang der Einstellungsdatei. Denken Sie daran, dass alle Importe am Anfang stehen sollten.

Dann erstellen wir eine env-Variable, die alle Schlüssel-Wert-Paare enthält, die in der .env verfügbar sind.

Der env('KEY')-Aufruf bedeutet, dass wir nach dem Wert dieses Schlüssels suchen. Stellen Sie sicher, dass Sie Ihre .env-Datei vor dem Weitermachen eingerichtet haben, da sonst ein Django ImproperlyConfigured-Fehler auftritt, wenn eine Umgebungsvariable nicht gesetzt wurde.

Beachten Sie, dass RECIPIENT_ADDRESS eine benutzerdefinierte Einstellung ist, die wir verwenden werden, um E-Mails an eine zugängliche Adresse zu senden.

Vergessen Sie nicht, die .env-Datei in Ihrer .gitignore aufzunehmen, falls Sie Git und GitHub verwenden. Sie können dies tun, indem Sie die Datei öffnen und die folgende Zeile hinzufügen:

.env

1. Versenden von E-Mails mit der Django Shell

Endlich kommen wir zum spannenden Teil des Artikels! Es ist Zeit, deine erste E-Mail an Django zu senden.

Öffne eine Terminal, aktiviere die virtuelle Umgebung und führe aus:

python manage.py shell

Dies erzeugt eine Shell, in der alle Django-Einstellungen bereits für uns konfiguriert sind. Füge in dieser brandneuen Shell den folgenden Code ein:

>>> 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

Wir können auch einen Einzeiler ohne Angabe der Argumente erstellen:

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

Lass uns den Code oben analysieren:

• Wir importieren die Django-Funktion send_mail.
• Dann importieren wir das settings-Objekt, das alle globalen Einstellungen und die pro-Site-Einstellungen (die im settings.py-Datei enthalten sind) enthält.
• Schließlich übergeben wir allen benötigten Argumenten an die send_mail-Funktion. Diese Funktion gibt die Anzahl der versendeten E-Mails zurück, in diesem Fall 1.

Beachte, wie wir das settings-Objekt verwenden, um die from_email (die E-Mail, mit der du E-Mails sendest) und die recipient_list (die RECIPIENT_ADDRESS-benutzerdefinierte Einstellung, die wir in der .env-Datei definiert haben) zu erhalten.

Nun, wenn ich mein Postfach überprüfe — da ich die Umgebungsvariable RECIPIENT_ADDRESS auf meine E-Mail-Adresse gesetzt habe — werde ich die von Django gesendete Nachricht erhalten.

2. Erstellen einer automatisierten Kontaktformular mit Django

In diesem Abschnitt werden wir eine automatisierte Kontaktformular mit Django-Formularen und der integrierten Funktion send_mail erstellen. Außerdem werden wir eine benutzerdefinierte Funktion send() innerhalb des Kontaktformulars erstellen, damit sie einfacher in den Ansichten implementiert werden kann.

Beginnen wir mit der Erstellung der Kontakt-App. Gehen Sie in das Projektverzeichnis – wo sich manage.py befindet – und führen Sie Folgendes aus:

python manage.py startapp contact

Installieren Sie es anschließend in Ihrer INSTALLED_APPS Variable innerhalb der Datei EmailProject/settings.py:

# EmailProject/settings.py

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

    # Custom
    'contact',
]

Bevor wir mit der contact App fortfahren, konfigurieren wir die urlpatterns innerhalb der Datei EmailProject/urls.py. Dazu importieren wir die Funktion django.urls.include und fügen die Kontakt-URLs ins Gesamtprojekt ein. Keine Sorge, wir werden die Kontakt-URLs später konfigurieren:

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # Neue Importe

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Kontakt-URLs einbinden
]

Kontaktformular

Gehen Sie in den Ordner der contact App und erstellen Sie eine forms.py Datei. Es ist eine gute Praxis, alle Ihre Formulare innerhalb einer forms.py Datei zu definieren, aber es ist nicht zwingend erforderlich. Deshalb enthält Django diese Datei standardmäßig nicht.

Sie können die Formulardatei mit folgenden Befehlen erstellen:

cd ../contact/
# Sie befanden sich im EmailProject-Ordner
touch forms.py

Öffnen Sie die gerade erstellte Datei und führen Sie die folgenden Importe durch:

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

Das Django Formularmodul bietet uns alle benötigten Klassen und Felder, um unser Kontaktformular zu erstellen. Wieder einmal importieren wir das Einstellungen-Objekt und die send_mail-Funktion, um E-Mails zu senden.

Unser Kontaktformular wird mehrere Felder enthalten und zwei benutzerdefinierte Methoden verwenden: get_info(), welche die vom Benutzer bereitgestellten Informationen formatiert, und send(), welche die Nachricht sendet.

Schauen wir uns dies in Code an:

# 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
        """
        # Gereinigte Daten
        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]
        )

Dies ist eine große Klasse, also lasst uns genau unterscheiden, was wir in jedem Teil tun. Zunächst definieren wir vier Felder, die zum Senden der Nachricht erforderlich sind:

• name und enquiry sind CharFields, die den Namen und den Grund für die Kontaktanfrage darstellen.
• email ist ein EmailField, der die E-Mail-Adresse der Person darstellt, die versucht, Sie zu kontaktieren. Beachten Sie, dass die E-Mail nicht von der E-Mail-Adresse des Benutzers, sondern von der E-Mail-Adresse gesendet wird, die Sie in Ihrem Django-Projekt zum Senden von E-Mails eingestellt haben.
• message ist ein weiterer CharField, mit dem Unterschied, dass wir das Textarea Widget verwenden. Das bedeutet, dass beim Anzeigen des Formulars ein <textarea> Tag anstelle eines einfachen <input> gerendert wird.

Beim Einstieg in die benutzerdefinierten Methoden verwenden wir nur die get_info Methode, um die vom Benutzer bereitgestellten Informationen zu formatieren und zwei Variablen zurückzugeben: subject, das nichts anderes als das inquiry Feld ist, und message, das die tatsächliche Nachricht ist, die von Django gesendet wird.

Andererseits bezieht sich die send() Methode nur auf die formatierten Informationen von get_info und sendet die Nachricht mit der send_mail Funktion.

Obwohl dieser Abschnitt ziemlich groß war, werden Sie sehen, wie wir die Kontaktansichten vereinfacht haben, indem wir die gesamte Sendelogik in die ContactForm selbst implementiert haben.

Kontaktansichten

Öffnen Sie die Datei contact/views.py und fügen Sie die folgenden Importe hinzu:

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

Wie Sie sehen, werden wir Django-generische Ansichten verwenden, was uns eine Menge Zeit spart, wenn es um einfache Aufgaben geht – beispielsweise beim Einrichten eines Formulars mit FormView oder beim Erstellen einer Ansicht, die nur ein Template rendert mit TemplateView.

Auch importieren wir das ContactForm, das wir in der vorherigen Sektion erstellt haben, sowie die reverse_lazy Funktion, die beim Arbeiten mit Klassen-basierten Ansichten verwendet wird.

Weiter mit den Ansichten, schreiben wir nun die 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):
        # Ruft die benutzerdefinierte send-Methode auf
        form.send()
        return super().form_valid(form)

Wie zu sehen ist, erstellen wir eine einfache FormView unter Verwendung des von uns erstellten ContactForm. Wir richten auch template_name und success_url ein. Später werden wir das HTML-Template schreiben und die URLs einrichten.

Die form_valid Methode ermöglicht es uns, die E-Mail mithilfe der ContactForm.send() Methode nur dann zu senden, wenn alle Felder des Formulars gültig sind. Das bedeutet, dass eine Nachricht nicht gesendet wird, wenn der Benutzer ungültige Eingaben macht – beispielsweise eine unformatierte E-Mail-Adresse.

Die obige Implementierung der form_valid Methode wäre in einer funktionsbasierten Ansicht äquivalent zu:

# Vorherige funktionsbasierte Kontaktansicht ...

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

Abschließend dieses Abschnitts werden wir eine ContactSuccessView schreiben, die dem Benutzer eine Erfolgsmeldung anzeigt. Da wir bereits die TemplateView Klasse importiert haben, müssen wir nur von ihr erben und das template_name Attribut definieren:

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

Sie können sich die views.py Datei im GitHub-Repository ansehen, falls Sie Bedenken haben.

Kontakt-URLs

Es ist an der Zeit, die URL-Muster des contact Apps zu erstellen. Da Django uns das urls.py Datei standardmäßig nicht gibt, müssen wir sie mit folgendem Befehl erstellen (stellen Sie sicher, sich im contact App-Ordner zu befinden):

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

Öffnen Sie diese Datei und richten Sie die app_name und urlpatterns Variablen ein:

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

Wir verwenden path um den Route und ihrem zugehörigen View zur URL-Konfiguration der App hinzuzufügen. Wenn wir die app_name Variable auf 'contact' setzen, bedeutet das, dass der URL Namensraum der App so aussieht:

contact:name_of_path
# Für ContactView
contact:contact
# Für ContactSuccessView
contact:success

Hinweis: Ein Namensraum ist, wie wir URLs dynamisch in Django-Vorlagen und Ansichten bezeichnen.

Sie können sich ausführlicher über den Django URL-Dispatcher in der offiziellen Dokumentation informieren.

Schreiben von Vorlagen

Django-Vorlagen sind die bevorzugte Methode, um Daten dynamisch anzuzeigen, indem HTML und spezielle Tags verwendet werden, die die Django-Vorlagensprache uns bietet.

Für diese spezifische App werden wir drei Vorlagen verwenden:

• base.html: Alle anderen Vorlagen werden von ihm erben. Es enthält das gesamte HTML-Gerüst, das alle Vorlagen haben müssen, sowie Links zu Bootstrap.
• contact.html: zeigt das Kontaktformular an.
• success.html: zeigt eine Erfolgsmeldung an.

Beginnen wir mit der Erstellung der Vorlagestruktur des Kontakt-App (stellen Sie sicher, dass Sie sich im Kontakt-App-Ordner befinden):

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

Die obigen Befehle erstellen die typische Vorlagestruktur einer wiederverwendbaren Django-App — appname/templates/appname — und die vorher erwähnten Baumvorlagen.

Hier ist, wie die App-Dateistruktur nun aussehen sollte:

.
├── 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

Lass uns in den Inhalt der base.html-Vorlage springen:

<!-- 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>

Wie Sie sehen können, handelt es sich um das einfache Skelett einer HTML-Datei, die Links zu Bootstrap 5 enthält. Dies ermöglicht es uns, unser Kontakt-App ohne CSS-Dateien zu gestalten.

Das Tag {% block name-of-block %} erlaubt es uns, einen Platzhalter einzurichten, den „Kind-Templates“ nutzen werden. Die Verwendung dieses Tags macht Vorlagenvererbung zu einer einfachen Aufgabe.

Bevor Sie sich den Formularen zuwenden, müssen Sie das Django crispy forms-Paket installieren, das es uns ermöglicht, diese leicht zu gestalten:

pip install django-crispy-forms

Noch einmal, crispy_forms ist eine Django-App, und wir müssen sie in der INSTALLED_APPS-Liste enthalten:

# config/settings.py

INSTALLED_APPS = [
    ...

    # 3rd party apps
    'crispy_forms',

    # Custom apps
    'contact',
]

# Gibt an, welches Frontend-Framework django crispy forms verwendet
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Wir verwenden die Bootstrap 4-Vorlagensammlung, weil die Bootstrap-Formularklassen zwischen der 4. und 5. Version kompatibel sind (zum Zeitpunkt des Schreibens).

Nun arbeiten wir an der contact.html-Vorlage:

<!-- 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 %}

Beachten Sie, wie wir die Basisvorlage erweitert und den Block-Platzhalter verwendet haben. Dies macht die Django Template Language so effizient, da es uns ermöglicht, viel HTML-Kopiervorgänge und -Einfügemarkierungen zu sparen.

Bezüglich des Formulars verwenden wir die Methode "post", was bedeutet, dass unsere ContactView die vom Benutzer bereitgestellten Daten verarbeitet und im Falle einer gültigen Form eine E-Mail sendet.

Das {% csrf_token %} ist in jedem Formular aus Sicherheitsgründen zwingend erforderlich. Die Django-Dokumentation hat eine spezielle Seite über CSRF-Token und die Gründe für ihre Verwendung bei der Arbeit mit Formularen.

Wir werden das Formular mit dem crispy Template-Tag rendern, weshalb wir die crispy Tags mit {% load crispy_forms_tags %} geladen haben.

Abschließend schreiben wir die success.html Vorlage:

{% 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 %}

Wie Sie sehen, handelt es sich um eine einfache Erfolgsmitteilung, die einen Link zur Kontaktformularkomponente enthält, falls der Benutzer eine weitere Nachricht senden möchte.

Fahren wir den Server erneut hoch und besuchen http://localhost:8000 (stellen Sie sicher, dass Sie das .venv aktiviert haben und sich im Stammverzeichnis des Projekts befinden):

python manage.py runserver

Das folgende Bild zeigt, wie das endgültige Kontaktformular aussieht.

Und hier ist ein Bild der Erfolgsmeldung.

Und hier ein Bild der E-Mail im Postfach.

Abschließend

Herzlichen Glückwunsch! Du hast gelernt, wie man E-Mails mit Django versendet und wie man eine Kontaktformular in Django erstellt.

Es gibt viele Möglichkeiten, E-Mails mit Django zu versenden. In diesem Tutorial hast du es mit deiner persönlichen E-Mail-Adresse gemacht, aber ich möchte, dass du dich mit anderen Tools beschäftigst und sie in deine Projekte integrierst.

In diesem Tutorial haben wir Folgendes behandelt:

• wie man Django-Einstellungen einrichtet, um E-Mails zu versenden
• wie man mit einem persönlichen E-Mail-Konto in einem kleinen Projekt E-Mails versendet
• wie man .env-Dateien verwendet, um sensible Daten in einem Django-Projekt zu nutzen
• wie man ein automatisches Kontaktformular erstellt

Weitere Informationen zu Django findest du in “Build a Photo-sharing App with Django”.

Häufig gestellte Fragen zum Versenden von E-Mails mit Django