예제 #1
0
def send_sendgrid_template(template_name, template_params, subject, sender_name, sender_email, recipient_name, recipient_email):
    '''Send a message via the SendGrid API.'''
    if template_name.strip() == 'share-to-recipient-web':
       logging.info('ignoring share to recipient message')
       return

    if template_name not in _TEMPLATE_NAME_TO_TEMPLATE_ID:
        logging.ing('template id not found for template name ' + template_name + ': ignoring message')
        return
    template_id = _TEMPLATE_NAME_TO_TEMPLATE_ID[template_name]

    mail = Mail()

    personalization = Personalization()
    personalization.add_to(Email(recipient_email))
    mail.add_personalization(personalization)

    sender_name = None
    if sender_email is None:
        sender_email = _FROM_ADDR
        sender_name = _FROM_NAME
    mail.set_from(Email(email=sender_email, name=sender_name))

    if subject:
        mail.set_subject(subject)

    mail.set_template_id(template_id)

    _send(mail)
예제 #2
0
def make_envelope(to, type, email_args):
    if current_app and current_app.config.get("TESTING"):
        return None

    from grant.user.models import User
    user = User.get_by_email(to)
    info = get_info_lookup[type](email_args)

    if user and 'subscription' in info:
        sub = info['subscription']
        if user and not is_subscribed(user.settings.email_subscriptions, sub):
            current_app.logger.debug(f'Ignoring send_email to {to} of type {type} because user is unsubscribed.')
            return None

    email = generate_email(type, email_args, user)
    mail = Mail(
        from_email=Email(SENDGRID_DEFAULT_FROM, SENDGRID_DEFAULT_FROMNAME),
        to_email=Email(to),
        subject=email['info']['subject'],
    )
    mail.add_content(Content('text/plain', email['text']))
    mail.add_content(Content('text/html', email['html']))

    mail.___type = type
    mail.___to = to

    return mail
예제 #3
0
    def _make_sendgrid_mail(self, message):
        mail = Mail()
        if message.sender:
            mail.from_email = Email(message.sender)
        else:
            mail.from_email = Email(self.default_sender)

        if message.subject:
            mail.subject = message.subject

        if message.recipients:
            if type(message.recipients) == list:
                personalization = Personalization()
                for recipient in message.recipients:
                    personalization.add_to(Email(recipient))
                mail.add_personalization(personalization)
            else:
                raise Exception("unsupported type yet")
        if message.body:
            mail.add_content(Content("text/plain", message.body))

        if message.html:
            mail.add_content(Content("text/html", message.html))

        if message.reply_to:
            mail.reply_to = Email(message.reply_to)

        return mail
예제 #4
0
def send_email(receiver_email, user_lang):
    """Send user account validation."""
    _ = gettext.translation(
        'account_validation',
        '/code/locale',
        languages=[user_lang]
    ).gettext
    sender = os.getenv('SENDER_EMAIL')

    token = jwt.encode(
        {'email': receiver_email},
        os.getenv('JWT_SECRET'),
        algorithm='HS512'
    ).decode('utf-8')

    validate_message = _((
        'Hi! Please, click on this <a href="{url}/{token}">link</a> '
        'to validate your account.'
    )).format(
        url=os.getenv('ACCOUNT_VALIDATION_URL'),
        token=token
    )

    sg = sendgrid.SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))
    from_email = Email(sender)
    to_email = Email(receiver_email)
    subject = _("ROAp: account validation")
    content = Content("text/html", validate_message)
    mail = Mail(from_email, subject, to_email, content)
    sg.client.mail.send.post(request_body=mail.get())
예제 #5
0
    def test_equality_email_name(self):
        address = "*****@*****.**"
        name = "SomeName"
        email1 = Email(address, name)
        email2 = Email(address, name)

        self.assertEqual(email1, email2)
예제 #6
0
def sendMail(scheduled_time, url, price, name):
    sg = sendgrid.SendGridAPIClient(
        apikey=
        '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'
    )
    from_email = Email("*****@*****.**")
    subject = "This is a test email."
    to_email = Email("*****@*****.**")
    content = Content('text/html', 'text')
    mail = Mail(from_email, subject, to_email, content)

    dynamic_template_data = {
        'name': name,
        "price": price,
        "date": "Denver",
        "firstName": name,
        'url': url
    }
    unixtime = time.mktime(scheduled_time.timetuple())
    mail.send_at = unixtime
    mail.personalizations[0].dynamic_template_data = dynamic_template_data
    # mail.personalizations[0].add_to(Email("*****@*****.**"))
    # mail.personalizations[0].add_substitution(Substitution('event[i].name', 'eat pray love'))
    # mail.personalizations[0].add_substitution(Substitution('event[i].price', '80'))
    # mail.personalizations[0].add_substitution(Substitution('event[i].date', '2018-Dec-14'))
    # mail.personalizations[0].add_substitution(Substitution('event[i].url', 'https://www.eventbrite.com/e/eat-pray-love-tickets-52187209348'))
    # mail.personalizations[0].add_substitution(Substitution('firstName', 'Bikram'))
    mail.template_id = "d-c9c69c9a4d164310a1c5f3c289b9d93c"
    try:
        sg.client.mail.send.post(request_body=mail.get())
    except urllib.HTTPError as e:
        e.read()
        exit()
예제 #7
0
def sender_reset_password(user, host):
    """
    Send the email to the user to reset his password.
    """
    link = f"{host}/user/reset_password/"
    data = {
        "code": user.check_code,
        "link": link,
        "username": str(user)
    }

    mail = Mail()
    mail.from_email = Email(
        os.environ.get('FROM_EMAIL'),
        os.environ.get('FROM_NAME_EMAIL')
    )
    mail.template_id = os.environ.get('ID_TEMPLATE_RESET_PASSWORD')
    mail.subject = "Réinitialisation de mot de passe."
    p = Personalization()
    p.add_to(Email(user.email, str(user)))
    p.dynamic_template_data = data
    mail.add_personalization(p)
    sg = SendGridAPIClient(api_key=os.environ.get('SENDGRID_API_KEY'))
    response = sg.client.mail.send.post(request_body=mail.get())

    return response
예제 #8
0
def send_mail(email, contact_name, company_name, telephone):
    # Create a text/plain message
    me = '*****@*****.**'
    you = '*****@*****.**'
    subject = u'[FRA] Demande de participation ({})'.format(company_name)
    text = u"""\
    Bonjour !

    Vous avez recu une nouvelle demande de participation !
    Nom du contact: {}
    Telephone: {}
    Nom de l'entreprise: {}
    Email: {}

    Cordialement,
    L'equipe Forum.
    """.format(contact_name, telephone, company_name, email)

    sg = sendgrid.SendGridAPIClient(apikey=os.environ.get('SENDGRID_API_KEY'))
    # Setting from, subject, content, reply to
    from_email = Email(me)
    to_email = Email(you)
    content = Content('text/plain', text)
    mail = Mail(from_email, subject, to_email, content)
    # Adding bcc
    mail.personalizations[0].add_bcc(Email('*****@*****.**'))
    # Sending email
    try:
        sg.client.mail.send.post(request_body=mail.get())
        return 'Email sent.'
    except:
        return 'Email not sent.'
예제 #9
0
    def test_helloEmail(self):
        self.maxDiff = None
        """Minimum required to send an email"""
        mail = Mail()

        mail.from_email = Email("*****@*****.**")

        mail.subject = "Hello World from the SendGrid Python Library"

        personalization = Personalization()
        personalization.add_to(Email("*****@*****.**"))
        mail.add_personalization(personalization)

        mail.add_content(Content("text/plain", "some text here"))
        mail.add_content(
            Content("text/html", "<html><body>some text here</body></html>"))

        self.assertEqual(
            json.dumps(mail.get(), sort_keys=True),
            '{"content": [{"type": "text/plain", "value": "some text here"}, '
            '{"type": "text/html", '
            '"value": "<html><body>some text here</body></html>"}], '
            '"from": {"email": "*****@*****.**"}, "personalizations": '
            '[{"to": [{"email": "*****@*****.**"}]}], '
            '"subject": "Hello World from the SendGrid Python Library"}')
def sendTests(email, assignment, assignment_type, event_list):
    from_email = Email("*****@*****.**")
    subject = "{} {}s".format(assignment, assignment_type)
    to_email = Email(email)
    content = Content("text/html", "Good Luck!")
    mail = Mail(from_email, subject, to_email, content)
    user = User.query.filter_by(email=email).first()
    mail.personalizations[0].add_substitution(Substitution("-name-", user.firstname.capitalize()))
    mail.personalizations[0].add_substitution(Substitution("-assignment-", assignment))
    mail.personalizations[0].add_substitution(Substitution("-assignment_types-", assignment_type+'s'))
    eventNum = len(event_list)
    for c in range(eventNum):
        mail.personalizations[0].add_substitution(Substitution("-Event{}name-".format(c+1), event_list[c][0]))
        mail.personalizations[0].add_substitution(Substitution("-Event{}Link-".format(c+1), event_list[c][1]))
    if eventNum == 1:
        mail.template_id = "8238dc2b-2da6-4006-90c4-9129416f9bba"
    elif eventNum == 2:
        mail.template_id = "21ad7fc8-3183-4a77-8509-bb06973f763f"
    elif eventNum == 3:
        mail.template_id = "ad7f080f-bffd-4314-a2ed-da86971b0cfb"
    elif eventNum == 4:
        mail.template_id = "19df88b3-25ef-4a16-bf51-519169cf70ab"
    response = sg.client.mail.send.post(request_body=mail.get())
    print(response.status_code)
    print(response.body)
    print(response.headers)
예제 #11
0
    def _build_sg_mail(self, email):
        mail = Mail()
        from_name, from_email = rfc822.parseaddr(email.from_email)
        # Python sendgrid client should improve
        # sendgrid/helpers/mail/mail.py:164
        if not from_name:
            from_name = None
        mail.set_from(Email(from_email, from_name))
        mail.set_subject(email.subject)

        personalization = Personalization()
        for e in email.to:
            personalization.add_to(Email(e))
        for e in email.cc:
            personalization.add_cc(Email(e))
        for e in email.bcc:
            personalization.add_bcc(Email(e))
        personalization.set_subject(email.subject)
        mail.add_content(Content("text/plain", email.body))
        if isinstance(email, EmailMultiAlternatives):
            for alt in email.alternatives:
                if alt[1] == "text/html":
                    mail.add_content(Content(alt[1], alt[0]))
        elif email.content_subtype == "html":
            mail.contents = []
            mail.add_content(Content("text/plain", ' '))
            mail.add_content(Content("text/html", email.body))

        if hasattr(email, 'categories'):
            for c in email.categories:
                mail.add_category(Category(c))

        if hasattr(email, 'template_id'):
            mail.set_template_id(email.template_id)
            if hasattr(email, 'substitutions'):
                for k, v in email.substitutions.items():
                    personalization.add_substitution(Substitution(k, v))

        for k, v in email.extra_headers.items():
            mail.add_header({k: v})

        for attachment in email.attachments:
            if isinstance(attachment, MIMEBase):
                attach = Attachment()
                attach.set_filename(attachment.get_filename())
                attach.set_content(base64.b64encode(attachment.get_payload()))
                mail.add_attachment(attach)
            elif isinstance(attachment, tuple):
                attach = Attachment()
                attach.set_filename(attachment[0])
                base64_attachment = base64.b64encode(attachment[1])
                if sys.version_info >= (3, ):
                    attach.set_content(str(base64_attachment, 'utf-8'))
                else:
                    attach.set_content(base64_attachment)
                attach.set_type(attachment[2])
                mail.add_attachment(attach)

        mail.add_personalization(personalization)
        return mail.get()
예제 #12
0
def sendgrid_email(user, recipient, subject, body):
    sg = sendgrid.SendGridAPIClient(apikey=SendGridAPIKey)
    from_email = Email(user)
    to_email = Email(recipient)
    content = Content("text/plain", body)
    mail = Mail(from_email, subject, to_email, content)
    response = sg.client.mail.send.post(request_body=mail.get())
    def send_email(self, to_email, from_email, subject, body):
        """Send the email

                :param to_email:   who the email is going to
                                   (e.g. 'First Last <*****@*****.**>')
                :param from_email: who the email is coming from
                                   (e.g. 'First Last <*****@*****.**>')
                :param subject:    the email subject line
                :param body:       the email body in HTML format
                :type to_email:    string
                :type from_email:  string
                :type subject:     string
                :type body:        string

                :returns: HTML status code and JSON message from SendGrid's API
                :rtype: Integer, JSON
        """
        from_email = Email(from_email)
        subject = subject
        to_email = Email(to_email)
        soup = BeautifulSoup(body, "html.parser")
        content = Content("text/plain", soup.get_text())
        mail = Mail(from_email, subject, to_email, content)
        response = self.sendgrid.client.mail.send.post(request_body=mail.get())
        return response.status_code, response.body
예제 #14
0
    def send_email_message(self, recipient, subject, html_message, text_message, sender_email, sender_name):
        """ Send email message via sendgrid-python.

        Args:
            recipient: Email address or tuple of (Name, Email-address).
            subject: Subject line.
            html_message: The message body in HTML.
            text_message: The message body in plain text.
        """

        if not current_app.testing:  # pragma: no cover
            try:
                # Prepare Sendgrid helper objects
                from sendgrid.helpers.mail import Email, Content, Substitution, Mail
                from_email = Email(sender_email, sender_name)
                to_email = Email(recipient)
                text_content = Content('text/plain', text_message)
                html_content = Content('text/html', html_message)
                # Prepare Sendgrid Mail object
                # Note: RFC 1341: text must be first, followed by html
                mail = Mail(from_email, subject, to_email, text_content)
                mail.add_content(html_content)
                # Send mail via the Sendgrid API
                response = self.sg.client.mail.send.post(request_body=mail.get())
                print(response.status_code)
                print(response.body)
                print(response.headers)
            except ImportError:
                raise ConfigError(SENDGRID_IMPORT_ERROR_MESSAGE)
            except Exception as e:
                print(e)
                print(e.body)
                raise
    def sendgrid_handler(self, queue_message, to_addrs_to_email_messages_map):
        self.logger.info(
            "Sending account:%s policy:%s %s:%s email:%s to %s" %
            (queue_message.get('account', ''), queue_message['policy']['name'],
             queue_message['policy']['resource'],
             str(len(queue_message['resources'])), queue_message['action'].get(
                 'template', 'default'), to_addrs_to_email_messages_map))

        from_email = Email(self.config['from_address'])
        subject = get_message_subject(queue_message)
        email_format = queue_message['action'].get('template_format', None)
        if not email_format:
            email_format = queue_message['action'].get(
                'template', 'default').endswith('html') and 'html' or 'plain'

        for email_to_addrs, email_content in six.iteritems(
                to_addrs_to_email_messages_map):
            for to_address in email_to_addrs:
                to_email = Email(to_address)
                content = Content("text/" + email_format, email_content)
                mail = Mail(from_email, subject, to_email, content)
                try:
                    self.sendgrid_client.client.mail.send.post(
                        request_body=mail.get())
                except (exceptions.UnauthorizedError,
                        exceptions.BadRequestsError) as e:
                    self.logger.warning(
                        "\n**Error \nPolicy:%s \nAccount:%s \nSending to:%s \n\nRequest body:"
                        "\n%s\n\nRequest headers:\n%s\n\n mailer.yml: %s" %
                        (queue_message['policy'],
                         queue_message.get('account', ''), email_to_addrs,
                         e.body, e.headers, self.config))
                    return False
        return True
예제 #16
0
    def post(self, request):
        email = request.data['username']
        user = User.objects.get(username=email)

        profile_id = user.profile.id
        profile = Profile.objects.get(id=profile_id)
        profile.password_reset_code = Profile.generate_password_reset_code()
        profile.save()
        url = 'https://bquest.ucladevx.com/password'
        if settings.DEBUG:
            url = 'http://*****:*****@bquest.ucladevx.com')
        to_email = Email(email)
        subject = 'BQuest User Password Reset'
        reset_link = "{}?code={}&userid={}".format(url,
                                                   profile.password_reset_code,
                                                   user.id)
        content = Content('text/html', 'N/A')
        mail = Mail(from_email, subject, to_email, content)
        mail.personalizations[0].add_substitution(
            Substitution('password_reset_link', reset_link))
        mail.template_id = PASSWORD_RESET_TEMPLATE

        sg = sendgrid.SendGridAPIClient(apikey=settings.SENDGRID_API_KEY)
        response = sg.client.mail.send.post(request_body=mail.get())
        if not (200 <= response.status_code < 300):
            raise ValidationError(
                {'sendgrid_status_code': response.status_code})
        return HttpResponse(status=200)
예제 #17
0
파일: app.py 프로젝트: colmarius/fwdform
def build_email(from_email, subject, to_email, message):
    """Sent email with Sendgrid"""
    mail = Mail(from_email=Email(from_email),
                subject=subject,
                to_email=Email(to_email),
                content=Content("text/plain", message))
    return mail
예제 #18
0
def send_mail(from_email,
              _to_email,
              subject,
              body,
              html=False,
              from_name="Gitcoin.co",
              cc_emails=None):
    """Send email via SendGrid."""
    # make sure this subscriber is saved
    if not settings.SENDGRID_API_KEY:
        print('No SendGrid API Key set. Not attempting to send email.')
        return
    to_email = _to_email
    get_or_save_email_subscriber(to_email, 'internal')

    # setup
    from_name = str(from_name)
    subject = str(subject)
    sg = sendgrid.SendGridAPIClient(apikey=settings.SENDGRID_API_KEY)
    from_email = Email(from_email, from_name)
    to_email = Email(to_email)
    contenttype = "text/plain" if not html else "text/html"

    # build content
    content = Content(contenttype, html) if html else Content(
        contenttype, body)
    if settings.IS_DEBUG_ENV:
        to_email = Email(
            settings.CONTACT_EMAIL
        )  # just to be double secret sure of what were doing in dev
        subject = _("[DEBUG] ") + subject
    mail = Mail(from_email, subject, to_email, content)
    response = None

    # build personalization
    p = Personalization()
    p.add_to(to_email)
    if cc_emails:  # only add CCif not in prod
        for cc_addr in set(cc_emails):
            cc_addr = Email(cc_addr)
            if settings.IS_DEBUG_ENV:
                cc_addr = to_email
            if cc_addr._email != to_email._email:
                p.add_to(cc_addr)
    mail.add_personalization(p)

    # debug logs
    print(f"-- Sending Mail '{subject}' to {_to_email}")

    # send mails
    try:
        response = sg.client.mail.send.post(request_body=mail.get())
    except UnauthorizedError:
        print(
            f'-- Sendgrid Mail failure - Unauthorized - Check sendgrid credentials'
        )
    except HTTPError as e:
        print(f'-- Sendgrid Mail failure - {e}')

    return response
def send_email(email, name):
    from_email = Email("*****@*****.**")
    to_email = Email(email)
    subject = SUBJECT
    content = Content("text/plain", BODY.format(name))
    mail = Mail(from_email, subject, to_email, content)
    response = sg.client.mail.send.post(request_body=mail.get())
예제 #20
0
def send_email(to_email, subject, body, from_email=FROM_EMAIL, html=True):
    # newlines get wrapped in email, use html
    body = body.replace('\n', '<br>')

    # if local no emails
    if settings.LOCAL:
        print('local env - no email, only print send_email args:')
        print('to_email: {}'.format(to_email))
        print('subject: {}'.format(subject))
        print('body: {}'.format(body))
        print('from_email: {}'.format(from_email))
        print('html: {}'.format(html))
        print()
        return

    from_email = Email(from_email)

    to_email = ADMIN_EMAIL if to_email == ME else to_email
    to_email = Email(to_email)

    type_ = html and "text/html" or "text/plain"

    content = Content(type_, body)

    mail = Mail(from_email, subject, to_email, content)

    response = sg.client.mail.send.post(request_body=mail.get())

    if str(response.status_code)[0] != '2':
        # TODO logging
        print('ERROR sending message, status_code {}'.format(
            response.status_code))

    return response
예제 #21
0
    def get_message(self, **kwargs):
        """
        Get message object for email
        """
        config = get_configurations()
        message = Mail()
        if "from_email" in kwargs:
            sender = Email()
            message_content = kwargs.get("message_content", "")
            sender.name = kwargs.get("sender", config['SENDGRID']['sender'])
            sender.email = kwargs.get("from_email",
                                      config['SENDGRID']['fromemail'])
            message.from_email = sender
        if "subject" in kwargs:
            message.subject = kwargs.get("subject", "")
        if "text" in kwargs:
            content = Content("text/plain", kwargs.get("text", ""))
            message.add_content(content)
        if "html" in kwargs:
            content = Content("text/html", kwargs.get("html", ""))
            message.add_content(content)
        if "category" in kwargs:
            category = Category(kwargs.get("category", ""))
            message.add_category(category)

        personalization = self.create_personalization(**kwargs)
        if personalization:
            message.add_personalization(personalization)

        return message.get()
예제 #22
0
 def send_email(self, to_email, subject, content):
     from_email = Email('*****@*****.**')
     to_email = Email(to_email)
     content = Content('text/plain', content)
     email = Mail(from_email, subject, to_email, content)
     response = self.sg.client.mail.send.post(request_body=email.get())
     return response.status_code, response.body, response.headers
예제 #23
0
def mail_login_creds(user_profile):
    if not user_profile.user:
        username = user_profile.name.split(' ')[0] + str(user_profile.id)
        password = ''.join(choice(chars) for i in range(8))
        user = User.objects.create_user(username=username, password=password)
        user_profile.user = user
        user_profile.save()

        send_to = user_profile.email
        name = user_profile.name
        body = email_body.login_creds()
        body = body % (name, username, password)

        sg = sendgrid.SendGridAPIClient(apikey=SENDGRID_API_KEY)
        from_email = Email('*****@*****.**')
        to_email = Email(send_to)
        subject = "Login Credentials for your account on Alertify app"
        content = Content('text/html', body)

        try:
            mail = Mail(from_email, subject, to_email, content)
            response = sg.client.mail.send.post(request_body=mail.get())
            if response.status_code % 100 != 2:
                raise Exception
        except Exception:
            user_profile.user = None
            user_profile.save()
            user.delete()
            message = "Error in mailing your login credentials. Please try again."
            return message

        message = "Your login credentials have been sent to {0}.".format(
            send_to)
        return message
예제 #24
0
파일: utils.py 프로젝트: owngoal63/qp3
def send_email_using_SendGrid(sender,
                              receiver,
                              mail_subject,
                              mail_content,
                              cc_email=None):

    message = Mail(
        from_email=sender,
        #to_emails = receiver,			# Removed since it generates an extra email with SendGrid
        subject=mail_subject,
        html_content=mail_content)

    if cc_email:
        cc = Email(cc_email)
        to = Email(receiver)
        p = Personalization()
        p.add_to(to)
        p.add_cc(cc)
        message.add_personalization(p)
    else:  # no cc
        to = Email(receiver)
        p = Personalization()
        p.add_to(to)
        message.add_personalization(p)

    try:
        sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
        response = sg.send(message)
        print(response.status_code)
        print(response.body)
        print(response.headers)
    except Exception as e:
        print(e.message)

    return
예제 #25
0
파일: utils.py 프로젝트: yashdusing/EvalAI
def send_email(
    sender=settings.CLOUDCV_TEAM_EMAIL,
    recipient=None,
    template_id=None,
    template_data={},
):
    """Function to send email

    Keyword Arguments:
        sender {string} -- Email of sender (default: {settings.TEAM_EMAIL})
        recipient {string} -- Recipient email address
        template_id {string} -- Sendgrid template id
        template_data {dict} -- Dictionary to substitute values in subject and email body
    """
    try:
        sg = sendgrid.SendGridAPIClient(
            apikey=os.environ.get("SENDGRID_API_KEY")
        )
        sender = Email(sender)
        mail = Mail()
        mail.from_email = sender
        mail.template_id = template_id
        to_list = Personalization()
        to_list.dynamic_template_data = template_data
        to_email = Email(recipient)
        to_list.add_to(to_email)
        mail.add_personalization(to_list)
        sg.client.mail.send.post(request_body=mail.get())
    except Exception:
        logger.warning(
            "Cannot make sendgrid call. Please check if SENDGRID_API_KEY is present."
        )
    return
예제 #26
0
def send(to_email, subject, content):
    """
    Send an email.

    :param tuple to_email: email recipient address and name
    :param basestring subject: email subject
    :param basestring content: email content
    """
    if not get_secret('sendgrid_key'):
        # This is a test machine
        return

    try:
        if to_email[0].endswith('@gmail.com'):
            sg = sendgrid.SendGridAPIClient(apikey=get_secret('sendgrid_key'))
            content = Content('text/plain', content)
            mail = Mail(Email(*from_email), subject, Email(to_email[0]),
                        content)
            sg.client.mail.send.post(request_body=mail.get())
        else:
            conn = SMTP('127.0.0.1', 25)
            mail = Envelope(to_addr=to_email[0],
                            from_addr=from_email,
                            subject=subject,
                            text_body=content)
            conn.send(mail)
    except Exception:
        traceback.print_exc()
예제 #27
0
파일: tasks.py 프로젝트: Praneethm181/web
def create_ticket_message(ticket):
    event = ticket.article.event
    tmpl = loader.get_template('events/email/ticket_message.md')
    subject = 'Entrada para {}'.format(event.name)
    body = tmpl.render({
        'ticket': ticket,
        'article': ticket.article,
        'category': ticket.article.category,
        'event': event,
    })
    mail = Mail(from_email=Email(settings.CONTACT_EMAIL,
                                 settings.ASSOCIATION_NAME),
                subject=subject,
                to_email=Email(ticket.customer_email),
                content=Content('text/html', as_markdown(body)))

    attachment = Attachment()
    pdf_filename = ticket.as_pdf()
    with open(pdf_filename, 'rb') as f:
        data = f.read()
    attachment.content = base64.b64encode(data).decode()
    attachment.type = 'application/pdf'
    attachment.filename = 'ticket.pdf'
    attachment.disposition = 'attachment'
    mail.add_attachment(attachment)
    return mail
예제 #28
0
    def _create_email(self, email: dict, email_id: str) -> Mail:
        self.log_debug('converting email %s to sendgrid format', email_id)
        mail = Mail()
        personalization = Personalization()

        for i, to in enumerate(email.get('to', [])):
            personalization.add_to(Email(to))
            self.log_debug('added to %d to email %s', i, email_id)

        for i, cc in enumerate(email.get('cc', [])):
            personalization.add_cc(Email(cc))
            self.log_debug('added cc %d to email %s', i, email_id)

        for i, bcc in enumerate(email.get('bcc', [])):
            personalization.add_bcc(Email(bcc))
            self.log_debug('added bcc %d to email %s', i, email_id)

        mail.add_personalization(personalization)
        self.log_debug('added recipients to email %s', email_id)

        mail.subject = email.get('subject', '(no subject)')
        self.log_debug('added subject to email %s', email_id)

        mail.add_content(Content('text/html', email.get('body')))
        self.log_debug('added content to email %s', email_id)

        mail.from_email = Email(email.get('from'))
        self.log_debug('added from to email %s', email_id)

        for i, attachment in enumerate(email.get('attachments', [])):
            mail.add_attachment(self._create_attachment(attachment))
            self.log_debug('added attachment %d to email %s', i, email_id)

        self.log_debug('converted email %s to sendgrid format', email_id)
        return mail
예제 #29
0
    def test_equality_different_emails(self):
        address1 = "*****@*****.**"
        email1 = Email(address1)
        address2 = "*****@*****.**"
        email2 = Email(address2)

        self.assertNotEqual(email1, email2)
예제 #30
0
    def send_email(self, to_email, subject, from_email=None, html=None, text=None, *args, **kwargs):
        if not any([from_email, self.default_from]):
            raise ValueError("Missing from email and no default.")
        if not any([html, text]):
            raise ValueError("Missing html or text.")

        self.set_from(Email(from_email or self.default_from))
        self.set_subject(subject)

        personalization = Personalization()

        if type(to_email) is list:
            for email in self._extract_emails(to_email):
                personalization.add_to(email)
        elif type(to_email) is Email:
            personalization.add_to(to_email)
        elif type(to_email) is str:
            personalization.add_to(Email(to_email))

        self.add_personalization(personalization)

        content = Content("text/html", html) if html else Content("text/plain", text)
        self.add_content(content)

        return self.client.mail.send.post(request_body=self.get())
예제 #31
0
def send_sendgrid(sendgrid_api_key=None, github_email_template=None, github_user_emails=None):

    assert sendgrid_api_key, "SendGrid API key is required"

    sg = SendGridAPIClient(apikey=sendgrid_api_key)

    metadata = github_email_template.metadata

    from_email = Email(metadata['from'])
    from_email.name = metadata['from_name']
    for ge in github_user_emails:

        # Add github_user into metadata
        metadata['user'] = ge

        # Render content with metadata
        content = Content("text/html", github_email_template.render_content(metadata))

        # Render subject with metadata
        subject = template_env.from_string(metadata['subject']).render(metadata)

        to_email = Email(ge.email)
        mail = Mail(from_email, subject, to_email, content)
        _body = mail.get()

        # Add custom args for log fields
        _custon = {}
        for key, value in metadata.iteritems():
            if key not in ESSENTIAL_FIELDS:
                _custon[key] = value
        _custon['repository'] = metadata['repository']
        _body['custom_args'] = _custon

        response = sg.client.mail.send.post(request_body=_body)

        if response.status_code > 300:
            # More than 300 means something wrong, do nothing.
            sys.exit()
예제 #32
0
    def test_empty_obj_add_email(self):
        email = Email()
        address = "*****@*****.**"
        email.email = address

        self.assertEqual(email.email, address)
예제 #33
0
    def test_add_unicode_name_with_comma(self):
        email = Email()
        name = u"Name, Some"
        email.name = name

        self.assertEqual(email.name, u'"' + name + u'"')
예제 #34
0
    def test_empty_obj_add_name(self):
        email = Email()
        name = "SomeName"
        email.name = name

        self.assertEqual(email.name, name)
예제 #35
0
    def test_add_name_with_comma(self):
        email = Email()
        name = "Name, Some"
        email.name = name

        self.assertEqual(email.name, '"' + name + '"')