Example #1
0
    def _transmit(self, queue_item, subscriber):
        config = queue_item.get('destination', {}).get('config', {})

        try:
            # detect if it's been formatted by the Email formatter, is so load the item
            try:
                item = json.loads(queue_item['formatted_item'])
                if 'message_subject' not in item:
                    item = {}
            except:
                item = {}

            if not config.get('recipients'):
                raise PublishEmailError.recipientNotFoundError(LookupError('recipient field not found!'))

            admins = app.config['ADMINS']
            recipients = config.get('recipients').rstrip(';').split(';')

            subject = item.get('message_subject', 'Story: {}'.format(queue_item['item_id']))
            text_body = item.get('message_text', queue_item['formatted_item'])
            html_body = item.get('message_html', queue_item['formatted_item'])

            # sending email synchronously
            send_email(subject=subject,
                       sender=admins[0],
                       recipients=recipients,
                       text_body=text_body,
                       html_body=html_body)

        except Exception as ex:
            raise PublishEmailError.emailError(ex, queue_item.get('destination'))
Example #2
0
    def _transmit(self, queue_item, subscriber):
        config = queue_item.get('destination', {}).get('config', {})

        try:
            # detect if it's been formatted by the Email formatter, is so load the item
            try:
                item = json.loads(queue_item['formatted_item'])
                if 'message_subject' not in item:
                    item = {}
            except:
                item = {}

            if not config.get('recipients'):
                raise PublishEmailError.recipientNotFoundError(
                    LookupError('recipient field not found!'))

            admins = app.config['ADMINS']
            recipients = config.get('recipients').rstrip(';').split(';')

            subject = item.get('message_subject',
                               'Story: {}'.format(queue_item['item_id']))
            text_body = item.get('message_text', queue_item['formatted_item'])
            html_body = item.get('message_html', queue_item['formatted_item'])

            # sending email synchronously
            send_email(subject=subject,
                       sender=admins[0],
                       recipients=recipients,
                       text_body=text_body,
                       html_body=html_body)

        except Exception as ex:
            raise PublishEmailError.emailError(ex,
                                               queue_item.get('destination'))
Example #3
0
 def test_send_email_multiline_subject(self):
     with self.app.app_context():
         with self.app.mail.record_messages() as outbox:
             send_email("foo\nbar", "admin@localhost", ["*****@*****.**"],
                        "text", "<p>html</p>")
             assert len(outbox) == 1
             assert outbox[0].subject == "foo"
 def test_send_email_multiline_subject(self):
     with self.app.app_context():
         with self.app.mail.record_messages() as outbox:
             send_email('foo\nbar', 'admin@localhost', ['*****@*****.**'],
                        'text', '<p>html</p>')
             assert len(outbox) == 1
             assert outbox[0].subject == 'foo'
def _send_user_email(user_id, message):
    """
    Send a notification to the user email

    :param user_id:
    :param message:
    :return:
    """
    user = superdesk.get_resource_service('users').find_one(req=None,
                                                            _id=user_id)
    if not user:
        return

    # Check if the user has email notifications enabled
    preferences = superdesk.get_resource_service(
        'preferences').get_user_preference(user.get('_id'))
    email_notification = preferences.get(
        'email:notification', {}) if isinstance(preferences, dict) else {}

    if not email_notification.get('enabled', False):
        return

    user_email = user.get('email')
    if not user_email:
        return

    admins = app.config['ADMINS']

    send_email(subject='Superdesk assignment',
               sender=admins[0],
               recipients=[user_email],
               text_body=message,
               html_body=message)
Example #6
0
def _send_user_email(user_id, text_message, html_message, data):
    """
    Send a notification to the user email

    :param user_id:
    :param text_message:
    :param html_message:
    :return:
    """
    user = superdesk.get_resource_service('users').find_one(req=None,
                                                            _id=user_id)
    if not user:
        return

    # Check if the user has email notifications enabled
    preferences = superdesk.get_resource_service(
        'preferences').get_user_preference(user.get('_id'))
    email_notification = preferences.get(
        'email:notification', {}) if isinstance(preferences, dict) else {}

    if not email_notification.get('enabled', False):
        return

    user_email = user.get('email')
    if not user_email:
        return

    admins = app.config['ADMINS']

    # Determine if there are any files attached to the event and send them as attachments
    attachments = []
    if data.get('event') and data.get('event', {}).get('files'):
        for file_id in data.get('event', {}).get('files'):
            event_file = superdesk.get_resource_service(
                'events_files').find_one(req=None, _id=file_id)
            media = app.media.get(event_file['media'], resource='events_files')
            fp = media.read()
            attachments.append(
                Attachment(filename=media.name,
                           content_type=media.content_type,
                           data=fp))

    send_email(subject='Superdesk assignment',
               sender=admins[0],
               recipients=[user_email],
               text_body=text_message,
               html_body=html_message,
               attachments=attachments)
Example #7
0
    def _transmit(self, queue_item, subscriber):
        config = queue_item.get('destination', {}).get('config', {})

        try:
            if not config.get('recipients'):
                raise PublishEmailError.recipientNotFoundError(LookupError('recipient field not found!'))

            admins = app.config['ADMINS']
            recipients = config.get('recipients').rstrip(';').split(';')
            subject = "Story: {}".format(queue_item['item_id'])
            text_body = queue_item['formatted_item']

            # sending email synchronously
            send_email(subject=subject,
                       sender=admins[0],
                       recipients=recipients,
                       text_body=text_body,
                       html_body=None)

        except PublishEmailError:
            raise
        except Exception as ex:
            raise PublishEmailError.emailError(ex, queue_item.get('destination'))
Example #8
0
    def _transmit(self, queue_item, subscriber):
        config = queue_item.get('destination', {}).get('config', {})

        try:
            # detect if it's been formatted by the Email formatter, is so load the item
            try:
                item = json.loads(queue_item['formatted_item'])
                if 'message_subject' not in item:
                    item = {}
            except Exception:
                item = {}

            admins = app.config['ADMINS']
            recipients = [
                r.strip() for r in config.get('recipients', '').split(';')
                if r.strip()
            ]
            bcc = [
                r.strip() for r in config.get('recipients_bcc', '').split(';')
                if r.strip()
            ]
            if not recipients and not bcc:
                raise PublishEmailError.recipientNotFoundError(
                    LookupError('recipient and bcc fields are empty!'))

            subject = item.get('message_subject',
                               'Story: {}'.format(queue_item['item_id']))
            text_body = item.get('message_text', queue_item['formatted_item'])
            html_body = item.get('message_html', queue_item['formatted_item'])

            # Attach feature media if required
            attachments = []
            if config.get('attach_media') and item.get('renditions'):
                # The CID can be used to embbed the image in the html template email like <img src=CID:cid-value>
                cid = config.get('media_cid', '')
                # Get the rendition that has been nominated for attaching to the email
                rendition = config.get('media_rendition', '')
                media_item = item.get('renditions', {}).get(rendition)
                if media_item and rendition:
                    media = app.media.get(media_item['media'],
                                          resource='upload')
                    im = Image.open(media)
                    if config.get('watermark', False):
                        im = get_watermark(im)

                    binary = io.BytesIO()
                    im.save(binary, 'jpeg', quality=80)

                    attachments.append(
                        Attachment(filename=media.name,
                                   content_type=media.content_type,
                                   data=binary.getvalue(),
                                   headers=[('Content-ID', cid)]))

            # sending email synchronously
            send_email(subject=subject,
                       sender=admins[0],
                       recipients=recipients,
                       text_body=text_body,
                       html_body=html_body,
                       bcc=bcc,
                       attachments=attachments)

        except Exception as ex:
            raise PublishEmailError.emailError(ex,
                                               queue_item.get('destination'))
Example #9
0
    def _transmit(self, queue_item, subscriber):
        config = queue_item.get("destination", {}).get("config", {})

        try:
            # detect if it's been formatted by the Email formatter, is so load the item
            try:
                item = json.loads(queue_item["formatted_item"])
                if "message_subject" not in item:
                    item = {}
            except Exception:
                item = {}

            admins = app.config["ADMINS"]
            recipients = [r.strip() for r in config.get("recipients", "").split(";") if r.strip()]
            bcc = [r.strip() for r in config.get("recipients_bcc", "").split(";") if r.strip()]
            if not recipients and not bcc:
                raise PublishEmailError.recipientNotFoundError(LookupError("recipient and bcc fields are empty!"))

            subject = item.get("message_subject", "Story: {}".format(queue_item["item_id"]))
            text_body = item.get("message_text", queue_item["formatted_item"])
            html_body = item.get("message_html", queue_item["formatted_item"])

            # Attach feature media if required
            attachments = []
            if config.get("attach_media") and item.get("renditions"):
                # The CID can be used to embbed the image in the html template email like <img src=CID:cid-value>
                cid = config.get("media_cid", "")
                # Get the rendition that has been nominated for attaching to the email
                rendition = config.get("media_rendition", "")
                media_item = item.get("renditions", {}).get(rendition)
                if media_item and rendition:
                    media = app.media.get(media_item["media"], resource="upload")
                    im = Image.open(media)
                    if config.get("watermark", False):
                        im = get_watermark(im)

                    binary = io.BytesIO()
                    im.save(binary, "jpeg", quality=80)

                    attachments.append(
                        Attachment(
                            filename=media.name,
                            content_type=media.content_type,
                            data=binary.getvalue(),
                            headers=[("Content-ID", cid)],
                        )
                    )

            # sending email synchronously
            send_email(
                subject=subject,
                sender=admins[0],
                recipients=recipients,
                text_body=text_body,
                html_body=html_body,
                bcc=bcc,
                attachments=attachments,
            )

        except Exception as ex:
            raise PublishEmailError.emailError(ex, queue_item.get("destination"))
def _send_user_email(user_id, contact_id, source, meta_message, data):
    """
    Send a notification to the user email

    :param user_id:
    :param text_message:
    :param html_message:
    :return:
    """
    email_address = None

    if contact_id:
        contact = superdesk.get_resource_service('contacts').find_one(
            req=None, _id=contact_id)
        email_address = next(iter(contact.get('contact_email') or []), None)
        data['recepient'] = contact
    elif user_id:
        user = superdesk.get_resource_service('users').find_one(req=None,
                                                                _id=user_id)
        data['recepient'] = user
        if not user:
            return

        # Check if the user has email notifications enabled
        preferences = superdesk.get_resource_service(
            'preferences').get_user_preference(user.get('_id'))
        email_notification = preferences.get(
            'email:notification', {}) if isinstance(preferences, dict) else {}

        if not email_notification.get('enabled', False):
            return

        email_address = user.get('email')

    if not email_address:
        return

    admins = app.config['ADMINS']

    data['subject'] = 'Superdesk assignment' + ': {}'.format(
        data.get('slugline') if data.get('slugline') else '')
    data['system_reciepient'] = get_assignment_acceptance_email_address()
    html_message = _get_email_message_html(source, meta_message, data)
    text_message = _get_email_message_string(source, meta_message, data)

    # Determine if there are any files attached to the event and send them as attachments
    attachments = []
    if data.get('event') and data.get('event', {}).get('files'):
        for file_id in data.get('event', {}).get('files'):
            event_file = superdesk.get_resource_service(
                'events_files').find_one(req=None, _id=file_id)
            media = app.media.get(event_file['media'], resource='events_files')
            fp = media.read()
            attachments.append(
                Attachment(filename=media.name,
                           content_type=media.content_type,
                           data=fp))

    if data.get('assignment') and (data['assignment'].get('planning',
                                                          {})).get('files'):
        for file_id in data['assignment']['planning']['files']:
            assignment_file = superdesk.get_resource_service(
                'planning_files').find_one(req=None, _id=file_id)
            if assignment_file:
                media = app.media.get(assignment_file['media'],
                                      resource='planning_files')
                fp = media.read()
                attachments.append(
                    Attachment(filename=media.name,
                               content_type=media.content_type,
                               data=fp))
            else:
                logger.error(
                    'File {} attached to assignment {} not found'.format(
                        file_id, data['assignment']['assignment_id']))

    if data.get('assignment') and (data['assignment'].get('planning',
                                                          {})).get('xmp_file'):
        file_id = data['assignment']['planning']['xmp_file']
        xmp_file = superdesk.get_resource_service('planning_files').find_one(
            req=None, _id=file_id)
        if xmp_file:
            media = app.media.get(xmp_file['media'], resource='planning_files')
            fp = media.read()
            attachments.append(
                Attachment(filename=media.name,
                           content_type=media.content_type,
                           data=fp))
        else:
            logger.error(
                'XMP File {} attached to assignment {} not found'.format(
                    data['assignment']['xmp_file'],
                    data['assignment']['assignment_id']))

    send_email(subject=data['subject'],
               sender=admins[0],
               recipients=[email_address],
               text_body=text_message,
               html_body=html_message,
               attachments=attachments)