Cómo enviar un correo electrónico con Django

En este tutorial, repasaremos cómo enviar correos electrónicos utilizando Django. Cubriremos cómo configurar conexiones SMTP de Django, cómo configurar una contraseña de aplicación para su proveedor de correo electrónico y cómo enviar correos electrónicos a través de la shell de Django. También veremos cómo configurar un formulario de contacto para su aplicación Django, lo que permitirá a sus clientes ponerse en contacto con usted.

La mayoría de las aplicaciones web utilizan el correo electrónico para gestionar operaciones cruciales, como restablecer contraseñas, activar cuentas, recibir comentarios de los clientes, enviar boletines y campañas de marketing. La mayoría de estas tareas requieren un servicio dedicado como SendGrid o Mailgun. Pero si no espera que su sitio reciba una gran cantidad de visitantes, en realidad puede hacer mucho a través de su proveedor de correo electrónico personal.

Enviar correos electrónicos con su correo electrónico personal es una opción razonable para proyectos pequeños o de prueba, por lo que adoptaremos ese enfoque aquí para mantener las cosas simples. Sin embargo, no es una buena idea usar su servicio de correo electrónico personal para su sitio web en producción. Puede obtener más información sobre restricciones de envío de Gmail, o referirse a las limitaciones de su proveedor de correo electrónico.

Nota: el código completo para este tutorial está disponible en GitHub.

Entendiendo SMTP

SMTP (o el Protocolo Simple de Transferencia de Correo) es un conjunto de reglas que determinan cómo se transfieren los correos electrónicos desde los remitentes hasta los destinatarios. Los servidores SMTP utilizan este protocolo para enviar y reenviar correos electrónicos salientes. (Tenga en cuenta que otros protocolos regulan cómo se reciben los correos electrónicos.)

Un servidor SMTP siempre tiene una dirección única y un puerto específico para enviar mensajes, que en la mayoría de los casos es 587. Veremos cómo el puerto es relevante al enviar correos electrónicos con Django.

Como usaremos Gmail, la dirección con la que trabajaremos es smtp.gmail.com, y el puerto será 587.

Ahora veamos cómo podemos enviar correos electrónicos con Django.

Creando un Proyecto Django

Cada proyecto Django debe tener un entorno virtual, ya que no queremos desordenar las dependencias del proyecto. Para crear uno, ejecute lo siguiente:

python -m venv .venv

Nota: si no está familiarizado con los entornos virtuales, asegúrese de consultar nuestra guía de entornos virtuales de Python.

El comando anterior crea un entorno virtual con el nombre .venv. Para activar este entorno virtual, puede utilizar lo siguiente:

source .venv/bin/activate

Dado que Django es un paquete de terceros, debe instalarlo con pip:

pip install django

Esto instalará la última versión de Django, que puede verificar con pip freeze.

Para crear un proyecto Django, llama al utilitario de línea de comandos django-admin:

django-admin startproject EmailProject

Con el comando anterior, estás creando un proyecto Django con el nombre EmailProject, pero puedes crear el proyecto con cualquier nombre que desees.

Ahora, ingresa al directorio del proyecto y ejecuta el servidor:

cd EmailProject
python manage.py runserver

Después de ejecutar el servidor Django, visita http://localhost:8000 en tu navegador. Verás una página generada automáticamente con las notas de lanzamiento de la última versión de Django.

Modificando Configuraciones

Necesitarás modificar el archivo de configuración antes de enviar correos electrónicos, así que localicemos ese archivo con el comando tree:

Nota: por simplicidad, estaremos usando solo comandos de sistemas UNIX (macOS o Linux).

tree

El comando tree muestra la estructura de archivos de un directorio. En este caso, dado que no le estamos dando un camino de directorio específico, obtendremos algo similar al siguiente si estamos en la carpeta raíz del proyecto:

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

1 directory, 6 files

El archivo que constantemente modificaremos a lo largo de este tutorial es el settings.py dentro de la carpeta EmailProject.

settings.py contiene toda la configuración del proyecto que necesitarás y te permite establecer variables personalizadas. Como dicen los documentos de Django, “Un archivo de configuración es simplemente un módulo de Python con variables de nivel de módulo”.

Veamos los ajustes necesarios para enviar un correo electrónico con Django. Abra el archivo EmailProject/settings.py y pegue los siguientes ajustes al final del archivo:

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

Analicemos el código anterior analizando cada uno de estos ajustes.

Backend de Email

La configuración EMAIL_BACKEND declara el backend que nuestro proyecto Django utilizará para conectarse al servidor SMTP.

Esta variable apunta a la clase smtp.EmailBackend que recibe todos los parámetros necesarios para enviar un correo electrónico. Te recomiendo encarecidamente que eches un vistazo al constructor de la clase directamente en el código fuente de Django. Te sorprenderá lo legible que es este código.

Nota: aunque esta clase es el EMAIL_BACKEND predeterminado, se considera una buena práctica ser explícito en los ajustes de Django.

Todos los demás ajustes de correo electrónico se basarán en el constructor de esta clase EmailBackend.

Host de Email

La configuración EMAIL_HOST se refiere al dominio del servidor SMTP que utilizarás. Esto depende de tu proveedor de correo electrónico. A continuación, se presenta una tabla con el host del servidor SMTP correspondiente a tres proveedores comunes:

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

Por ahora, dejamos esta configuración en blanco ya que utilizaremos un archivo .env más adelante para evitar claves sensibles codificadas de forma rígida o configuraciones específicas por sitio. Nunca debes establecer credenciales directamente en el código.

Utilizaremos Django Environ para resolver este problema.

Puerto de Correo

La configuración EMAIL_PORT debe establecerse en 587 porque es el puerto predeterminado para la mayoría de los servidores SMTP. Esto sigue siendo cierto para proveedores de correo electrónico personales.

Este puerto se utiliza junto con la encriptación TLS para garantizar la seguridad al enviar correos electrónicos.

Correo Use TLS

Transport Layer Security (TLS) es un protocolo de seguridad utilizado en todo el Web para encriptar la comunicación entre aplicaciones web (Django) y servidores (servidor SMTP).

Inicialmente, establecemos la variable EMAIL_USE_TLS en True. Esto significa que Django utilizará Transport Layer Security para conectarse al servidor SMTP y enviar correos electrónicos. (Es obligatorio para proveedores de correo electrónico personales.)

Usuario del Host de Correo

La configuración EMAIL_HOST_USER es tu dirección de correo electrónico personal. Déjala en blanco por ahora, ya que utilizaremos django-environ para configurar todas estas credenciales.

Contraseña del Host de Correo

La configuración EMAIL_HOST_PASSWORD es la contraseña de la aplicación que obtendrás de tu cuenta de correo electrónico, proceso que realizaremos justo después de esta sección.

Igual situación: deja esta configuración en blanco, ya que utilizaremos variables de entorno más adelante.

Configurar una Contraseña de Aplicación en Gmail

Para usar la configuración EMAIL_HOST_PASSWORD necesitarás activar el acceso a aplicaciones poco seguras y tener una contraseña de aplicación desde tu dirección de correo electrónico personal.

Si no activas el acceso a aplicaciones poco seguras, probablemente recibirás un SMTPAuthenticationError, porque Django no tiene forma de cumplir con los protocolos de seguridad de Google.

Puedes optar por usar tu contraseña normal, pero sería incluso más arriesgado que usar una contraseña de aplicación. Mi consejo es crear una nueva cuenta de Gmail o usar una dirección de correo electrónico de “prueba”.

Teniendo esto en cuenta, puedes obtener una contraseña de aplicación de Gmail siguiendo los pasos a continuación. Ten en cuenta que si estás usando una cuenta existente y has habilitado la verificación en dos pasos, puedes omitir los pasos 2 y 3:

1. Crea o inicia sesión en una cuenta de Gmail
2. Dirígete a myaccount.google.com/lesssecureapps y activa la opción de aplicaciones poco seguras.
   
3. Habilita autenticación de dos factores, ya que es necesario para obtener una contraseña de aplicación.
   
4. Ahora que tienes habilitada la autenticación de dos factores, es momento de obtener una contraseña de aplicación. Puedes hacerlo accediendo a la sección de seguridad de tu cuenta de Google, desplazándote hasta la sección de Inicio de sesión en Google y haciendo clic en Contraseñas de aplicación.
   

Tendrás que volver a introducir tu contraseña (contraseña de la cuenta), antes de ser redirigido a la página de contraseñas de aplicación.

Una vez dentro, haz clic en seleccionar aplicación, donde elegirás un nombre personalizado para esa contraseña de aplicación —como “Enviar correo Django”— y luego haz clic en GENERAR.

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

Si estás utilizando otros proveedores de correo electrónico, asegúrate de leer las siguientes guías:

• Contraseña de aplicación de Yahoo
• Contraseña de aplicación de Outlook o Hotmail

Usando Django Environ para Ocultar Claves Sensibles

Incluso si solo estás enviando correos electrónicos en desarrollo, no deberías escribir contraseñas directamente en el código fuente. Esto se vuelve aún más importante al utilizar un sistema de control de versiones junto con GitHub para alojar tu proyecto. No quieres que la gente acceda a tus datos.

Veamos cómo podemos prevenir esto utilizando Django-environ.

Crea un archivo .env dentro del directorio EmailProject (donde se encuentra el archivo settings.py) con el siguiente comando:

cd EmailProject/
ls

settings.py # El archivo de configuración debe estar aquí

touch .env

Ahora, abre ese archivo .env y escribe los siguientes pares clave-valor:

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

Desglosemos el contenido de este archivo:

• EMAIL_HOST: la dirección del servidor SMTP de tu proveedor de correo electrónico. Consulta la tabla de proveedores de correo arriba para una guía rápida. En este caso, estoy usando smtp.gmail.com, la dirección SMTP de Gmail.
• EMAIL_HOST_USER: tu dirección de correo electrónico.
• EMAIL_HOST_PASSWORD: la contraseña de la aplicación que acabas de generar. Ten en cuenta que no incluye espacios.
• RECIPIENT_ADDRESS: la dirección de correo electrónico en la que recibirás los mensajes. Esta es una configuración personalizada que crearemos más adelante para enviar todos los correos electrónicos al mismo destinatario.

Para hacer uso de estas variables de entorno, necesitaremos instalar Django-environ:

pip install django-environ

Nota: asegúrate de que tu entorno virtual esté activado.

Ahora, abre el settings.py ubicado en el directorio EmailProject y utiliza el código a continuación:

# EmailProject/settings.py
# Esto debería estar al inicio del archivo
import environ

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

# Configuraciones anteriores ...
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')

# Configuración personalizada. Para correo electrónico
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Primero, estamos importando el paquete environ al inicio del archivo de configuración. Recuerda que todas las importaciones deben estar al inicio.

Luego creamos una variable env que contendrá todos los pares clave-valor disponibles en el .env.

La declaración env('KEY') significa que estamos buscando el valor de esa clave. Asegúrate de haber configurado tu archivo .env antes de continuar, porque obtendrás un error de Django ImproperlyConfigured en caso de que alguna variable de entorno no haya sido establecida.

Tenga en cuenta que RECIPIENT_ADDRESS es una configuración personalizada que utilizaremos para enviar los correos electrónicos a una dirección que podemos acceder.

No olvides incluir el archivo .env en tu .gitignore en caso de que estés usando Git y GitHub. Puedes hacerlo abriendo el archivo y agregando la siguiente línea:

.env

1. Enviar Correo Electrónico con la Shell de Django

¡Finalmente llegamos a la parte interesante del artículo! Es hora de enviar tu primer correo electrónico a Django.

Abre una terminal, activa el entorno virtual y ejecuta:

python manage.py shell

Esto creará una shell con todas las configuraciones de Django ya establecidas para nosotros. Dentro de esa nueva shell, pega el siguiente código:

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

También podemos hacer una línea sin especificar los argumentos:

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

Analicemos el código anterior:

• Importamos la función de Django send_mail.
• Luego importamos el objeto settings que contiene todas las configuraciones globales y las configuraciones por sitio (aquellas dentro del archivo settings.py).
• Finalmente, pasamos todos los argumentos necesarios a la función send_mail. Esta función devuelve el número de correos enviados, en este caso, 1.

Observa cómo estamos usando el objeto settings para obtener el from_email (el correo electrónico con el que enviamos correos) y la recipient_list (la configuración personalizada RECIPIENT_ADDRESS que definimos en el archivo .env).

Ahora, si reviso mi bandeja de entrada — ya que establecí la variable de entorno RECIPIENT_ADDRESS a mi dirección de correo electrónico — recibiré el mensaje enviado por Django.

2. Construir un Formulario de Contacto Automatizado con Django

En esta sección, construiremos un formulario de contacto automatizado con formularios de Django y la función incorporada send_mail. Además, crearemos una función personalizada, send(), dentro del formulario de contacto para facilitar su implementación en las vistas.

Comencemos creando la aplicación de contacto. Entre en el directorio raíz del proyecto, donde se encuentra manage.py, y ejecute:

python manage.py startapp contact

Luego, instálelo en su variable INSTALLED_APPS dentro del archivo EmailProject/settings.py:

# EmailProject/settings.py

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

    # Personalizado
    'contact',
]

Antes de avanzar con la aplicación contact, configuremos las urlpatterns dentro del archivo EmailProject/urls.py. Para ello, importe la función django.urls.include e incluya las URL de contacto en el proyecto general. No se preocupe; configuraremos las URL de contacto más adelante:

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # Nueva importación

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Incluir URLs de Contacto
]

Formulario de Contacto

Entre en la carpeta de la aplicación contact y cree un archivo forms.py. Es una buena práctica definir todos sus formularios dentro de un archivo forms.py, pero no es obligatorio. Por eso Django no incluye este archivo por defecto.

Puede crear el archivo de formularios con los siguientes comandos:

cd ../contact/
# Usted estaba dentro de la carpeta EmailProject
touch forms.py

Abra el archivo que acaba de crear y realice las siguientes importaciones:

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

El módulo form de Django nos proporciona todas las clases y campos necesarios para crear nuestro formulario de contacto. Una vez más estamos importando el objeto settings y la función send_mail para enviar los correos electrónicos.

Nuestro formulario de contacto contendrá varios campos y utilizará dos métodos personalizados: get_info(), que formatea la información proporcionada por el usuario, y send(), que enviará el mensaje.

Veamos cómo se implementa esto en código:

# 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
        """
        # Datos limpios
        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]
        )

Esta es una clase enorme, así que desglosemos lo que estamos haciendo en cada parte. En primer lugar, definimos cuatro campos que serán necesarios para enviar el mensaje:

• name y enquiry son CharFields que representan el nombre y la razón del mensaje de contacto.
• email es un EmailField que representa el correo electrónico de la persona que intenta ponerse en contacto contigo. Tenga en cuenta que el correo electrónico no se enviará desde la dirección de correo electrónico del usuario, sino desde la dirección de correo electrónico que configuraste para enviar los correos electrónicos en el proyecto de Django.
• message es otro CharField con la excepción de que estamos utilizando el widget Textarea. Esto significa que, al mostrar el formulario, se renderizará una etiqueta <textarea> en lugar de una simple <input>.

Al adentrarnos en los métodos personalizados, solo estamos utilizando el método get_info para formatear la información proporcionada por el usuario y devolver dos variables: subject, que no es más que el campo inquiry, y el message, que será el mensaje real enviado por Django.

Por otro lado, el método send() solo obtiene la información formateada de get_info y envía el mensaje con la función send_mail.

Aunque esta sección fue bastante grande, verás cómo simplificamos las vistas de contacto implementando toda la lógica de envío en el ContactForm mismo.

Vistas de Contacto

Abre el archivo contact/views.py y agrega las siguientes importaciones:

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

Como puedes ver, vamos a utilizar vistas genéricas de Django, lo que nos ahorra una gran cantidad de tiempo al realizar tareas simples, por ejemplo, al configurar un formulario con FormView o crear una vista que solo renderiza una plantilla con TemplateView.

Además, estamos importando el ContactForm que construimos en la sección anterior y la función reverse_lazy utilizada al trabajar con vistas basadas en clases.

Continuando con las vistas, escribamos el 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):
        # Llama al método personalizado send
        form.send()
        return super().form_valid(form)

Como puedes ver, estamos construyendo una simple FormView utilizando el ContactForm que creamos. También estamos configurando el template_name y el success_url. Escribiremos la plantilla HTML y configuraremos las URLs más adelante.

El método form valid nos permite enviar el correo electrónico utilizando el método ContactForm.send() solo si todos los campos del formulario son válidos. Esto implica que si el usuario introduce una entrada inválida, como una dirección de correo electrónico sin formato, el mensaje no se enviará.

La implementación del método form_valid anterior sería equivalente a lo siguiente en una vista basada en función:

# Vista de contacto basada en función anterior...

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

Terminando esta sección, vamos a escribir un ContactSucessView, que mostrará un mensaje de éxito al usuario. Como ya hemos importado la clase TemplateView, solo necesitamos heredar de ella y definir el atributo template_name:

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

Puedes revisar el archivo views.py en el repositorio de GitHub en caso de que tengas alguna inquietud.

URLs de Contacto

Es hora de crear los patrones de URL del contact app. Dado que Django no nos proporciona el archivo urls.py por defecto, tendremos que crearlo con el siguiente comando (asegúrate de estar dentro de la carpeta del contact app):

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

Abre ese archivo y configura las variables app_name y 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"),
]

Utilizamos path para incluir la ruta y su vista correspondiente en la configuración de URL de la aplicación. Cuando establecemos la variable app_name en 'contact', significa que el namespacing de URL de la aplicación será así:

contact:name_of_path
# Para ContactView
contact:contact
# Para ContactSuccessView
contact:success

Nota: un namespace es cómo llamamos a las URLs de manera dinámica en las plantillas y vistas de Django.

Puedes obtener más información sobre el despachador de URL de Django en la documentación oficial.

Escribiendo plantillas

Las plantillas de Django son la forma preferida de mostrar datos de manera dinámica, utilizando HTML y etiquetas especiales que el Lenguaje de Plantillas de Django nos proporciona.

Para esta aplicación específica, utilizaremos tres plantillas:

• base.html: de las otras plantillas heredarán. Contendrá el esqueleto HTML que todos los templates deben tener, así como enlaces a Bootstrap.
• contact.html: muestra el formulario de contacto.
• success.html: muestra un mensaje de éxito.

Comencemos creando la estructura de la plantilla de la aplicación de contacto (asegúrate de estar dentro de la carpeta de la aplicación de contacto):

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

Los comandos anteriores crean la estructura de plantillas típica de una aplicación Django reutilizable — appname/templates/appname — y los archivos de plantilla en árbol que mencioné anteriormente.

Así es como debería verse ahora la estructura de archivos de la aplicación:

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

Saltemos al contenido de la plantilla 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>

Como puedes ver, es el simple esqueleto de un archivo HTML que incluye enlaces a Bootstrap 5. Esto nos permite estilizar nuestra aplicación de contacto sin utilizar archivos CSS.

La etiqueta {% block name-of-block %} nos permite establecer un marcador de posición que utilizarán las “plantillas hijas”. El uso de esta etiqueta hace que la herencia de plantillas sea una tarea sencilla.

Antes de adentrarnos en los formularios, necesitarás instalar el paquete Django crispy forms, que nos permite estilizarlos fácilmente:

pip install django-crispy-forms

Una vez más, crispy_forms es una aplicación de Django, y necesitamos incluirla en la lista INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # apps de terceros
    'crispy_forms',

    # apps personalizados
    'contact',
]

# Indica el framework frontend que usa django crispy forms
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Utilizamos el paquete de plantillas de Bootstrap 4, porque las clases de formulario de Bootstrap son compatibles entre las versiones 4 y 5 (en el momento de escribir esto).

Ahora, trabajemos en la plantilla 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 %}

Observa cómo extendimos la plantilla base y utilizamos el marcador de posición del bloque. Esto es lo que hace que Django Template Language sea tan eficiente, ya que nos permite ahorrar una gran cantidad de copia y pegado de HTML.

Hablando del formulario, estamos utilizando el método "post", lo que significa que nuestro ContactView procesará los datos proporcionados por el usuario y enviará el correo electrónico si el formulario es válido.

El {% csrf_token %} es obligatorio en cada formulario debido a razones de seguridad. La documentación de Django tiene una página dedicada sobre tokens CSRF y las razones para usarlos al trabajar con formularios.

Vamos a renderizar el formulario con la etiqueta crispy, razón por la cual cargamos las etiquetas crispy con {% load crispy_forms_tags %}.

Finalmente, escribamos la plantilla 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 %}

Como puedes ver, es un simple anuncio de éxito que incluye un enlace al formulario de contacto en caso de que el usuario desee enviar otro mensaje.

Vamos a ejecutar el servidor nuevamente y visitar http://localhost:8000 (asegúrate de que el .venv esté activado y que estés dentro de la carpeta raíz del proyecto):

python manage.py runserver

La imagen a continuación muestra cómo se ve el formulario de contacto final.

Y esta es una imagen del mensaje de éxito.

Y aquí hay una imagen del correo electrónico en la bandeja de entrada.

Conclusión

¡Felicidades! Has aprendido a enviar correos electrónicos con Django y a construir un formulario de contacto de Django también.

Existen muchas formas de enviar correos electrónicos con Django. En este tutorial, lo hiciste con tu dirección de correo personal, pero me gustaría que explores otras herramientas e integrarlas en tus proyectos.

En este tutorial, hemos cubierto lo siguiente:

• cómo configurar la configuración de Django para enviar correos electrónicos
• cómo usar una cuenta de correo personal para enviar correos en un proyecto pequeño
• cómo usar archivos .env para utilizar datos sensibles en un proyecto de Django
• cómo construir un formulario de contacto automatizado

Para obtener más información sobre Django, consulta “Construye una Aplicación de Compartir Fotos con Django”.

Preguntas Frecuentes sobre Cómo Enviar Correo Electrónico con Django