def test_helloEmail(self):
self.maxDiff = None
"""Minimum required to send an email"""
mail = Mail()
mail.from_email = Email("*****@*****.**")
mail.subject = "Hello World from the SendGrid Python Library"
personalization = Personalization()
personalization.add_to(Email("*****@*****.**"))
mail.add_personalization(personalization)
mail.add_content(Content("text/plain", "some text here"))
mail.add_content(
Content("text/html", "<html><body>some text here</body></html>"))
self.assertEqual(
json.dumps(mail.get(), sort_keys=True),
'{"content": [{"type": "text/plain", "value": "some text here"}, '
'{"type": "text/html", '
'"value": "<html><body>some text here</body></html>"}], '
'"from": {"email": "*****@*****.**"}, "personalizations": '
'[{"to": [{"email": "*****@*****.**"}]}], '
'"subject": "Hello World from the SendGrid Python Library"}')
def sender_new_order_status(order_queryset):
"""
Sending an email to the client to indicate a change of status.
"""
done = True
for order in order_queryset:
data = {
'reforder': order.reference,
'clientname': order.first_name,
'price': order.total_price,
'status': order.status
}
mail = Mail()
mail.from_email = Email(os.environ.get('FROM_EMAIL'),
os.environ.get('FROM_NAME_EMAIL'))
mail.template_id = os.environ.get('ID_TEMPLATE_UPDATE_CMD')
mail.subject = "Le statu de votre commande a changée"
p = Personalization()
p.add_to(Email(order.email, f"{order.last_name} {order.first_name}"))
p.dynamic_template_data = data
mail.add_personalization(p)
sg = SendGridAPIClient(api_key=os.environ.get('SENDGRID_API_KEY'))
response = sg.client.mail.send.post(request_body=mail.get())
if response.status_code == 202:
continue
else:
done = False
return done
def get_recipients():
emails = config.get_emails()
to_list = Personalization()
for email in emails:
to_list.add_to(To(email))
return to_list
def send_email_using_SendGrid(sender,
receiver,
mail_subject,
mail_content,
cc_email=None):
message = Mail(
from_email=sender,
#to_emails = receiver, # Removed since it generates an extra email with SendGrid
subject=mail_subject,
html_content=mail_content)
if cc_email:
cc = Email(cc_email)
to = Email(receiver)
p = Personalization()
p.add_to(to)
p.add_cc(cc)
message.add_personalization(p)
else: # no cc
to = Email(receiver)
p = Personalization()
p.add_to(to)
message.add_personalization(p)
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
print(response.status_code)
print(response.body)
print(response.headers)
except Exception as e:
print(e.message)
return
def send_email(subject, sender, recipients, text_body, html_body):
message = Mail(
from_email=sender,
# to_emails=recipients,
subject=subject,
html_content=Content('text/html', html_body))
txt_content = Content('text/txt', text_body)
message.add_content(txt_content)
#for personalization so you can't see other people sent email
for r in recipients:
person = Personalization()
person.add_to(Email(r))
message.add_personalization(person)
try:
sg = SendGridAPIClient(current_app.config['SENDGRID_API_KEY'])
response = sg.send(message)
print(response.status_code)
print(response.body)
print(response.headers)
return True
except Exception as e:
print(e)
return False
def sender_reset_password(user, host):
"""
Send the email to the user to reset his password.
"""
link = f"{host}/user/reset_password/"
data = {
"code": user.check_code,
"link": link,
"username": str(user)
}
mail = Mail()
mail.from_email = Email(
os.environ.get('FROM_EMAIL'),
os.environ.get('FROM_NAME_EMAIL')
)
mail.template_id = os.environ.get('ID_TEMPLATE_RESET_PASSWORD')
mail.subject = "Réinitialisation de mot de passe."
p = Personalization()
p.add_to(Email(user.email, str(user)))
p.dynamic_template_data = data
mail.add_personalization(p)
sg = SendGridAPIClient(api_key=os.environ.get('SENDGRID_API_KEY'))
response = sg.client.mail.send.post(request_body=mail.get())
return response
def construct_email(mailfrom: str, mailto: list, subject: str, content: str,
attfilename: str, data: str):
"""
still intake one mailfrom and one mailto for now
params:
mailfrom: an email,
mailto: an email,
subject: str,
data: csv-ready string
attfilename: filename for attachment
"""
mail = Mail()
mail.from_email = Email(mailfrom)
mail.subject = subject
mail.add_content(Content("text/html", content))
personalization = Personalization()
for i in mailto:
personalization.add_to(Email(i))
mail.add_personalization(personalization)
attachment = Attachment()
attachment.content = str(base64.b64encode(data.encode('utf-8')), 'utf-8')
attachment.type = 'text/csv'
attachment.filename = attfilename
attachment.disposition = 'attachment'
mail.add_attachment(attachment)
return mail
def _make_sendgrid_mail(self, message):
mail = Mail()
if message.sender:
mail.from_email = Email(message.sender)
else:
mail.from_email = Email(self.default_sender)
if message.subject:
mail.subject = message.subject
if message.recipients:
if type(message.recipients) == list:
personalization = Personalization()
for recipient in message.recipients:
personalization.add_to(Email(recipient))
mail.add_personalization(personalization)
else:
raise Exception("unsupported type yet")
if message.body:
mail.add_content(Content("text/plain", message.body))
if message.html:
mail.add_content(Content("text/html", message.html))
if message.reply_to:
mail.reply_to = Email(message.reply_to)
return mail
def send_sendgrid_template(template_name, template_params, subject, sender_name, sender_email, recipient_name, recipient_email):
'''Send a message via the SendGrid API.'''
if template_name.strip() == 'share-to-recipient-web':
logging.info('ignoring share to recipient message')
return
if template_name not in _TEMPLATE_NAME_TO_TEMPLATE_ID:
logging.ing('template id not found for template name ' + template_name + ': ignoring message')
return
template_id = _TEMPLATE_NAME_TO_TEMPLATE_ID[template_name]
mail = Mail()
personalization = Personalization()
personalization.add_to(Email(recipient_email))
mail.add_personalization(personalization)
sender_name = None
if sender_email is None:
sender_email = _FROM_ADDR
sender_name = _FROM_NAME
mail.set_from(Email(email=sender_email, name=sender_name))
if subject:
mail.set_subject(subject)
mail.set_template_id(template_id)
_send(mail)
def test_helloEmail(self):
self.maxDiff = None
"""Minimum required to send an email"""
mail = Mail()
mail.from_email = Email("*****@*****.**")
mail.subject = "Hello World from the SendGrid Python Library"
personalization = Personalization()
personalization.add_to(Email("*****@*****.**"))
mail.add_personalization(personalization)
mail.add_content(Content("text/plain", "some text here"))
mail.add_content(
Content(
"text/html",
"<html><body>some text here</body></html>"))
self.assertEqual(
json.dumps(
mail.get(),
sort_keys=True),
'{"content": [{"type": "text/plain", "value": "some text here"}, '
'{"type": "text/html", '
'"value": "<html><body>some text here</body></html>"}], '
'"from": {"email": "*****@*****.**"}, "personalizations": '
'[{"to": [{"email": "*****@*****.**"}]}], '
'"subject": "Hello World from the SendGrid Python Library"}'
)
self.assertTrue(isinstance(str(mail), str))
def _notify(job):
try:
logger.debug(
f"Sending email notification to {job.user_name} <{job.user_email}>"
)
sendgrid = SendGridAPIClient()
mail = Mail()
mail.from_email = Email("DD-DeCaF <*****@*****.**>")
mail.template_id = "d-8caebf4f862b4c67932515c45c5404cc"
personalization = Personalization()
personalization.add_to(Email(job.user_email))
personalization.dynamic_template_data = {
"name": job.user_name,
"product": job.product_name,
"organism": job.organism_name,
"results_url": f"https://caffeine.dd-decaf.eu/jobs/{job.job_id}",
}
mail.add_personalization(personalization)
sendgrid.client.mail.send.post(request_body=mail.get())
except Exception as error:
# Suppress any problem so it doesn't mark the entire workflow as failed,
# but do log a warning for potential follow-up.
logger.warning(
"Unable to send email notification upon job completion",
exc_info=error,
)
def get(self, request, *args, **kwargs):
self.template = self.get_object(kwargs.get('tp_pk'))
self.person = self.get_person(kwargs.get('to_pk'), kwargs.get('tp_pk'))
mail = Mail()
mail.set_from(Email(self.request.user.email))
mail.set_subject(self.template.title)
personalization = Personalization()
personalization.add_to(Email(self.person.email))
mail.add_personalization(personalization)
body = self.render_body(self.person.name, self.template.template_email.path)
mail.add_content(Content("text/html", body))
if self.template.attachment:
path = self.template.attachment.path
ext = path.split('.')[-1]
with open(path, "rb") as f:
mail.add_attachment(self.attach_file(
f, ext, self.template.slug, self.template.title))
self.sg.client.mail.send.post(request_body=mail.get())
messages.info(
request,
"""You have just send an email to <strong>{0.email}</strong>
with the subject <strong>{1}</strong>
"""
.format(self.person, self.template.title))
self.person.email_sent = True
self.person.save()
return super(SendEmailView, self).get(request, *args, **kwargs)
def form_valid(self, form):
self.template = form.cleaned_data['template']
self.email = form.cleaned_data['email']
self.subject = form.cleaned_data['subject']
mail = Mail()
mail.set_from(Email(self.request.user.email))
mail.set_subject(self.subject)
personalization = Personalization()
personalization.add_to(Email(self.email))
mail.add_personalization(personalization)
body_personalized = self.render_body(
form.cleaned_data['name'],
self.template.template_file.path)
body = self.render_content(
body_personalized,
form.cleaned_data['content'],
self.subject)
mail.add_content(Content("text/html", body))
if form.cleaned_data['attachment']:
file_name = form.cleaned_data['attachment'].name
ext = file_name.split('.')[-1]
with form.cleaned_data['attachment'] as f:
mail.add_attachment(self.attach_file(
f, ext,
slugify(file_name),
self.subject))
self.sg.client.mail.send.post(request_body=mail.get())
return super(CustomEmailView, self).form_valid(form)
def send_email(
sender=settings.CLOUDCV_TEAM_EMAIL,
recipient=None,
template_id=None,
template_data={},
):
"""Function to send email
Keyword Arguments:
sender {string} -- Email of sender (default: {settings.TEAM_EMAIL})
recipient {string} -- Recipient email address
template_id {string} -- Sendgrid template id
template_data {dict} -- Dictionary to substitute values in subject and email body
"""
try:
sg = sendgrid.SendGridAPIClient(
apikey=os.environ.get("SENDGRID_API_KEY")
)
sender = Email(sender)
mail = Mail()
mail.from_email = sender
mail.template_id = template_id
to_list = Personalization()
to_list.dynamic_template_data = template_data
to_email = Email(recipient)
to_list.add_to(to_email)
mail.add_personalization(to_list)
sg.client.mail.send.post(request_body=mail.get())
except Exception:
logger.warning(
"Cannot make sendgrid call. Please check if SENDGRID_API_KEY is present."
)
return
def send_letter(self,
template_id,
emails,
dynamic_template_data=None,
categories=None):
categories = categories or []
dynamic_template_data = dynamic_template_data or {}
mail = Mail()
mail.template_id = template_id
mail.from_email = Email(email=settings.EMAIL_FROM,
name=settings.DEFAULT_FROM_EMAIL)
for email in emails:
personalization = Personalization()
personalization.add_to(Email(email))
personalization.dynamic_template_data = dynamic_template_data
mail.add_personalization(personalization)
for category in categories:
mail.add_category(Category(category))
return self._send_letter(mail.get())
def send_email(to, subject, html_content, files=None,
dryrun=False, cc=None, bcc=None,
mime_subtype='mixed', **kwargs):
"""
Send an email with html content using sendgrid.
To use this plugin:
0. include sendgrid subpackage as part of your Airflow installation, e.g.,
pip install airflow[sendgrid]
1. update [email] backend in airflow.cfg, i.e.,
[email]
email_backend = airflow.contrib.utils.sendgrid.send_email
2. configure Sendgrid specific environment variables at all Airflow instances:
SENDGRID_MAIL_FROM={your-mail-from}
SENDGRID_API_KEY={your-sendgrid-api-key}.
"""
mail = Mail()
mail.from_email = Email(os.environ.get('SENDGRID_MAIL_FROM'))
mail.subject = subject
# Add the recipient list of to emails.
personalization = Personalization()
to = get_email_address_list(to)
for to_address in to:
personalization.add_to(Email(to_address))
if cc:
cc = get_email_address_list(cc)
for cc_address in cc:
personalization.add_cc(Email(cc_address))
if bcc:
bcc = get_email_address_list(bcc)
for bcc_address in bcc:
personalization.add_bcc(Email(bcc_address))
# Add custom_args to personalization if present
pers_custom_args = kwargs.get('personalization_custom_args', None)
if isinstance(pers_custom_args, dict):
for key in pers_custom_args.keys():
personalization.add_custom_arg(CustomArg(key, pers_custom_args[key]))
mail.add_personalization(personalization)
mail.add_content(Content('text/html', html_content))
categories = kwargs.get('categories', [])
for cat in categories:
mail.add_category(Category(cat))
# Add email attachment.
for fname in files or []:
basename = os.path.basename(fname)
attachment = Attachment()
with open(fname, "rb") as f:
attachment.content = base64.b64encode(f.read())
attachment.type = mimetypes.guess_type(basename)[0]
attachment.filename = basename
attachment.disposition = "attachment"
attachment.content_id = '<%s>' % basename
mail.add_attachment(attachment)
_post_sendgrid_mail(mail.get())
def test_unicode_values_in_substitutions_helper(self):
""" Test that the Substitutions helper accepts unicode values """
self.maxDiff = None
"""Minimum required to send an email"""
mail = Mail()
mail.from_email = Email("*****@*****.**")
mail.subject = "Testing unicode substitutions with the SendGrid Python Library"
personalization = Personalization()
personalization.add_to(Email("*****@*****.**"))
personalization.add_substitution(Substitution("%city%", u"Αθήνα"))
mail.add_personalization(personalization)
mail.add_content(Content("text/plain", "some text here"))
mail.add_content(
Content(
"text/html",
"<html><body>some text here</body></html>"))
expected_result = {
"content": [
{
"type": "text/plain",
"value": "some text here"
},
{
"type": "text/html",
"value": "<html><body>some text here</body></html>"
}
],
"from": {
"email": "*****@*****.**"
},
"personalizations": [
{
"substitutions": {
"%city%": u"Αθήνα"
},
"to": [
{
"email": "*****@*****.**"
}
]
}
],
"subject": "Testing unicode substitutions with the SendGrid Python Library",
}
self.assertEqual(
json.dumps(mail.get(), sort_keys=True),
json.dumps(expected_result, sort_keys=True)
)
def send_notification(notification, trigger_check, metric_log):
print('send_notification starting with params: '
f'notification_id={metric_log.affiliate_id} '
f'trigger check={trigger_check.id}'
f'trigger={trigger_check.trigger}')
to_emails = []
for receiver in notification.receivers.all():
if receiver.name == 'Affiliate Manager':
affiliate = get_affiliate(metric_log.affiliate_id)
employee = Employee.objects.get(pk=affiliate.account_manager_id)
email_address = (employee.email if not employee.use_secondary else
employee.secondary_email)
to_emails.append(email_address)
if receiver.name == 'Account Manager':
ho_offer = get_offer(metric_log.offer_id)
manager_id = ho_offer.Advertiser['account_manager_id']
employee = Employee.objects.get(pk=manager_id)
email_address = (employee.email if not employee.use_secondary else
employee.secondary_email)
to_emails.append(email_address)
if receiver.name == 'Administrators':
for recipient in Recipient.objects.filter(active=True):
to_emails.append(recipient.email)
macros = {
'{value}': metric_log.value,
'{offer-id}': metric_log.offer_id,
'{offer-name}': Offer.objects.get(pk=metric_log.offer_id).name,
'{affiliate-id}': metric_log.affiliate_id
}
sg = sendgrid.SendGridAPIClient(apikey=settings.SENDGRID_API_KEY)
mail = Mail()
mail.from_email = Email(settings.NETWORK_EMAIL)
subject = notification.subject
message = notification.message
for macro, value in macros.items():
message = message.replace(macro, str(value))
subject = subject.replace(macro, str(value))
now = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
message += f"<br><br><small>generated at: {now}</small>"
mail.subject = subject
mail.add_content(Content("text/html", message))
personalization = Personalization()
for email in to_emails:
personalization.add_to(Email(email))
mail.add_personalization(personalization)
response = sg.client.mail.send.post(request_body=mail.get())
print(f'send_notification: response.status_code={response.status_code}')
print('send_notification: '
f'notification_id={metric_log.affiliate_id} '
f'trigger check={trigger_check.id}')
def send_email(*, receivers: list, subject: str, content: str, celery_task=None):
"""
Kwargs:
receivers [List[Str]]:
A list of emails to send the mail.
subject [Str]:
The subject of the mail
content [Str]:
The HTML content of the mail
"""
if not sg or not receivers:
return None
message = Mail(
from_email=("*****@*****.**", "Ora"),
# to_emails="*****@*****.**",
subject=subject,
html_content=content,
# subject='Sending with Twilio SendGrid is Fun',
# html_content='<strong>and easy to do anywhere, even with Python</strong>'
)
# Add the receivers
to_list = Personalization()
for recv in receivers:
# to_list.add_to(Email("EMAIL ADDRESS"))
to_list.add_to(Email(recv))
# Inject the receivers to the email
message.add_personalization(to_list)
status_code = 500
try:
response = sg.send(message)
status_code = response.status_code
except HTTPError as exc:
status_code = 401
if celery_task:
mark_task_as_failed(celery_task, reason=str(exc))
except IncompleteRead as exc:
status_code = 401
if celery_task:
mark_task_as_failed(celery_task, reason=str(exc))
except UnauthorizedError as exc:
status_code = 401
if celery_task:
mark_task_as_failed(celery_task, reason=str(exc))
# return {
# "status_code": response.status_code,
# "body": response.body,
# "headers": response.headers,
# }
return status_code
def build_email(self):
mail = Mail(from_email=self.from_email,
subject=self.subject,
to_email=self.from_email,
content=self.email_content)
personalization = Personalization()
for email in self.emails:
personalization.add_to(Email(email))
mail.add_personalization(personalization)
return mail.get()
def send_email(self):
# send email using the self.cleaned_data dictionary
first_name = self.cleaned_data.get("fname")
last_name = self.cleaned_data.get("lname")
email = self.cleaned_data.get("email")
phone = self.cleaned_data.get("phone")
message = self.cleaned_data.get("message")
# Issue response to client via sendgrid API
sendgrid_client = SendGridAPIClient(config('SENDGRID_API_KEY'))
mail = Mail()
mail.from_email = From(config('EMAIL_FROM'))
mail.to_email = To(email)
mail.subject = "Your Enquiry with Mayan Web Studio"
mail.template_id = config('SENDGRID_TEMPLATE_ID')
p = Personalization()
p.add_to(To(email))
p.dynamic_template_data = {
"firstName": first_name,
"lastName": last_name,
"phone": phone
}
mail.add_personalization(p)
response = sendgrid_client.client.mail.send.post(
request_body=mail.get())
print(response.status_code)
print(response.body)
print(response.headers)
# Send notification email to Mayan
subject, from_email, to = 'New Enquiry for Mayan Web Studio', config(
'EMAIL_FROM'), '*****@*****.**'
text_content = 'This is an important message.'
html_content = '''
<h3>New Enquiry from</h3>
<ul>
<li>First Name: $(first_name)</li>
<li>Last Name: $(last_name)</li>
<li>Email: $(email)</li>
<li>Phone: $(phone)</li>
<li>Message: $(message)</li>
</ul>
'''
html_content = html_content.replace("$(first_name)", first_name)
html_content = html_content.replace("$(last_name)", last_name)
html_content = html_content.replace("$(email)", email)
html_content = html_content.replace("$(phone)", phone)
html_content = html_content.replace("$(message)", message)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
def build_email(context, subject, message):
mail = Mail(from_email=Email(context['from_email']),
subject=subject,
content=Content('text/plain', message))
personalization = Personalization()
for to_addr in context['to_email'].split(';'):
personalization.add_to(Email(to_addr))
mail.add_personalization(personalization)
return mail
def _make_sendgrid_mail(self, message):
mail = Mail()
if message.sender:
mail.from_email = Email(message.sender)
else:
mail.from_email = Email(self.default_sender)
if message.mail_options and message.mail_options.get('from_name'):
mail.from_email.name = message.mail_options.get('from_name')
template_id = getattr(message, 'template_id', None)
if template_id:
mail.template_id = template_id
if message.subject:
mail.subject = message.subject
if message.recipients:
if type(message.recipients) == list:
personalization = Personalization()
for recipient in message.recipients:
personalization.add_to(Email(recipient))
dynamic_template_data = getattr(message,
'dynamic_template_data', None)
if dynamic_template_data:
personalization.dynamic_template_data = dynamic_template_data
mail.add_personalization(personalization)
else:
raise Exception("unsupported type yet")
if message.body:
mail.add_content(Content("text/plain", message.body))
if message.html:
mail.add_content(Content("text/html", message.html))
if message.reply_to:
mail.reply_to = Email(message.reply_to)
if message.attachments:
for attachment in message.attachments:
file_content = base64.b64encode(
attachment.data).decode('UTF-8')
mail.add_attachment(
Attachment(
file_content=file_content,
file_name=attachment.filename,
file_type=attachment.content_type,
disposition=attachment.disposition,
))
return mail
def add_recipients(mail_object: Mail, recipients: List[str]) -> None:
"""
Takes a sendgrid mail object and adds a list of e-mails as blind-copy recipients.
Arguments:
mail_object {Mail} -- Mail object respresenting e-mail.
recipients {List[str]} -- String list of e-mails to be sent to.
"""
personalization = Personalization()
for address in recipients:
personalization.add_bcc(Email(email=address))
mail_object.add_personalization(personalization)
def create_mail_config(from_email: str, subject: str, to_emails: List[str],
content: str) -> dict:
mail = Mail()
mail.from_email = Email(from_email)
mail.subject = subject
personalization = Personalization()
for email in to_emails:
personalization.add_to(Email(email))
mail.add_personalization(personalization)
mail.add_content(Content("text/html", content))
return mail.get()
def _create_email(self, email: dict, email_id: str) -> Mail:
self.log_debug('converting email %s to sendgrid format', email_id)
mail = Mail()
personalization = Personalization()
for i, to in enumerate(email.get('to', [])):
personalization.add_to(Email(to))
self.log_debug('added to %d to email %s', i, email_id)
for i, cc in enumerate(email.get('cc', [])):
personalization.add_cc(Email(cc))
self.log_debug('added cc %d to email %s', i, email_id)
for i, bcc in enumerate(email.get('bcc', [])):
personalization.add_bcc(Email(bcc))
self.log_debug('added bcc %d to email %s', i, email_id)
mail.add_personalization(personalization)
self.log_debug('added recipients to email %s', email_id)
mail.subject = email.get('subject', '(no subject)')
self.log_debug('added subject to email %s', email_id)
mail.add_content(Content('text/html', email.get('body')))
self.log_debug('added content to email %s', email_id)
mail.from_email = Email(email.get('from'))
self.log_debug('added from to email %s', email_id)
for i, attachment in enumerate(email.get('attachments', [])):
mail.add_attachment(self._create_attachment(attachment))
self.log_debug('added attachment %d to email %s', i, email_id)
self.log_debug('converted email %s to sendgrid format', email_id)
return mail
def build(self, to_email, subject, body):
mail = Mail()
from_email = self.config['MAILER_FROM_EMAIL']
from_name = self.config['MAILER_FROM_NAME']
mail.from_email = Email(from_email, from_name)
mail.subject = subject
personalization = Personalization()
personalization.add_to(Email(to_email))
mail.add_personalization(personalization)
mail.add_content(Content("text/plain", body))
return mail.get()
def send_email(self, to_email, subject, from_email=None, html=None, text=None, *args, **kwargs):
if not any([from_email, self.default_from]):
raise ValueError("Missing from email and no default.")
if not any([html, text]):
raise ValueError("Missing html or text.")
self.set_from(Email(from_email or self.default_from))
self.set_subject(subject)
personalization = Personalization()
if type(to_email) is list:
for email in self._extract_emails(to_email):
personalization.add_to(email)
elif type(to_email) is Email:
personalization.add_to(to_email)
elif type(to_email) is str:
personalization.add_to(Email(to_email))
self.add_personalization(personalization)
content = Content("text/html", html) if html else Content("text/plain", text)
self.add_content(content)
return self.client.mail.send.post(request_body=self.get())
def send_registration_mail(attendee: Attendee, event: Event):
qr_data = gen_qrcode(data=str(attendee.uuid)).read()
template = templates['REGISTRATION']
mail = Mail()
mail.from_email = Email(template['FROM_EMAIL'], template['FROM_NAME'])
mail.template_id = template['ID']
mail.add_category(Category(template['CATEGORY']))
attachment1 = Attachment()
attachment1.content = base64.b64encode(qr_data).decode('ascii')
attachment1.filename = template['FILENAME']
mail.add_attachment(attachment1)
personalization = Personalization()
personalization.add_substitution(
Substitution("%first_name%",
attendee.name.split()[0]))
personalization.add_substitution(Substitution("%event_name%", event.name))
personalization.add_to(Email(attendee.email, attendee.name))
mail.add_personalization(personalization)
try:
sg.client.mail.send.post(request_body=mail.get())
return qr_data
except Exception as e:
raise e
def send_email(receivers,
subject,
content,
template_id=None,
text_replacements=None,
sender_name=None,
sender_email=None,
attachments=None,
cc_list=None,
bcc_list=None):
print(os.environ.get('SENDGRID_API_KEY'), ' is the sendgrid api key')
sendgrid_client = sendgrid.SendGridAPIClient(
api_key=os.environ.get('SENDGRID_API_KEY'))
sender = sendgrid.Email(name=sender_name, email=sender_email)
mail = Mail(from_email=sender, subject=subject, content=content)
personalization = Personalization()
if len(receivers) == 0:
error = Error({'detail': 'Please enter receiver mailId'},
status=status.HTTP_400_BAD_REQUEST)
return error, None
else:
for receiver in receivers:
personalization.add_to(receiver)
personalization.add_to(receivers[0])
for cc in cc_list and cc_list is not None:
personalization.add_cc(cc)
for bcc in bcc_list and bcc_list is not None:
personalization.add_bcc(bcc)
mail.add_personalization(personalization)
if text_replacements is not None:
for text_replacement in text_replacements:
for key, value in text_replacement.items():
mail.personalizations[0].add_substitution(
Substitution(key, value))
mail.template_id = template_id
if attachments is not None:
for attachment in attachments:
mail.add_attachment(attachment)
response = sendgrid_client.client.mail.send.post(
request_body=mail.get())
return {'status': True, 'response': response.body.decode().strip()}
def send_email(recipients, gt_email, subject, content):
"""Sends email.
If an authorization error occurs ensure endgrid.env file is in root, then 'source ./sendgrid.env'
Args:
recipients (User or list): Individual User or list of students.
gt_email (str): The address that the email will come from (can be anything we want).
subject (str): subject of the email.
content (str): content of the email.
Returns:
HttpResponse: HttpResponse.
"""
# Check if the recipients list is empty
if not recipients:
return HttpResponse("No recipients were found.")
student_email_list = []
# Only a single student
if isinstance(recipients, User):
student_email_list.append(Email(recipients.email))
elif isinstance(recipients, list):
if isinstance(recipients[0], str):
for student in recipients:
student_email_list.append(Email(student))
else:
for student in recipients:
student_email_list.append(Email(student.email))
else:
return HttpResponseBadRequest("Bad Request")
# Handle email sending
sendgrid = SendGridAPIClient(settings.EMAIL_SENDGRID_KEY)
mail = Mail()
mail.from_email = Email(gt_email)
mail.subject = subject
mail.add_content(Content("text/plain", content))
if settings.DEBUG:
# if debug, send email to grepthink email
personalization = Personalization()
# If you wish to receive emails to personal email you can refector the below email. Do NOT update repo.
personalization.add_to(Email("*****@*****.**"))
mail.add_personalization(personalization)
else:
# add recipients to the outgoing Mail object
# Ensure everyone can't see everyone elses emails in the 'to:' of the email
for email in student_email_list:
personalization = Personalization()
personalization.add_to(email)
mail.add_personalization(personalization)
sendgrid.client.mail.send.post(request_body=mail.get())
return HttpResponse("Email Sent!")
def send(self, notification):
'''
Accepts a notification and sends an email using included data.
If SENDGRID_REPORTING_KEY and EMAIL_REPORT_SENDER are available
in config, it uses Sendgrid to deliver the email. Otherwise, it
uses plain SMTP through send_email()
'''
user = notification.user
to = notification.email or user.email
full_name = user.get_nice_name()
first_name = user.first_name or user.get_nice_name()
if (hasattr(config, "SENDGRID_REPORTING_KEY")
and hasattr(config, "EMAIL_REPORT_SENDER")):
from sendgrid.helpers.mail import (Email, Mail, Personalization,
Content, Substitution)
import sendgrid
self.sg_instance = sendgrid.SendGridAPIClient(
apikey=config.SENDGRID_REPORTING_KEY)
mail = Mail()
mail.from_email = Email(config.EMAIL_REPORT_SENDER,
"Mist.io Reports")
personalization = Personalization()
personalization.add_to(Email(to, full_name))
personalization.subject = notification.subject
sub1 = Substitution("%name%", first_name)
personalization.add_substitution(sub1)
if "unsub_link" in notification:
sub2 = Substitution("%nsub%", notification.unsub_link)
personalization.add_substitution(sub2)
mail.add_personalization(personalization)
mail.add_content(Content("text/plain", notification.body))
if "html_body" in notification:
mail.add_content(Content("text/html", notification.html_body))
mdict = mail.get()
try:
return self.sg_instance.client.mail.send.post(
request_body=mdict)
except urllib2.URLError as exc:
logging.error(exc)
exit()
except Exception as exc:
logging.error(str(exc.status_code) + ' - ' + exc.reason)
logging.error(exc.to_dict)
exit()
else:
send_email(notification.subject,
notification.body, [to],
sender="config.EMAIL_REPORT_SENDER")
def send_email(to, subject, html_content, files=None,
dryrun=False, cc=None, bcc=None,
mime_subtype='mixed', **kwargs):
"""
Send an email with html content using sendgrid.
To use this plugin:
0. include sendgrid subpackage as part of your Airflow installation, e.g.,
pip install airflow[sendgrid]
1. update [email] backend in airflow.cfg, i.e.,
[email]
email_backend = airflow.contrib.utils.sendgrid.send_email
2. configure Sendgrid specific environment variables at all Airflow instances:
SENDGRID_MAIL_FROM={your-mail-from}
SENDGRID_API_KEY={your-sendgrid-api-key}.
"""
mail = Mail()
mail.from_email = Email(os.environ.get('SENDGRID_MAIL_FROM'))
mail.subject = subject
# Add the recipient list of to emails.
personalization = Personalization()
to = get_email_address_list(to)
for to_address in to:
personalization.add_to(Email(to_address))
if cc:
cc = get_email_address_list(cc)
for cc_address in cc:
personalization.add_cc(Email(cc_address))
if bcc:
bcc = get_email_address_list(bcc)
for bcc_address in bcc:
personalization.add_bcc(Email(bcc_address))
mail.add_personalization(personalization)
mail.add_content(Content('text/html', html_content))
# Add custom_args to personalization if present
pers_custom_args = kwargs.get('personalization_custom_args', None)
if isinstance(pers_custom_args, dict):
for key in pers_custom_args.keys():
personalization.add_custom_arg(CustomArg(key, pers_custom_args[key]))
# Add email attachment.
for fname in files or []:
basename = os.path.basename(fname)
attachment = Attachment()
with open(fname, "rb") as f:
attachment.content = base64.b64encode(f.read())
attachment.type = mimetypes.guess_type(basename)[0]
attachment.filename = basename
attachment.disposition = "attachment"
attachment.content_id = '<%s>' % basename
mail.add_attachment(attachment)
_post_sendgrid_mail(mail.get())
def test_sendgrid_api_key(self):
"""Tests if including SendGrid API will throw an Exception"""
# Minimum required to send an email
self.max_diff = None
mail = Mail()
mail.from_email = Email("*****@*****.**")
mail.subject = "Hello World from the SendGrid Python Library"
personalization = Personalization()
personalization.add_to(Email("*****@*****.**"))
mail.add_personalization(personalization)
# Try to include SendGrid API key
try:
mail.add_content(
Content(
"text/plain",
"some SG.2123b1B.1212lBaC here"))
mail.add_content(
Content(
"text/html",
"<html><body>some SG.Ba2BlJSDba.232Ln2 here</body></html>"))
self.assertEqual(
json.dumps(
mail.get(),
sort_keys=True),
'{"content": [{"type": "text/plain", "value": "some text here"}, '
'{"type": "text/html", '
'"value": "<html><body>some text here</body></html>"}], '
'"from": {"email": "*****@*****.**"}, "personalizations": '
'[{"to": [{"email": "*****@*****.**"}]}], '
'"subject": "Hello World from the SendGrid Python Library"}'
)
# Exception should be thrown
except Exception:
pass
# Exception not thrown
else:
self.fail("Should have failed as SendGrid API key included")
def send_email(self, to_email, subject, from_email=None, html=None, text=None, *args, **kwargs): # noqa
if not any([from_email, self.default_from]):
raise ValueError("Missing from email and no default.")
if not any([html, text]):
raise ValueError("Missing html or text.")
self.from_email = Email(from_email or self.default_from)
self.subject = subject
personalization = Personalization()
if type(to_email) is list:
for email in self._extract_emails(to_email):
personalization.add_to(email)
elif type(to_email) is Email:
personalization.add_to(to_email)
elif type(to_email) is str:
personalization.add_to(Email(to_email))
self.add_personalization(personalization)
content = Content("text/html", html) if html else Content("text/plain", text)
self.add_content(content)
return self.client.mail.send.post(request_body=self.get())
def get_recipient_objects(_notify):
_recipients = get_recipient_list(_notify)
_mail = _setup_email(_notify)
_pers = Personalization()
_pers.subject = _notify.notify_title
if _recipients.get("to"):
for _recipient in _recipients["to"]:
_pers.add_to(Email(**_recipient))
for _recipient in _recipients["cc"]:
_pers.add_cc(Email(**_recipient))
_mail.add_personalization(_pers)
return (_mail,)
_recipient_list = []
for _recipient in _recipients.get("recipients", []):
_pers_copy = deepcopy(_pers)
_pers_copy.add_to(Email(**_recipient))
_mail_copy = deepcopy(_mail)
_mail_copy.add_personalization(_pers_copy)
_recipient_list.append(_mail_copy)
return tuple(_recipient_list)
def _prepare_sendgrid_data(self):
self.ensure_one()
s_mail = Mail()
s_mail.set_from(Email(self.email_from))
s_mail.set_reply_to(Email(self.reply_to))
s_mail.add_custom_arg(CustomArg('odoo_id', self.message_id))
html = self.body_html or ' '
p = re.compile(r'<.*?>') # Remove HTML markers
text_only = self.body_text or p.sub('', html.replace('<br/>', '\n'))
s_mail.add_content(Content("text/plain", text_only))
s_mail.add_content(Content("text/html", html))
test_address = config.get('sendgrid_test_address')
# TODO For now only one personalization (transactional e-mail)
personalization = Personalization()
personalization.set_subject(self.subject or ' ')
if not test_address:
if self.email_to:
personalization.add_to(Email(self.email_to))
for recipient in self.recipient_ids:
personalization.add_to(Email(recipient.email))
if self.email_cc:
personalization.add_cc(Email(self.email_cc))
else:
_logger.info('Sending email to test address {}'.format(
test_address))
personalization.add_to(Email(test_address))
self.email_to = test_address
if self.sendgrid_template_id:
s_mail.set_template_id(self.sendgrid_template_id.remote_id)
for substitution in self.substitution_ids:
personalization.add_substitution(Substitution(
substitution.key, substitution.value))
s_mail.add_personalization(personalization)
for attachment in self.attachment_ids:
s_attachment = Attachment()
# Datas are not encoded properly for sendgrid
s_attachment.set_content(base64.b64encode(base64.b64decode(
attachment.datas)))
s_attachment.set_filename(attachment.name)
s_mail.add_attachment(s_attachment)
return s_mail.get()
def send_email(to, subject, html_content, files=None, dryrun=False, cc=None,
bcc=None, mime_subtype='mixed', sandbox_mode=False, **kwargs):
"""
Send an email with html content using sendgrid.
To use this plugin:
0. include sendgrid subpackage as part of your Airflow installation, e.g.,
pip install 'apache-airflow[sendgrid]'
1. update [email] backend in airflow.cfg, i.e.,
[email]
email_backend = airflow.contrib.utils.sendgrid.send_email
2. configure Sendgrid specific environment variables at all Airflow instances:
SENDGRID_MAIL_FROM={your-mail-from}
SENDGRID_API_KEY={your-sendgrid-api-key}.
"""
if files is None:
files = []
mail = Mail()
from_email = kwargs.get('from_email') or os.environ.get('SENDGRID_MAIL_FROM')
from_name = kwargs.get('from_name') or os.environ.get('SENDGRID_MAIL_SENDER')
mail.from_email = Email(from_email, from_name)
mail.subject = subject
mail.mail_settings = MailSettings()
if sandbox_mode:
mail.mail_settings.sandbox_mode = SandBoxMode(enable=True)
# Add the recipient list of to emails.
personalization = Personalization()
to = get_email_address_list(to)
for to_address in to:
personalization.add_to(Email(to_address))
if cc:
cc = get_email_address_list(cc)
for cc_address in cc:
personalization.add_cc(Email(cc_address))
if bcc:
bcc = get_email_address_list(bcc)
for bcc_address in bcc:
personalization.add_bcc(Email(bcc_address))
# Add custom_args to personalization if present
pers_custom_args = kwargs.get('personalization_custom_args', None)
if isinstance(pers_custom_args, dict):
for key in pers_custom_args.keys():
personalization.add_custom_arg(CustomArg(key, pers_custom_args[key]))
mail.add_personalization(personalization)
mail.add_content(Content('text/html', html_content))
categories = kwargs.get('categories', [])
for cat in categories:
mail.add_category(Category(cat))
# Add email attachment.
for fname in files:
basename = os.path.basename(fname)
attachment = Attachment()
attachment.type = mimetypes.guess_type(basename)[0]
attachment.filename = basename
attachment.disposition = "attachment"
attachment.content_id = '<{0}>'.format(basename)
with open(fname, "rb") as f:
attachment.content = base64.b64encode(f.read()).decode('utf-8')
mail.add_attachment(attachment)
_post_sendgrid_mail(mail.get())
def _build_sg_mail(self, email):
mail = Mail()
from_name, from_email = rfc822.parseaddr(email.from_email)
# Python sendgrid client should improve
# sendgrid/helpers/mail/mail.py:164
if not from_name:
from_name = None
mail.set_from(Email(from_email, from_name))
mail.set_subject(email.subject)
personalization = Personalization()
for e in email.to:
personalization.add_to(Email(e))
for e in email.cc:
personalization.add_cc(Email(e))
for e in email.bcc:
personalization.add_bcc(Email(e))
personalization.set_subject(email.subject)
mail.add_content(Content("text/plain", email.body))
if isinstance(email, EmailMultiAlternatives):
for alt in email.alternatives:
if alt[1] == "text/html":
mail.add_content(Content(alt[1], alt[0]))
elif email.content_subtype == "html":
mail.contents = []
mail.add_content(Content("text/plain", ' '))
mail.add_content(Content("text/html", email.body))
if hasattr(email, 'categories'):
for c in email.categories:
mail.add_category(Category(c))
if hasattr(email, 'custom_args'):
for k, v in email.custom_args.items():
mail.add_custom_arg(CustomArg(k, v))
if hasattr(email, 'template_id'):
mail.set_template_id(email.template_id)
if hasattr(email, 'substitutions'):
for key, value in email.substitutions.items():
personalization.add_substitution(Substitution(key, value))
# SendGrid does not support adding Reply-To as an extra
# header, so it needs to be manually removed if it exists.
reply_to_string = ""
for key, value in email.extra_headers.items():
if key.lower() == "reply-to":
reply_to_string = value
else:
mail.add_header({key: value})
# Note that if you set a "Reply-To" header *and* the reply_to
# attribute, the header's value will be used.
if not mail.reply_to and hasattr(email, "reply_to") and email.reply_to:
# SendGrid only supports setting Reply-To to a single address.
# See https://github.com/sendgrid/sendgrid-csharp/issues/339.
reply_to_string = email.reply_to[0]
# Determine whether reply_to contains a name and email address, or
# just an email address.
if reply_to_string:
reply_to_name, reply_to_email = rfc822.parseaddr(reply_to_string)
if reply_to_name and reply_to_email:
mail.set_reply_to(Email(reply_to_email, reply_to_name))
elif reply_to_email:
mail.set_reply_to(Email(reply_to_email))
for attachment in email.attachments:
if isinstance(attachment, MIMEBase):
attach = Attachment()
attach.set_filename(attachment.get_filename())
attach.set_content(base64.b64encode(attachment.get_payload()))
mail.add_attachment(attach)
elif isinstance(attachment, tuple):
attach = Attachment()
attach.set_filename(attachment[0])
base64_attachment = base64.b64encode(attachment[1])
if sys.version_info >= (3,):
attach.set_content(str(base64_attachment, 'utf-8'))
else:
attach.set_content(base64_attachment)
attach.set_type(attachment[2])
mail.add_attachment(attach)
mail.add_personalization(personalization)
return mail.get()
def test_kitchenSink(self):
self.maxDiff = None
"""All settings set"""
mail = Mail()
mail.from_email = Email("*****@*****.**", "Example User")
mail.subject = "Hello World from the SendGrid Python Library"
personalization = Personalization()
personalization.add_to(Email("*****@*****.**", "Example User"))
personalization.add_to(Email("*****@*****.**", "Example User"))
personalization.add_cc(Email("*****@*****.**", "Example User"))
personalization.add_cc(Email("*****@*****.**", "Example User"))
personalization.add_bcc(Email("*****@*****.**"))
personalization.add_bcc(Email("*****@*****.**"))
personalization.subject = "Hello World from the Personalized SendGrid Python Library"
personalization.add_header(Header("X-Test", "test"))
personalization.add_header(Header("X-Mock", "true"))
personalization.add_substitution(
Substitution("%name%", "Example User"))
personalization.add_substitution(Substitution("%city%", "Denver"))
personalization.add_custom_arg(CustomArg("user_id", "343"))
personalization.add_custom_arg(CustomArg("type", "marketing"))
personalization.send_at = 1443636843
mail.add_personalization(personalization)
personalization2 = Personalization()
personalization2.add_to(Email("*****@*****.**", "Example User"))
personalization2.add_to(Email("*****@*****.**", "Example User"))
personalization2.add_cc(Email("*****@*****.**", "Example User"))
personalization2.add_cc(Email("*****@*****.**", "Example User"))
personalization2.add_bcc(Email("*****@*****.**"))
personalization2.add_bcc(Email("*****@*****.**"))
personalization2.subject = "Hello World from the Personalized SendGrid Python Library"
personalization2.add_header(Header("X-Test", "test"))
personalization2.add_header(Header("X-Mock", "true"))
personalization2.add_substitution(
Substitution("%name%", "Example User"))
personalization2.add_substitution(Substitution("%city%", "Denver"))
personalization2.add_custom_arg(CustomArg("user_id", "343"))
personalization2.add_custom_arg(CustomArg("type", "marketing"))
personalization2.send_at = 1443636843
mail.add_personalization(personalization2)
mail.add_content(Content("text/plain", "some text here"))
mail.add_content(
Content(
"text/html",
"<html><body>some text here</body></html>"))
attachment = Attachment()
attachment.content = "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4gQ3JhcyBwdW12"
attachment.type = "application/pdf"
attachment.filename = "balance_001.pdf"
attachment.disposition = "attachment"
attachment.content_id = "Balance Sheet"
mail.add_attachment(attachment)
attachment2 = Attachment()
attachment2.content = "BwdW"
attachment2.type = "image/png"
attachment2.filename = "banner.png"
attachment2.disposition = "inline"
attachment2.content_id = "Banner"
mail.add_attachment(attachment2)
mail.template_id = "13b8f94f-bcae-4ec6-b752-70d6cb59f932"
mail.add_section(
Section(
"%section1%",
"Substitution Text for Section 1"))
mail.add_section(
Section(
"%section2%",
"Substitution Text for Section 2"))
mail.add_header(Header("X-Test1", "test1"))
mail.add_header(Header("X-Test3", "test2"))
mail.add_header({"X-Test4": "test4"})
mail.add_category(Category("May"))
mail.add_category(Category("2016"))
mail.add_custom_arg(CustomArg("campaign", "welcome"))
mail.add_custom_arg(CustomArg("weekday", "morning"))
mail.send_at = 1443636842
mail.batch_id = "sendgrid_batch_id"
mail.asm = ASM(99, [4, 5, 6, 7, 8])
mail.ip_pool_name = "24"
mail_settings = MailSettings()
mail_settings.bcc_settings = BCCSettings(
True, Email("*****@*****.**"))
mail_settings.bypass_list_management = BypassListManagement(True)
mail_settings.footer_settings = FooterSettings(
True,
"Footer Text",
"<html><body>Footer Text</body></html>")
mail_settings.sandbox_mode = SandBoxMode(True)
mail_settings.spam_check = SpamCheck(
True, 1, "https://spamcatcher.sendgrid.com")
mail.mail_settings = mail_settings
tracking_settings = TrackingSettings()
tracking_settings.click_tracking = ClickTracking(
True, True)
tracking_settings.open_tracking = OpenTracking(
True,
"Optional tag to replace with the open image in the body of the message")
tracking_settings.subscription_tracking = SubscriptionTracking(
True,
"text to insert into the text/plain portion of the message",
"<html><body>html to insert into the text/html portion of the message</body></html>",
"Optional tag to replace with the open image in the body of the message")
tracking_settings.ganalytics = Ganalytics(
True,
"some source",
"some medium",
"some term",
"some content",
"some campaign")
mail.tracking_settings = tracking_settings
mail.reply_to = Email("*****@*****.**")
expected_result = {
"asm": {
"group_id": 99,
"groups_to_display": [4, 5, 6, 7, 8]
},
"attachments": [
{
"content": "TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3"
"RldHVyIGFkaXBpc2NpbmcgZWxpdC4gQ3JhcyBwdW12",
"content_id": "Balance Sheet",
"disposition": "attachment",
"filename": "balance_001.pdf",
"type": "application/pdf"
},
{
"content": "BwdW",
"content_id": "Banner",
"disposition": "inline",
"filename": "banner.png",
"type": "image/png"
}
],
"batch_id": "sendgrid_batch_id",
"categories": [
"May",
"2016"
],
"content": [
{
"type": "text/plain",
"value": "some text here"
},
{
"type": "text/html",
"value": "<html><body>some text here</body></html>"
}
],
"custom_args": {
"campaign": "welcome",
"weekday": "morning"
},
"from": {
"email": "*****@*****.**",
"name": "Example User"
},
"headers": {
"X-Test1": "test1",
"X-Test3": "test2",
"X-Test4": "test4"
},
"ip_pool_name": "24",
"mail_settings": {
"bcc": {
"email": "*****@*****.**",
"enable": True
},
"bypass_list_management": {
"enable": True
},
"footer": {
"enable": True,
"html": "<html><body>Footer Text</body></html>",
"text": "Footer Text"
},
"sandbox_mode": {
"enable": True
},
"spam_check": {
"enable": True,
"post_to_url": "https://spamcatcher.sendgrid.com",
"threshold": 1
}
},
"personalizations": [
{
"bcc": [
{
"email": "*****@*****.**"
},
{
"email": "*****@*****.**"
}
],
"cc": [
{
"email": "*****@*****.**",
"name": "Example User"
},
{
"email": "*****@*****.**",
"name": "Example User"
}
],
"custom_args": {
"type": "marketing",
"user_id": "343"
},
"headers": {
"X-Mock": "true",
"X-Test": "test"
},
"send_at": 1443636843,
"subject": "Hello World from the Personalized SendGrid "
"Python Library",
"substitutions": {
"%city%": "Denver",
"%name%": "Example User"
},
"to": [
{
"email": "*****@*****.**",
"name": "Example User"
},
{
"email": "*****@*****.**",
"name": "Example User"
}
]
},
{
"bcc": [
{
"email": "*****@*****.**"
},
{
"email": "*****@*****.**"
}
],
"cc": [
{
"email": "*****@*****.**",
"name": "Example User"
},
{
"email": "*****@*****.**",
"name": "Example User"
}
],
"custom_args": {
"type": "marketing",
"user_id": "343"
},
"headers": {
"X-Mock": "true",
"X-Test": "test"
},
"send_at": 1443636843,
"subject": "Hello World from the Personalized SendGrid "
"Python Library",
"substitutions": {
"%city%": "Denver",
"%name%": "Example User"
},
"to": [
{
"email": "*****@*****.**",
"name": "Example User"
},
{
"email": "*****@*****.**",
"name": "Example User"
}
]
}
],
"reply_to": {
"email": "*****@*****.**"
},
"sections": {
"%section1%": "Substitution Text for Section 1",
"%section2%": "Substitution Text for Section 2"
},
"send_at": 1443636842,
"subject": "Hello World from the SendGrid Python Library",
"template_id": "13b8f94f-bcae-4ec6-b752-70d6cb59f932",
"tracking_settings": {
"click_tracking": {
"enable": True,
"enable_text": True
},
"ganalytics": {
"enable": True,
"utm_campaign": "some campaign",
"utm_content": "some content",
"utm_medium": "some medium",
"utm_source": "some source",
"utm_term": "some term"
},
"open_tracking": {
"enable": True,
"substitution_tag": "Optional tag to replace with the "
"open image in the body of the message"
},
"subscription_tracking": {
"enable": True,
"html": "<html><body>html to insert into the text/html "
"portion of the message</body></html>",
"substitution_tag": "Optional tag to replace with the open"
" image in the body of the message",
"text": "text to insert into the text/plain portion of"
" the message"
}
}
}
self.assertEqual(
json.dumps(mail.get(), sort_keys=True),
json.dumps(expected_result, sort_keys=True)
)
def _build_sg_mail(self, msg):
mail = Mail()
mail.from_email = Email(*self._parse_email_address(msg.from_email))
mail.subject = msg.subject
personalization = Personalization()
for addr in msg.to:
personalization.add_to(Email(*self._parse_email_address(addr)))
for addr in msg.cc:
personalization.add_cc(Email(*self._parse_email_address(addr)))
for addr in msg.bcc:
personalization.add_bcc(Email(*self._parse_email_address(addr)))
personalization.subject = msg.subject
for k, v in msg.extra_headers.items():
if k.lower() == "reply-to":
mail.reply_to = Email(v)
else:
personalization.add_header(Header(k, v))
if hasattr(msg, "template_id"):
mail.template_id = msg.template_id
if hasattr(msg, "substitutions"):
for k, v in msg.substitutions.items():
personalization.add_substitution(Substitution(k, v))
# write through the ip_pool_name attribute
if hasattr(msg, "ip_pool_name"):
if not isinstance(msg.ip_pool_name, basestring):
raise ValueError(
"ip_pool_name must be a string, got: {}; "
"see https://sendgrid.com/docs/API_Reference/Web_API_v3/Mail/"
"index.html#-Request-Body-Parameters".format(
type(msg.ip_pool_name)))
if not 2 <= len(msg.ip_pool_name) <= 64:
raise ValueError(
"the number of characters of ip_pool_name must be min 2 and max 64, got: {}; "
"see https://sendgrid.com/docs/API_Reference/Web_API_v3/Mail/"
"index.html#-Request-Body-Parameters".format(
len(msg.ip_pool_name)))
mail.ip_pool_name = msg.ip_pool_name
# write through the send_at attribute
if hasattr(msg, "send_at"):
if not isinstance(msg.send_at, int):
raise ValueError(
"send_at must be an integer, got: {}; "
"see https://sendgrid.com/docs/API_Reference/SMTP_API/scheduling_parameters.html#-Send-At".format(
type(msg.send_at)))
personalization.send_at = msg.send_at
mail.add_personalization(personalization)
if hasattr(msg, "reply_to") and msg.reply_to:
if mail.reply_to:
# If this code path is triggered, the reply_to on the sg mail was set in a header above
reply_to = Email(*self._parse_email_address(msg.reply_to))
if reply_to.email != mail.reply_to.email or reply_to.name != mail.reply_to.name:
raise ValueError("Sendgrid only allows 1 email in the reply-to field. " +
"Reply-To header value != reply_to property value.")
if not isinstance(msg.reply_to, basestring):
if len(msg.reply_to) > 1:
raise ValueError("Sendgrid only allows 1 email in the reply-to field")
mail.reply_to = Email(*self._parse_email_address(msg.reply_to[0]))
else:
mail.reply_to = Email(*self._parse_email_address(msg.reply_to))
for attch in msg.attachments:
attachment = Attachment()
if isinstance(attch, MIMEBase):
filename = attch.get_filename()
if not filename:
ext = mimetypes.guess_extension(attch.get_content_type())
filename = "part-{0}{1}".format(uuid.uuid4().hex, ext)
attachment.filename = filename
# todo: Read content if stream?
attachment.content = attch.get_payload().replace("\n", "")
attachment.type = attch.get_content_type()
content_id = attch.get("Content-ID")
if content_id:
# Strip brackets since sendgrid's api adds them
if content_id.startswith("<") and content_id.endswith(">"):
content_id = content_id[1:-1]
attachment.content_id = content_id
attachment.disposition = "inline"
else:
filename, content, mimetype = attch
attachment.filename = filename
# Convert content from chars to bytes, in both Python 2 and 3.
# todo: Read content if stream?
if isinstance(content, str):
content = content.encode('utf-8')
attachment.content = base64.b64encode(content).decode()
attachment.type = mimetype
mail.add_attachment(attachment)
msg.body = ' ' if msg.body == '' else msg.body
if isinstance(msg, EmailMultiAlternatives):
mail.add_content(Content("text/plain", msg.body))
for alt in msg.alternatives:
if alt[1] == "text/html":
mail.add_content(Content(alt[1], alt[0]))
elif msg.content_subtype == "html":
mail.add_content(Content("text/plain", " "))
mail.add_content(Content("text/html", msg.body))
else:
mail.add_content(Content("text/plain", msg.body))
if hasattr(msg, "categories"):
for cat in msg.categories:
mail.add_category(Category(cat))
if hasattr(msg, "asm"):
if "group_id" not in msg.asm:
raise KeyError("group_id not found in asm")
if "groups_to_display" in msg.asm:
mail.asm = ASM(msg.asm["group_id"], msg.asm["groups_to_display"])
else:
mail.asm = ASM(msg.asm["group_id"])
mail_settings = MailSettings()
mail_settings.sandbox_mode = SandBoxMode(self.sandbox_mode)
mail.mail_settings = mail_settings
tracking_settings = TrackingSettings()
tracking_settings.open_tracking = OpenTracking(self.track_email)
mail.tracking_settings = tracking_settings
return mail.get()
