Como Enviar Email com Django

Neste tutorial, vamos mostrar como enviar e-mails usando Django. Vamos cobrir como configurar as conexões SMTP do Django, como configurar uma senha de aplicativo para o seu provedor de e-mail e como enviar e-mails através do shell do Django. Também veremos como configurar um formulário de contato para o seu aplicativo Django, o que permitirá que seus clientes entrem em contato com você.

A maioria das aplicações web usa e-mail para gerenciar operações críticas, como redefinir senhas, ativação de conta, receber feedback do cliente, enviar newsletters e campanhas de marketing. A maioria dessas tarefas requer um serviço dedicado como SendGrid ou Mailgun. Mas se você não espera que seu site receba uma quantidade massiva de visitantes, você pode realmente fazer muito usando o seu provedor de e-mail pessoal.

Enviar e-mails com o seu e-mail pessoal é uma opção razoável para projetos pequenos ou de teste, então vamos adotar essa abordagem aqui para manter as coisas simples. No entanto, não é uma boa ideia usar o serviço de e-mail pessoal para seu site de produção. Você pode aprender mais sobre limitações de envio do Gmail, ou consultar as limitações do seu provedor de e-mail.

Nota: o código completo deste tutorial está disponível no GitHub.

Entendendo o SMTP

SMTP (ou o Simple Mail Transfer Protocol) é um conjunto de regras para determinar como os emails são transferidos dos remetentes para os destinatários. Os servidores SMTP utilizam este protocolo para enviar e encaminhar emails de saída. (Note que outros protocolos regulam como os emails são recebidos.)

Um servidor SMTP sempre possui um endereço único e uma porta específica para envio de mensagens, que na maioria dos casos é 587. Veremos como a porta é relevante ao enviar emails com Django.

Como utilizaremos o Gmail, o endereço com o qual trabalharemos é smtp.gmail.com, e a porta será 587.

Agora, vejamos como podemos enviar emails com Django.

Criando um Projeto Django

Todo projeto Django deve ter um ambiente virtual, pois não queremos bagunçar as dependências do projeto. Para criar um, execute o seguinte:

python -m venv .venv

Nota: se você não está familiarizado com ambientes virtuais, certifique-se de verificar nosso Guia de ambientes virtuais Python.

O comando acima cria um ambiente virtual com o nome .venv. Para ativar este ambiente virtual, você pode usar o seguinte:

source .venv/bin/activate

Como Django é um pacote de terceiros, você deve instalá-lo com pip:

pip install django

Isso instalará a versão mais recente de Django, que você pode verificar com pip freeze.

Para criar um projeto Django, você chama o utilitário de linha de comando django-admin:

django-admin startproject EmailProject

Com o comando acima, você está criando um projeto Django com o nome EmailProject, mas você pode criar o projeto com qualquer nome que desejar.

Agora, entre na pasta do projeto e inicie o servidor:

cd EmailProject
python manage.py runserver

Após iniciar o servidor Django, visite http://localhost:8000 em seu navegador. Você verá uma página gerada automaticamente com notas sobre a versão mais recente do Django.

Modificando Configurações

Você precisará modificar o arquivo de configurações antes de enviar emails, então vamos localizar esse arquivo com o comando tree:

Nota: por simplicidade, usaremos apenas comandos de sistema UNIX (macOS ou Linux).

tree

O comando tree exibe a estrutura de arquivos de um diretório. Neste caso, como não estamos fornecendo um caminho de diretório específico, obteremos algo semelhante ao seguinte se estivermos na pasta raiz do projeto:

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

1 directory, 6 files

O arquivo que constantemente modificaremos ao longo deste tutorial é o settings.py dentro da pasta EmailProject.

settings.py contém todas as configurações do projeto que você precisará e permite definir variáveis personalizadas. Como dizem as documentações do Django, “Um arquivo de configurações é apenas um módulo Python com variáveis no nível do módulo”.

Vamos analisar as configurações necessárias para enviar um email com Django. Abra o arquivo EmailProject/settings.py e cole as seguintes configurações no final do arquivo:

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

Vamos analisar o código acima analisando cada uma dessas configurações.

Backend de Email

A configuração EMAIL_BACKEND declara o backend que nosso projeto Django usará para se conectar ao servidor SMTP.

Essa variável aponta para a classe smtp.EmailBackend que recebe todos os parâmetros necessários para enviar um email. Recomendo fortemente que você dê uma olhada no construtor da classe diretamente no código-fonte do Django. Você ficará surpreso com a legibilidade desse código.

Nota: embora essa classe seja o EMAIL_BACKEND padrão, é considerado uma boa prática ser explícito nas configurações do Django.

Todas as outras configurações de email serão baseadas no construtor desta classe EmailBackend.

Host de Email

A configuração EMAIL_HOST refere-se ao domínio do servidor SMTP que você usará. Isso depende do seu provedor de email. Abaixo está uma tabela com o host do servidor SMTP correspondente a três provedores comuns:

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

Estamos deixando essa configuração em branco por enquanto, pois usaremos um arquivo .env mais tarde para evitar chaves sensíveis codificadas diretamente ou configurações específicas do site. Você nunca deve definir credenciais diretamente no código.

Vamos usar o Django Environ para resolver esse problema.

Porta de Email

A configuração EMAIL_PORT deve ser definida como 587 porque é a porta padrão para a maioria dos servidores SMTP. Isso continua verdadeiro para provedores de email pessoais.

Esta porta é usada junto com a criptografia TLS para garantir a segurança do envio de emails.

Email Use TLS

Transport Layer Security (TLS) é um protocolo de segurança usado em todo o Web para criptografar a comunicação entre aplicativos web (Django) e servidores (servidor SMTP).

Inicialmente, definimos a variável EMAIL_USE_TLS como True. Isso significa que o Django usará a Transport Layer Security para se conectar ao servidor SMTP e enviar emails. (É obrigatório para provedores de email pessoais.)

Usuário do Host de Email

A configuração EMAIL_HOST_USER é seu endereço de email pessoal. Deixe-o em branco por enquanto, pois usaremos o django-environ para configurar todas essas credenciais.

Senha do Host de Email

A configuração EMAIL_HOST_PASSWORD é a senha de aplicativo que você obterá de sua conta de email — um processo que faremos logo após esta seção.

Mesma história: deixe esta configuração em branco, pois usaremos variáveis ambientais mais tarde.

Configurar uma Senha de Aplicativo no Gmail

Para usar a configuração EMAIL_HOST_PASSWORD, você precisará ativar o acesso a aplicativos menos seguros e ter uma senha de aplicativo de seu endereço de email pessoal.

Se você não ativar o acesso a aplicativos menos seguros, provavelmente receberá um SMTPAuthenticationError, pois o Django não tem como cumprir os protocolos de segurança do Google.

Você pode optar por usar sua senha normal, mas isso seria ainda mais arriscado do que usar uma senha de aplicativo. Minha recomendação é criar uma nova conta do Gmail ou usar um endereço de email “de teste”.

Levando isso em consideração, você pode obter uma senha de aplicativo do Gmail com os passos abaixo. Observe que se você estiver usando uma conta existente e habilitou a verificação em duas etapas, pode pular os passos 2 e 3:

1. Crie ou faça login em uma conta do Gmail
2. Vá para myaccount.google.com/lesssecureapps e ative a opção de aplicativos menos seguros.
   
3. Ative a autenticação de dois fatores, pois é necessária para obter uma senha de aplicativo.
   
4. Agora que você tem a autenticação de dois fatores ativada, é hora de obter uma senha de aplicativo. Você pode fazer isso indo até a seção de segurança de sua conta do Google, rolando até a seção Entrar no Google e clicando em Senhas de aplicativo.
   

Você precisará reintroduzir sua senha (senha da conta), antes de ser redirecionado para a página de Senhas de aplicativo.

Uma vez dentro, clique em selecionar aplicativo, onde você escolherá um nome personalizado para essa senha de aplicativo — como “Enviar Email Django” — e depois clique em GERAR.

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

Se você estiver usando outros provedores de email, certifique-se de ler os seguintes guias:

• Senha de aplicativo Yahoo
• Senha de aplicativo Outlook ou Hotmail

Utilizando Django Environ para ocultar chaves sensíveis

Mesmo que você esteja apenas enviando emails no desenvolvimento, não deve escrever senhas diretamente no código fonte. Isso se torna ainda mais importante ao usar um sistema de controle de versão junto com o GitHub para hospedar seu projeto. Você não quer que as pessoas acessem seus dados.

Vejamos como podemos evitar isso usando Django-environ.

Crie um arquivo .env dentro do diretório EmailProject (onde o arquivo settings.py está localizado) com o comando abaixo:

cd EmailProject/
ls

settings.py # O arquivo de configurações deve estar aqui

touch .env

Agora, abra aquele arquivo .env e insira os seguintes pares chave-valor:

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

Analisando o conteúdo deste arquivo:

• EMAIL_HOST: o endereço do servidor SMTP do seu provedor de email. Consulte a tabela de hosts de email acima para orientação rápida. Neste caso, estou usando smtp.gmail.com, o endereço SMTP do Gmail.
• EMAIL_HOST_USER: seu endereço de email.
• EMAIL_HOST_PASSWORD: a senha de aplicativo que você acabou de gerar. Tenha em mente que não inclui nenhum espaço.
• RECIPIENT_ADDRESS: o endereço de email no qual você receberá as mensagens. Esta é uma configuração personalizada que criaremos mais tarde para enviar todos os emails para o mesmo destinatário.

Para utilizar esses variáveis de ambiente, precisaremos instalar o Django-environ:

pip install django-environ

Nota: certifique-se de que seu ambiente virtual esteja ativado.

Agora, abra o settings.py localizado na pasta EmailProject e use o código abaixo:

# EmailProject/settings.py
# Isso deve estar no início do arquivo
import environ

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

# Configurações 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')

# Configuração personalizada. Para email
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Primeiro, estamos importando o pacote environ no topo do arquivo de configurações. Lembre-se de que todas as importações devem estar no início.

Em seguida, criamos uma variável env que conterá todos os pares chave-valor disponíveis no .env.

A declaração env('KEY') significa que estamos procurando o valor dessa chave. Certifique-se de ter configurado seu arquivo .env antes de prosseguir, pois você receberá um erro ImproperlyConfigured do Django caso alguma variável de ambiente não tenha sido definida.

Note que RECIPIENT_ADDRESS é uma configuração personalizada que usaremos para enviar emails para um endereço que podemos acessar.

Não esqueça de incluir o arquivo .env em seu .gitignore caso esteja usando o Git e GitHub. Você pode fazer isso abrindo-o e adicionando a seguinte linha:

.env

1. Enviando Emails com o Shell do Django

Finalmente, chegamos à parte mais interessante do artigo! É hora de enviar seu primeiro email para o Django.

Abra um terminal, ative o ambiente virtual e execute:

python manage.py shell

Isso criará um shell com todas as configurações do Django já pré-configuradas para nós. Dentro desse novo shell, cole o seguinte 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

Também podemos fazer uma linha única sem especificar os argumentos:

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

Vamos analisar o código acima:

• Importamos a função do Django send_mail.
• Em seguida, importamos o objeto settings que contém todas as configurações globais e as configurações por site (aquelas dentro do arquivo settings.py).
• Por fim, passamos todos os argumentos necessários para a função send_mail. Essa função retorna o número de emails enviados, neste caso, 1.

Observe como estamos usando o objeto settings para obter o from_email (o email com o qual você está enviando emails) e a recipient_list (a configuração personalizada RECIPIENT_ADDRESS que definimos no arquivo .env).

Agora, se eu verificar minha caixa de entrada — como defini a variável ambiental RECIPIENT_ADDRESS como meu endereço de email — receberei a mensagem enviada pelo Django.

2. Criar um Formulário de Contato Automatizado com Django

Nesta seção, construiremos um formulário de contato automatizado com formulários Django e a função interna send_mail. Além disso, criaremos uma função personalizada, send(), dentro do formulário de contato para facilitar sua implementação nas views.

Vamos começar criando o aplicativo de contato. Entre na pasta raiz do projeto — onde manage.py está localizado — e execute:

python manage.py startapp contact

Em seguida, instale-o na variável INSTALLED_APPS dentro do arquivo EmailProject/settings.py:

# EmailProject/settings.py

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

    # Custom
    'contact',
]

Antes de avançar com o aplicativo contact, configuremos os urlpatterns dentro do arquivo EmailProject/urls.py. Para fazer isso, importe a função django.urls.include e inclua os URLs de contato no projeto em geral. Não se preocupe; configuraremos os URLs de contato mais tarde:

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # Nova importação

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

Formulário de Contato

Entre na pasta do aplicativo contact e crie um arquivo forms.py. É uma boa prática definir todos os seus formulários dentro de um arquivo forms.py, mas não é obrigatório. É por isso que o Django não inclui esse arquivo por padrão.

Você pode criar o arquivo de formulários com os seguintes comandos:

cd ../contact/
# Você estava dentro da pasta EmailProject
touch forms.py

Abra o arquivo que acabou de criar e faça as seguintes importações:

# contact/forms.py

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

O módulo form do Django fornece todas as classes e campos necessários para criar nosso formulário de contato. Mais uma vez estamos importando o objeto settings e a função send_mail para enviar os emails.

Nosso formulário de contato conterá vários campos e usará dois métodos personalizados: get_info(), que formata as informações fornecidas pelo usuário, e send(), que enviará a mensagem.

Vamos ver isso implementado em 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
        """
        
# Cleaned data

        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 é uma classe enorme, então vamos analisar o que estamos fazendo em cada parte. Primeiro, definimos quatro campos que serão necessários para enviar a mensagem:

• name e enquiry são CharFields que representam o nome e o motivo da mensagem de contato.
• email é um EmailField que representa o email da pessoa que está tentando contatar você. Tenha em mente que o email não será enviado pelo endereço de email do usuário, mas pelo endereço de email que você configurou para enviar os emails no projeto Django.
• message é outro CharField com a exceção de que estamos usando o widget Textarea. Isso significa que, ao exibir o formulário, ele renderizará uma tag <textarea> em vez de uma simples <input>.

Avançando para os métodos personalizados, estamos apenas usando o método get_info para formatar as informações fornecidas pelo usuário e retornar duas variáveis: subject, que nada mais é do que o campo inquiry, e o message, que será a mensagem real enviada por Django.

Por outro lado, o método send() apenas obtém as informações formatadas do get_info e envia a mensagem com a função send_mail.

Embora esta seção tenha sido bastante ampla, você verá como simplificamos as visualizações de contato implementando toda a lógica de envio no próprio ContactForm.

Visualizações de Contato

Abra o arquivo contact/views.py e adicione as seguintes importações:

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

Como você pode ver, vamos usar visualizações genéricas do Django, o que nos economiza muito tempo ao realizar tarefas simples — por exemplo, ao configurar um formulário com FormView ou criar uma visualização que renderiza apenas um modelo com TemplateView.

Além disso, estamos importando o ContactForm que construímos na seção anterior e a função reverse_lazy usada ao trabalhar com views baseadas em classes.

Continuando com as views, vamos escrever o 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):
        # Chama o método personalizado send
        form.send()
        return super().form_valid(form)

Como você pode ver, estamos construindo uma simples FormView usando o ContactForm que criamos. Também estamos configurando o template_name e o success_url. Vamos escrever o template HTML e configurar as URLs mais tarde.

O método form valid nos permite enviar o email usando o método ContactForm.send() apenas se todos os campos do formulário forem válidos. Isso implica que, se o usuário inserir uma entrada inválida — como um endereço de email não formatado — a mensagem não será enviada.

A implementação acima do método form_valid seria equivalente ao seguinte em uma view baseada em função:

# Visualização de contato baseada em função anterior ...

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

Encerrando esta seção, vamos escrever um ContactSucessView, que exibirá uma mensagem de sucesso ao usuário. Como já importamos a classe TemplateView, precisamos apenas herdar dela e definir o atributo template_name:

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

Você pode verificar o arquivo views.py no repositório do GitHub caso tenha alguma dúvida.

URLs de Contato

É hora de criar os padrões de URL do aplicativo contact. Como o Django não fornece o arquivo urls.py por padrão, precisaremos criá-lo com o seguinte comando (certifique-se de estar dentro da pasta do aplicativo contact):

pwd
# /caminho/para/projeto/EmailProject/contact
touch urls.py

Abra esse arquivo e configure as variáveis 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"),
]

Usamos path para incluir a rota e sua respectiva visualização na configuração de URL do aplicativo. Quando definimos a variável app_name como 'contact', isso significa que o namespacing de URL do aplicativo será assim:

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

Nota: um namespace é o que chamamos dinamicamente de URLs em templates e Views do Django.

Você pode aprender mais sobre o despachante de URLs do Django na documentação oficial.

Escrevendo templates

Os templates do Django são a maneira preferida de exibir dados dinamicamente, usando HTML e tags especiais que a Linguagem de Templates do Django nos fornece.

Para este aplicativo específico, usaremos três templates:

• base.html: todos os outros templates herdarão dele. Conterá todo o esqueleto HTML que todos os templates devem ter, bem como links para o Bootstrap.
• contact.html: exibe o formulário de contato.
• success.html: exibe uma mensagem de sucesso.

Vamos começar criando a estrutura de templates do aplicativo de contato (certifique-se de que você está dentro da pasta do aplicativo de contato):

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

Os comandos acima criam a estrutura de templates típica de um aplicativo Django reutilizável — appname/templates/appname — e os arquivos de template de árvore que mencionei anteriormente.

Aqui está como a estrutura de arquivos do aplicativo deve agora parecer:

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

Vamos mergulhar no conteúdo do template 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 pode ver, é o esqueleto simples de um arquivo HTML que inclui links para Bootstrap 5. Isso nos permite estilizar nosso aplicativo de contato sem usar arquivos CSS.

O tag {% block name-of-block %} permite configurar um espaço reservado que as “templates filhas” utilizarão. O uso deste tag torna a herança de templates uma tarefa fácil.

Antes de entrar nas formas, você precisará instalar o pacote Django crispy forms, que nos permite estilizá-las facilmente:

pip install django-crispy-forms

Mais uma vez, crispy_forms é um aplicativo Django, e precisamos incluí-lo na lista INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # apps de 3ª parte
    'crispy_forms',

    # apps personalizados
    'contact',
]

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

Utilizamos o pacote de templates do Bootstrap 4, porque as classes de formulário do Bootstrap são compatíveis entre as versões 4 e 5 (na época da escrita).

Agora, vamos trabalhar no 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 %}

Observe como estendemos o template base e fizemos uso do espaço reservado de bloco. Isso é o que torna a Linguagem de Template Django tão eficiente, pois nos permite evitar muita cópia e colagem de HTML.

Ao falar sobre o formulário, estamos usando o método "post", o que significa que nosso ContactView processará os dados fornecidos pelo usuário e enviará o email se o formulário for válido.

O {% csrf_token %} é obrigatório em todos os formulários por motivos de segurança. A documentação do Django tem uma página dedicada sobre tokens CSRF e as razões para usá-los ao trabalhar com formulários.

Vamos renderizar o formulário com a tag crispy, razão pela qual carregamos as tags crispy com {% load crispy_forms_tags %}.

Finalmente, vamos escrever o 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 %}

Como você pode ver, é um simples anúncio de sucesso que inclui um link para o formulário de contato caso o usuário queira enviar outra mensagem.

Vamos reiniciar o servidor e visitar http://localhost:8000 (certifique-se de que o .venv está ativado e você está dentro da pasta raiz do projeto):

python manage.py runserver

A imagem abaixo mostra como fica o formulário de contato final.

E esta é uma imagem da mensagem de sucesso.

E aqui está uma imagem do email na caixa de entrada.

Concluindo

Parabéns! Você aprendeu a enviar emails com o Django e também a construir um formulário de contato Django.

Há muitas maneiras de enviar emails com o Django. Neste tutorial, você fez isso com seu endereço de email pessoal, mas gostaria que explorasse outras ferramentas e as integrou em seus projetos.

Neste tutorial, abordamos o seguinte:

• como configurar as configurações do Django para servir emails
• como usar uma conta de email pessoal para enviar emails em um pequeno projeto
• como usar arquivos .env para usar dados sensíveis em um projeto Django
• como construir um formulário de contato automatizado

Para mais informações sobre o Django, confira “Construa um App de Compartilhamento de Fotos com Django”.

Perguntas Frequentes sobre Como Enviar Email com Django