Tworzenie szablonów wiadomości e-mail za pomocą Django

206

Chcę wysyłać wiadomości e-mail w formacie HTML przy użyciu takich szablonów Django:

<html>
<body>
hello <strong>{{username}}</strong>
your account activated.
<img src="mysite.com/logo.gif" />
</body>

Nic nie mogę znaleźć send_mail, a django-mailer wysyła tylko szablony HTML, bez dynamicznych danych.

Jak korzystać z silnika szablonów Django do generowania wiadomości e-mail?

— Anakin
źródło

3

Uwaga 1.7oferty Django html_messagena send_email stackoverflow.com/a/28476681/953553

— andilabs

Cześć @anakin, od dawna borykam się z tym problemem i postanowiłem stworzyć dla niego pakiet. Byłbym bardzo szczęśliwy, jeśli otrzymam Twoją opinię: github.com/charlesthk/django-simple-mail

— Charlesthk

385

Z dokumentów , aby wysłać wiadomość e-mail w formacie HTML, należy użyć alternatywnych typów treści, takich jak:

from django.core.mail import EmailMultiAlternatives

subject, from_email, to = 'hello', 'from@example.com', 'to@example.com'
text_content = 'This is an important message.'
html_content = '<p>This is an <strong>important</strong> message.</p>'
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()

Prawdopodobnie będziesz potrzebować dwóch szablonów wiadomości e-mail - tekstowego, który wygląda mniej więcej tak, przechowywanego w katalogu szablonów pod email.txt:

Hello {{ username }} - your account is activated.

i HTMLy, przechowywany pod email.html:

Hello <strong>{{ username }}</strong> - your account is activated.

Następnie możesz wysłać wiadomość e-mail przy użyciu obu tych szablonów, korzystając z get_template:

from django.core.mail import EmailMultiAlternatives
from django.template.loader import get_template
from django.template import Context

plaintext = get_template('email.txt')
htmly     = get_template('email.html')

d = Context({ 'username': username })

subject, from_email, to = 'hello', 'from@example.com', 'to@example.com'
text_content = plaintext.render(d)
html_content = htmly.render(d)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()

— Dominic Rodger
źródło

40

Myślę, że możesz to uprościć za pomocą render_to_string , co pozwoliłoby ci stracić osobne linie przypisujące szablony do plaintexti htmly, i po prostu ustawić szablony i konteksty podczas definiowania text_contenti html_content.

— cms_mgr

@cms_mgr Czy możesz opracować to, co chcesz powiedzieć i jak możemy tego używać

— akki

3

@akki patrz odpowiedź andi poniżej, co również upraszcza alternatywną część dzięki dodaniu parametru html_message do send_email () w Django 1.7

— Mike S

Przepraszam, ale dlaczego jednocześnie używamy txt i htmly do wysyłania wiadomości. Nie zrozumiałem tej logiki

— Shashank Vivek

są tylko przykładami pokazującymi różne metody, możesz użyć dowolnej z nich @ShashankVivek

— erdemlal 21.04.17

242

Chłopców i dziewcząt!

Od wersji 1.7 Django w metodzie send_emailhtml_message parametr został dodany.

html_message: Jeśli podasz html_message, wynikowy e-mail będzie wieloczęściowym / alternatywnym e-mailem z wiadomością jako typem tekstu / zwykłej treści i html_message jako typem treści tekstowej / html.

Możesz więc po prostu:

from django.core.mail import send_mail
from django.template.loader import render_to_string


msg_plain = render_to_string('templates/email.txt', {'some_params': some_params})
msg_html = render_to_string('templates/email.html', {'some_params': some_params})

send_mail(
    'email title',
    msg_plain,
    'some@sender.com',
    ['some@receiver.com'],
    html_message=msg_html,
)

— andilabs
źródło

1

Zauważ, że „email.txt” i „email.html” znajdują się w szablonach katalogów zdefiniowanych w ustawieniach, niż tylko render_to_string („email.txt”, {'some_params': some_params} _

— Bruno Vermeulen

Dzięki za render_to_stringpodpowiedź, bardzo przydatna.

— hoefling

1

Dobre rozwiązanie! Nie send_mailmożna jednak ustawić niestandardowego nagłówka, np. Return-PathKtóry można ustawić za pomocą opcjiEmailMultiAlternatives's constructor header parameter

— Qlimax

26

Zrobiłem django-szablonowy e-mail , starając się rozwiązać ten problem, zainspirowany tym rozwiązaniem (i potrzebą, w pewnym momencie, przejścia z używania szablonów django na używanie mailchimp itp. Zestawu szablonów do e-maili transakcyjnych, szablonowych dla mój własny projekt). Nadal jest to jednak praca w toku, ale w powyższym przykładzie zrobiłbyś:

from templated_email import send_templated_mail
send_templated_mail(
        'email',
        'from@example.com',
        ['to@example.com'],
        { 'username':username }
    )

Po dodaniu następującego pliku do settings.py (aby uzupełnić przykład):

TEMPLATED_EMAIL_DJANGO_SUBJECTS = {'email':'hello',}

Spowoduje to automatyczne wyszukanie szablonów o nazwach „templated_email / email.txt” i „templated_email / email.html” odpowiednio dla części zwykłej i HTML w normalnych katalogach / modułach ładujących django (narzekając, jeśli nie może znaleźć co najmniej jednego z nich) .

— Darb
źródło

1

Dla mnie wygląda dobrze. Skróciłem to i wrzuciłem do biletu, aby dodać django.shortcuts.send_templated_mail: code.djangoproject.com/ticket/17193

— Tom Christie

Fajnie, cieszę się, że został zaproponowany jako narzędzie dla rdzenia django. Mój przypadek użycia / fokus dla biblioteki lib jest nieco większy niż tylko skrót (łatwe przełączanie między dostawcami poczty, którzy mają klucz / wartość interfejsu API do wysyłania poczty), ale wydaje się, że brakuje w rdzeniu funkcji

— Darb

15

Użyj EmailMultiAlternatives i render_to_string, aby skorzystać z dwóch alternatywnych szablonów (jeden w postaci zwykłego tekstu i jeden w html):

from django.core.mail import EmailMultiAlternatives
from django.template import Context
from django.template.loader import render_to_string

c = Context({'username': username})    
text_content = render_to_string('mail/email.txt', c)
html_content = render_to_string('mail/email.html', c)

email = EmailMultiAlternatives('Subject', text_content)
email.attach_alternative(html_content, "text/html")
email.to = ['to@example.com']
email.send()

— Rick Westera
źródło

5

Stworzyłem Django Simple Mail, aby mieć prosty, konfigurowalny i wielokrotnego użytku szablon dla każdej transakcyjnej wiadomości e-mail, którą chcesz wysłać.

Treść i szablony wiadomości e-mail można edytować bezpośrednio od administratora django.

Na przykład zarejestrowałbyś swój adres e-mail:

from simple_mail.mailer import BaseSimpleMail, simple_mailer


class WelcomeMail(BaseSimpleMail):
    email_key = 'welcome'

    def set_context(self, user_id, welcome_link):
        user = User.objects.get(id=user_id)
        return {
            'user': user,
            'welcome_link': welcome_link
        }


simple_mailer.register(WelcomeMail)

I wyślij to w ten sposób:

welcome_mail = WelcomeMail()
welcome_mail.set_context(user_id, welcome_link)
welcome_mail.send(to, from_email=None, bcc=[], connection=None, attachments=[],
                   headers={}, cc=[], reply_to=[], fail_silently=False)

Chciałbym uzyskać wszelkie informacje zwrotne.

— Charlesthk
źródło

Bardzo by to pomogło, jeśli prześlesz aplikację demo swojego pakietu na repozytorium.

— ans2human

Cześć @ ans2human, dziękuję za tę sugestię, dodaję ją do listy ulepszeń!

— Charlesthk

3

W przykładzie występuje błąd .... jeśli użyjesz go tak, jak napisano, wystąpi następujący błąd:

<type 'wyjątki.Exception'>: obiekt „dict” nie ma atrybutu „render_context”

Musisz dodać następujący import:

from django.template import Context

i zmień słownik na:

d = Context({ 'username': username })

Zobacz http://docs.djangoproject.com/en/1.2/ref/templates/api/#rendering-a-context

— idbill
źródło

Dzięki - teraz jest to naprawione.

— Dominic Rodger

3

Django Mail Templated to bogata w funkcje aplikacja Django do wysyłania wiadomości e-mail za pomocą systemu szablonów Django.

Instalacja:

pip install django-mail-templated

Konfiguracja:

INSTALLED_APPS = (
    ...
    'mail_templated'
)

Szablon:

{% block subject %}
Hello {{ user.name }}
{% endblock %}

{% block body %}
{{ user.name }}, this is the plain text part.
{% endblock %}

Pyton:

from mail_templated import send_mail
send_mail('email/hello.tpl', {'user': user}, from_email, [user.email])

Więcej informacji: https://github.com/artemrizhov/django-mail-templated

— raacer
źródło

To było naprawdę łatwe w użyciu. Dzięki.

— cheenbabes,

Cześć, jak mogę ustawić wszystkich moich odbiorców na BCC?

— aldesabido,

@aldesabido To tylko opakowanie wokół standardowej klasy Django EmailMessage. Więc należy czytać z oficjalnej dokumentacji przy poszukiwaniu takich cech: docs.djangoproject.com/en/1.10/topics/email wziąć również spojrzeć na podobne pytanie: stackoverflow.com/questions/3470172/...

— raacer

Mówiąc ściślej, standardowy EmailMessage nie jest zawijany, ale dziedziczony. To jest rozszerzenie dla klasy standardowej :)

— raacer,

Czy można uwzględnić JS / CSS w szablonie?

— Daniel Shatz,

3

Wiem, że to stare pytanie, ale wiem też, że niektórzy ludzie są tacy jak ja i zawsze szukają aktualnych odpowiedzi , ponieważ stare odpowiedzi mogą czasami zawierać nieaktualne informacje, jeśli nie zostaną zaktualizowane.

Jest teraz styczeń 2020 i używam Django 2.2.6 i Python 3.7

Uwaga: Korzystam z DJANGO REST FRAMEWORK , poniższy kod do wysyłania e-maili był w moim widoku modeluviews.py

Po przeczytaniu wielu fajnych odpowiedzi właśnie to zrobiłem.

from django.template.loader import render_to_string
from django.core.mail import EmailMultiAlternatives

def send_receipt_to_email(self, request):

    emailSubject = "Subject"
    emailOfSender = "email@domain.com"
    emailOfRecipient = 'xyz@domain.com'

    context = ({"name": "Gilbert"}) #Note I used a normal tuple instead of  Context({"username": "Gilbert"}) because Context is deprecated. When I used Context, I got an error > TypeError: context must be a dict rather than Context

    text_content = render_to_string('receipt_email.txt', context, request=request)
    html_content = render_to_string('receipt_email.html', context, request=request)

    try:
        #I used EmailMultiAlternatives because I wanted to send both text and html
        emailMessage = EmailMultiAlternatives(subject=emailSubject, body=text_content, from_email=emailOfSender, to=[emailOfRecipient,], reply_to=[emailOfSender,])
        emailMessage.attach_alternative(html_content, "text/html")
        emailMessage.send(fail_silently=False)

    except SMTPException as e:
        print('There was an error sending an email: ', e) 
        error = {'message': ",".join(e.args) if len(e.args) > 0 else 'Unknown Error'}
        raise serializers.ValidationError(error)

Ważny! Więc jak się render_to_stringdostać receipt_email.txti receipt_email.html? U mnie settings.pymam, TEMPLATESa poniżej to, jak to wygląda

Zwróć uwagę DIRS, jest ta linia. os.path.join(BASE_DIR, 'templates', 'email_templates') Ta linia sprawia, że moje szablony są dostępne. W moim katalogu_projektu mam folder o nazwie templatesi podkatalog o email_templatestakiej nazwie project_dir->templates->email_templates. Moje szablony receipt_email.txti receipt_email.htmlznajdują się w email_templatespodkatalogu.

TEMPLATES = [
{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [os.path.join(BASE_DIR, 'templates'), os.path.join(BASE_DIR, 'templates', 'email_templates')],
    'APP_DIRS': True,
    'OPTIONS': {
        'context_processors': [
            'django.template.context_processors.debug',
            'django.template.context_processors.request',
            'django.contrib.auth.context_processors.auth',
            'django.contrib.messages.context_processors.messages',
        ],
    },
},
]

Pozwolę sobie tylko dodać, recept_email.txtże tak wygląda;

Dear {{name}},
Here is the text version of the email from template

I moje receipt_email.htmlwygląda tak;

Dear {{name}},
<h1>Now here is the html version of the email from the template</h1>

— manpikin
źródło

0

Napisałem fragment, który pozwala wysyłać wiadomości e-mail renderowane przy użyciu szablonów przechowywanych w bazie danych. Przykład:

EmailTemplate.send('expense_notification_to_admin', {
    # context object that email template will be rendered with
    'expense': expense_request,
})

— Andrii Zarubin
źródło

0

Jeśli chcesz dynamicznych szablonów wiadomości e-mail dla swojej poczty, zapisz treść wiadomości e-mail w tabelach bazy danych. To właśnie zapisałem jako kod HTML w bazie danych =

<p>Hello.. {{ first_name }} {{ last_name }}.  <br> This is an <strong>important</strong> {{ message }}
<br> <b> By Admin.</b>

 <p style='color:red'> Good Day </p>

W twoich poglądach:

from django.core.mail import EmailMultiAlternatives
from django.template.loader import get_template

def dynamic_email(request):
    application_obj = AppDetails.objects.get(id=1)
    subject = 'First Interview Call'
    email = request.user.email
    to_email = application_obj.email
    message = application_obj.message

    text_content = 'This is an important message.'
    d = {'first_name': application_obj.first_name,'message':message}
    htmly = FirstInterviewCall.objects.get(id=1).html_content #this is what i have saved previously in database which i have to send as Email template as mentioned above HTML code

    open("partner/templates/first_interview.html", "w").close() # this is the path of my file partner is the app, Here i am clearing the file content. If file not found it will create one on given path.
    text_file = open("partner/templates/first_interview.html", "w") # opening my file
    text_file.write(htmly) #putting HTML content in file which i saved in DB
    text_file.close() #file close

    htmly = get_template('first_interview.html')
    html_content = htmly.render(d)  
    msg = EmailMultiAlternatives(subject, text_content, email, [to_email])
    msg.attach_alternative(html_content, "text/html")
    msg.send()

Spowoduje to wysłanie dynamicznego szablonu HTML zapisanego w Db.

— Javed
źródło

0

send_emai()nie działało dla mnie, więc użyłem EmailMessage tutaj w dokumentach django .

Dołączyłem dwie wersje ansera:

Tylko z wersją e-mail HTML
Za pomocą zwykłego tekstu i wersji HTML

from django.template.loader import render_to_string 
from django.core.mail import EmailMessage

# import file with html content
html_version = 'path/to/html_version.html'

html_message = render_to_string(html_version, { 'context': context, })

message = EmailMessage(subject, html_message, from_email, [to_email])
message.content_subtype = 'html' # this is required because there is no plain text email version
message.send()

Jeśli chcesz dołączyć wersję e-maila w postaci zwykłego tekstu, zmień powyższe w następujący sposób:

from django.template.loader import render_to_string 
from django.core.mail import EmailMultiAlternatives # <= EmailMultiAlternatives instead of EmailMessage

plain_version = 'path/to/plain_version.html' # import plain version. No html content
html_version = 'path/to/html_version.html' # import html version. Has html content

plain_message = render_to_string(plain_version, { 'context': context, })
html_message = render_to_string(html_version, { 'context': context, })

message = EmailMultiAlternatives(subject, plain_message, from_email, [to_email])
message.attach_alternative(html_message, "text/html") # attach html version
message.send()

Moje wersje zwykła i HTML wyglądają tak: plain_version.html:

Plain text {{ context }}

html_version.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 ...
 </head>
<body>
<table align="center" border="0" cellpadding="0" cellspacing="0" width="320" style="border: none; border-collapse: collapse; font-family:  Arial, sans-serif; font-size: 14px; line-height: 1.5;">
...
{{ context }}
...
</table>
</body>
</html>

— alkadelik
źródło

-1

Lubię używać tego narzędzia, aby umożliwić łatwe wysyłanie wiadomości e-mail w formacie HTML i TXT z łatwym przetwarzaniem kontekstowym: https://github.com/divio/django-emailit

— matinfo
źródło