django-dav-events/dav_events/emails.py

# -*- coding: utf-8 -*-
import logging
from django.apps import apps
from django.core.exceptions import ImproperlyConfigured
from django.core.mail import EmailMessage
from django.template.loader import get_template

logger = logging.getLogger(__name__)


class AbstractMail(object):
    _subject = u''
    _template_name = None

    def _get_sender(self):
        app_config = apps.get_containing_app_config(__package__)
        return app_config.settings.email_sender

    def _get_subject(self, subject_fmt=None, **kwargs):
        if subject_fmt is None:
            subject_fmt = self._subject
        app_config = apps.get_containing_app_config(__package__)
        if app_config.settings.email_subject_prefix:
            subject_fmt = u'%s %s' % (app_config.settings.email_subject_prefix, subject_fmt)
        subject = subject_fmt.format(**kwargs)
        return subject

    def _get_template(self):
        if not self._template_name:
            raise ImproperlyConfigured('%s._template_name ist not set.', self.__class__.__name__)
        return get_template(self._template_name)

    def _get_context_data(self, extra_context=None):
        app_config = apps.get_containing_app_config(__package__)
        context = {
            'base_url': app_config.settings.email_base_url,
        }
        if extra_context:
            context.update(extra_context)
        return context

    def _get_body(self, context=None):
        template = self._get_template()
        context = self._get_context_data(extra_context=context)
        return template.render(context)

    def _get_recipients(self):
        raise NotImplementedError()

    def send(self):
        subject = self._get_subject()
        body = self._get_body()
        sender = self._get_sender()
        recipients = self._get_recipients()

        emo = EmailMessage(subject=subject, body=body, from_email=sender, to=recipients)
        logger.info(u'Send %s to %s', self.__class__.__name__, recipients)
        emo.send()


class AbstractEventMail(AbstractMail):
    _template_name = 'dav_events/emails/default.txt'

    def __init__(self, recipient, event):
        self._recipient = recipient
        self._event = event

    def _get_subject(self, subject_fmt=None, **kwargs):
        if subject_fmt is None:
            subject_fmt = self._subject

        if self._event.number:
            subject_fmt = u'%s: %s' % (self._event.number, subject_fmt)

        return super(AbstractEventMail, self)._get_subject(subject_fmt=subject_fmt, **kwargs)

    def _get_recipients(self):
        r = u'"{fullname}" <{email}>'.format(fullname=self._recipient.get_full_name(),
                                             email=self._recipient.email)
        return [r]

    def _get_context_data(self, extra_context=None):
        context = super(AbstractEventMail, self)._get_context_data(extra_context=extra_context)
        context['recipient'] = self._recipient
        context.update(self._event.get_template_context())
        return context


class EventUpdatedMail(AbstractEventMail):
    _subject = u'Veranstaltung geändert'
    _template_name = 'dav_events/emails/event_updated.txt'

    def __init__(self, diff=None, editor=None, *args, **kwargs):
        self._diff = diff
        self._editor = editor
        super(EventUpdatedMail, self).__init__(*args, **kwargs)

    def _get_context_data(self, extra_context=None):
        context = super(EventUpdatedMail, self)._get_context_data(extra_context=extra_context)
        context['diff'] = self._diff
        context['editor'] = self._editor.get_full_name()
        return context


class EventSubmittedMail(AbstractEventMail):
    _subject = u'Veranstaltung eingereicht'
    _template_name = 'dav_events/emails/event_submitted.txt'


class EventToAcceptMail(AbstractEventMail):
    _subject = u'Veranstaltung freigeben'
    _template_name = 'dav_events/emails/event_to_accept.txt'

    def __init__(self, accept_action=None, *args, **kwargs):
        self._accept_action = accept_action
        super(EventToAcceptMail, self).__init__(*args, **kwargs)

    def _get_context_data(self, extra_context=None):
        context = super(EventToAcceptMail, self)._get_context_data(extra_context=extra_context)
        context['accept_url'] = self._accept_action.get_absolute_url()
        return context


class EventAcceptedMail(AbstractEventMail):
    _subject = u'Veranstaltung freigegeben'
    _template_name = 'dav_events/emails/event_accepted.txt'


class EventToPublishMail(AbstractEventMail):
    _subject = u'Veranstaltung veröffentlichen'
    _template_name = 'dav_events/emails/event_to_publish.txt'

    def __init__(self, confirm_publication_action=None, *args, **kwargs):
        self._confirm_publication_action = confirm_publication_action
        super(EventToPublishMail, self).__init__(*args, **kwargs)

    def _get_context_data(self, extra_context=None):
        context = super(EventToPublishMail, self)._get_context_data(extra_context=extra_context)
        context['confirm_publication_url'] = self._confirm_publication_action.get_absolute_url()
        return context


class PasswordSetEmail(AbstractMail):
    _subject = u'Zugangsdaten'
    _template_name = 'dav_events/emails/password_set.txt'

    def __init__(self, user, password):
        self._user = user
        self._password = password

    def _get_recipients(self):
        r = u'{fullname} <{email}>'.format(fullname=self._user.get_full_name(),
                                           email=self._user.email)
        return [r]

    def _get_context_data(self, extra_context=None):
        context = super(PasswordSetEmail, self)._get_context_data(extra_context=extra_context)
        context.update({
            'fullname': self._user.get_full_name(),
            'username': self._user.username,
            'password': self._password
        })
        return context