예제 #1
0
    def send_email_notification(self, template, result):
        '''
         This function is called from ckanext-datarequest after a DataRequest is
         created, commented on or closed. The organization selected during the
         DataRequest creation is sent an email notification if an admin has
         added an email address for notification.
         '''
        context = self._get_context()
        data_dict = {
            'organization_id': result['organization'].get('name'),
            'success': True,
        }

        channels = toolkit.get_action(constants.EMAIL_CHANNELS_SHOW)(context, data_dict)
        if channels:
            extra_vars = {
                            'site_url': config.get('ckan.site_url'),
                            'site_title': config.get('ckan.site_title'),
                            'datarequest_url': result['datarequest_url'],
                            'datarequest_title': result['title'],
                            'datarequest_description': result['description'],
                            'action_type': template,
                        }

            email_subject = base.render_jinja2('notify/email/{}.txt'.format('subject'), extra_vars)
            email_body = base.render_jinja2('notify/email/{}.txt'.format(template), extra_vars)

            for channel in channels:
                channel = dotdict(channel)              
                mailer.mail_user(channel, email_subject, email_body)
예제 #2
0
def request_validation(admin, admin_email, resource_url):
    ''' Send request to specific user for data resource validation

    :param admin: The admin username
    :type admin: string
    :param admin_email: The admin email
    :type admin_email: string
    :param resource_url: The full URL to the resource
    :type resource_url: string
    '''
    if not admin:
        raise MailerException(_('Admin username not provided'))
    if not admin_email:
        raise MailerException(_('Admin email not provided'))
    if not resource_url:
        raise MailerException(_('Resource URL not provided'))

    site_title = config.get('ckan.site_title')
    body = render_jinja2('emails/request_access_body.txt', {
        'resource_url': resource_url,
        'site_title': site_title,
        'user_name': admin
    })
    subject = render_jinja2('emails/request_access_subject.txt',
                            {'site_title': site_title})
    subject = subject.split('\n')[0]

    mailer.mail_recipient(admin, admin_email, subject, body, headers={})
예제 #3
0
def notify_lockout(user):
    extra_vars = {
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
    }

    subject = render_jinja2('security/emails/lockout_subject.txt', extra_vars)
    subject = subject.split('\n')[0]  # Make sure we only use the first line

    body = render_jinja2('security/emails/lockout_mail.txt', extra_vars)

    mail_user(user, subject, body)
예제 #4
0
def news_subscription_create(context, data_dict):
    '''Create a subscription .

        :param notify_by_mail: Setting if user should be notified by mail for news.
        :type notify_by_mail: boolean, default False

        :returns: the newly created subscription object
        :rtype: dictionary

        '''

    l.check_access('news_subscription', context, data_dict)
    news_subscription_schema = schema.news_subscription_schema()
    data, errors = df.validate(data_dict, news_subscription_schema, context)

    if errors:
        raise t.ValidationError(errors)

    model = context['model']
    user = context['user']
    user_obj = model.User.get(user)

    notify_by_mail = data_dict.get('notify_by_mail', False)

    is_subscribed = ckanextNewsSubscriptions.get_subscription(user_obj.id)

    if is_subscribed:
        raise t.ValidationError('Subscribtion for user %s already exists!' %
                                user_obj.name)

    subscription = ckanextNewsSubscriptions(subscriber_id=user_obj.id,
                                            notify_by_mail=notify_by_mail)
    subscription.save()
    out = subscription.as_dict()
    send_email_condition = config.get('testing', False)
    if not send_email_condition:
        # Notify the user via email
        # TODO: E-mail notifications should be sent asynchronous using celery tasks
        # TODO: Setup email server for testing mode
        vars = {
            'site_title_dk': config_option_show('ckan.site_title', 'da_DK'),
            'site_title_en': config_option_show('ckan.site_title', 'en'),
            'site_url': config.get('ckan.site_url'),
            'user_name': user_obj.name
        }
        msg_body = render_jinja2('emails/news_subscriptions.txt', vars)
        msg_subject = render_jinja2('emails/news_subscriptions_subject.txt',
                                    vars)
        send_email(msg_body, user_obj.email, msg_subject)

    return out
def send_notification_emails(users, template, extra_vars):
    """
    Sets the email body and sends an email notification to each user in the list provided

    :param users: list of user email addresses to receive the notification
    :param template: string indicating which email template to use
    :param extra_vars: dict
    :return:
    """
    if users:
        subject = render_jinja2('emails/subjects/{0}.txt'.format(template), extra_vars)
        body = render_jinja2('emails/bodies/{0}.txt'.format(template), extra_vars)

        for user in users:
            toolkit.enqueue_job(send_email, [user, subject, body], title=u'Comment Email')
예제 #6
0
def prepare_error_mail(context, source_id, status, template):
    extra_vars = get_mail_extra_vars(context, source_id, status)
    body = render_jinja2(template, extra_vars)
    subject = '{} - Harvesting Job - Error Notification'\
              .format(config.get('ckan.site_title'))

    return subject, body
예제 #7
0
    def send_slack_notification(self, template, result):
        '''
        This function is called from ckanext-datarequest after a DataRequest is
        created, commented on or closed. The organization selected during the
        DataRequest creation is sent a slack notification if an admin has
        added Slack as a notification channel.
        '''

        context = self._get_context()
        organization = result.get('organization', None)
        data_dict = {
            'organization_id': organization['name'] if organization else '',
            'success': True,
        }

        channels = toolkit.get_action(constants.SLACK_CHANNELS_SHOW)(context, data_dict)
        if channels:
            extra_vars = {
                            'site_title': config.get('ckan.site_title'),
                            'datarequest_url': result['datarequest_url'],
                            'datarequest_title': result['title'],
                            'datarequest_description': result['description'],
                        }
            slack_message = {'text': base.render_jinja2('notify/slack/{}.txt'.format(template), extra_vars)}

            for channel in channels:
                requests.post(
                    channel['webhook_url'], data=json.dumps(slack_message),
                    headers={'Content-type': 'application/json'}
                )
예제 #8
0
def prepare_summary_mail(context, source_id, status):
    extra_vars = get_mail_extra_vars(context, source_id, status)
    body = render_jinja2('emails/summary_email.txt', extra_vars)
    subject = '{} - Harvesting Job Successful - Summary Notification'\
                  .format(config.get('ckan.site_title'))
    
    return subject, body
예제 #9
0
def notify_lockout(user, lockout_timeout):
    extra_vars = {
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
        'password_reset_url':
        config.get('ckan.site_url').rstrip('/') + '/user/login',
        'lockout_mins': lockout_timeout // 60,
    }

    subject = render_jinja2('security/emails/lockout_subject.txt', extra_vars)
    subject = subject.split('\n')[0]  # Make sure we only use the first line

    body = render_jinja2('security/emails/lockout_mail.txt',
                         extra_vars) + _build_footer_content(extra_vars)

    mail_user(user, subject, body)
예제 #10
0
def _compose_email_body(org_dict, user, event='request'):
    org_link = toolkit.url_for('data-container_read', id=org_dict['name'], qualified=True)
    return render_jinja2('emails/data_container_{0}.txt'.format(event), {
        'user_name': user.fullname or user.name,
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'org_title': org_dict['title'],
        'org_link': org_link,
    })
예제 #11
0
파일: mailer.py 프로젝트: xiaokaixi/ckan
def get_reset_link_body(user):
    extra_vars = {
        'reset_link': get_reset_link(user),
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
    }
    # NOTE: This template is translated
    return render_jinja2('emails/reset_password.txt', extra_vars)
예제 #12
0
def _get_reset_link_body(user):
    extra_vars = {
        'reset_link': get_reset_link(user),
        'site_title_dk': config_option_show('ckan.site_title', 'da_DK'),
        'site_title_en': config_option_show('ckan.site_title', 'en'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
    }
    return render_jinja2('emails/reset_password.txt', extra_vars)
예제 #13
0
파일: mailer.py 프로젝트: PublicaMundi/ckan
def get_reset_link_body(user):
    extra_vars = {
        'reset_link': get_reset_link(user),
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
    }
    # NOTE: This template is translated
    return render_jinja2('emails/reset_password.txt', extra_vars)
예제 #14
0
def get_reg_link_body(user):
    extra_vars = {
        'reg_link': get_reset_link(user),
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url') + '/' + h.lang(),
        'user_name': user.name,
        'tou_version': get_latest_legal_version('tou'),
        'privacy_version': get_latest_legal_version('privacy')
        }
    return render_jinja2('emails/user_registration.txt', extra_vars)
예제 #15
0
파일: mailer.py 프로젝트: xiaokaixi/ckan
def send_reset_link(user):
    create_reset_key(user)
    body = get_reset_link_body(user)
    extra_vars = {'site_title': config.get('ckan.site_title')}
    subject = render_jinja2('emails/reset_password_subject.txt', extra_vars)

    # Make sure we only use the first line
    subject = subject.split('\n')[0]

    mail_user(user, subject, body)
예제 #16
0
def compose_container_email_body(container, user, event):
    context = {}
    context['recipient'] = user.fullname or user.name
    context['site_title'] = config.get('ckan.site_title')
    context['site_url'] = config.get('ckan.site_url')
    context['container'] = container
    context['container_url'] = toolkit.url_for('data-container_read',
                                               id=container['name'],
                                               qualified=True)
    return render_jinja2('emails/container/%s.html' % event, context)
def _send_mail(user_ids, action_type, datarequest):

    for user_id in user_ids:
        try:
            user_data = model.User.get(user_id)
            extra_vars = {
                'datarequest': datarequest,
                'user': user_data,
                'site_title': config.get('ckan.site_title'),
                'site_url': config.get('ckan.site_url')
            }

            subject = base.render_jinja2('emails/subjects/{0}.txt'.format(action_type), extra_vars)
            body = base.render_jinja2('emails/bodies/{0}.txt'.format(action_type), extra_vars)

            mailer.mail_user(user_data, subject, body)

        except Exception:
            logging.exception("Error sending notification to {0}".format(user_id))
예제 #18
0
def get_registration_body(user):
    """set up text for user registration email"""
    extra_vars = {
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.get('name'),
        'display_name': user.get('display_name', user['name'])
    }
    # NOTE: This template is translated
    return render_jinja2('emails/registration.txt', extra_vars)
예제 #19
0
def _send_reset_link(user):
    create_reset_key(user)
    body = _get_reset_link_body(user)
    extra_vars = {
        'site_title_dk': config_option_show('ckan.site_title', 'da_DK'),
        'site_title_en': config_option_show('ckan.site_title', 'en')
    }
    subject = render_jinja2('emails/reset_password_subject.txt', extra_vars)
    subject = subject.split('\n')[0]
    mail_user(user, subject, body)
예제 #20
0
def _send_mail(user_ids, action_type, datarequest, job_title):
    for user_id in user_ids:
        try:
            user_data = model.User.get(user_id)
            extra_vars = {
                'datarequest': datarequest,
                'user': user_data,
                'site_title': config.get('ckan.site_title'),
                'site_url': config.get('ckan.site_url')
            }
            subject = base.render_jinja2(
                'emails/subjects/{0}.txt'.format(action_type), extra_vars)
            body = base.render_jinja2(
                'emails/bodies/{0}.txt'.format(action_type), extra_vars)
            tk.enqueue_job(mailer.mail_user, [user_data, subject, body],
                           title=job_title)
        except Exception:
            logging.exception(
                "Error sending notification to {0}".format(user_id))
예제 #21
0
파일: mailer.py 프로젝트: xiaokaixi/ckan
def send_invite(user, group_dict=None, role=None):
    create_reset_key(user)
    body = get_invite_body(user, group_dict, role)
    extra_vars = {'site_title': config.get('ckan.site_title')}
    subject = render_jinja2('emails/invite_user_subject.txt', extra_vars)

    # Make sure we only use the first line
    subject = subject.split('\n')[0]

    mail_user(user, subject, body)
예제 #22
0
def _compose_email_body(user, dataset, role, event):
    dataset_link = toolkit.url_for('dataset_read', id=dataset.id, qualified=True)
    return render_jinja2('collaborators/emails/{0}_collaborator.html'.format(event), {
        'user_name': user.fullname or user.name,
        'role': role,
        'site_title': toolkit.config.get('ckan.site_title'),
        'site_url': toolkit.config.get('ckan.site_url'),
        'dataset_title': dataset.title,
        'dataset_link': dataset_link
    })
예제 #23
0
def _send_mail(user_ids, action_type, datarequest):

    for user_id in user_ids:
        try:
            user_data = model.User.get(user_id)
            extra_vars = {
                "datarequest": datarequest,
                "user": user_data,
                "site_title": config.get("ckan.site_title"),
                "site_url": config.get("ckan.site_url"),
            }

            subject = base.render_jinja2(f"emails/subjects/{action_type}.txt",
                                         extra_vars)
            body = base.render_jinja2(f"emails/bodies/{action_type}.txt",
                                      extra_vars)

            mailer.mail_user(user_data, subject, body)

        except Exception:
            logging.exception(f"Error sending notification to {user_id}")
예제 #24
0
def request_resource(context, data_dict):
    '''Sent Email with a resource request to the owner of a dataset.'''
    contact_email = data_dict.get('contact_email')
    owner_id = data_dict.get('creator_id')
    resource_id = data_dict.get('resource_id')
    resource_link = toolkit.url_for(
        action='resource_read',
        controller='package',
        id=data_dict.get('package_name'),
        resource_id=resource_id)
    package = package_show(context, {'id':data_dict.get('package_name')})
    dashboard_restricted = config.get(
        'ckan.site_url') + '/dashboard/restricted'
    # create request e-mail
    extra_vars = {
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_email': data_dict.get('email'),
        'resource_name': data_dict.get('resource_name'),
        'resource_link': config.get('ckan.site_url') + resource_link,
        'package_name': data_dict.get('pkg_title'),
        'message': data_dict.get('message', ''),
        'dashboard_restricted': dashboard_restricted,
        'admin_email_to': config.get('email_to', 'email_to_undefined')}

    body = render_jinja2(
        'restricted/emails/restricted_access_unauth_request.txt', extra_vars)
    subject = \
        _('Αίτημα πρόσβασης στο {0}  από τον χρήστη {1}').format(
            data_dict.get('resource_name'),
            data_dict.get('email'))

    # send e-mail
    try:
        ckan.lib.mailer.mail_recipient(data_dict.get('email'), contact_email,
                                       subject, body)
    except ckan.lib.mailer.MailerException:
        success = False
        # return 'Error sending e-mail'

    request_dict = {'resource_id': resource_id, 'message': data_dict.get('message'),
                    'owner_id': owner_id, 'request_email': data_dict.get('email')
                    }

    logic.save_restricted_request(request_dict)

    # return _('Mail sent!')
    data = {'resource_id': resource_id, 'maintainer_email': contact_email,
            'user_email': data_dict.get('email'), 'package_title':data_dict.get('pkg_title'),
            'message': data_dict.get('message')}
    return render(
        'restricted/restricted_request_access_result.html',
        extra_vars={'data': data, 'pkg_dict': package, 'success': True})
예제 #25
0
def send_registration_email(user):
    """send new users an email at the time of registartion"""
    body = get_registration_body(user)
    extra_vars = {'site_title': config.get('ckan.site_title')}
    subject = render_jinja2('emails/registration_subject.txt', extra_vars)

    # Make sure we only use the first line
    subject = subject.split('\n')[0]

    recipient_name = user.get('display_name', user['name'])
    recipient_email = user.get('email')
    mailer.mail_recipient(recipient_name, recipient_email, subject, body)
예제 #26
0
파일: mailer.py 프로젝트: PublicaMundi/ckan
def send_reset_link(user):
    create_reset_key(user)
    body = get_reset_link_body(user)
    extra_vars = {
        'site_title': config.get('ckan.site_title')
    }
    subject = render_jinja2('emails/reset_password_subject.txt', extra_vars)

    # Make sure we only use the first line
    subject = subject.split('\n')[0]

    mail_user(user, subject, body)
예제 #27
0
파일: mailer.py 프로젝트: PublicaMundi/ckan
def send_invite(user, group_dict=None, role=None):
    create_reset_key(user)
    body = get_invite_body(user, group_dict, role)
    extra_vars = {
        'site_title': config.get('ckan.site_title')
    }
    subject = render_jinja2('emails/invite_user_subject.txt', extra_vars)

    # Make sure we only use the first line
    subject = subject.split('\n')[0]

    mail_user(user, subject, body)
예제 #28
0
def prepare_summary_mail(context, source_id, status, template):
    extra_vars = get_mail_extra_vars(context, source_id, status)
    body = render_jinja2(template, extra_vars)

    if str(status['last_job']['stats'].get('errored', 0)) == '0':
        subject = '{} - Harvesting Job Successful - Summary Notification'\
                  .format(config.get('ckan.site_title'))
    else:
        subject = '{} - Harvesting Job with Errors - Summary Notification'\
                  .format(config.get('ckan.site_title'))

    return subject, body
예제 #29
0
def request_activation(user):
    """ Request activation for user
    :param user: the user for whom an activation link should be requested
    :type user: dict
    """

    create_activation_key(user)
    site_title = config.get('ckan.site_title')
    site_url = config.get('ckan.site_url')

    body = render_jinja2(
        'emails/confirm_user_email.txt', {
            'activation_link': get_activation_link(user),
            'site_url': site_url,
            'site_title': site_title,
            'user_name': user.name
        })
    subject = render_jinja2('emails/confirm_user_subject.txt',
                            {'site_title': site_title})
    subject = subject.split('\n')[0]

    mailer.mail_recipient(user.name, user.email, subject, body, headers={})
예제 #30
0
def send_email_dataset_notification(datasets_by_contacts, action_type):
    for contact in datasets_by_contacts:
        try:
            log.info("Preparing email data for {0} notification to {1}".format(
                action_type, contact.get('email')))
            datasets = []
            for contact_dataset in contact.get('datasets', {}):
                date = datetime.strptime(
                    contact_dataset.get('next_update_due'), '%Y-%m-%d')

                datasets.append({
                    'url':
                    h.url_for('dataset_read',
                              id=contact_dataset.get('name'),
                              _external=True),
                    'next_due_date':
                    date.strftime('%d/%m/%Y')
                })

            extra_vars = {'datasets': datasets}
            subject = render_jinja2(
                'emails/subjects/{0}.txt'.format(action_type), extra_vars)
            body = render_jinja2('emails/bodies/{0}.txt'.format(action_type),
                                 extra_vars)

            site_title = 'Data | Queensland Government'
            site_url = config.get('ckan.site_url')
            enqueue_job(mailer._mail_recipient, [
                contact.get('email'),
                contact.get('email'), site_title, site_url, subject, body
            ],
                        title=action_type)
            log.info(
                "Added email to job worker default queue for {0} notification to {1}"
                .format(action_type, contact.get('email')))
        except Exception as e:
            log.error("Error sending {0} notification to {1}".format(
                action_type, contact.get('email')))
            log.error(str(e))
def send_notification_email(template, to=None, extra_vars=[]):
    """
    Compile an alert email notification to be sent via the job worker queue

    :param template: string
    :param to: string
    :param extra_vars: list
    :return:
    """
    from ckan.lib.base import render_jinja2
    from ckan.plugins import toolkit

    if not to:
        to = config.get('ckanext.harvest_tools.email_to',
                        config.get('email_to'))

    subject = config.get('ckan.site_title') + ' - ' + render_jinja2(
        'emails/subject/{0}.txt'.format(template), extra_vars)
    body = render_jinja2('emails/body/{0}.txt'.format(template), extra_vars)

    toolkit.enqueue_job(send_email, [to, subject, body],
                        title=u'Harvest tools email alert')
예제 #32
0
def _build_footer_content(extra_vars):
    custom_path = config.get('ckanext.security.brute_force_footer_path')
    if (custom_path and os.path.exists(custom_path)):
        log.warning(
            'Overriding brute force lockout email footer with {}'.format(
                custom_path))
        with open(custom_path, 'r') as footer_file:
            footer_content = footer_file.read()
        env = config['pylons.app_globals'].jinja_env
        template = env.from_string(footer_content)
        return '\n\n' + template.render(**extra_vars)
    else:
        footer_path = 'security/emails/lockout_footer.txt'
        return '\n\n' + render_jinja2(footer_path, extra_vars)
예제 #33
0
파일: tests.py 프로젝트: bwica/origin
    def test_reset_password_custom_body(self):
        user = factories.User()
        user_obj = model.User.by_name(user['name'])

        mailer.send_reset_link(user_obj)

        # check it went to the mock smtp server
        msgs = self.get_smtp_messages()
        assert_equal(len(msgs), 1)
        msg = msgs[0]
        extra_vars = {'reset_link': mailer.get_reset_link(user_obj)}
        expected = render_jinja2('emails/reset_password.txt', extra_vars)
        body = self.get_email_body(msg[3])
        assert_equal(expected, body)
        assert_in('**test**', body)
예제 #34
0
def _compose_email_body(data_dict, user, event='request', feedback=None):
    '''
    Formats an email body
    '''
    pkg_link = toolkit.url_for('dataset_read', id=data_dict['name'], qualified=True)
    return render_jinja2('emails/package_publish_{0}.html'.format(event), {
        'admin_name': user.fullname or user.name,
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'package_title': data_dict.get('title'),
        'package_description': data_dict.get('notes', ''),
        'package_url': pkg_link,
        'publisher_name': data_dict.get('contact_name'),
        'feedback': feedback
    })
예제 #35
0
파일: tests.py 프로젝트: CIOIL/DataGovIL
    def test_reset_password_custom_body(self):
        user = factories.User()
        user_obj = model.User.by_name(user['name'])

        mailer.send_reset_link(user_obj)

        # check it went to the mock smtp server
        msgs = self.get_smtp_messages()
        assert_equal(len(msgs), 1)
        msg = msgs[0]
        extra_vars = {
            'reset_link': mailer.get_reset_link(user_obj)
        }
        expected = render_jinja2('emails/reset_password.txt',
                                 extra_vars)
        body = self.get_email_body(msg[3])
        assert_equal(expected, body)
        assert_in('**test**', body)
예제 #36
0
파일: mailer.py 프로젝트: PublicaMundi/ckan
def get_invite_body(user, group_dict=None, role=None):
    if group_dict:
        group_type = (_('organization') if group_dict['is_organization']
                      else _('group'))

    extra_vars = {
        'reset_link': get_reset_link(user),
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
    }
    if role:
        extra_vars['role_name'] = h.roles_translated().get(role, _(role))
    if group_dict:
        extra_vars['group_type'] = group_type
        extra_vars['group_title'] = group_dict.get('title')

    # NOTE: This template is translated
    return render_jinja2('emails/invite_user.txt', extra_vars)
예제 #37
0
파일: tests.py 프로젝트: CIOIL/DataGovIL
    def test_invite_user_custom_body(self):
        user = factories.User()
        user_obj = model.User.by_name(user['name'])

        mailer.send_invite(user_obj)

        # check it went to the mock smtp server
        msgs = self.get_smtp_messages()
        assert_equal(len(msgs), 1)
        msg = msgs[0]
        extra_vars = {
            'reset_link': mailer.get_reset_link(user_obj),
            'user_name': user['name'],
            'site_title': config.get('ckan.site_title'),
        }
        expected = render_jinja2('emails/invite_user.txt',
                                 extra_vars)
        body = self.get_email_body(msg[3])
        assert_equal(expected, body)
        assert_in('**test**', body)
예제 #38
0
파일: tests.py 프로젝트: CIOIL/DataGovIL
    def test_invite_user_custom_subject(self):
        user = factories.User()
        user_obj = model.User.by_name(user['name'])

        mailer.send_invite(user_obj)

        # check it went to the mock smtp server
        msgs = self.get_smtp_messages()
        assert_equal(len(msgs), 1)
        msg = msgs[0]
        extra_vars = {
            'site_title': config.get('ckan.site_title'),
        }
        expected = render_jinja2('emails/invite_user_subject.txt',
                                 extra_vars)
        expected = expected.split('\n')[0]

        subject = self.get_email_subject(msg[3])
        assert_equal(expected, subject)
        assert_in('**test**', subject)
예제 #39
0
def send_feedback(context):
    '''
    Sends a feedback message to the recipients in the feedback.recipients
    config list.

    :param dict context: A dictionary containing the name, email and feedback
                         from a user.
    '''

    body = render_jinja2('emails/feedback.txt', context)
    subject = 'IOOS Catalog Feedback'

    recipients = config.get('feedback.recipients')
    if not recipients:
        log.info("No recipients specified, feedback email not sent")
        return
    recipients = recipients.split(' ')
    mail = Mail()
    msg = Message(subject, sender=config.get('smtp.mail_from'), recipients=recipients)
    msg.extra_headers = {"referring_site": context['referrer']}
    msg.body = body
    mail.send(msg)
예제 #40
0
def _get_issue_email_body(issue, issue_subject, user_obj):
    extra_vars = _get_issue_vars(issue, issue_subject, user_obj)
    # Would use p.toolkit.render, but it mucks with response and other things,
    # which is unnecessary, and p.toolkit.render_text uses genshi...
    return render_jinja2('issues/email/new_issue.html', extra_vars=extra_vars)
예제 #41
0
def _get_comment_email_body(comment, issue_subject, user_obj, recipient):
    extra_vars = _get_issue_vars(comment.issue, issue_subject, user_obj,
                                 recipient)
    extra_vars['comment'] = comment
    return render_jinja2('issues/email/new_comment.html',
                         extra_vars=extra_vars)
예제 #42
0
def user_invite(context, data_dict):
    '''Invite a new user.

    You must be authorized to create group members.

    :param email: the email of the user to be invited to the group
    :type email: string
    :param group_id: the id or name of the group
    :type group_id: string
    :param role: role of the user in the group. One of ``member``, ``editor``,
        or ``admin``
    :type role: string

    :returns: the newly created yser
    :rtype: dictionary
    '''
    toolkit.check_access('user_invite', context, data_dict)

    schema = context.get('schema',
                         logic.schema.default_user_invite_schema())
    data, errors = toolkit.navl_validate(data_dict, schema, context)
    if errors:
        raise toolkit.ValidationError(errors)

    model = context['model']
    group = model.Group.get(data['group_id'])
    if not group:
        raise toolkit.ObjectNotFound()

    name = logic.action.create._get_random_username_from_email(data['email'])
    password = str(random.SystemRandom().random())
    data['name'] = name
    data['password'] = password
    data['state'] = model.State.PENDING
    user_dict = toolkit.get_action('user_create')(context, data)
    user = model.User.get(user_dict['id'])
    member_dict = {
        'username': user.id,
        'id': data['group_id'],
        'role': data['role']
    }
    toolkit.get_action('group_member_create')(context, member_dict)

    if group.is_organization:
        group_dict = toolkit.get_action('organization_show')(context,
            {'id': data['group_id']})
    else:
        group_dict = toolkit.get_action('group_show')(context,
            {'id': data['group_id']})

    mailer.create_reset_key(user)

    # Email body
    group_type = (toolkit._('organization') if group_dict['is_organization']
                  else toolkit._('group'))
    role = data['role']
    extra_vars = {
        'reset_link': mailer.get_reset_link(user),
        'site_title': config.get('ckan.site_title'),
        'site_url': config.get('ckan.site_url'),
        'user_name': user.name,
        'role_name': authz.roles_trans().get(role, toolkit._(role)),
        'group_type': group_type,
        'group_title': group_dict.get('title'),
    }

    # NOTE: This template is translated
    body = render_jinja2('emails/invite_user.txt', extra_vars)
    subject = toolkit._('Invite for {site_title}').format(
        site_title=config.get('ckan.site_title'))

    mailer.mail_user(user, subject, body)

    return model_dictize.user_dictize(user, context)