Come Inviare Email con Django

In questo tutorial, passeremo attraverso il processo di invio di email utilizzando Django. Copriremo come configurare le connessioni SMTP di Django, come impostare una password per app per il tuo provider di posta elettronica e come inviare email attraverso il shell di Django. Esamineremo anche come configurare un modulo di contatto per il tuo app Django, che permetterà ai tuoi clienti di contattarti.

La maggior parte delle applicazioni web utilizza la posta elettronica per gestire operazioni cruciali, come il reset delle password, l’attivazione degli account, la ricezione di feedback dei clienti, l’invio di newsletter e campagne di marketing. La maggior parte di queste attività richiede un servizio dedicato come SendGrid o Mailgun. Ma se non ti aspetti che il tuo sito riceva una grande quantità di visitatori, puoi effettivamente fare molto attraverso il tuo provider di posta personale.

Inviare email con la tua posta personale è un’opzione ragionevole per progetti piccoli o di test, quindi in questo caso adotteremo questo approccio per mantenere le cose semplici. Tuttavia, non è una buona idea utilizzare il tuo servizio di posta personale per il tuo sito di produzione. Puoi saperne di più su vincoli di invio di Gmail, o fare riferimento ai limiti del tuo provider di posta.

Nota: il codice completo per questo tutorial è disponibile su GitHub.

Comprendere SMTP

SMTP (o il Simple Mail Transfer Protocol) è un insieme di regole che determinano come le email vengono trasferite dagli mittenti ai destinatari. I server SMTP utilizzano questo protocollo per inviare e reindirizzare le email in uscita. (Si noti che altri protocolli governano come le email vengono ricevute.)

Un server SMTP ha sempre un indirizzo unico e una porta specifica per l’invio dei messaggi, che nella maggior parte dei casi è 587. Vedremo come la porta sia rilevante durante l’invio di email con Django.

Dato che utilizzeremo Gmail, l’indirizzo con cui lavoreremo sarà smtp.gmail.com e la porta sarà 587.

Ora vediamo come possiamo inviare email con Django.

Creazione di un Progetto Django

Ogni progetto Django dovrebbe avere un ambiente virtuale, poiché non vogliamo disturbare le dipendenze del progetto. Per crearne uno, esegui il seguente comando:

python -m venv .venv

Nota: se non hai familiarità con gli ambienti virtuali, assicurati di consultare la nostra guida sui virtual environments Python.

Il comando sopra crea un ambiente virtuale con il nome .venv. Per attivare questo ambiente virtuale, puoi utilizzare quanto segue:

source .venv/bin/activate

Dato che Django è un pacchetto di terze parti, devi installarlo con pip:

pip install django

Questo installerà la versione più recente di Django, che puoi verificare con pip freeze.

Per creare un progetto Django, si utilizza lo strumento della riga di comando django-admin:

django-admin startproject EmailProject

Con il comando sopra, si crea un progetto Django chiamato EmailProject, ma è possibile creare il progetto con qualsiasi nome desideri.

Ora, accedi alla directory del progetto e avvia il server:

cd EmailProject
python manage.py runserver

Dopo aver avviato il server Django, visita http://localhost:8000 nel tuo browser. Vedrai una pagina generata automaticamente con le note sulla versione più recente di Django.

Modifica delle Impostazioni

Sarà necessario modificare il file delle impostazioni prima di inviare email, quindi cerchiamo il file con il comando tree:

Nota: per semplicità, utilizzeremo solo comandi di sistema UNIX (macOS o Linux).

tree

Il comando tree visualizza la struttura dei file di una directory. In questo caso, poiché non gli diamo un percorso di directory specifico, otterremo qualcosa di simile al seguente se siamo nella cartella radice del progetto:

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

1 directory, 6 files

Il file che modifichiamo costantemente durante questo tutorial è il settings.py all’interno della cartella EmailProject.

settings.py contiene tutte le configurazioni del progetto necessarie e ti consente di impostare variabili personalizzate. Come dicono le documentazioni di Django, “Un file di impostazioni è solo un modulo Python con variabili a livello di modulo”.

Esaminiamo le impostazioni necessarie per inviare una email con Django. Apri il file EmailProject/settings.py e inserisci le seguenti impostazioni in fondo al file:

# 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 = ''

Analizziamo il codice sopra esaminando ognuna di queste impostazioni.

Backend Email

L’impostazione EMAIL_BACKEND dichiara il backend che il nostro progetto Django utilizzerà per connettersi al server SMTP.

Questa variabile punta alla classe smtp.EmailBackend che riceve tutti i parametri necessari per inviare un’email. Ti consiglio vivamente di dare un’occhiata al costruttore della classe direttamente nel codice sorgente di Django. Sarai sorpreso da quanto questo codice sia leggibile.

Nota: sebbene questa classe sia il EMAIL_BACKEND predefinito, è considerato una buona pratica essere espliciti nelle impostazioni di Django.

Tutte le altre impostazioni email si baseranno sul costruttore di questa classe EmailBackend.

Host Email

L’impostazione EMAIL_HOST si riferisce al dominio del server SMTP che utilizzerai. Questo dipende dal tuo provider di posta elettronica. Di seguito è riportata una tabella con il server host SMTP corrispondente a tre provider comuni:

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

Stiamo lasciando questa impostazione vuota per ora poiché utilizzeremo un file .env in seguito per evitare chiavi sensibili codificate in modo rigido o configurazioni per sito. Non dovresti mai impostare le credenziali direttamente nel codice.

Utilizzeremo Django Environ per risolvere questo problema.

Porta Email

L’impostazione EMAIL_PORT deve essere impostata su 587 perché è la porta predefinita per la maggior parte dei server SMTP. Questo rimane vero per i provider di posta elettronica personali.

Questa porta viene utilizzata insieme alla crittografia TLS per garantire la sicurezza della spedizione di posta elettronica.

Email Use TLS

Transport Layer Security (TLS) è un protocollo di sicurezza utilizzato in tutto il Web per crittografare la comunicazione tra app web (Django) e server (server SMTP).

In origine, abbiamo impostato la variabile EMAIL_USE_TLS su True. Ciò significa che Django utilizzerà la Transport Layer Security per connettersi al server SMTP e inviare email. (È obbligatorio per i provider di posta elettronica personali.)

Email Host User

L’impostazione EMAIL_HOST_USER è l’indirizzo email personale. Lascialo vuoto per ora, poiché utilizzeremo django-environ per impostare tutte queste credenziali.

Email Host Password

La configurazione EMAIL_HOST_PASSWORD è la password dell’app che otterrete dal vostro account di posta elettronica — il processo che faremo subito dopo questa sezione.

Stessa storia: lascia questa impostazione vuota, poiché useremo le variabili ambientali in seguito.

Configurare una Password dell’App in Gmail

Per utilizzare la configurazione EMAIL_HOST_PASSWORD è necessario attivare l’accesso a app meno sicure e avere una password dell’app dal vostro indirizzo di posta elettronica personale.

Se non attivate l’accesso a app meno sicure, probabilmente riceverete un SMTPAuthenticationError, perché Django non ha modo di rispettare i protocolli di sicurezza di Google.

Potreste scegliere di utilizzare la vostra normale password, ma sarebbe ancora più rischioso che utilizzare una password dell’app. Il mio consiglio è di creare un nuovo account Gmail o di utilizzare un indirizzo di posta “di prova”.

Tenendo questo in considerazione, potete ottenere una password dell’app Gmail seguendo i passaggi seguenti. Notate che se state utilizzando un account esistente e avete abilitato la verifica in due passaggi, potete saltare i passaggi 2 e 3:

1. Crea o accedi a un account Gmail
2. Vai su myaccount.google.com/lesssecureapps e attiva l’opzione per app meno sicure.
   
3. Abilita autenticazione a due fattori, poiché è richiesta per ottenere una password per l’app.
   
4. Ora che hai l’autenticazione a due fattori abilitata, è il momento di ottenere una password per l’app. Puoi farlo andando nella sezione di sicurezza del tuo account Google, scorrendo fino alla sezione Firma in Google e cliccando su Password per app.
   

Dovrai inserire di nuovo la tua password (password dell’account), prima di essere reindirizzato alla pagina delle password per app.

Una volta dentro, clicca su seleziona app, dove sceglierai un nome personalizzato per quella password per app — come “Invia email Django” — quindi clicca su GENERA.

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

Se utilizzi altri provider di posta elettronica, assicurati di leggere le guide seguenti:

• Password per app Yahoo
• Password per app Outlook o Hotmail

Utilizzando Django Environ per Nascondere Chiavi Sensitive

Anche se stai solo inviando email in fase di sviluppo, non dovresti scrivere password direttamente nel codice sorgente. Ciò diventa ancora più importante quando si utilizza un sistema di controllo delle versioni insieme a GitHub per ospitare il tuo progetto. Non vuoi che le persone accedano ai tuoi dati.

Vediamo come possiamo prevenire questo utilizzando Django-environ.

Crea un file .env all’interno della directory EmailProject (dove si trova il file settings.py) con il comando seguente:

cd EmailProject/
ls

settings.py # Il file delle impostazioni deve trovarsi qui

touch .env

Ora, apri quel file .env e inserisci le seguenti coppie chiave-valore:

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

Scomponendo il contenuto di questo file:

• EMAIL_HOST: l’indirizzo del server SMTP del tuo provider di posta elettronica. Consulta la tabella degli host email sopra per una guida rapida. In questo caso, sto utilizzando smtp.gmail.com, l’indirizzo SMTP di Gmail.
• EMAIL_HOST_USER: il tuo indirizzo email.
• EMAIL_HOST_PASSWORD: la password dell’app che hai appena generato. Tieni presente che non include alcuno spazio.
• RECIPIENT_ADDRESS: l’indirizzo email in cui riceverai i messaggi. Questa è una configurazione personalizzata che creeremo in seguito per inviare tutte le email allo stesso destinatario.

Per utilizzare queste variabili ambientali, dobbiamo installare Django-environ:

pip install django-environ

Nota: assicurati che l’ambiente virtuale sia attivato.

Ora, apri il file settings.py situato nella directory EmailProject e utilizza il codice seguente:

# EmailProject/settings.py
# Questo dovrebbe essere all'inizio del file
import environ

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

# Impostazioni precedenti ...
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')

# Impostazione personalizzata. Per email
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Innanzitutto, importiamo il pacchetto environ all’inizio del file delle impostazioni. Ricorda che tutti gli import dovrebbero essere all’inizio.

Quindi creiamo una variabile env che conterrà tutte le coppie chiave-valore disponibili nel .env.

La dichiarazione env('KEY') significa che stiamo cercando il valore di quella chiave. Assicurati di aver configurato il tuo file .env prima di procedere, perché potresti ricevere un errore Django ImproperlyConfigured se qualche variabile ambientale non fosse stata impostata.

Nota che RECIPIENT_ADDRESS è una impostazione personalizzata che useremo per inviare le email a un indirizzo accessibile.

Non dimenticare di includere il file .env nel tuo .gitignore nel caso tu stia utilizzando Git e GitHub. Puoi farlo semplicemente aprendolo e aggiungendo la seguente riga:

.env

1. Inviare E-mail con la Shell di Django

Finalmente arriviamo alla parte interessante dell’articolo! È ora di inviare il tuo primo e-mail a Django.

Apri un terminale, attiva l’ambiente virtuale e esegui:

python manage.py shell

Questo creerà una shell con tutte le impostazioni di Django già configurate per noi. All’interno di quella nuova shell, incolla il seguente codice:

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

Possiamo anche fare un’unica riga senza specificare gli argomenti:

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

Analizziamo il codice sopra:

• Importiamo la funzione di Django send_mail.
• Quindi importiamo l’oggetto settings che contiene tutte le impostazioni globali e le impostazioni per sito (quelle all’interno del file settings.py).
• Infine, passiamo tutti gli argomenti necessari alla funzione send_mail. Questa funzione restituisce il numero di e-mail inviate, in questo caso, 1.

Nota come stiamo usando l’oggetto settings per ottenere il from_email (l’e-mail con cui stiamo inviando e-mail) e la recipient_list (la configurazione personalizzata RECIPIENT_ADDRESS che abbiamo definito nel file .env).

Ora, se controllo la mia casella di posta — poiché ho impostato la variabile ambientale RECIPIENT_ADDRESS sulla mia e-mail — riceverò il messaggio inviato da Django.

2. Creare un Form di Contatto Automatico con Django

In questa sezione, costruiremo un modulo di contatto automatico con form Django e la funzione send_mail integrata. Inoltre, creeremo una funzione personalizzata, send(), all’interno del modulo di contatto per renderlo più semplice da implementare nelle views.

Iniziamo creando l’app di contatto. Entra nella directory principale del progetto — dove si trova manage.py — e esegui:

python manage.py startapp contact

Successivamente, installalo nella variabile INSTALLED_APPS all’interno del file EmailProject/settings.py:

# EmailProject/settings.py

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

    # Personalizzato
    'contact',
]

Prima di procedere con l’app contact, configuriamo le urlpatterns all’interno del file EmailProject/urls.py. Per fare ciò, importa la funzione django.urls.include e include le URL di contatto nel progetto complessivo. Non preoccuparti; configureremo le URL di contatto in seguito:

# EmailProject/urls.py

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Include URL di Contatto
]

Modulo di Contatto

Entra nella cartella dell’app contact e crea un file forms.py. È una buona pratica definire tutti i tuoi form all’interno di un file forms.py, ma non è obbligatorio. Questo è il motivo per cui Django non include questo file per impostazione predefinita.

Puoi creare il file dei form con i seguenti comandi:

cd ../contact/
# Eri all'interno della cartella EmailProject
touch forms.py

Apri il file appena creato e effettua le seguenti importazioni:

# contact/forms.py

from django import forms
from django.conf import settings
from django.core.mail import send_mail

Il modulo form di Django ci fornisce tutte le classi e i campi necessari per creare il nostro modulo di contatto. Ancora una volta stiamo importando l’oggetto settings e la funzione send_mail per inviare le email.

Il nostro modulo di contatto conterrà diversi campi e utilizzerà due metodi personalizzati: get_info(), che formata le informazioni fornite dall’utente, e send(), che invierà il messaggio.

Vediamo come questo è implementato nel codice:

# 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
        """
        
# Dati puliti

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

Questa è una classe molto ampia, quindi analizziamo cosa stiamo facendo in ogni parte. Innanzitutto, definiamo quattro campi che saranno necessari per inviare il messaggio:

• name e enquiry sono CharFields che rappresentano il nome e il motivo del messaggio di contatto.
• email è un EmailField che rappresenta l’indirizzo email della persona che cerca di contattarti. Tenete presente che l’email non verrà inviata dall’indirizzo email dell’utente, ma dall’indirizzo email che avete impostato per inviare le email nel progetto Django.
• message è un altro CharField con l’eccezione che stiamo utilizzando il widget Textarea. Ciò significa che, quando si visualizza il form, verrà generato un tag <textarea> invece di un semplice <input>.

Andando nelle metodi personalizzati, stiamo utilizzando solo il metodo get_info per formattare le informazioni fornite dall’utente e restituire due variabili: subject, che non è altro che il campo inquiry, e il message, che sarà il messaggio effettivo inviato da Django.

D’altra parte, il metodo send() ottiene solo le informazioni formattate da get_info e invia il messaggio utilizzando la funzione send_mail.

Anche se questa sezione era piuttosto ampia, vedrai come abbiamo semplificato le visualizzazioni del contatto implementando tutta la logica di invio nel ContactForm stesso.

Visualizzazioni del Contatto

Apri il file contact/views.py e aggiungi le seguenti importazioni:

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

Come puoi vedere, utilizzeremo generic views di Django, che ci risparmiano un sacco di tempo nel compiere compiti semplici — ad esempio, quando si configura un form con FormView o si crea una vista che visualizza solo un template con TemplateView.

Inoltre, stiamo importando il ContactForm che abbiamo costruito nella sezione precedente e la funzione reverse_lazy utilizzata durante lo sviluppo di class-based views.

Proseguendo con le viste, scriviamo il 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):
        # Chiama il metodo personalizzato send
        form.send()
        return super().form_valid(form)

Come potete vedere, stiamo creando una semplice vista FormView utilizzando il ContactForm che abbiamo creato. Stiamo anche impostando il template_name e il success_url. Scriveremo il template HTML e configureremo le URL in seguito.

Il metodo form valid ci consente di inviare l’email utilizzando il metodo ContactForm.send() solo se tutti i campi del form sono validi. Ciò significa che se l’utente inserisce input non valido — come un indirizzo email non formattato — il messaggio non verrà inviato.

L’implementazione del metodo form_valid sopra sarebbe equivalente al seguente in una vista basata su funzione:

# Vista di contatto basata su funzione precedente ...

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

Concludendo questa sezione, scriveremo un ContactSuccessView, che mostrerà un messaggio di successo all’utente. Poiché abbiamo già importato la classe TemplateView, dobbiamo solo ereditarla e definire l’attributo template_name:

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

Puoi consultare il file views.py sul repository GitHub nel caso tu abbia preoccupazioni.

URL dei Contatti

È ora di creare i pattern URL dell’app contact. Poiché Django non ci fornisce il file urls.py per impostazione predefinita, dovremo crearlo con il seguente comando (assicurati di trovarti nella cartella dell’app contact):

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

Apri quel file e configura le variabili app_name e 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"),
]

Usiamo path per includere la rotta e la relativa vista nella configurazione URL dell’app. Quando impostiamo la variabile app_name su 'contact', significa che lo spazio dei nomi URL dell’app sarà simile a questo:

contact:name_of_path
# Per ContactView
contact:contact
# Per ContactSuccessView
contact:success

Nota: uno spazio dei nomi è ciò che chiamiamo dinamicamente gli URL nei template e nelle viste di Django.

Puoi imparare di più sull’indicizzatore degli URL di Django nella documentazione ufficiale.

Scrittura di modelli

I modelli Django sono il metodo preferito per mostrare dati in modo dinamico, utilizzando HTML e tag speciali che il Linguaggio di Template Django ci fornisce.

Per questo specifico app, utilizzeremo tre modelli:

• base.html: tutti gli altri modelli erediteranno da esso. Contenente tutto lo scheletro HTML che tutti i modelli devono avere, così come i collegamenti a Bootstrap.
• contact.html: mostra il modulo di contatto.
• success.html: mostra un messaggio di successo.

Iniziamo creando la struttura del modello dell’app contatto (assicurati di essere all’interno della cartella dell’app contatto):

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

I comandi sopra creano la struttura del modello tipica di un’app Django riutilizzabile — appname/templates/appname — e i file dei modelli a albero che ho menzionato prima.

Ecco come dovrebbe apparire ora la struttura del file dell’app:

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

Saltiamo al contenuto del modello 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>

Come puoi vedere, si tratta dello scheletro semplice di un file HTML che include collegamenti a Bootstrap 5. Ciò ci permette di stilizzare il nostro app di contatto senza utilizzare file CSS.

Il tag {% block name-of-block %} ci permette di impostare un segnaposto che verrà utilizzato dai “template figli”. L’uso di questo tag rende l’ereditarietà dei template un compito facile.

Prima di addentrarci nelle form, dovrai installare il pacchetto Django crispy forms, che ci permette di stilizzarle facilmente:

pip install django-crispy-forms

Ancora una volta, crispy_forms è un’app Django, e dobbiamo includerla nell’elenco INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # app di terze parti
    'crispy_forms',

    # app personalizzate
    'contact',
]

# Indica il framework frontend utilizzato da django crispy forms
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Utilizziamo il pacchetto di template di Bootstrap 4, poiché le classi di form di Bootstrap sono compatibili tra la 4a e la 5a versione (al momento della stesura).

Ora, lavoriamo sul 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 %}

Nota come abbiamo esteso il template base e utilizzato il segnaposto di blocco. Questo è ciò che rende il Django Template Language così efficiente, poiché ci consente di risparmiare molto copia e incolla di HTML.

Parlando del modulo, stiamo utilizzando il metodo "post", il che significa che il nostro ContactView elaborherà i dati forniti dall’utente e invierà la mail se il modulo è valido.

Il {% csrf_token %} è obbligatorio in ogni modulo per ragioni di sicurezza. La documentazione di Django ha una pagina dedicata su CSRF tokens e le ragioni per utilizzarli quando si lavora con moduli.

Renderizzeremo il modulo con la tag crispy, ed è per questo che abbiamo caricato le tag crispy con {% load crispy_forms_tags %}.

Infine, scriviamo il template 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 %}

Come puoi vedere, è un semplice annuncio di successo che include un link al modulo di contatto nel caso l’utente volesse inviare un’altra messaggio.

Eseguiamo di nuovo il server e visitiamo http://localhost:8000 (assicurati di avere attivato il .venv e di essere all’interno della cartella radice del progetto):

python manage.py runserver

L’immagine qui sotto mostra come appare il modulo di contatto finale.

E questa è un’immagine del messaggio di successo.

Ed ecco un’immagine della mail nella casella di posta.

Concludendo

Congratulazioni! Hai imparato a inviare email con Django e a costruire anche un modulo di contatto Django.

Ci sono molti modi per inviare email con Django. In questa guida, l’hai fatto con il tuo indirizzo email personale, ma vorrei che esplorassi altri strumenti e li integriassi nei tuoi progetti.

In questa guida, abbiamo trattato quanto segue:

• come configurare le impostazioni di Django per servire email
• come utilizzare un account email personale per inviare email in un piccolo progetto
• come utilizzare i file .env per utilizzare dati sensibili in un progetto Django
• come costruire un modulo di contatto automatico

Per ulteriori informazioni su Django, consulta “Costruisci un’app di condivisione di foto con Django”.

Domande frequenti su come inviare email con Django