Criando modelos de email com o Django

207

Quero enviar emails em HTML, usando modelos do Django como este:

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

Não consigo encontrar nada send_maile o django-mailer envia apenas modelos HTML, sem dados dinâmicos.

Como eu uso o mecanismo de modelo do Django para gerar e-mails?

— Anakin
fonte

3

Observe que o Django 1.7oferece html_messageno send_email stackoverflow.com/a/28476681/953553

— andilabs

Oi @anakin, Eu luto com esse problema há muito tempo e decidi criar um pacote para isso. Eu ficaria muito feliz em receber o seu feedback: github.com/charlesthk/django-simple-mail

— Charlesthk

385

Na documentação , para enviar email em HTML, você deseja usar tipos de conteúdo alternativos, como este:

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

Você provavelmente desejará dois modelos para o seu e-mail - um texto simples, semelhante a este, armazenado no diretório de modelos em email.txt:

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

e um HTMLy, armazenado em email.html:

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

Em seguida, você pode enviar um email usando os dois modelos usando get_template, desta forma:

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
fonte

40

Eu acho que você pode simplificar isso com render_to_string , que iria deixá-lo perder as linhas separadas atribuir modelos para plaintexte htmly, e apenas definir modelos e contextos quando você define text_contente html_content.

— Cms_mgr

@cms_mgr Você pode elaborar o que você quer dizer e como podemos usar isso

— akki

3

@akki veja a resposta de andi abaixo, que também simplifica a parte alternativa, graças ao parâmetro html_message ser adicionado ao send_email () no Django 1.7

— Mike S

Perdoe-me, mas por que usamos txt e htmly ao mesmo tempo para um e-mail? Eu não obter essa lógica

— Shashank Vivek

eles são apenas exemplos para mostrar diferentes tipos de métodos, você pode usar qualquer um deles @ShashankVivek

— erdemlal:

242

Meninos e meninas!

Desde o método 1.7 do Django no send_email , o html_messageparâmetro foi adicionado.

html_message: se html_message for fornecido, o email resultante será um email alternativo / com várias partes com mensagem como o tipo de texto / conteúdo sem formatação e html_message como o tipo de conteúdo de texto / html.

Então você pode apenas:

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
fonte

1

Observe que 'email.txt' e 'email.html' estão em um modelo de diretório, conforme definido nas configurações, do que apenas render_to_string ('email.txt', {'some_params': some_params} _

— Bruno Vermeulen

Obrigado pela render_to_stringdica, muito útil.

— hoefling

1

Boa solução! No entanto, send_mailnão é possível definir algum cabeçalho personalizado, como, por exemplo, o Return-Pathque pode ser definido com oEmailMultiAlternatives's constructor header parameter

— Qlimax

26

Fiz o django-modelado-email em um esforço para resolver esse problema, inspirado por esta solução (e a necessidade, em algum momento, de usar modelos de django para usar um mailchimp etc.) conjunto de modelos para emails transacionais e modelados para meu próprio projeto). Ainda é um trabalho em andamento, mas, para o exemplo acima, você faria:

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

Com a adição do seguinte a settings.py (para concluir o exemplo):

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

Isso procurará automaticamente modelos denominados 'templated_email / email.txt' e 'templated_email / email.html' para as partes simples e html, respectivamente, nos diretórios / carregadores normais do modelo django (queixa se não conseguir encontrar pelo menos um deles) .

— Darb
fonte

1

Parece bom para mim. Eu aparadas esse baixo e jogado em um bilhete para adicionar django.shortcuts.send_templated_mail: code.djangoproject.com/ticket/17193

— Tom Christie

Legal, fico feliz em vê-lo sendo proposto como uma ferramenta para o núcleo do django. Meu caso de uso / foco para a lib é um pouco maior que apenas o atalho (alternância fácil entre provedores de e-mail que possuem APIs de chave / valor para o envio de e-mails), mas parece um recurso ausente do núcleo

— Darb

15

Use EmailMultiAlternatives e render_to_string para usar dois modelos alternativos (um em texto sem formatação e outro em 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
fonte

5

Criei o Django Simple Mail para ter um modelo simples, personalizável e reutilizável para cada email transacional que você gostaria de enviar.

O conteúdo e os modelos de e-mails podem ser editados diretamente do administrador do django.

Com o seu exemplo, você registraria seu email:

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)

E envie assim:

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)

Gostaria muito de receber algum feedback.

— Charlesthk
fonte

Ajudaria muito se você enviar um aplicativo de demonstração do seu pacote no seu repositório.

— Ans2human #

Olá @ ans2human, obrigado por esta sugestão, adiciono-a à lista de melhorias!

— Charlestk #

3

Há um erro no exemplo .... se você usá-lo como escrito, ocorre o seguinte erro:

<type 'exceptions.Exception'>: o objeto 'dict' não tem atributo 'render_context'

Você precisará adicionar a seguinte importação:

from django.template import Context

e mude o dicionário para:

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

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

— idbill
fonte

Obrigado - isso foi corrigido agora.

— Dominic Rodger

3

O Django Mail Templated é um aplicativo Django rico em recursos para enviar e-mails com o sistema de modelos do Django.

Instalação:

pip install django-mail-templated

Configuração:

INSTALLED_APPS = (
    ...
    'mail_templated'
)

Modelo:

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

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

Pitão:

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

Mais informações: https://github.com/artemrizhov/django-mail-templated

— atacante
fonte

Isso foi realmente fácil de usar. Obrigado.

— Cheenbabes

Olá, como posso definir todos os meus destinatários para Cco?

— Aldesabido 20/10

@aldesabido Este é apenas um invólucro da classe EmailMessage padrão do Django. Portanto, você deve ler a documentação oficial ao procurar esses recursos: docs.djangoproject.com/en/1.10/topics/email Veja também uma pergunta semelhante: stackoverflow.com/questions/3470172/…

— raacer

Para ser mais preciso, o EmailMessage padrão não é agrupado, mas herdado.

— 1026 raacer

É possível incluir JS / CSS no modelo?

— Daniel Shatz

3

Sei que essa é uma pergunta antiga, mas também sei que algumas pessoas são como eu e estão sempre procurando respostas atualizadas , pois as respostas antigas às vezes podem ter informações obsoletas, se não forem atualizadas.

Agora é janeiro de 2020 e estou usando o Django 2.2.6 e o Python 3.7

Nota: Eu uso o DJANGO REST FRAMEWORK , o código abaixo para enviar e-mail estava em um modelo no meuviews.py

Então, depois de ler várias respostas legais, foi isso que eu fiz.

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)

Importante! Então, como render_to_stringfica receipt_email.txte receipt_email.html? No meu settings.py, eu tenho TEMPLATESe abaixo é como ele se parece

Preste atenção DIRS, existe esta linha os.path.join(BASE_DIR, 'templates', 'email_templates') . Esta linha é o que torna meus modelos acessíveis. No meu project_dir, tenho uma pasta chamada templatese um subdiretório chamadoemail_templates assim project_dir->templates->email_templates. Meus modelos receipt_email.txte receipt_email.htmlestão sob o email_templatessubdiretório.

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',
        ],
    },
},
]

Deixe-me acrescentar que, minha recept_email.txtaparência fica assim;

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

E, minha receipt_email.htmlaparência é assim;

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

— manpikin
fonte

0

Escrevi um trecho que permite enviar e-mails renderizados com modelos armazenados no banco de dados. Um exemplo:

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

— Andrii Zarubin
fonte

0

Se você deseja modelos de email dinâmicos para o seu email, salve o conteúdo do email nas tabelas do banco de dados. Isto é o que eu salvei como código HTML no banco de dados =

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

Na sua opinião:

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

Isso enviará ao modelo HTML dinâmico o que você salvou no banco de dados.

— Javed
fonte

0

send_emai()não funcionou para mim, então eu usei EmailMessage aqui no django docs .

Eu incluí duas versões do anser:

Somente com a versão de email html
Com email em texto sem formatação e versões de email em 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()

Se você deseja incluir uma versão em texto sem formatação do seu e-mail, modifique o descrito acima desta forma:

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

Minhas versões simples e html ficam assim: 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
fonte

-1

Gosto de usar esta ferramenta para permitir o envio fácil de emails em HTML e TXT com fácil processamento de contexto: https://github.com/divio/django-emailit

— matinfo
fonte