def test_emails():
test_emails = ['*****@*****.**']
all_shows = shows_this_week()
text = all_shows_to_markdown(all_shows)
html = markdown(text)
today, next_week = week_interval()
tomorrow = today + relativedelta(days=+1)
date_format = "%m/%d"
responses = []
# make a secure connection to SendGrid
sg = SendGridClient(SENDGRID_USER, SENDGRID_PASSWORD, secure=True)
for email in test_emails:
# make a message object
message = Mail()
message.set_subject('NYC Jazz Digest: {} to {}'.format(tomorrow.strftime(date_format), next_week.strftime(date_format)))
message.set_html(html)
message.set_text(text)
message.set_from('NYC Jazz Digest <*****@*****.**>')
# add a recipient
message.add_to(email)
# use the Web API to send your message
responses.append(str(sg.send(message)))
return '\n'.join(responses)
class TestSendGrid(unittest.TestCase):
def setUp(self):
self.sg = SendGridClient(os.getenv('SG_USER'), os.getenv('SG_PWD'))
def test_send(self):
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject('test')
m.set_html('WIN')
m.set_text('WIN')
m.set_from('*****@*****.**')
m.add_substitution('subKey', 'subValue')
m.add_section('testSection', 'sectionValue')
m.add_category('testCategory')
m.add_unique_arg('testUnique', 'uniqueValue')
m.add_filter('testFilter', 'filter', 'filterValue')
m.add_attachment_stream('testFile', 'fileValue')
self.sg.send(m)
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"toname[]": ["John Doe"],
"html": "WIN",
"text": "WIN",
"subject": "test",
"files[testFile]": "fileValue",
"from": "*****@*****.**",
"headers": "",
"fromname": "",
"replyto": ""
}
''')
test_url['x-smtpapi'] = json.dumps(json.loads('''
{
"sub": {
"subKey": ["subValue"]
},
"section": {
"testSection":"sectionValue"
},
"category": ["testCategory"],
"unique_args": {
"testUnique":"uniqueValue"
},
"filters": {
"testFilter": {
"settings": {
"filter": "filterValue"
}
}
}
}
'''))
self.assertEqual(url, test_url)
def send_email(report, title):
API_KEY = os.environ.get('SENDGRID_KEY')
if API_KEY is None:
print 'No SendGrid API key found! Please set the SENDGRID_KEY env var'
sys.exit(1)
sg = SendGridClient(API_KEY, raise_errors=True)
# Backwards compatability for emails stored as strings, not lists
emails = report['project_details']['email']
if type(emails) is not list:
emails = [emails]
for address in emails:
message = Mail()
message.add_to(address)
message.set_subject(title)
message.set_html(generate_email_text(report))
message.set_from('STACKS <*****@*****.**>')
try:
sg.send(message)
except SendGridError as e:
print e
except SendGridClientError as e:
print e
except SendGridServerError as e:
print e
def __init__(self, api_key, sender, recipient):
self.api_key = api_key
self.sender = sender
self.recipient = recipient
from sendgrid import SendGridClient
self._sg = SendGridClient(self.api_key)
def send_digest():
sg = SendGridClient(SENDGRID_USER, SENDGRID_PASSWORD, secure=True)
responses = []
today, next_week = week_interval()
tomorrow = today + relativedelta(days=+1)
date_format = "%m/%d"
subject = 'NYC Jazz Digest: {} to {}'.format(tomorrow.strftime(date_format), next_week.strftime(date_format))
from_addr = 'NYC Jazz Digest <*****@*****.**>'
all_shows = shows_this_week()
text = all_shows_to_markdown(all_shows)
for user in User.query(User.opt_out == False).fetch():
unsubcribe_link = ROOT_URL + '/unsubscribe/' + user.uuid
unsubscribe_phrase = "\n\nClick [here]({}) to unsubscribe.".format(unsubcribe_link)
text += unsubscribe_phrase
html = markdown(text)
message = Mail()
message.set_subject(subject)
message.set_html(html)
message.set_text(text)
message.set_from(from_addr)
# add a recipient
message.add_to(user.email)
# use the Web API to send your message
responses.append(str(sg.send(message)))
return '\n'.join(responses)
def send_email(routes_to_report):
"""Send email using sendgrid."""
number_of_routes = len(routes_to_report)
if number_of_routes == 0:
return False
formatted_date = dt.datetime.utcnow().strftime("%A, %b %d")
rich_email_body = render_template("email.html",
routes=routes_to_report,
date=formatted_date)
sg = SendGridClient(config.SG_USERNAME,
config.SG_PASSWORD,
raise_errors=True)
formatted_time = dt.datetime.utcnow().strftime("%F %T")
subject = '({}): {} routes'
subject = subject.format(formatted_time, number_of_routes)
try:
message = Mail(to=config.TO_EMAIL,
subject=subject,
html=rich_email_body,
from_email=config.FROM_EMAIL)
status, msg = sg.send(message)
return msg
except SendGridClientError as e:
print 'Failed to send email: ', e
raise
def send_email(report, title):
API_KEY = os.environ.get('SENDGRID_KEY')
if API_KEY is None:
print 'No SendGrid API key found! Please set the SENDGRID_KEY env var'
sys.exit(1)
sg = SendGridClient(API_KEY, raise_errors=True)
# Backwards compatability for emails stored as strings, not lists
emails = report['project_details']['email']
if type(emails) is not list:
emails = [emails]
for address in emails:
message = Mail()
message.add_to(address)
message.set_subject(title)
message.set_html(generate_email_text(report))
message.set_from('STACKS <*****@*****.**>')
try:
sg.send(message)
except SendGridError as e:
print e
except SendGridClientError as e:
print e
except SendGridServerError as e:
print e
def __init__(self, api_key, sender, recipient):
"""Initialize the service."""
self.api_key = api_key
self.sender = sender
self.recipient = recipient
from sendgrid import SendGridClient
self._sg = SendGridClient(self.api_key)
def send_revocation_request_email(cfg, keyid, hex, user_email):
# Send message using sendgrid api
client = SendGridClient(cfg.config.sendgrid.api_key)
message = get_sendgrid_request_message(cfg, keyid, hex, user_email)
response = client.send(message)
# Return JSON success message (response[1]) and HTTP status (response[0])
return response[1], response[0]
def send_revocation_request_email(cfg, keyid, hex, user_email):
# Send message using sendgrid api
client = SendGridClient(cfg.config.sendgrid.api_key)
message = get_sendgrid_request_message(cfg, keyid, hex, user_email)
response = client.send(message)
# Return JSON success message (response[1]) and HTTP status (response[0])
return response[1], response[0]
def send(sender_mail, send_to, subject, html, text=None):
client = SendGridClient(current_app.config.get('SENDGRID_USERNAME'), current_app.config.get('SENDGRID_PASSWORD'))
message = Mail()
message.set_from(sender_mail)
message.add_to(send_to)
message.set_subject(subject)
message.set_html(html)
message.set_text(text)
client.send(message)
def recieve_result():
account_sid = "ACe36f8844f05de80021faa460764b6d33"
auth_token = "f22d67391209d2a4f8f54266cd721978"
client = TwilioRestClient(account_sid, auth_token)
global numberTwo
value = request.form
fromValue = value.get("From")
bodyValue = value.get("Body")
toValue = value.get("To")
# print "Body: " + bodyValue
# print "From: " + fromValue
# print "To: " + toValue
value = "True"
if str(bodyValue) == "An outage was reported in your area. We expect this to be resolved by 6pm today.":
value = "False"
elif str(bodyValue).strip().lower() == "yes":
value = "yes"
if value == "True":
htmlForEmail = '<html><body><img src="http://wedte.com/wp-content/uploads/2013/01/PowerOutage.jpg" alt="Power Outage"><p></p><p></p><h3> We think that your house may have a power outage. If this is true, simply reply to this e-mail with any response so that the Electricty Supplier can serve you faster. <p></p><br><br></h3></body></html>'
sg = SendGridClient(SendGridUserName, SendGridPassword)
message = Mail()
message.add_to(emailValue)
message.set_subject("Is there a Power Outage at your house?")
message.set_html(htmlForEmail)
message.set_from(FromEmail)
status, msg = sg.send(message)
message = client.messages.create(
body="We think that your house may have a power outage. If this is true, simply reply to this text with a 'yes' so that the Electricty Supplier can serve you faster.",
to=str(personalNumber), # Replace with your phone number
from_=str(number),
) # Replace with your Twilio number
elif value == "yes":
value = "True"
elif value == "no":
value = "False"
payload = {"powerOutage": value, "twilioNumber": number}
r = requests.post("http://ec2-54-68-73-74.us-west-2.compute.amazonaws.com:5000/powerreply", data=payload)
numberTwo = number
print str(value)
print numberTwo
return "Test"
def sendEmail(sender, recipient, subject, html, text) :
sg= SendGridClient('ecpf', 'Iheart1!', secure=True)
message = Mail()
message.set_subject(subject)
message.set_html(html)
message.set_text(text)
message.set_from(sender)
message.add_to(recipient)
sg.send(message)
return True
def sendEmail(sender, recipient, subject, html, text):
sg = SendGridClient('ecpf', 'Iheart1!', secure=True)
message = Mail()
message.set_subject(subject)
message.set_html(html)
message.set_text(text)
message.set_from(sender)
message.add_to(recipient)
sg.send(message)
return True
class EmailClient(object):
def __init__(self):
self.sg = SendGridClient(SG_API_KEY)
self.message = Mail()
self.message.set_from(SG_FROM)
self.message.set_from_name(SG_FROM_NAME)
def send_sg_email(self, correo):
# valores de envío
self.message.add_to(correo.correo)
self.message.add_to_name(correo.nombre_cliente)
self.message.set_subject(correo.asunto)
self.message.set_html(correo.html)
# valores personalizados
unique_args = {
'empresa': correo.empresa,
'rut_receptor': correo.rut_receptor,
'rut_emisor': correo.rut_emisor,
'tipo_envio': correo.tipo_envio,
'tipo_dte': correo.tipo_dte,
'numero_folio': correo.numero_folio,
'resolucion_receptor': correo.resolucion_receptor,
'resolucion_emisor': correo.resolucion_emisor,
'monto': correo.monto,
'fecha_emision': correo.fecha_emision,
'fecha_recepcion': correo.fecha_recepcion,
'estado_documento': correo.estado_documento,
'tipo_operacion': correo.tipo_operacion,
'tipo_receptor': correo.tipo_receptor,
}
self.message.set_unique_args(unique_args)
# Validacion de adjuntos
if correo.attachs:
for adjunto in correo.attachs:
adj = AttachModel.query(ancestor=adjunto).get()
self.message.add_attachment_stream(adj.nombre, adj.archivo)
# enviando el mail
status, msg = self.sg.send(self.message)
# imprimiendo respuesta
logging.info(status)
logging.info(msg)
def send_mail_to_user_attach(self, correo):
# valores de envío
self.message.add_to(correo['email'])
self.message.add_to_name(correo['user_name'])
self.message.set_subject(correo['subject'])
self.message.set_html(correo['html'])
if correo['attach']:
self.message.add_attachment_stream(correo['attach']['name'], correo['attach']['file'])
status, msg = self.sg.send(self.message)
# imprimiendo respuesta
logging.info(status)
logging.info(msg)
def send_email(name: str, address: str, subject: str, template: str, values: dict) -> bool:
sg = SendGridClient(config.SENDGRID_API_USER, config.SENDGRID_API_KEY)
mail = Mail()
mail.set_from('tototo <*****@*****.**>')
mail.add_to(name + ' <' + address + '>')
mail.set_subject(subject)
mail.set_html(render_template(template, **values))
status, _ = sg.send(mail)
return status == 200
def send_email(name: str, address: str, subject: str, template: str,
values: dict) -> bool:
sg = SendGridClient(config.SENDGRID_API_USER, config.SENDGRID_API_KEY)
mail = Mail()
mail.set_from('tototo <*****@*****.**>')
mail.add_to(name + ' <' + address + '>')
mail.set_subject(subject)
mail.set_html(render_template(template, **values))
status, _ = sg.send(mail)
return status == 200
class SendgridNotificationService(BaseNotificationService):
def __init__(self, api_key, sender, recipient):
self.api_key = api_key
self.sender = sender
self.recipient = recipient
from sendgrid import SendGridClient
self._sg = SendGridClient(self.api_key)
def send_message(self, message='', **kwargs):
subject = kwargs.get(ATTR_TITLE)
from sendgrid import Mail
mail = Mail(from_email=self.sender, to=self.recipient,
html=message, text=message, subject=subject)
self._sg.send(mail)
def __init__(self): self.email_config = SendGridConfiguration.objects.all()[:1].get() self.sg = SendGridClient(self.email_config.api_key) self.message = Mail() self.message.set_from(self.email_config.email_from) self.message.set_from_name(self.email_config.email_from_name) self.message.set_subject(self.email_config.email_subject)
class SGEmailClient(object):
def __init__(self):
self.email_config = SendGridConfiguration.objects.all()[:1].get()
self.sg = SendGridClient(self.email_config.api_key)
self.message = Mail()
self.message.set_from(self.email_config.email_from)
self.message.set_from_name(self.email_config.email_from_name)
self.message.set_subject(self.email_config.email_subject)
def send_report_email(self, email, report):
template_config = TemplateReport.objects.all()[:1].get()
user = get_object_or_404(User, pk=email)
logger.info(user)
html = unicode(template_config.html_template).format(
user_name=user.first_name,
)
self.message.add_to(user.email)
self.message.add_to_name(user.first_name)
self.message.set_html(html)
if report['report']:
self.message.add_attachment_stream(
report['name'] , report['report']
)
status, msg = self.sg.send(self.message)
logger.info('{0} - {1}'.format(status, msg))
def __init__(self, sendgrid_account=None, sendgrid_password=None):
self.sg = SendGridClient(sendgrid_account,
sendgrid_password,
raise_errors=True)
self.sender = 'sendgrid'
self.to_put = []
self.to_delete = []
def send_email(self, request):
# make a secure connection to SendGrid
sg = SendGridClient(get_mail_username(), get_mail_pass(), secure=True)
# make a message object
message = Mail()
message.set_subject('message subject')
message.set_html('<strong>HTML message body</strong>')
message.set_text('plaintext message body')
message.set_from('*****@*****.**')
# add a recipient
message.add_to('John Doe <*****@*****.**>')
# use the Web API to send your message
sg.send(message)
return message_types.VoidMessage()
def send_email(self, request):
# make a secure connection to SendGrid
sg = SendGridClient(get_mail_username(), get_mail_pass(), secure=True)
# make a message object
message = Mail()
message.set_subject('message subject')
message.set_html('<strong>HTML message body</strong>')
message.set_text('plaintext message body')
message.set_from('*****@*****.**')
# add a recipient
message.add_to('John Doe <*****@*****.**>')
# use the Web API to send your message
sg.send(message)
return message_types.VoidMessage()
def post(self):
application_key = ndb.Key(urlsafe=self.request.get('form-key'))
application = application_key.get()
not_complete = self._not_complete()
if True in not_complete.values(): # If there is an error
self.response.set_status(204)
self._serve_page(errors=self._not_complete())
else:
applicant = self.user
application.submit_time = datetime.now()
application.put()
config = ndb.Key(Settings, 'config').get()
sg = SendGridClient(config.sendgrid_username,
config.sendgrid_password,
secure=True)
verification_email = Mail(
from_name="NYDKC Awards Committee",
from_email="*****@*****.**",
subject="DKC Application Confirmation for %s %s" %
(applicant.first_name, applicant.last_name),
to=applicant.email)
template_values = {
'applicant': applicant,
'application': application
}
verification_email.set_html(
JINJA_ENVIRONMENT.get_template(
'confirmation-email.html').render(template_values))
htmlhandler = html2text.HTML2Text()
verification_email.set_text(
htmlhandler.handle(verification_email.html).encode("UTF+8"))
code, response = sg.send(verification_email)
response = json.loads(response)
if response["message"] == "error":
logging.error(("Problem with sending email to %s: " %
verification_email.to) +
str(response["errors"]))
self._serve_page()
return
self.redirect('/application')
def send_email(subject, body):
"""Send a message with stuff filled in for sleepybymail."""
client = SendGridClient(SENDGRID_USER, SENDGRID_PASS, raise_errors=True)
message = Mail(from_email=FROM_EMAIL,
to=TO_ADDR,
subject=subject,
html=body,
text=body)
status, msg = client.send(message)
if status == 200:
print "Message sent successfully."
if status != 200:
print "Message delivery failed."
print "status", status
print "msg", msg
def send_email(subject, body):
"""Send a message with stuff filled in for sleepybymail."""
client = SendGridClient(SENDGRID_USER, SENDGRID_PASS, raise_errors=True)
message = Mail(
from_email=FROM_EMAIL,
to=TO_ADDR,
subject=subject,
html=body,
text=body)
status, msg = client.send(message)
if status == 200:
print "Message sent successfully."
if status != 200:
print "Message delivery failed."
print "status", status
print "msg", msg
def sendEmailWithSendGrid(sender, to, subject, body, html):
# make a secure connection to SendGrid
sg = SendGridClient(username, password, secure=True)
# make a message object
message = Mail()
message.set_subject(subject)
message.set_html(html)
message.set_text(body)
message.set_from(sender)
# add a recipient
message.add_to(to)
logging.debug("message %s" % message)
# use the Web API to send your message
sg.send(message)
class SendgridNotificationService(BaseNotificationService):
"""Implement the notification service for email via Sendgrid."""
def __init__(self, api_key, sender, recipient):
"""Initialize the service."""
self.api_key = api_key
self.sender = sender
self.recipient = recipient
from sendgrid import SendGridClient
self._sg = SendGridClient(self.api_key)
def send_message(self, message='', **kwargs):
"""Send an email to a user via SendGrid."""
subject = kwargs.get(ATTR_TITLE)
from sendgrid import Mail
mail = Mail(from_email=self.sender, to=self.recipient,
html=message, text=message, subject=subject)
self._sg.send(mail)
def threshold_not_met(petitioner_id, organization, election, threshold, signatures, position, petition_email, admin_emails):
petitioner = netid2name(petitioner_id)
# Make a secure connection to SendGrid
sg = SendGridClient('harmonica1243', 'xqBrrnNqbGuvtEUpNRs3RePW', secure=True)
# Replace with the message that we want to send, such as the name of the person and the position
html_petition = '<p style="text-align: left;"><b>Dear ' + petitioner + ',</b></p><p style="text-align: center;">' \
'<p>Your petition no longer has the required number of signatures</p><ul><li><b>Organization:</b> ' \
+ organization + '</li><li><b>Election:</b> ' + election + '</li><li><b>Position:</b> ' + position + '</li>' \
'<li><b>Number of Signatures Required:</b> ' + threshold + '</li><li><b>Number of Signatures Obtained:</b> ' \
+ signatures + '</li></ul><p>Please contact the organization directly with any questions about the petition.' \
'</p></p><p style="text-align: left;"><b>Rice Apps Petitions</b></p>'
html_admin = '<p style="text-align: left;"><b>Dear Organization Administrator,</b></p><p style="text-align: center;">' \
'<p>This petition no longer has the required number of signatures</p><ul><li><b>Petition Creator:</b> ' \
+ petitioner + '</li><li><b>Organization:</b> ' + organization + '</li><li><b>Election:</b> ' + election + \
'</li><li><b>Position:</b> ' + position + '</li><li><b>Number of Signatures Required:</b> ' + threshold + \
'</li><li><b>Number of Signatures Obtained:</b> ' + signatures + '</li></ul><p>Please contact ' + ADMIN_ID + \
'@rice.edu with any questions.</p></p><p style="text-align: left;"><b>Rice Apps Petitions</b></p>'
# Make a message Object
message = Mail()
# Message Subject, Body and To
message.set_subject('Petition No Longer Has Enough Signatures')
message.set_html(html_petition)
message.set_from('*****@*****.**')
message.add_to('<' + petition_email + '>')
sg.send(message)
# Make a message Object
message = Mail()
# Message Subject, Body and To
message.set_subject('Petition No Longer Has Enough Signatures')
message.set_html(html_admin)
message.set_from('*****@*****.**')
for email in admin_emails:
message.add_to('<' + email + '>')
sg.send(message)
def send_email(subject='Test email', from_email='*****@*****.**', from_name='D. Goodwin', recipients=['*****@*****.**'], text_body='Hello from Flask', html_body='Hello from <b>Flask</b>'): from sendgrid import SendGridClient, Mail api_key = 'm3tr0pl4c3s' api_user = '******' sendgrid = SendGridClient(username=api_user, password=api_key, raise_errors=True, host='http://api.sendgrid.com', port=80, ) message = Mail() message.add_to(recipients) message.set_from(from_email) message.set_from_name(from_name) message.set_subject(subject) message.set_text(text_body) message.set_html(html_body) try: sendgrid.send(message) except Exception as e: print "fail: %s" %(e)
def post(self):
application_key = ndb.Key(urlsafe=self.request.get('form-key'))
application = application_key.get()
not_complete = self._not_complete()
if True in not_complete.values(): # If there is an error
self.response.set_status(204)
self._serve_page(errors=self._not_complete())
else:
applicant = self.user
application.submit_time = datetime.now()
application.put()
config = ndb.Key(Settings, 'config').get()
sg = SendGridClient(config.sendgrid_username, config.sendgrid_password, secure=True)
verification_email = Mail(from_name="NYDKC Awards Committee",
from_email="*****@*****.**",
subject="DKC Application Confirmation for %s %s" % (applicant.first_name, applicant.last_name),
to=applicant.email
)
template_values = {
'applicant': applicant,
'application': application
}
verification_email.set_html(JINJA_ENVIRONMENT.get_template('confirmation-email.html').render(template_values))
htmlhandler = html2text.HTML2Text()
verification_email.set_text(htmlhandler.handle(verification_email.html).encode("UTF+8"))
code, response = sg.send(verification_email)
response = json.loads(response)
if response["message"] == "error":
logging.error(("Problem with sending email to %s: " % verification_email.to) + str(response["errors"]))
self._serve_page()
return
self.redirect('/application')
def __init__(self, settings, db_manager, logger, info):
self._collection = 'users.pending'
super(PendingUser, self).__init__(settings, db_manager, logger, info)
for key in ('token', 'tries', 'auth_id', 'email'):
if key not in info:
raise ValueError('[%s] not found in info' % key)
#email settings
email_settings = self.settings['auth']['email']
username = email_settings['username']
password = email_settings['password']
self._sg = SendGridClient(username, password, raise_errors=True)
self._email_from = settings['email']['from']
self._domain = settings['server']['domain']
class PendingUser(BaseUser):
def __init__(self, settings, db_manager, logger, info):
self._collection = 'users.pending'
super(PendingUser, self).__init__(settings, db_manager, logger, info)
for key in ('token', 'tries', 'auth_id', 'email'):
if key not in info:
raise ValueError('[%s] not found in info' % key)
#email settings
email_settings = self.settings['auth']['email']
username = email_settings['username']
password = email_settings['password']
self._sg = SendGridClient(username, password, raise_errors=True)
self._email_from = settings['email']['from']
self._domain = settings['server']['domain']
def activate(self, token):
#TODO: add max tries for abuse protection
if is_equal(token, self.info['token']):
self.logger.debug('[%s] -> valid activation token', self.info['email'])
#valid activation, retrieve and remove document
user = self.db_manager.find_document('users.pending', {'email': self.info['email']})
#delete unwanted fields
del user['tries'], user['token']
if not self.db_manager.insert_document('users.active', user):
raise ActivationError("Couldn't activate user", 500)
#this way, if we can't insert user in active collection, he stays
# in pending
self.db_manager.remove_document('users.pending', {'email': self.info['email']})
else:
raise ActivationError('Bad token', 400)
def send_activation_mail(self):
message = Mail()
message.add_to(self.info['email'])
message.set_subject('UthPortal activation')
address = self.info['email']
token = self.info['token']
auth_id = self.info['auth_id']
self.logger.debug('domain: ' + self._domain)
#TODO: make some proper html
message.set_html(
"Please click on the following link to activate your account:\
<a href={0}/api/v1/users/activate?email={1}&token={2}>Activate</a>, \
This is your 8-digit unique user id: {3}\
Use this in your app, when asked for it.\
This id is used to personalize your push notifications.\
Please don't share this ID as it is supposed to be kept secret."\
.format(self._domain, address, token, auth_id))
message.set_text('Token: {0}, 8-digit: {1}'.format(token, auth_id))
message.set_from('UthPortal <%s>' % self._email_from)
try:
self._sg.send(message)
except SendGridError as error:
self.logger.error('SendGrid error: ' + str(error))
raise NetworkError("Cannot send activation-email.", 500)
except SendGridClientError as error:
self.logger.error('SendGrid CLIENT error: ' + error.args[1])
raise NetworkError('Cannot send activation e-mail.', 500)
except SendGridServerError as error:
self.logger.error('SendGrid SERVER error: [{0}] -> [{1}] ',format(
error.args[0],
error.args[1]
))
raise NetworkError('Mail server currently un-available', 503)
class TestSendGrid(unittest.TestCase):
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
self.maxDiff = None
def test_apikey_init(self):
sg = SendGridClient(SG_PWD)
self.assertEqual(sg.password, SG_PWD)
self.assertIsNone(sg.username)
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test_unicode_recipients(self):
recipients = [unicode('*****@*****.**'), unicode('*****@*****.**')]
m = Mail(to=recipients,
subject='testing',
html='awesome',
from_email='*****@*****.**')
mock = {'to[]': ['*****@*****.**', '*****@*****.**']}
result = self.sg._build_body(m)
self.assertEqual(result['to[]'], mock['to[]'])
def test_send(self):
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject('test')
m.set_html('WIN')
m.set_text('WIN')
m.set_from('*****@*****.**')
m.set_asm_group_id(42)
m.add_cc('*****@*****.**')
m.add_bcc('*****@*****.**')
m.add_substitution('subKey', 'subValue')
m.add_section('testSection', 'sectionValue')
m.add_category('testCategory')
m.add_unique_arg('testUnique', 'uniqueValue')
m.add_filter('testFilter', 'filter', 'filterValue')
m.add_attachment_stream('testFile', 'fileValue')
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"toname[]": ["John Doe"],
"html": "WIN",
"text": "WIN",
"subject": "test",
"files[testFile]": "fileValue",
"from": "*****@*****.**",
"cc[]": ["*****@*****.**"],
"bcc[]": ["*****@*****.**"]
}
''')
test_url['x-smtpapi'] = json.dumps(
json.loads('''
{
"sub": {
"subKey": ["subValue"]
},
"section": {
"testSection":"sectionValue"
},
"category": ["testCategory"],
"unique_args": {
"testUnique":"uniqueValue"
},
"filters": {
"testFilter": {
"settings": {
"filter": "filterValue"
}
}
},
"asm_group_id": 42
}
'''))
try:
self.assertItemsEqual(url, test_url)
except: # Python 3+
self.assertCountEqual(url, test_url)
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test__build_body_unicode(self):
"""test _build_body() handles encoded unicode outside ascii range"""
from_email = '\xd0\x9d\xd0\xb8\xd0\xba\xd0\[email protected]'
from_name = '\xd0\x9a\xd0\xbb\xd0\xb0\xd0\xb2\xd0\xb4\xd0\xb8\xd1\x8f'
subject = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
text = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
html = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject(subject)
m.set_html(html)
m.set_text(text)
m.set_from("%s <%s>" % (from_name, from_email))
url = self.sg._build_body(m)
self.assertEqual(from_email, url['from'])
self.assertEqual(from_name, url['fromname'])
self.assertEqual(subject, url['subject'])
self.assertEqual(text, url['text'])
self.assertEqual(html, url['html'])
def test_smtpapi_add_to(self):
'''Test that message.to gets a dummy address for the header to work'''
m = Mail()
m.smtpapi.add_to('*****@*****.**')
m.set_from('*****@*****.**')
m.set_subject('test')
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"subject": "test",
"from": "*****@*****.**"
}
''')
test_url['x-smtpapi'] = json.dumps(
json.loads('''
{
"to": ["*****@*****.**"]
}
'''))
self.assertEqual(url, test_url)
import stripe
app = Flask(__name__)
app.debug = True
app.config['SECRET_KEY'] = environ.get('SECRET_KEY')
app.config['STORMPATH_API_KEY_ID'] = environ.get('STORMPATH_API_KEY_ID')
app.config['STORMPATH_API_KEY_SECRET'] = environ.get(
'STORMPATH_API_KEY_SECRET')
app.config['STORMPATH_APPLICATION'] = environ.get('STORMPATH_APPLICATION')
app.config['STRIPE_SECRET_KEY'] = environ.get('STRIPE_SECRET_KEY')
app.config['STRIPE_PUBLISHABLE_KEY'] = environ.get('STRIPE_PUBLISHABLE_KEY')
app.config['COINBASE_API_KEY'] = environ.get('COINBASE_API_KEY')
sendgrid = SendGridClient(
environ.get('SENDGRID_USERNAME'),
environ.get('SENDGRID_PASSWORD'),
)
stormpath_manager = StormpathManager(app)
stormpath_manager.login_view = '.login'
stripe.api_key = app.config['STRIPE_SECRET_KEY']
##### Website
@app.route('/')
def index():
"""Basic home page."""
return render_template('index.html')
db.init_app(app)
migrate = Migrate(app, db)
manager = Manager(app)
def make_shell_context():
return dict(app=app, db=db, User=User, Region=Region, Place=Place)
manager.add_command('shell', Shell(make_context=make_shell_context))
manager.add_command('db', MigrateCommand)
# Register blueprints
app.register_blueprint(index.blueprint)
app.register_blueprint(region.blueprint)
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
hashids = Hashids(alphabet='abcdefghijklmnopqrstuvwxyz0123456789')
sendgrid = SendGridClient(secrets.SENDGRID_USERNAME, secrets.SENDGRID_PASSWORD)
if __name__ == '__main__':
manager.run()
def setUp(self):
self.sg = SendGridClient(os.getenv('SG_USER'), os.getenv('SG_PWD'))
def post(self):
applicant = self.user
application_key = ndb.Key(urlsafe=self.request.get('form-key'))
application = application_key.get()
if self._no_verify() or application.submit_time:
logging.info("Attempt to modify verification by %s", applicant.email)
self._serve_page()
return
task = self.request.get('task')
if task != 'applicant':
user_id = self.user.get_id()
token = self.user_model.create_signup_token(user_id)
verification_url = self.uri_for('verification', type='v', user_id=user_id, signup_token=token, _full=True)
logging.info(verification_url)
config = ndb.Key(Settings, 'config').get()
sg = SendGridClient(config.sendgrid_username, config.sendgrid_password, secure=True)
verification_email = Mail(from_name="NYDKC Awards Committee",
from_email="*****@*****.**",
subject="Distinguished Key Clubber Application Verification for %s %s" % (applicant.first_name, applicant.last_name)
)
verifier = ""
if task == 'ltg':
application.verification_ltg_email = self.request.get('ltg-email')
application.verification_ltg_token = token
application.verification_ltg_sent = True
verification_email.add_to(application.verification_ltg_email)
verifier = "Lieutenant Governor " + applicant.ltg.title()
elif task == 'club-president':
application.verification_club_president_email = self.request.get('club-president-email')
application.verification_club_president_token = token
application.verification_club_president_sent = True
verification_email.add_to(application.verification_club_president_email)
verifier = "Club President " + applicant.club_president.title()
elif task == 'faculty-advisor':
application.verification_faculty_advisor_email = self.request.get('faculty-advisor-email')
application.verification_faculty_advisor_token = token
application.verification_faculty_advisor_sent = True
verification_email.add_to(application.verification_faculty_advisor_email)
verifier = "Faculty Advisor " + applicant.faculty_advisor.title()
template_values = {
'applicant': applicant,
'verification_url': verification_url,
'verifier': verifier
}
verification_email.set_html(JINJA_ENVIRONMENT.get_template('verification-email.html').render(template_values))
htmlhandler = html2text.HTML2Text()
verification_email.set_text(htmlhandler.handle(verification_email.html).encode("UTF+8"))
verification_email.add_unique_arg('user_id', user_id)
code, response = sg.send(verification_email)
response = json.loads(response)
if response["message"] == "error":
logging.error(("Problem with sending email to %s: " % verification_email.to) + str(response["errors"]))
self._serve_page()
return
else:
application.verification_applicant = True
application.verification_applicant_date = datetime.now()
application.put()
self._serve_page()
from flask import Flask, redirect, request, render_template, jsonify, make_response
from sendgrid import Mail, SendGridClient
import os
app = Flask('PostCards')
sg = SendGridClient(os.getenv('SG_USER'), os.getenv('SG_PWD'))
# Post Schema
# ID
# from
# image
posts = {}
@app.route('/', methods=['GET'])
def new_postcard():
ID = len(posts)
posts[ID] = {}
return redirect('/edit/%s' % ID, code=302)
@app.route('/edit/<int:ID>', methods=['GET', 'PUT'])
def edit_handler(ID):
if request.method == 'GET':
return render_template('postcard.html', post=posts[ID], editor=True)
else:
posts[ID] = request.get_json()
return jsonify(**posts[ID])
def set_sendgrid_client(self, sendgrid_account, sendgrid_password):
self.sg = SendGridClient(sendgrid_account,
sendgrid_password,
raise_errors=True)
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
def create_sendgrid():
return SendGridClient(Configuration.MAIL_USERNAME,
Configuration.MAIL_PASSWORD,
raise_errors=True)
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
self.maxDiff = None
class TestSendGrid(unittest.TestCase):
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
self.maxDiff = None
def test_apikey_init(self):
sg = SendGridClient(SG_PWD)
self.assertEqual(sg.password, SG_PWD)
self.assertIsNone(sg.username)
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test_unicode_recipients(self):
recipients = [unicode('*****@*****.**'), unicode('*****@*****.**')]
m = Mail(to=recipients,
subject='testing',
html='awesome',
from_email='*****@*****.**')
mock = {'to[]': ['*****@*****.**', '*****@*****.**']}
result = self.sg._build_body(m)
self.assertEqual(result['to[]'], mock['to[]'])
def test_send(self):
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject('test')
m.set_html('WIN')
m.set_text('WIN')
m.set_from('*****@*****.**')
m.set_asm_group_id(42)
m.add_cc('*****@*****.**')
m.add_bcc('*****@*****.**')
m.add_substitution('subKey', 'subValue')
m.add_section('testSection', 'sectionValue')
m.add_category('testCategory')
m.add_unique_arg('testUnique', 'uniqueValue')
m.add_filter('testFilter', 'filter', 'filterValue')
m.add_attachment_stream('testFile', 'fileValue')
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"toname[]": ["John Doe"],
"html": "WIN",
"text": "WIN",
"subject": "test",
"files[testFile]": "fileValue",
"from": "*****@*****.**",
"cc[]": ["*****@*****.**"],
"bcc[]": ["*****@*****.**"]
}
''')
test_url['x-smtpapi'] = json.dumps(json.loads('''
{
"sub": {
"subKey": ["subValue"]
},
"section": {
"testSection":"sectionValue"
},
"category": ["testCategory"],
"unique_args": {
"testUnique":"uniqueValue"
},
"filters": {
"testFilter": {
"settings": {
"filter": "filterValue"
}
}
},
"asm_group_id": 42
}
'''))
try:
self.assertItemsEqual(url, test_url)
except: # Python 3+
self.assertCountEqual(url, test_url)
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test__build_body_unicode(self):
"""test _build_body() handles encoded unicode outside ascii range"""
from_email = '\xd0\x9d\xd0\xb8\xd0\xba\xd0\[email protected]'
from_name = '\xd0\x9a\xd0\xbb\xd0\xb0\xd0\xb2\xd0\xb4\xd0\xb8\xd1\x8f'
subject = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
text = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
html = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject(subject)
m.set_html(html)
m.set_text(text)
m.set_from("%s <%s>" % (from_name, from_email))
url = self.sg._build_body(m)
self.assertEqual(from_email, url['from'])
self.assertEqual(from_name, url['fromname'])
self.assertEqual(subject, url['subject'])
self.assertEqual(text, url['text'])
self.assertEqual(html, url['html'])
def test_smtpapi_add_to(self):
'''Test that message.to gets a dummy address for the header to work'''
m = Mail()
m.smtpapi.add_to('*****@*****.**')
m.set_from('*****@*****.**')
m.set_subject('test')
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"subject": "test",
"from": "*****@*****.**"
}
''')
test_url['x-smtpapi'] = json.dumps(json.loads('''
{
"to": ["*****@*****.**"]
}
'''))
self.assertEqual(url, test_url)
import stripe
app = Flask(__name__)
app.debug = True
app.config['SECRET_KEY'] = environ.get('SECRET_KEY')
app.config['STORMPATH_API_KEY_ID'] = environ.get('STORMPATH_API_KEY_ID')
app.config['STORMPATH_API_KEY_SECRET'] = environ.get('STORMPATH_API_KEY_SECRET')
app.config['STORMPATH_APPLICATION'] = environ.get('STORMPATH_APPLICATION')
app.config['STRIPE_SECRET_KEY'] = environ.get('STRIPE_SECRET_KEY')
app.config['STRIPE_PUBLISHABLE_KEY'] = environ.get('STRIPE_PUBLISHABLE_KEY')
app.config['COINBASE_API_KEY'] = environ.get('COINBASE_API_KEY')
sendgrid = SendGridClient(
environ.get('SENDGRID_USERNAME'),
environ.get('SENDGRID_PASSWORD'),
)
stormpath_manager = StormpathManager(app)
stormpath_manager.login_view = '.login'
stripe.api_key = app.config['STRIPE_SECRET_KEY']
##### Website
@app.route('/')
def index():
"""Basic home page."""
return render_template('index.html')
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
celery = make_celery(app)
db = SQLAlchemy(app)
lm = LoginManager(app)
lm.login_view = 'index_page'
sg = SendGridClient(app.config['SENDGRID_USER'],
app.config['SENDGRID_API_KEY'])
hashids = Hashids(salt=app.config.get('HASHIDS_SALT'), min_length=8)
from app import views, tables, admins, apis # noqa: E402,F401
class LockedModelView(admins.AdminAccessModelView):
can_delete = False
class EditableModelView(admins.AdminAccessModelView):
page_size = 50
admin = Admin(app,
def test_apikey_init(self):
sg = SendGridClient(SG_PWD)
self.assertEqual(sg.password, SG_PWD)
self.assertIsNone(sg.username)
"""
Example of how to send a message.
"""
from sendgrid import SendGridClient, Mail
import quickieconfig as qc
SENDGRID_USER = qc.param("SENDGRID_USER")
SENDGRID_PASS = qc.param("SENDGRID_PASS")
FROM_EMAIL = qc.param("FROM_EMAIL")
TO_ADDR = qc.param("TARGET_EMAIL")
BODY = "foo"
client = SendGridClient(SENDGRID_USER, SENDGRID_PASS, raise_errors=True)
message = Mail(from_email=FROM_EMAIL, to=TO_ADDR, subject="test", text=BODY)
status, msg = client.send(message)
print "status", status
print "msg", msg
def setUp(self):
self.sg = SendGridClient(SG_USER, SG_PWD)
self.maxDiff = None
class TestSendGrid(unittest.TestCase):
def setUp(self):
self.sg = SendGridClient(os.getenv('SG_USER'), os.getenv('SG_PWD'))
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test_unicode_recipients(self):
recipients = [unicode('*****@*****.**'), unicode('*****@*****.**')]
m = Mail(to=recipients,
subject='testing',
html='awesome',
from_email='*****@*****.**')
mock = {'to[]': ['*****@*****.**', '*****@*****.**']}
result = self.sg._build_body(m)
self.assertEqual(result['to[]'], mock['to[]'])
def test_send(self):
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject('test')
m.set_html('WIN')
m.set_text('WIN')
m.set_from('*****@*****.**')
m.add_substitution('subKey', 'subValue')
m.add_section('testSection', 'sectionValue')
m.add_category('testCategory')
m.add_unique_arg('testUnique', 'uniqueValue')
m.add_filter('testFilter', 'filter', 'filterValue')
m.add_attachment_stream('testFile', 'fileValue')
url = self.sg._build_body(m)
url.pop('api_key', None)
url.pop('api_user', None)
url.pop('date', None)
test_url = json.loads('''
{
"to[]": ["*****@*****.**"],
"toname[]": ["John Doe"],
"html": "WIN",
"text": "WIN",
"subject": "test",
"files[testFile]": "fileValue",
"from": "*****@*****.**"
}
''')
test_url['x-smtpapi'] = json.dumps(json.loads('''
{
"sub": {
"subKey": ["subValue"]
},
"section": {
"testSection":"sectionValue"
},
"category": ["testCategory"],
"unique_args": {
"testUnique":"uniqueValue"
},
"filters": {
"testFilter": {
"settings": {
"filter": "filterValue"
}
}
}
}
'''))
self.assertEqual(url, test_url)
@unittest.skipUnless(sys.version_info < (3, 0), 'only for python2')
def test__build_body_unicode(self):
"""test _build_body() handles encoded unicode outside ascii range"""
from_email = '\xd0\x9d\xd0\xb8\xd0\xba\xd0\[email protected]'
from_name = '\xd0\x9a\xd0\xbb\xd0\xb0\xd0\xb2\xd0\xb4\xd0\xb8\xd1\x8f'
subject = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
text = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
html = '\xd0\x9d\xd0\xb0\xd0\xb4\xd0\xb5\xd0\xb6\xd0\xb4\xd0\xb0'
reply_to = '\xd0\x9d\xd0\xb8\xd0\xba\xd0\[email protected]'
m = Mail()
m.add_to('John, Doe <*****@*****.**>')
m.set_subject(subject)
m.set_html(html)
m.set_text(text)
m.set_from("%s <%s>" % (from_name, from_email))
url = self.sg._build_body(m)
self.assertEqual(from_email, url['from'])
self.assertEqual(from_name, url['fromname'])
self.assertEqual(subject, url['subject'])
self.assertEqual(text, url['text'])
self.assertEqual(html, url['html'])
def setup():
sg = SendGridClient(USER_NAME, PASSWORD)
return sg
from flask import (Flask, render_template, request, redirect, url_for,
session, jsonify, flash)
from flask.ext.bootstrap import Bootstrap
from flask.ext.pymongo import PyMongo
from sendgrid import SendGridClient, Mail, SendGridError
app = Flask(__name__)
app.config.from_object('config')
mongo = PyMongo(app)
sendgrid = SendGridClient(app.config['SENDGRID_USERNAME'],
app.config['SENDGRID_PASSWORD'],
raise_errors=True)
Bootstrap(app)
from forms import SendEmailForm
DEFAULT_EMAIL_TEXT = """This is an e-mail sent from sample-email-sender
Here is the sent info:
first_name: %s
last_name: %s
country: %s
city: %s
Goodbye!"""
@app.route('/', methods=['GET', 'POST'])
from pymongo import MongoClient
from sendgrid import Mail, SendGridClient, SendGridClientError, SendGridServerError
# Debug snippet:
import pprint
debug_printer = pprint.PrettyPrinter()
assert (platform.python_version_tuple()[0:2] == ('3', '3'))
if 'MONGOLAB_URI' in os.environ: # prod
client = MongoClient(os.environ.get('MONGOLAB_URI'))
else: # dev
client = MongoClient(os.environ.get('MONGODB_URI'))
sg = SendGridClient(os.environ.get('SENDGRID_ORANGE_KEY'), raise_errors=True)
db = client.get_default_database()
alert_text = "Tomorrow's weather earned a score of {}, which beats the threshold of {}. Visit https://saunter.io."
def send_alerts(score, threshold):
sub_list = db.subscribers.find_one({"_id": 13722})
for email in sub_list['emails']:
message = Mail()
message.add_to(email)
message.set_subject("Nice weather alert")
message.set_html(alert_text.format(score, threshold))
message.set_text(alert_text.format(score, threshold))
def post(self):
applicant = self.user
application_key = ndb.Key(urlsafe=self.request.get('form-key'))
application = application_key.get()
if self._no_verify() or application.submit_time:
logging.info("Attempt to modify verification by %s",
applicant.email)
self._serve_page()
return
task = self.request.get('task')
if task != 'applicant':
user_id = self.user.get_id()
token = self.user_model.create_signup_token(user_id)
verification_url = self.uri_for('verification',
type='v',
user_id=user_id,
signup_token=token,
_full=True)
logging.info(verification_url)
config = ndb.Key(Settings, 'config').get()
sg = SendGridClient(config.sendgrid_username,
config.sendgrid_password,
secure=True)
verification_email = Mail(
from_name="NYDKC Awards Committee",
from_email="*****@*****.**",
subject=
"Distinguished Key Clubber Application Verification for %s %s"
% (applicant.first_name, applicant.last_name))
verifier = ""
if task == 'ltg':
application.verification_ltg_email = self.request.get(
'ltg-email')
application.verification_ltg_token = token
application.verification_ltg_sent = True
verification_email.add_to(application.verification_ltg_email)
verifier = "Lieutenant Governor " + applicant.ltg.title()
elif task == 'club-president':
application.verification_club_president_email = self.request.get(
'club-president-email')
application.verification_club_president_token = token
application.verification_club_president_sent = True
verification_email.add_to(
application.verification_club_president_email)
verifier = "Club President " + applicant.club_president.title()
elif task == 'faculty-advisor':
application.verification_faculty_advisor_email = self.request.get(
'faculty-advisor-email')
application.verification_faculty_advisor_token = token
application.verification_faculty_advisor_sent = True
verification_email.add_to(
application.verification_faculty_advisor_email)
verifier = "Faculty Advisor " + applicant.faculty_advisor.title(
)
template_values = {
'applicant': applicant,
'verification_url': verification_url,
'verifier': verifier
}
verification_email.set_html(
JINJA_ENVIRONMENT.get_template(
'verification-email.html').render(template_values))
htmlhandler = html2text.HTML2Text()
verification_email.set_text(
htmlhandler.handle(verification_email.html).encode("UTF+8"))
verification_email.add_unique_arg('user_id', str(user_id))
code, response = sg.send(verification_email)
response = json.loads(response)
if response["message"] == "error":
logging.error(("Problem with sending email to %s: " %
verification_email.to) +
str(response["errors"]))
self._serve_page()
return
else:
application.verification_applicant = True
application.verification_applicant_date = datetime.now()
application.put()
self._serve_page()
