def send_email_verification(user, content):
try:
mandrill_client = mandrill.Mandrill(MANDRILL_API_KEY)
message = {
'from_email':
EMAIL_SENDER,
'from_name':
EMAIL_SENDER_NAME,
'headers': {
'Reply-To': EMAIL_SENDER
},
'html':
content,
'important':
True,
'subject':
'Electric Studio - Email Verification',
'to': [{
'email': user['email'],
'name': user['first_name'] + ' ' + user['last_name'],
'type': 'to'
}]
}
mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool')
except mandrill.Error:
raise
def __action(**kwargs):
redata = kwargs['redata']
jdata = kwargs['jdata']
if ShouldRun(redata, jdata):
to_address = redata['data']['to_address']
subject = redata['data']['subject']
body = redata['data']['body']
config = kwargs['config']
client = mandrill.Mandrill(config['mandrill_api_key'])
message = {
'from_email': '*****@*****.**',
'from_name': 'Runbook Notifications',
'subject': subject,
'text': body,
'to': [{
'email': to_address
}],
}
results = client.messages.send(message=message, async=True)
failures = []
for result in results:
if result['status'] not in _MANDRILL_SUCCESS_STATUSES:
failures.append('%s - %s' %
(result['email'], result['reject_reason']))
if failures:
raise Exception('Email notifications failed:\n%s' %
'\n'.join(failures))
return True
def send_email_template(template, user, context, subject, branch=None):
try:
mandrill_client = mandrill.Mandrill(MANDRILL_API_KEY)
message = {
'from_email':
EMAIL_SENDER,
'from_name':
EMAIL_SENDER_NAME,
'headers': {
'Reply-To': EMAIL_SENDER
},
'important':
True,
'subject':
'Electric Studio - ' + subject +
(' - {}'.format(branch) if branch else ''),
'to': [{
'email': user['email'],
'name': user['first_name'] + ' ' + user['last_name'],
'type': 'to'
}],
'global_merge_vars': []
}
for k, v in context.items():
message['global_merge_vars'].append({'name': k, 'content': v})
mandrill_client.messages.send_template(template, [], message)
except mandrill.Error:
raise
def send_email(user, content, subject, branch=None):
try:
mandrill_client = mandrill.Mandrill(MANDRILL_API_KEY)
message = {
'from_email':
EMAIL_SENDER,
'from_name':
EMAIL_SENDER_NAME,
'headers': {
'Reply-To': EMAIL_SENDER
},
'html':
content,
'important':
True,
'subject':
'Electric Studio - ' + subject +
(' - {}'.format(branch) if branch else ''),
'to': [{
'email': user['email'],
'name': user['first_name'] + ' ' + user['last_name'],
'type': 'to'
}]
}
mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool')
except mandrill.Error:
raise
def enviar_correo_mandrill(keyMandrill, from_email, from_name, html, subject,
tag, to_email, to_name):
try:
mandrill_client = mandrill.Mandrill(keyMandrill)
message = {
'from_email': from_email,
'from_name': from_name,
'html': html,
'important': False,
'merge': True,
'merge_language': 'mailchimp',
'subject': subject,
'tags': [tag],
'to': [{
'email': to_email,
'name': to_name,
'type': 'to'
}],
'track_clicks': True,
'track_opens': True,
'tracking_domain': None,
'url_strip_qs': None,
'view_content_link': None
}
result = mandrill_client.messages.send(message, False, 'Main Pool',
time.strftime("%H:%M:%S"))
except mandrill.Error as e:
print('A mandrill error occurred: %s - %s' % (e.__class__, e))
raise
def publish_message(self, message):
mandrill_client = mandrill.Mandrill(settings.EMAIL_MANDRILL.KEY)
try:
result = mandrill_client.messages.send(
message={
'to': [{'email': message.recipient}],
'from_email': message.sender,
'from_name': message.sender_name,
'html': message.content,
'subject': message.subject,
'headers': settings.EMAIL_MANDRILL.HEADERS,
'track_opens': settings.EMAIL_MANDRILL.TRACK_OPENS,
'auto_text': settings.EMAIL_MANDRILL.AUTO_TEXT,
'inline_css': settings.EMAIL_MANDRILL.INLINE_CSS,
'url_strip_qs': settings.EMAIL_MANDRILL.URL_STRIP_QS,
'preserve_recipients': settings.EMAIL_MANDRILL.PRESERVE_RECIPIENTS,
'view_content_link': settings.EMAIL_MANDRILL.VIEW_CONTENT_LINK,
'async': settings.EMAIL_MANDRILL.ASYNC,
'attachments': self._serialize_attachments(message)
},
)[0]
mandrill_state = result['status'].upper()
state = self.MANDRILL_STATES_MAPPING.get(mandrill_state)
error = self.MANDRILL_STATES.get_label(mandrill_state) if state == EmailMessage.STATE.ERROR else None
if mandrill_state == self.MANDRILL_STATES.REJECTED:
error += ', mandrill message: "{}"'.format(result['reject_reason'])
extra_sender_data = message.extra_sender_data or {}
extra_sender_data['result'] = result
self.update_message(message, state=state, sent_at=timezone.now(),
extra_sender_data=extra_sender_data, error=error)
except mandrill.Error as ex:
self.update_message(message, state=EmailMessage.STATE.ERROR, error=force_text(ex))
def send_report(report_dict: dict):
"""Send reports to emails defined in env file
"""
try:
if not environ.get('REPORT_FROM_EMAIL'):
logger.info(
'Sender email address not provided. Report will not be sent via email.'
)
return
mandrill_client = mandrill.Mandrill(environ.get('MANDRILL_API_KEY'))
message = {
'subject': environ.get('REPORT_EMAIL_SUBJECT', 'Tempcheck report'),
'from_email': environ.get('REPORT_FROM_EMAIL'),
'from_name': environ.get('REPORT_FROM_NAME', 'Tempcheck'),
'html': render_to_string('report.html',
report_dict,
using='jinja2'),
'preserve_recipients': False
}
to_emails = environ.get('REPORT_TO_EMAIL', '').split(',')
to_names = environ.get('REPORT_TO_NAME', '').split(',')
message['to'] = [{
'email': email.strip(),
'name': name.strip()
} for email, name in zip(to_emails, to_names)]
result = mandrill_client.messages.send(message)
logger.info(f'Mandrill Results:\n{result}')
logger.info('Report sent')
except mandrill.Error as error:
logger.error(error)
def send_constructed_mail(message, template_name=None):
try:
mandrill_client = mandrill.Mandrill(settings.MANDRILL_API_KEY)
if template_name:
del message['full_html']
return mandrill_client.messages.send_template(
template_name=template_name,
template_content=[{
'name': 'main',
'content': message['html']
}],
message=message,
async=False,
ip_pool='Main Pool',
)
else:
message['html'] = message['full_html']
del message['full_html']
return mandrill_client.messages.send(
message=message,
async=False,
ip_pool='Main Pool',
)
except mandrill.Error as e:
print('A mandrill error occurred: %s - %s' % (e.__class__, e))
return False
def send_email(to, subject, body):
mandrill_api_key = 'cwNBWRdwZIir-XXhG3gLVA'
mandrill_client = mandrill.Mandrill(mandrill_api_key)
try:
body = '<p>' + body.replace("\n", "<br>")
except Exception as e:
body = '<p>' + body
_message = dict()
_message['from_email'] = '*****@*****.**'
_message['from_name'] = 'Vidooly'
to = to.strip().split(",")
all_mail = []
for mail_id in to:
to_template = dict()
to_template['email'] = mail_id
to_template['type'] = 'to'
all_mail.append(to_template)
_message['to'] = all_mail
_message['subject'] = subject
_message['html'] = body
result = mandrill_client.messages.send(message=_message)
print result
def get(self):
invitee_email = self.request.get("invitee") or "*****@*****.**"
inviter_email = "*****@*****.**"
m = mandrill.Mandrill(
apikey=secrets.mandrillApiKey,
debug=True)
msg = {'subject': "Ei como vai?",
'from_email': '*****@*****.**',
'from_name': "Lantern Beta",
'to': [{'email': invitee_email}],
'track_opens': False,
'track_clicks': False,
'auto_text': True,
'url_slip_qs': True,
'preserve_recipients': False,
'bcc_address': '*****@*****.**',
'global_merge_vars': mergevarize(
{'INVITER_EMAIL': inviter_email,
'INVITER_NAME': "Estevo",
'OSXINSTALLERURL': 'https://example.com/lantern.dmg',
'WININSTALLERURL': 'https://example.com/lantern.exe',
'DEB32INSTALLERURL':
'https://example.com/lantern32.deb',
'DEB64INSTALLERURL':
'https://example.com/lantern64.deb'})}
res = self.response.write(
m.messages.send_template('cloud-invite', [], msg))
self.response.write(cgi.escape(repr(res)))
def mandrill_send(to=None, subject=None, message=None, reply_to=None):
try:
mandrill_client = mandrill.Mandrill(
c.config.getVal("console.mandrill_key"))
message = {
'auto_html': None,
'auto_text': None,
'from_email': '*****@*****.**',
'from_name': 'OpenCanary',
'text': message,
'subject': subject,
'to': [{
'email': to,
'type': 'to'
}],
}
if reply_to:
message["headers"] = {"Reply-To": reply_to}
result = mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool')
except mandrill.Error, e:
print 'Oliver: mandrill_send'
print 'A mandrill error occurred: %s - %s' % (e.__class__, e)
def sample_email():
imgurl = 'http://python.mfamt.org/files/images/pics/hoover-tower-fog.jpg'
img = requests.get(imgurl)
imgdata = b64encode(img.content)
MANDRILL_API_KEY = 'cwNBWRdwZIir-XXhG3gLVA'
mandrill_client = mandrill.Mandrill(MANDRILL_API_KEY)
message = { 'from_email': '*****@*****.**',
'from_name': 'Vidooly',
'to': [{
'email': '*****@*****.**',
'name': 'Whoever',
'type': 'to'
},
{
'email': '*****@*****.**',
'name': 'Whoever',
'type': 'to'
}
],
'subject': "Sending you a pic of Stanford campus",
'html': "<p>Here's a photo of the <a href='https://www.flickr.com/photos/zokuga/15138926354/'>Stanford campus</a>",
'attachments': [{'name': 'stanfordimage.jpg',
'type': 'image/jpeg',
'content': imgdata
}]
}
result = mandrill_client.messages.send(message = message)
print(result)
def send_mail():
mandrill_client = mandrill.Mandrill('Your Mandrill API key')
try:
message = {
'bcc_address':
'*****@*****.**',
'from_email':
'*****@*****.**',
'from_name':
'Brandon Walsh',
'to': [{
'email': '*****@*****.**',
'name': 'Recipient Name',
'type': 'to'
}],
'html':
'<p>' + socket.gethostbyname(socket.gethostname()) + '</p>',
'subject':
'RPi IP'
}
result = mandrill_client.messages.send(message=message,
async=False,
ip_pool='',
send_at='')
print result
except mandrill.Error, e:
# Mandrill errors are thrown as exceptions
print 'A mandrill error occurred: %s - %s' % (e.__class__, e)
# A mandrill error occurred: <class 'mandrill.UnknownSubaccountError'> - No subaccount exists with the id 'customer-123'
raise
def email_the_address():
try:
mandrill_client = mandrill.Mandrill('mXGeLCGXhGCrtiNMXCHCkQ')
subject_val = "Today's LB3K Address"
body_val = read_file()
print(subject_val)
print(body_val)
message = {
'from_name': 'SeamsLessComplicated',
'from_email': '*****@*****.**',
'subject': subject_val,
'to': [{'email': '*****@*****.**',
'name': 'Max Warner',
'type': 'to'},
{'email': '*****@*****.**',
'name': 'Adam Smith',
'type': 'to'},
{'email': '*****@*****.**',
'name': 'Jason Piercy',
'type': 'to'}],
'merge_language': 'mailchimp',
'text': body_val
}
result = mandrill_client.messages.send(message)
print(result)
if result[0]['status'] == 'sent' and result[0]['reject_reason'] == None:
sys.exit(0)
else:
sys.exit(1)
except mandrill.Error as e:
print("A mandrill error occurred: ", e)
raise
def mandrill_send(to=None, subject=None, message=None, reply_to=None):
try:
mandrill_client = mandrill.Mandrill(
c.config.getVal("console.mandrill_key"))
message = {
'auto_html': None,
'auto_text': None,
'from_email': '*****@*****.**',
'from_name': 'OpenCanary',
'text': message,
'subject': subject,
'to': [{
'email': to,
'type': 'to'
}],
}
if reply_to:
message["headers"] = {"Reply-To": reply_to}
# With Python 3.7 this line will fail because async is a reserved word
# The new line should be: result = mandrill_client.messages.send(message=message, asy=False, ip_pool='Main Pool')
result = mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool')
except mandrill.Error, e:
print('A mandrill error occurred: %s - %s' % (e.__class__, e))
def send_error_report():
try:
mandrill_client = mandrill.Mandrill(config['MANDRILL_KEY'])
message = {
'auto_html':
None,
'auto_text':
None,
'from_email':
'',
'from_name':
'',
'subject':
'500 Error on Route' + str(request.base_url),
'text':
'Master! It appears someone caused an internal error. :' +
str(request),
'to': [{
'email': config['MANDRILL_ADDRESS'],
'name': config['MANDRILL_ADDRESS_NAME'],
'type': 'to'
}],
}
result = mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool',
send_at='2012-01-05 12:42:01')
logger.info(result)
except mandrill.Error, e: # Mandrill errors are thrown as exceptions
logger.error('A mandrill error occurred: %s - %s' % (e.__class__, e))
def email_notification_for(restaurant_arrived_name):
try:
mandrill_client = mandrill.Mandrill('mXGeLCGXhGCrtiNMXCHCkQ')
subject_val = restaurant_arrived_name + ' is here!!'
print(subject_val)
print(restaurant_arrived_name)
message = {
'from_name':
'SeamsLessComplicated',
'from_email':
'*****@*****.**',
'subject':
subject_val,
'to': [{
'email': '*****@*****.**',
'name': 'Max Warner',
'type': 'to'
}],
'merge_language':
'mailchimp'
}
result = mandrill_client.messages.send(message)
print(result)
except mandrill.Error as e:
print("A mandrill error occurred: ", e)
raise
def contact():
message = {
'to': [{
'email': '*****@*****.**'
}],
'subject':
'Prise de contact sur le site de PromoMaker',
'from_email':
'*****@*****.**',
'html':
'<br>'.join([
'Prénom : %s' % request.form.get('firstname', ''),
'Nom : %s' % request.form.get('lastname', ''),
'Email : %s' % request.form.get('email', ''),
'Société : %s' % request.form.get('company', ''),
'Téléphone : %s' % request.form.get('phone', '')
])
}
if app.debug:
print(message)
else:
mandrill.Mandrill(MANDRILL_KEY).messages.send(message=message)
flash('Nous vous remercions pour votre demande. '
'Notre équipe va revenir vers vous dans les plus brefs délais.')
return redirect(url_for('page'))
def notify(self, recipient_email, first_name, last_name):
mandrill_client = mandrill.Mandrill(self.mandrill_api_key)
template_content = None
message = {
'subject': self.subject,
'from_email': self.from_email,
'from_name': self.from_name,
'to': [{
'email': recipient_email,
'name': first_name + ' ' + last_name
}],
'headers': {'Reply-To': self.from_email},
'important': False,
'track_opens': True,
'track_clicks': True,
'auto_text': True,
'inline_css': True,
'merge_language': 'handlebars',
'global_merge_vars': [{'name': 'first_name', 'content': first_name}]
}
try:
logging.debug('sending mandrill receipt template')
result = mandrill_client.messages.send_template(template_name='receipt-template',
template_content=template_content, message=message,
async=False)
return result
except mandrill.Error as e:
error_message = 'A mandrill error occurred: %s - %s' % (
e.__class__, e)
logging.exception(error_message, e)
# A mandrill error occurred: <class 'mandrill.InvalidKeyError'> -
# Invalid API key
raise
def send_email(email, link, expires_in):
try:
mandrill_client = mandrill.Mandrill(
environ.get('MANDRILL_API_KEY'))
message = {
'subject':
"Verify your account",
'from_email':
"*****@*****.**",
'from_name':
"Tempcheck",
'html':
"<p>Thank you for registering with us. " +
f"Click <a href='{link}'>here</a> " +
"to verify your account. Note that this link " +
f"will expire in {expires_in} hours.</p>",
"preserve_recipients":
False
}
message["to"] = [{"email": email.strip()}]
result = mandrill_client.messages.send(message)
logger.info(f'Mandrill Results:\n{result}')
logger.info('verification email sent')
except mandrill.Error as error:
logger.error(error)
return False
return True
def mandrill_send(self, msg=None, canarydrop=None):
try:
mandrill_client = mandrill.Mandrill(settings.MANDRILL_API_KEY)
message = {
'auto_html': None,
'auto_text': None,
'from_email': msg['from_address'],
'from_name': msg['from_display'],
'text': msg['body'],
'subject': msg['subject'],
'to': [{'email': canarydrop['alert_email_recipient'],
'name': '',
'type': 'to'}],
}
if settings.DEBUG:
pprint.pprint(message)
else:
result = mandrill_client.messages.send(message=message,
async=False,
ip_pool='Main Pool')
log.msg('Sent alert to {recipient} for token {token}'\
.format(recipient=canarydrop['alert_email_recipient'],
token=canarydrop.canarytoken.value()))
except mandrill.Error, e:
# Mandrill errors are thrown as exceptions
log.err('A mandrill error occurred: %s - %s' % (e.__class__, e))
def share():
if request.method == 'POST':
try:
email_address = request.form['emailAddress']
email_link = request.form['inviteLink']
mandrill_client = mandrill.Mandrill('your_key_here')
message = {
'from_email':
'*****@*****.**',
'to': [{
'email': email_address
}],
'html':
'<h4>You have been invited to a splitscreen session!</h4><p><a href='
+ email_link +
'>Join the session</a></p><p><img src="cid:logo"/></p>',
'subject':
'Invitation to a splitscreen session',
'images': [{
'content': surfly_encoded_logo,
'name': 'logo',
'type': 'image/png'
}]
}
result = mandrill_client.messages.send(message=message,
async=False)
return render_template('fourth_frame.html')
except mandrill.Error, e:
return render_template('error.html', error=e)
raise
def contact(request):
if request.method == 'POST':
form = forms.ContactForm(request.POST)
if form.is_valid():
try:
# send the contact information via Mandrill
m = mandrill.Mandrill(settings.MANDRILL_API_KEY)
m.messages.send({
'text':
form.cleaned_data.get('message'),
'subject':
form.cleaned_data.get('subject'),
'name':
form.cleaned_data.get('name'),
'from_email':
form.cleaned_data.get('email'),
'to': [{
'email': '*****@*****.**',
'name': 'Gabriel Key',
}],
})
logging.info('Sent contact email: {0}'.format(
form.cleaned_data))
except mandrill.InvalidKeyError, e:
logging.error('Cannot send contact email: {0}'.format(
form.cleaned_data))
logging.exception(e)
except mandrill.Error, e:
logging.error('Cannot send contact email: {0}'.format(
form.cleaned_data))
logging.exception(e)
return redirect('contact_complete')
def send_mail(orgnr):
orgnr = (orgnr, )
query = "SELECT email from brukere JOIN subs ON subs.bruker_id=brukere.id WHERE subs.orgnr_id=%s;"
cursor.execute(query, orgnr)
ret = [i[0] for i in cursor.fetchall() if i[0]]
api = config.api
mail = mandrill.Mandrill(api)
for i in ret:
print("Sent a mail to " + i + " because of org " + orgnr[0] + "!")
query = "SELECT orgnr, navn, addresse, tvangsavvikling, avvikling, konkurs from bedrifter where orgnr=%s;"
cursor.execute(query, orgnr)
data_ret = cursor.fetchall()[0]
status = statuser[data_ret[-3:].index("J")]
render = out_mail.render(orgnr=data_ret[0],
status=status,
navn=data_ret[1],
addresse=data_ret[2])
message = {
"from_email": "*****@*****.**",
"to": [{
"email": "*****@*****.**"
}],
"subject": "Konkurs varsel",
"html": render
}
mail.messages.send(message=message, async=True)
def __init__(self):
"""
Initialize the Mandrill connection.
"""
self.mandrill_client = mandrill.Mandrill(
local_settings.MANDRILL_API_KEY)
def _send_mail(template_name, email_to, context, tags):
project = context.get('project', '').lower()
test_proj_list = FI_TEST_PROJECTS.split(',')
new_context = _remove_test_projects(context, test_proj_list)
if project not in test_proj_list:
mandrill_client = mandrill.Mandrill(API_KEY)
message = {'to': [], 'global_merge_vars': [], 'merge_vars': []}
for email in email_to:
fname_mail = _get_recipient_first_name(email)
merge_var = {
'rcpt': email,
'vars': [{
'name': 'fname',
'content': fname_mail
}]
}
message['to'].append({'email': email})
message['merge_vars'].append(merge_var)
for key, value in new_context.items():
message['global_merge_vars'].append({
'name': key,
'content': value
})
message['tags'] = tags
mandrill_client.messages.send_template(template_name, [], message)
else:
# Mail should not be sent if is a test project
pass
def send_mandrill_mail(template_name, subject, email_to, email_vars=None, attachments=None, images=None):
if not email_vars:
email_vars = dict()
try:
mandrill_client = mandrill.Mandrill(MANDRILL_API_KEY)
message = {
'subject': subject,
'from_email': '*****@*****.**',
'from_name': 'MHacks',
'to': [{'email': email_to}],
'global_merge_vars': []
}
if attachments:
message['attachments'] = attachments
if images:
message['images'] = images
for k, v in email_vars.items():
message['global_merge_vars'].append(
{'name': k, 'content': v}
)
return mandrill_client.messages.send_template(template_name, [], message)
except mandrill.Error as e:
logger = logging.getLogger(__name__)
logger.error('A mandrill error occurred: %s - %s' % (e.__class__, e))
print('A mandrill error occurred: %s - %s' % (e.__class__, e))
raise
def send_mandrill(self, message):
_logger.warn('send_mandrill message %s' % str(message.keys()))
_logger.warn('send_mandrill get_content_maintype %s' %
str(message.get_content_maintype()))
mandrill_client = mandrill.Mandrill(tools.config.get('mandrill_key'))
name, email = parse_mail(message['From'])
name_to, email_to = parse_mail(message['To'])
mess = {}
mess['from_email'] = email
mess['from_name'] = name
#mess['headers']= {'Reply-To': message['Reply-To']}
mess['subject'] = message['Subject']
mess['to'] = [{'email': email_to, 'name': name_to, 'type': 'to'}]
text = None
html = None
for curr in message.walk():
if curr.get_content_type() == 'text/plain':
text = base64.b64decode(curr.get_payload())
if curr.get_content_type() == 'text/html':
html = base64.b64decode(curr.get_payload())
_logger.warn('walk text get_content_maintype %s' %
str(curr.get_content_maintype()))
_logger.warn('walk text payload %s' % str(curr.get_payload()))
_logger.warn('walk type %s' % str(curr.get_content_type()))
mess['html'] = html
mess['text'] = text
_logger.warn('send_mandrill mess %s' % str(mess))
result = mandrill_client.messages.send(message=mess, async=False)[0]
mess_id = message['Message-Id']
message_obj = self.env['mail.message'].search([('message_id', '=',
mess_id)])
if len(message_obj) > 0:
message_obj = message_obj[0]
else:
_logger.warn('dont found message for update with id %s' % mess_id)
return mess_id
message_obj.mandrill_status = result['status']
message_obj.mandrill_id = result['_id']
message_obj.mandrill_reject_reason = result['reject_reason']
#m_obj=self.env['mail.mail'].search([('mail_message_id', '=', message_obj.id)])
_logger.warn('send_mandrill result %s' % str(result))
_logger.warn('send_mandrill Message-Id %s' % str(mess_id))
return mess_id
def send_apt_info_email_to_consumer(consumer_info, nav_info,
scheduled_appointment, post_errors):
"""
This function takes a dictionary populated with data about a consumer appointment with a navigator, and sends a
confirmation email to the consumer.
:param consumer_info:
:param nav_info:
:param scheduled_appointment:
:param post_errors: (type: list) list of error messages
:return:
"""
try:
mandrill_client = mandrill.Mandrill('1veuJ5Rt5CtLEDj64ijXIA')
message_content = "Hello, you have an appointment scheduled with {!s} {!s} at {!s}. They will be contacting you at {!s}. We look forward to speaking with you!".format(
nav_info["first_name"], nav_info["last_name"],
scheduled_appointment["Appointment Date and Time"],
consumer_info["phone"])
message = {
'auto_html':
None,
'auto_text':
None,
'from_email':
'*****@*****.**',
'from_name':
'Patient Innovation Center',
'headers': {
'Reply-To': nav_info["email"]
},
'html':
'<p>{!s}</p>'.format(message_content),
'important':
True,
'subject':
scheduled_appointment["Appointment Title"],
# 'text': 'Example text content',
'to': [{
'email':
consumer_info["email"],
'name':
'{!s} {!s}'.format(consumer_info["first_name"],
consumer_info["last_name"]),
'type':
'to'
}],
}
result = mandrill_client.messages.send(message=message)
'''
[{'_id': 'abc123abc123abc123abc123abc123',
'email': '*****@*****.**',
'reject_reason': 'hard-bounce',
'status': 'sent'}]
'''
except mandrill.Error:
# Mandrill errors are thrown as exceptions
post_errors.append('A mandrill error occurred')
def __init__(self, *args, **kwargs):
self.client = mandrill.Mandrill(settings.MANDRILL_API_KEY)
self.email_template = kwargs.get('email_template')
self.email_tag = kwargs.get('email_tag')
self.merge_tags = kwargs.get('merge_tags')
self.merge_content = kwargs.get('merge_content')
self.from_name = kwargs.get('from_name', settings.DEFAULT_FROM_NAME)
super(MandrillEmailBackend, self).__init__(*args, **kwargs)
