[Django]-Send_mass_emails with EmailMultiAlternatives

That is send_mass_mail() rewritten to use EmailMultiAlternatives:

from django.core.mail import get_connection, EmailMultiAlternatives

def send_mass_html_mail(datatuple, fail_silently=False, user=None, password=None, 
                        connection=None):
    """
    Given a datatuple of (subject, text_content, html_content, from_email,
    recipient_list), sends each message to each recipient list. Returns the
    number of emails sent.

    If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
    If auth_user and auth_password are set, they're used to log in.
    If auth_user is None, the EMAIL_HOST_USER setting is used.
    If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.

    """
    connection = connection or get_connection(
        username=user, password=password, fail_silently=fail_silently)
    messages = []
    for subject, text, html, from_email, recipient in datatuple:
        message = EmailMultiAlternatives(subject, text, from_email, recipient)
        message.attach_alternative(html, 'text/html')
        messages.append(message)
    return connection.send_messages(messages)

I followed a mixed approach, sending to users both plain text and html messages and personalizing messages for every user.

I started from the section Sending multiple emails od Django documentation.

from django.conf import settings
from django.contrib.auth.models import User
from django.core import mail
from django.core.mail.message import EmailMultiAlternatives
from django.template.loader import get_template
from django.template import Context

...

connection = mail.get_connection()
connection.open()
messages = list()

for u in users:
    c = Context({ 'first_name': u.first_name, 'reseller': self,})
    subject, from_email, to = 'new reseller', settings.SERVER_EMAIL, u.email
    text_content = plaintext.render(c)
    html_content = htmly.render(c)
    msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
    msg.attach_alternative(html_content, "text/html")
    messages.append(msg)

connection.send_messages(messages)
connection.close()

This is how I do the task (tested code):

from html2text import html2text

from django.utils.translation import ugettext as _
from django.core.mail import EmailMultiAlternatives, get_connection


def create_message(subject, message_plain, message_html, email_from, email_to,
                   custom_headers=None, attachments=None):
    """Build a multipart message containing a multipart alternative for text (plain, HTML) plus
    all the attached files.
    """
    if not message_plain and not message_html:
        raise ValueError(_('Either message_plain or message_html should be not None'))

    if not message_plain:
        message_plain = html2text(message_html)

    return {'subject': subject, 'body': message_plain, 'from_email': email_from, 'to': email_to,
            'attachments': attachments or (), 'headers': custom_headers or {}}


def send_mass_html_mail(datatuple):
    """send mass EmailMultiAlternatives emails
    see: http://stackoverflow.com/questions/7583801/send-mass-emails-with-emailmultialternatives
    datatuple = ((subject, msg_plain, msg_html, email_from, email_to, custom_headers, attachments),)
    """
    connection = get_connection()
    messages = []
    for subject, message_plain, message_html, email_from, email_to, custom_headers, attachments in datatuple:
        msg = EmailMultiAlternatives(
            **create_message(subject, message_plain, message_html, email_from, email_to, custom_headers, attachments))
        if message_html:
            msg.attach_alternative(message_html, 'text/html')
        messages.append(msg)

    return connection.send_messages(messages)

Here’s a succinct version:

from django.core.mail import get_connection, EmailMultiAlternatives

def send_mass_html_mail(subject, message, html_message, from_email, recipient_list):
    emails = []
    for recipient in recipient_list:
        email = EmailMultiAlternatives(subject, message, from_email, [recipient])
        email.attach_alternative(html_message, 'text/html')
        emails.append(email)
    return get_connection().send_messages(emails)

When you are sending multiple/mass/bulk emails, establishing and closing SMPT/any connection is an expensive process, you have to reuse the connection instead of creating and destroying the connection for every recipient.

You have to create a single connection and send all the emails at once.

from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from django.core import mail

def send_bulk_email(emails_list, subject, context, template, from_email):
    html_content = render_to_string(template, context)
    text_content = strip_tags(html_content)
    emails = []
    for recipient in emails_list:
        email = EmailMultiAlternatives(subject, text_content, from_email, [recipient])
        email.attach_alternative(html_content, "text/html")
        emails.append(email)
    connection = mail.get_connection()
    return connection.send_messages(emails)