Как отправлять письма с помощью Django

В этом уроке мы рассмотрим, как отправлять письма с использованием Django. Мы расскажем о настройке соединений SMTP в Django, о том, как настроить пароль приложения для вашего провайдера электронной почты, и о том, как отправлять письма через оболочку Django. Также мы рассмотрим, как настроить контактную форму для вашего приложения Django, что позволит вашим клиентам связаться с вами.

Большинство веб-приложений используют электронную почту для управления важными операциями, такими как сброс паролей, активация учетной записи, получение отзывов клиентов, отправка рассылок и маркетинговых кампаний. Большинство из этих задач требует специализированного сервиса, такого как SendGrid или Mailgun. Но если вы не ожидаете, что ваш сайт привлечет огромное количество посетителей, вы можете действительно многое сделать через ваш личный провайдер электронной почты.

Отправка писем с использованием вашей личной электронной почты является разумным вариантом для небольших или тестовых проектов, поэтому мы будем использовать этот подход здесь, чтобы упростить задачу. Однако использовать личную почту для рабочего сайта не рекомендуется. Вы можете узнать больше о ограничениях отправки Gmail или ознакомиться с ограничениями вашего провайдера электронной почты.

Примечание: полная версия кода для этого урока доступна на GitHub.

Понимание SMTP

SMTP (или Простой протокол пересылки почты) представляет собой набор правил, определяющих, как электронные письма передаются от отправителей к получателям. Серверы SMTP используют этот протокол для отправки и ретрансляции исходящих сообщений. (Обратите внимание, что другие протоколы регулируют, как электронные письма получаются.)

SMTP-сервер всегда имеет уникальный адрес и конкретный порт для отправки сообщений, который в большинстве случаев равен 587. Мы увидим, как порт имеет значение при отправке писем с помощью Django.

Так как мы будем использовать Gmail, адрес, с которым мы будем работать, это smtp.gmail.com, а порт будет 587.

Теперь давайте посмотрим, как можно отправлять письма с помощью Django.

Создание проекта Django

Каждый проект Django должен иметь виртуальное окружение, так как мы не хотим загромождать зависимости проекта. Чтобы создать одно, выполните следующее:

python -m venv .venv

Примечание: если вы не знакомы с виртуальными окружениями, обязательно ознакомьтесь с нашей руководством по виртуальным окружениям Python.

Команда выше создает виртуальное окружение с именем .venv. Чтобы активировать это виртуальное окружение, вы можете использовать следующее:

source .venv/bin/activate

Так как Django является сторонней библиотекой, его нужно установить с помощью pip:

pip install django

Это установит последнюю версию Django, которую вы можете проверить с помощью pip freeze.

Для создания проекта Django вызываете утилиту командной строки django-admin:

django-admin startproject EmailProject

С помощью приведенной выше команды вы создаете проект Django с именем EmailProject, но вы можете создать проект с любым желаемым именем.

Теперь перейдите в каталог проекта и запустите сервер:

cd EmailProject
python manage.py runserver

После запуска сервера Django посетите http://localhost:8000 в своем браузере. Вы увидите автоматически сгенерированную страницу с последними заметками о выпуске Django.

Изменение Настроек

Перед отправкой электронных писем вам нужно будет изменить файл настроек, поэтому давайте найдем этот файл с помощью команды tree:

Примечание: ради простоты мы будем использовать только команды UNIX (macOS или Linux) системы.

tree

Команда tree выводит структуру файлов каталога. В данном случае, поскольку мы не указываем конкретный путь к каталогу, мы получим что-то подобное следующему, если находимся в корневом каталоге проекта:

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

1 directory, 6 files

Файл, который мы будем постоянно изменять в этом учебнике, — это settings.py внутри папки EmailProject.

settings.py содержит все конфигурации проекта, которые вам понадобятся, и позволяет устанавливать пользовательские переменные. Как говорят документации Django, “Файл настроек — это просто модуль Python с переменными на уровне модуля”.

Давайте рассмотрим настройки, необходимые для отправки электронной почты с помощью Django. Откройте файл EmailProject/settings.py и вставьте следующие настройки внизу файла:

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

Давайте разберем код выше, анализируя каждую из этих настроек.

Backend электронной почты

Настройка EMAIL_BACKEND объявляет backend, который наш проект Django будет использовать для подключения к SMTP-серверу.

Эта переменная указывает на класс smtp.EmailBackend, который получает все необходимые параметры для отправки электронной почты. Я настоятельно рекомендую взглянуть на конструктор класса непосредственно в исходном коде Django. Вы будете удивлены, насколько этот код читабелен.

Примечание: хотя этот класс является дефолтным EMAIL_BACKEND, считается хорошим тоном быть явным в настройках Django.

Все остальные настройки электронной почты будут основаны на конструкторе этого класса EmailBackend.

Хост электронной почты

Настройки EMAIL_HOST относятся к домену SMTP-сервера, который вы будете использовать. Это зависит от вашего провайдера электронной почты. Ниже приведена таблица с SMTP-сервером, соответствующим трем распространенным провайдерам:

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

Мы оставляем эту настройку пустой на данный момент, так как будем использовать файл .env позже, чтобы избежать жесткого кодирования чувствительных ключей или конфигураций для каждого сайта. Вы никогда не должны устанавливать учетные данные непосредственно в код.

Мы будем использовать Django Environ для решения этой проблемы.

Порт электронной почты

Настройка EMAIL_PORT должна быть установлена на 587, так как это стандартный порт для большинства SMTP-серверов. Это остается верным для личных провайдеров электронной почты.

Этот порт используется вместе с шифрованием TLS для обеспечения безопасности отправки электронной почты.

Использование TLS для электронной почты

Протокол транспортного уровня безопасности (TLS) – это протокол безопасности, используемый в Интернете для шифрования коммуникации между веб-приложениями (Django) и серверами (SMTP-сервером).

Первоначально мы устанавливаем переменную EMAIL_USE_TLS в True. Это означает, что Django будет использовать транспортный уровень безопасности для подключения к SMTP-серверу и отправки писем. (Это обязательно для личных провайдеров электронной почты.)

Пользователь хоста электронной почты

Настройка EMAIL_HOST_USER – это ваш личный адрес электронной почты. Оставьте его пустым на данный момент, так как мы будем использовать django-environ для настройки всех этих учетных данных.

Пароль хоста электронной почты

Настройка пароля хоста электронной почты

Настройка EMAIL_HOST_PASSWORD — это пароль приложения, который вы получите от своего аккаунта электронной почты — процесс, который мы будем выполнять сразу после этого раздела.

То же самое: оставьте эту настройку пустой, так как мы будем использовать переменные окружения позже.

Настройка пароля приложения в Gmail

Чтобы использовать настройку EMAIL_HOST_PASSWORD, вам нужно активировать доступ для менее безопасных приложений и иметь пароль приложения от вашего личного адреса электронной почты.

Если вы не активируете доступ для менее безопасных приложений, вы, вероятно, столкнетесь с SMTPAuthenticationError, потому что Django не имеет возможности соответствовать протоколам безопасности Google.

Вы можете выбрать использование обычного пароля, но это было бы даже более рискованно, чем использование пароля приложения. Мой совет — создать новый аккаунт Gmail или использовать адрес электронной почты для “тестирования”.

Учитывая это, вы можете получить пароль приложения Gmail по следующим шагам. Обратите внимание, что если вы используете существующий аккаунт и включили двухэтапную проверку, вы можете пропустить шаги 2 и 3:

1. Создайте или войдите в аккаунт Gmail
2. Перейдите по ссылке myaccount.google.com/lesssecureapps и включите опцию для менее безопасных приложений.
   
3. Включите двухфакторную аутентификацию, так как её требуют для получения пароля приложения.
   
4. Теперь, когда у вас включена двухфакторная аутентификация, пришло время получить пароль приложения. Вы можете сделать это, перейдя в раздел безопасности вашей учетной записи Google, прокрутив страницу до раздела Вход в Google и нажав на Пароли приложений.
   

Вам потребуется повторно ввести свой пароль (пароль учетной записи), прежде чем вы будете перенаправлены на страницу паролей приложений.

После этого нажмите на выбрать приложение, где вы выберете произвольное название для этого пароля приложения — например, “Django Send Email” — затем нажмите на СОЗДАТЬ.

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

Если вы используете другие провайдеры электронной почты, убедитесь, что ознакомились с следующими руководствами:

• Пароль приложения Yahoo
• Пароль приложения Outlook или Hotmail

Использование Django Environ для скрытия чувствительных ключей

Даже если вы просто отправляете электронные письма в процессе разработки, не стоит прямо вписывать пароли в исходный код. Это становится еще более важным при использовании системы контроля версий вместе с GitHub для размещения вашего проекта. Вы не хотите, чтобы люди имели доступ к вашим данным.

Давайте посмотрим, как мы можем предотвратить это, используя Django-environ.

Создайте файл .env внутри директории EmailProject (где находится файл settings.py) с помощью следующей команды:

cd EmailProject/
ls

settings.py # Файл настроек должен быть здесь

touch .env

Теперь откройте этот файл .env и введите следующие пары ключ-значение:

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

Разберем содержимое этого файла:

• EMAIL_HOST: адрес SMTP сервера вашего провайдера электронной почты. Обратитесь к таблице провайдеров выше для быстрого руководства. В данном случае я использую smtp.gmail.com, адрес SMTP Gmail.
• EMAIL_HOST_USER: ваш адрес электронной почты.
• EMAIL_HOST_PASSWORD: пароль приложения, который вы только что создали. Имейте в виду, что он не содержит пробелов.
• RECIPIENT_ADDRESS: адрес электронной почты, на который будут приходить сообщения. Это настраиваемое значение, которое мы создадим позже для отправки всех писем одному получателю.

Чтобы использовать эти переменные окружения, нам нужно установить Django-environ:

pip install django-environ

Примечание: убедитесь, что активировано виртуальное окружение.

Теперь откройте settings.py, расположенный в директории EmailProject, и используйте следующий код:

# EmailProject/settings.py
# Это должно быть в начале файла
import environ

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

# Предыдущие настройки ...
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')

# Пользовательская настройка. Для email
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

Сначала импортируем пакет environ в начале файла настроек. Помните, что все импорты должны быть в начале.

Затем создаем переменную env, которая будет содержать все пары ключ-значение, доступные в .env.

Оператор env('KEY') означает, что мы ищем значение этого ключа. Убедитесь, что вы настроили файл .env перед продолжением, потому что в случае, если какая-то переменная окружения не была установлена, вы получите ошибку Django ImproperlyConfigured.

Обратите внимание, что RECIPIENT_ADDRESS — это пользовательская настройка, которую мы будем использовать для отправки писем по адресу, который мы можем получить.

Не забудьте включить файл .env в ваш .gitignore, если вы используете Git и GitHub. Вы можете сделать это, просто открыв его и добавив следующую строку:

.env

1. Отправка Email через Django Shell

Наконец, мы добрались до сочной части статьи! Пришло время отправить свой первый email в Django.

Откройте терминал, активируйте виртуальное окружение и запустите:

python manage.py shell

Это создаст оболочку с уже настроенными для нас Django настройками. Внутри этой свежей оболочки вставьте следующий код:

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

Мы также можем сделать однострочник, не указывая аргументы:

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

Давайте разберем код выше:

• Мы импортируем функцию Django send_mail.
• Затем мы импортируем объект settings, который содержит все глобальные настройки и настройки для сайта (те, что внутри файла settings.py).
• Наконец, мы передаем все необходимые аргументы функции send_mail. Эта функция возвращает количество отправленных писем, в данном случае, 1.

Обратите внимание, как мы используем объект settings для получения from_email (email, с которого отправляются письма) и recipient_list (настраиваемая настройка RECIPIENT_ADDRESS, которую мы определили в .env).

Теперь, если я проверю свою почту — так как я установил переменную окружения RECIPIENT_ADDRESS на мой email — я получу сообщение, отправленное Django.

2. Создание автоматической контактной формы с Django

В этом разделе мы создадим автоматизированную контактную форму с использованием Django форм и встроенной функции send_mail. Также мы создадим пользовательскую функцию send() внутри контактной формы, чтобы ее было легче реализовать в представлениях.

Начнем с создания приложения контактов. Введите корневую директорию проекта — где находится manage.py — и запустите:

python manage.py startapp contact

Затем установите его в свою переменную INSTALLED_APPS внутри файла EmailProject/settings.py:

# EmailProject/settings.py

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

    # Custom
    'contact',
]

Перед тем как продолжить с приложением contact, давайте настроим urlpatterns внутри файла EmailProject/urls.py. Для этого импортируйте функцию django.urls.include и включите URL-адреса контактов в общий проект. Не волнуйтесь, мы настроим URL-адреса контактов позже:

# EmailProject/urls.py

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Include Contact URLs
]

Контактная форма

Перейдите в папку приложения contact и создайте файл forms.py. Хорошей практикой является определение всех своих форм внутри файла forms.py, но это не обязательно. Вот почему Django не включает этот файл по умолчанию.

Вы можете создать файл форм с помощью следующих команд:

cd ../contact/
# Вы находились в папке EmailProject
touch forms.py

Откройте созданный файл и выполните следующие импорты:

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

Модуль Django form предоставляет все необходимые классы и поля для создания формы контактов. Опять же мы импортируем объект settings и функцию send_mail для отправки электронных писем.

Наша форма контактов будет содержать несколько полей и использовать две пользовательские функции: get_info(), которая форматирует предоставленную пользователем информацию, и send(), которая отправит сообщение.

Давайте рассмотрим это в коде:

# 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
        """
        # Очищенные данные
        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]
        )

Это огромный класс, поэтому давайте разберем, что мы делаем в каждой части. Во-первых, мы определяем четыре поля, которые будут необходимы для отправки сообщения:

• name и enquiry являются CharFields, представляющими имя и причину контактной записи.
• email — это EmailField, представляющий адрес электронной почты человека, пытающегося связаться с вами. Следует учитывать, что сообщение не будет отправлено с адреса электронной почты пользователя, а будет отправлено с адреса электронной почты, который вы установили для отправки сообщений в проекте Django.
• message — это еще один CharField, но с отличием: используется виджет Textarea, что означает, что при отображении формы будет рендериться тег <textarea> вместо простого <input>.

Переходя к пользовательским методам, мы используем только метод get_info, который форматирует информацию, предоставленную пользователем, и возвращает две переменные: subject, которая является просто полем inquiry, и message, которая будет фактическим сообщением, отправленным через Django.

С другой стороны, метод send() просто получает отформатированную информацию из get_info и отправляет сообщение с помощью функции send_mail.

Хотя эта секция была довольно обширной, вы увидите, как мы упростили представления контактов, внедрив всю логику отправки в сам ContactForm.

Представления Контактов

Откройте файл contact/views.py и добавьте следующие импорты:

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

Как видите, мы будем использовать общие представления Django, что значительно экономит время при выполнении простых задач — например, при настройке формы с помощью FormView или создании представления, которое просто рендерит шаблон с помощью TemplateView.

Также мы импортируем ContactForm, который создали в предыдущем разделе, и функцию reverse_lazy, используемую при работе с классовыми представлениями.

Продолжая с представлениями, давайте напишем 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):
        # Вызывает пользовательский метод send
        form.send()
        return super().form_valid(form)

Как видите, мы строим простое FormView с использованием ContactForm, который создали. Также настраиваем template_name и success_url. HTML-шаблон и настройку URL будем делать позже.

Метод form_valid позволяет отправлять email с помощью метода ContactForm.send() только если все поля формы валидны. Это означает, что если пользователь вводит невалидные данные — например, неформатированный адрес электронной почты — сообщение не будет отправлено.

Вышеупомянутая реализация метода form_valid эквивалентна следующему в представлении на основе функции:

# Предыдущее представление на основе функции contact_view ...

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

Заканчивая эту секцию, мы собираемся написать ContactSucessView, который покажет сообщение об успешном контакте пользователю. Так как мы уже импортировали класс TemplateView, нам нужно только наследоваться от него и определить атрибут template_name:

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

Вы можете ознакомиться с файлом views.py в репозитории на GitHub, если у вас возникнут какие-либо вопросы.

URL-схемы контактов

Пришло время создать URL-схемы приложения contact. Так как Django не предоставляет файл urls.py по умолчанию, нам нужно будет создать его с помощью следующей команды (убедитесь, что вы находитесь внутри папки приложения contact):

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

Откройте этот файл и настройте переменные app_name и 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"),
]

Мы используем path для включения маршрута и соответствующего представления в конфигурацию URL приложения. Когда мы устанавливаем переменную app_name в 'contact', это означает, что пространство имен URL приложения будет выглядеть следующим образом:

contact:name_of_path
# Для ContactView
contact:contact
# Для ContactSuccessView
contact:success

Примечание: пространство имен — это то, как мы динамически называем URL-адреса в шаблонах Django и представлениях.

Вы можете узнать больше о диспетчере URL Django в официальной документации.

Написание шаблонов

Шаблоны Django являются предпочтительным способом отображения данных динамически, используя HTML и специальные теги, которые предоставляет нам язык шаблонов Django.

Для этого конкретного приложения мы будем использовать три шаблона:

• base.html: все другие шаблоны будут наследовать от него. Он будет содержать все HTML-скелет, который должны иметь все шаблоны, а также ссылки на Bootstrap.
• contact.html: отображает форму контакта.
• success.html: отображает сообщение об успешном выполнении.

Давайте начнем с создания структуры шаблонов приложения контактов (убедитесь, что вы находитесь внутри папки приложения контактов):

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

Команды выше создают типичную структуру шаблонов для повторно используемого приложения Django — appname/templates/appname — и три упомянутых выше файла шаблонов.

Вот как теперь должна выглядеть структура файлов приложения:

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

Давайте перейдем к содержимому шаблона 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>

Как видите, это простой скелет HTML-файла, который включает ссылки на Bootstrap 5. Это позволяет нам стилизовать наше приложение контактов, не используя файлы CSS.

Тег {% block name-of-block %} позволяет нам создать заполнитель, который будут использовать “дочерние шаблоны”. Использование этого тега делает наследование шаблонов легкой задачей.

Перед тем, как приступить к формам, вам нужно установить пакет Django crispy forms, который позволяет легко их стилизовать:

pip install django-crispy-forms

Опять же, crispy_forms – это приложение Django, и его нужно включить в список INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # сторонние приложения
    'crispy_forms',

    # пользовательские приложения
    'contact',
]

# Указывает используемую фронтенд-платформу django crispy forms
CRISPY_TEMPLATE_PACK = 'bootstrap4'

Мы используем шаблонный пакет Bootstrap 4, потому что классы форм Bootstrap совместимы между 4-й и 5-й версиями (на момент написания).

Теперь давайте поработаем над шаблоном 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 %}

Обратите внимание, как мы расширили базовый шаблон и использовали заполнитель блока. Это то, что делает язык шаблонов Django настолько эффективным, поскольку он позволяет избежать многократного копирования и вставки HTML.

Говоря о форме, мы используем метод "post", что означает, что наш ContactView будет обрабатывать данные, предоставленные пользователем, и отправлять письмо, если форма действительна.

Тег {% csrf_token %} обязателен во всех формах по соображениям безопасности. Документация Django содержит специальную страницу о CSRF токенах и причинах их использования при работе с формами.

Мы будем отображать форму с помощью тега crispy, поэтому мы загрузили теги crispy с помощью {% load crispy_forms_tags %}.

Наконец, давайте напишем шаблон 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 %}

Как видите, это простая анонс успеха, которая включает ссылку на контактную форму в случае, если пользователю захочется отправить еще одно сообщение.

Давайте запустим сервер снова и посетим http://localhost:8000 (убедитесь, что активирован .venv и вы находитесь в корневом каталоге проекта):

python manage.py runserver

Ниже представлено изображение окончательной контактной формы.

А вот изображение сообщения об успехе.

И вот изображение письма в почтовом ящике.

Подводя итоги

Поздравляю! Вы узнали, как отправлять электронные письма с помощью Django и как создавать форму для связи в Django.

Существует множество способов отправлять письма с помощью Django. В этом уроке вы сделали это с использованием личного адреса электронной почты, но я предлагаю вам изучить другие инструменты и интегрировать их в свои проекты.

В этом уроке мы рассмотрели следующее:

• как настроить настройки Django для обслуживания писем
• как использовать личный аккаунт электронной почты для отправки писем в небольшом проекте
• как использовать файлы .env для использования конфиденциальных данных в проекте Django
• как создать автоматическую форму для связи

Для получения дополнительной информации о Django, ознакомьтесь с “Сборка приложения для обмена фотографиями с использованием Django“.

Часто задаваемые вопросы о том, как отправлять письма с помощью Django