django-templated-email

To send emails automatically after a form submission in a Django view, use the TemplatedEmailFormViewMixin. This mixin is designed to work with views that inherit from Django's FormMixin (like CreateView or UpdateView).

By default, the email template context will include form_data if the form is valid, or form_errors if the form is invalid.

To implement the mixin, you must provide a way to identify recipients and a template name (or a method to retrieve template names).

from templated_email.generic_views import TemplatedEmailFormViewMixin
from django.views.generic import CreateView

class AuthorCreateView(TemplatedEmailFormViewMixin, CreateView):
    model = Author
    fields = ['name', 'email']
    success_url = '/create_author/'
    template_name = 'authors/create_author.html'

    # Mandatory: define who receives the email
    def templated_email_get_recipients(self, form):
        return [form.data['email']]

    # Mandatory if templated_email_template_name is not set
    # def templated_email_get_template_names(self, valid):
    #     return 'welcome'

You can enable a feature to view a rendered copy of the email in a web browser.

1. Add 'templated_email' to your INSTALLED_APPS.
2. Include the library's URLs in your project's urls.py: path('', include('templated_email.urls', namespace='templated_email')).
3. When calling send_templated_mail, set create_link=True.
4. In your template, use the email_uuid variable to generate a link to the web view.

Note: A copy of the rendered email is stored in your database. You are responsible for managing this storage growth.

# urls.py
from django.urls import path, include

urlpatterns = [
    path('', include('templated_email.urls', namespace='templated_email')),
]

# Sending the mail
send_templated_mail(
    template_name='welcome', 
    from_email='from@example.com',
    recipient_list=['to@example.com'],
    context={}, 
    create_link=True
)

# In template
{% if email_uuid %}
  <a href="http://www.yoursite.com{% url 'templated_email:show_email' uuid=email_uuid %}">
    view this e-mail on the web
  </a>
{% endif %}

To include images directly in the email body, use the InlineImage class.

1. Read the image content (from a file or a Django ImageField).
2. Create an InlineImage instance with a filename and content.
3. Pass the InlineImage object into the email context.
4. In your HTML template, use the object directly in an <img> tag.

Note: All InlineImage objects in the context will be attached to the email, even if they aren't used in the template. These images are uploaded to your media storage.

from templated_email import InlineImage

# 1. Get content
with open('pikachu.png', 'rb') as f:
    image_data = f.read()

# 2. Create InlineImage
inline_image = InlineImage(filename="pikachu.png", content=image_data)

# 3. Pass to context
send_templated_mail(
    template_name='welcome',
    from_email='from@example.com',
    recipient_list=['to@example.com'],
    context={'pikachu_image': inline_image}
)

# 4. In template HTML block:
# <img src="{{ pikachu_image }}">

Use send_templated_mail as a shortcut to render a template and send an email immediately. It is similar to Django's render_to_response but for emails.

Parameters:

• template_name: The name of the template (without extension).
• from_email: The sender's email address.
• recipient_list: A list of recipient email addresses.
• context: A dictionary of variables to pass to the template.
• cc (optional): List of CC recipients.
• bcc (optional): List of BCC recipients.
• headers (optional): Dictionary of custom email headers.
• template_prefix (optional): Directory prefix for templates (must end with /).
• template_suffix (optional): File suffix for templates.

from templated_email import send_templated_mail

send_templated_mail(
    template_name='welcome',
    from_email='from@example.com',
    recipient_list=['to@example.com'],
    context={
        'username': request.user.username,
        'full_name': request.user.get_full_name(),
        'signup_date': request.user.date_joined
    },
    # Optional:
    # cc=['cc@example.com'],
    # bcc=['bcc@example.com'],
    # headers={'My-Custom-Header': 'Custom Value'},
    # template_prefix="my_emails/",
    # template_suffix="email",
)

When using TemplatedEmailFormViewMixin, you can override several attributes and methods to control how and when emails are sent.

Attributes

• templated_email_template_name (str): The name of the template to use (e.g., 'welcome'). Mandatory if templated_email_get_template_names() is not implemented.
• templated_email_send_on_success (bool): Whether to send the email if the form is valid. Defaults to True.
• templated_email_send_on_failure (bool): Whether to send the email if the form is invalid. Defaults to False.
• templated_email_from_email (str): The sender email address. Falls back to settings.TEMPLATED_EMAIL_FROM_EMAIL or DEFAULT_FROM_EMAIL.

Methods

• templated_email_get_template_names(self, valid): Returns a string (single template) or a list (uses the first existing template in the list). Mandatory if templated_email_template_name is not set.
• templated_email_get_recipients(self, form): Mandatory. Returns the list of recipient email addresses.
• templated_email_get_context_data(**kwargs): Optional. Add extra data to the template context. Always call super().templated_email_get_context_data(**kwargs) to preserve default context.
• templated_email_get_send_email_kwargs(self, valid, form): Optional. Add or modify kwargs used by the mail sending process (e.g., adding bcc). Call super() to get defaults.
• templated_email_send_templated_mail(*args, **kwargs): Optional. Override to change how the mail is dispatched (e.g., offloading to a Celery task).