Exemplo n.º 1
0
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)
Exemplo n.º 2
0
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
Exemplo n.º 3
0
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
Exemplo n.º 4
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 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
Exemplo n.º 6
0
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
Exemplo n.º 7
0
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)
Exemplo n.º 8
0
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)
Exemplo n.º 9
0
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
Exemplo n.º 10
0
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)
Exemplo n.º 11
0
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))
Exemplo n.º 12
0
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)
Exemplo n.º 13
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]
Exemplo n.º 14
0
    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()
Exemplo n.º 15
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]
Exemplo n.º 16
0
    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()
Exemplo n.º 17
0
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 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)
Exemplo n.º 19
0
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)
Exemplo n.º 20
0
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
Exemplo n.º 21
0
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)
Exemplo n.º 22
0
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
Exemplo n.º 23
0
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)
Exemplo n.º 24
0
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
Exemplo n.º 25
0
    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')
Exemplo n.º 26
0
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
Exemplo n.º 27
0
    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')
Exemplo n.º 28
0
    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()
Exemplo n.º 29
0
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)
Exemplo n.º 30
0
        return render_template('register.html', error=err.message)

    login_user(_user, remember=True)

    message = Mail(
        to=_user.email,
        subject='Welcome to BitRich!',
        text='',
        from_email='*****@*****.**',
    )
    message.set_html(
        render_template(
            'email/verification_email.html',
            user=user,
        ).encode('utf_8').decode('unicode_escape'))
    sendgrid.send(message)

    return redirect(url_for('dashboard'))


@app.route('/login', methods=['GET', 'POST'])
def login():
    """
    This view logs in a user given an email address and password.

    This works by querying Stormpath with the user's credentials, and either
    getting back the User object itself, or an exception (in which case well
    tell the user their credentials are invalid).

    If the user is valid, we'll log them in, and store their session for later.
    """
Exemplo n.º 31
0
    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()
Exemplo n.º 32
0
        # If something fails, we'll display a user-friendly error message.
        return render_template('register.html', error=err.message)

    login_user(_user, remember=True)

    message = Mail(
        to = _user.email,
        subject = 'Welcome to BitRich!',
        text = '',
        from_email = '*****@*****.**',
    )
    message.set_html(render_template(
        'email/verification_email.html',
        user = user,
    ).encode('utf_8').decode('unicode_escape'))
    sendgrid.send(message)

    return redirect(url_for('dashboard'))


@app.route('/login', methods=['GET', 'POST'])
def login():
    """
    This view logs in a user given an email address and password.

    This works by querying Stormpath with the user's credentials, and either
    getting back the User object itself, or an exception (in which case well
    tell the user their credentials are invalid).

    If the user is valid, we'll log them in, and store their session for later.
    """
Exemplo n.º 33
0
"""
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