Add a new Communication app that manages all of Oscar's communications.

docs/source/internals/getting_started.rst

@@ -64,7 +64,7 @@ Now add Oscar's context processors to the template settings, listed below:
 
     'oscar.apps.search.context_processors.search_form',
     'oscar.apps.checkout.context_processors.checkout',
-    'oscar.apps.customer.notifications.context_processors.notifications',
+    'oscar.apps.communication.notifications.context_processors.notifications',
     'oscar.core.context_processors.metadata',
 
 Next, modify ``INSTALLED_APPS`` to be a list, and add ``django.contrib.sites``,
@@ -91,6 +91,7 @@ depends on. Also set ``SITE_ID``:
         'oscar.apps.shipping.apps.ShippingConfig',
         'oscar.apps.catalogue.apps.CatalogueConfig',
         'oscar.apps.catalogue.reviews.apps.CatalogueReviewsConfig',
+        'oscar.apps.communication.apps.CommunicationConfig',
         'oscar.apps.partner.apps.PartnerConfig',
         'oscar.apps.basket.apps.BasketConfig',
         'oscar.apps.payment.apps.PaymentConfig',

docs/source/ref/apps/communication.rst

@@ -0,0 +1,22 @@
+=============
+Communication
+=============
+
+The Communication app is used to manage emails and notifications to users.
+If ``OSCAR_SAVE_SENT_EMAILS_TO_DB`` is ``True``, then all sent emails
+are saved to the database as instances of ``oscar.apps.communication.models.Email``
+
+The ``Dispatcher`` class from ``oscar.apps.communication.utils`` is used to send
+emails and notifications.
+
+Abstract models
+---------------
+
+.. automodule:: oscar.apps.communication.abstract_models
+    :members:
+
+Utils
+-----
+
+.. automodule:: oscar.apps.communication.utils
+    :members:

docs/source/ref/apps/customer.rst

@@ -2,10 +2,9 @@
 Customer
 ========
 
-The customer app bundles communication with customers. This includes models
-to record product alerts and sent emails. It also contains the views that
-allow a customer to manage their data (profile information, shipping addresses,
-etc.)
+The customer app includes models to record product alerts and sent emails.
+It also contains the views that allow a customer to manage their data
+(profile information, shipping addresses, etc.)
 
 Abstract models
 ---------------
@@ -40,4 +39,13 @@ The context for the alert email body contains a ``hurry`` variable that is set
 to ``True`` if the number of active alerts for a product is greater than the
 quantity of the product available in stock.
 
-Alerts are sent using the Communication Event framework.
+CustomerDispatcher
+------------------
+
+``oscar.apps.customer.utils.CustomerDispatcher`` is used to send customer emails
+(e.g., registration, password reset, order confirmations).
+
+AlertsDispatcher
+----------------
+
+``oscar.apps.customer.alerts.utils.AlertsDispatcher`` is used to send product alerts.

docs/source/ref/settings.rst

@@ -292,6 +292,14 @@ A URL which is passed into the templates for communication events.  It is not
 used in Oscar's default templates but could be used to include static assets
 (e.g. images) in a HTML email template.
 
+``OSCAR_SAVE_SENT_EMAILS_TO_DB``
+--------------------------------
+
+Default: ``True``
+
+Indicates if sent emails will be saved to database as instances of
+``oscar.apps.communication.models.Email``.
+
 Offer settings
 ==============
 
@@ -530,3 +538,11 @@ Default: ``False``
 A flag to control whether Oscar's CSV writer should prepend a byte order mark
 (BOM) to CSV files that are encoded in UTF-8. Useful for compatibility with some
 CSV readers, Microsoft Excel in particular.
+
+
+``OSCAR_URL_SCHEMA``
+--------------------
+
+Default: ``http``
+
+The schema that will be used to build absolute url in ``absolute_url`` template tag.

docs/source/ref/templatetags.rst

@@ -193,3 +193,30 @@ This renders something like:
 .. code-block:: html
 
     Time since creation: 2 days
+
+
+URL tags
+-----------
+
+Load these tags using ``{% load url_tags %}``.
+
+``absolute_url``
+~~~~~~~~~~~~~~~~~~
+
+Returns an absolute URL for the provided domain and path.
+
+.. code-block:: html+django
+
+    <a href="{% absolute_url site.domain reset_url %}" class="btn-primary">Reset password</a>
+
+This tag can be used with ``blocktrans`` as follows:
+
+.. code-block:: html+django
+
+    {% absolute_url site.domain reset_url as absolute_reset_url %}
+    {% blocktrans with url=absolute_reset_url %}
+        You can reset your password here - {{ url }}
+    {% endblocktrans %}
+
+The schema for absolute url can be set through ``OSCAR_URL_SCHEMA``
+setting (``http`` by default).

docs/source/releases/v2.1.rst

@@ -1,6 +1,6 @@
-=======================
+========================================
 Oscar 2.1 release notes (in development)
-=======================
+========================================
 
 :release: tbd
 
@@ -19,7 +19,7 @@ Compatibility
 .. _new_in_2.1:
 
 What's new in Oscar 2.1?
-~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 - The database performance of ``offer.Range.all_products()`` was substantially
   improved. The internals of that method have changed and specifically
@@ -31,6 +31,68 @@ What's new in Oscar 2.1?
   Django doesn't generate migrations if a project modifies the ``OSCAR_IMAGE_FOLDER``
   to specify a custom directory structure for uploaded images.
 
+Communications app
+------------------
+
+A new ``communication`` app was introduced to provide a single point of entry
+for all communications sent by Oscar. This is a significant change with implications
+as follows:
+
+- Projects will need to add
+  ``oscar.apps.communication.apps.CommunicationConfig`` to ``INSTALLED_APPS``.
+
+  The ``CommunicationEventType``, ``Email`` and ``Notification`` models have
+  moved from the ``customer`` app to the ``communication`` app. In order to
+  preserve existing data, the table names for these models are unchanged.
+
+  This is a change that requires database migration.
+
+- The ``Dispatcher`` class moved from ``customer.utils`` to
+  ``communication.utils``. ``Dispatcher`` is now responsible for sending
+  all notifications, and not just emails.
+
+- A ``CustomerDispatcher`` utility class that wraps the core ``Dispatcher``
+  has been introduced to the ``customer`` app for sending communications to
+  customers.
+
+- An ``AlertsDispatcher`` utility class that wraps the core ``Dispatcher``
+  has been introduced to the ``customer.alerts`` module for sending product
+  alerts.
+
+- An ``OrderDispatcher``  utility class that wraps the core ``Dispatcher``
+  has been introduced to the ``order`` app for sending order related
+  communications.
+
+- A new setting, ``OSCAR_SAVE_SENT_EMAILS_TO_DB`` controls whether emails
+  sent through the ``Dispatcher`` are saved to the database. This defaults
+  to ``True``.
+
+- The ability to send multipart emails with attachments was added to the new
+  dispatcher.
+
+- All communication email templates (``commtype_*``) have moved from
+  moved from ``customer/emails`` to ``communication/emails``.
+
+- Templates in ``customer/email/`` and ``customer/notification/`` have moved
+  to ``communication/email/`` and ``communication/notification/``.
+
+- An ``absolute_url`` template tag was introduced to facilitate generating
+  absolute URLs in templates for a given domain and path. The schema for
+  generated URLs is configured via the ``OSCAR_URL_SCHEMA`` setting, which defaults
+  to ``http``.
+
+Backwards incompatible changes in Oscar 2.1
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- The ``category`` field has been removed from the
+  ``communication.Notification`` model. This change requires database migration.
+
+- The ``checkout.mixins.OrderPlacementMixin.send_confirmation_message``
+  method has been replaced with a new ``send_order_placed_email`` method.
+
+- ``customer.notifications.context_processors.notifications`` has moved to
+  ``communication.notifications.context_processors.notifications``.
+
 Bug fixes
 ~~~~~~~~~
 
@@ -64,4 +126,28 @@ Dependency changes
 .. _deprecated_features_in_2.1:
 
 Deprecated features
-~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~
+
+- ``customer.alerts.utils.send_alerts`` is deprecated.
+  Use ``AlertsDispatcher.send_alerts`` instead.
+
+- ``customer.alerts.utils.send_alert_confirmation`` is deprecated.
+  Use ``AlertsDispatcher.send_product_alert_confirmation_email_for_user``
+  instead.
+
+- ``customer.alerts.utils.send_product_alerts`` is deprecated.
+  Use ``AlertsDispatcher.send_product_alert_email_for_user`` instead.
+
+- ``customer.notifications.services.notify_user`` is deprecated.
+  Use Dispatcher.notify_user``.
+
+- ``customer.notifications.services.notify_users`` is deprecated.
+  Use ``Dispatcher.notify_users`` instead.
+
+- ``customer.forms.PasswordResetForm.get_reset_url`` has been removed.
+
+- ``customer.views.ProfileUpdateView.form_valid`` was modified
+  to use a new ``send_email_changed_email`` method.
+
+- ``customer.views.ChangePasswordView.form_valid`` was modified
+  to use a new ``send_password_changed_email`` method.

sandbox/apps/gateway/views.py

@@ -3,13 +3,15 @@ import logging
 from django import http
 from django.contrib import messages
 from django.contrib.auth.models import User
-from django.core.mail import send_mail
 from django.template.loader import get_template
 from django.urls import reverse
 from django.views import generic
 
 from apps.gateway import forms
 from oscar.apps.customer.forms import generate_username
+from oscar.core.loading import get_class
+
+Dispatcher = get_class('communication.utils', 'Dispatcher')
 
 logger = logging.getLogger('gateway')
 
@@ -41,10 +43,10 @@ class GatewayView(generic.FormView):
         return user
 
     def send_confirmation_email(self, real_email, user, password):
-        msg = get_template('gateway/email.txt').render({
-            'email': user.email,
-            'password': password
-        })
-        send_mail('Dashboard access to Oscar sandbox',
-                  msg, 'blackhole@latest.oscarcommerce.com',
-                  [real_email])
+        msgs = {
+            'subject': 'Dashboard access to Oscar sandbox',
+            'body': get_template('gateway/email.txt').render({
+                'email': user.email, 'password': password})
+        }
+        Dispatcher().send_email_messages(
+            real_email, msgs, from_email='blackhole@latest.oscarcommerce.com')

sandbox/settings.py

@@ -131,7 +131,7 @@ TEMPLATES = [
 
                 # Oscar specific
                 'oscar.apps.search.context_processors.search_form',
-                'oscar.apps.customer.notifications.context_processors.notifications',
+                'oscar.apps.communication.notifications.context_processors.notifications',
                 'oscar.apps.checkout.context_processors.checkout',
                 'oscar.core.context_processors.metadata',
             ],
@@ -264,6 +264,7 @@ INSTALLED_APPS = [
     'oscar.apps.shipping.apps.ShippingConfig',
     'oscar.apps.catalogue.apps.CatalogueConfig',
     'oscar.apps.catalogue.reviews.apps.CatalogueReviewsConfig',
+    'oscar.apps.communication.apps.CommunicationConfig',
     'oscar.apps.partner.apps.PartnerConfig',
     'oscar.apps.basket.apps.BasketConfig',
     'oscar.apps.payment.apps.PaymentConfig',

src/oscar/__init__.py

@@ -36,6 +36,7 @@ INSTALLED_APPS = [
     'oscar.apps.shipping.apps.ShippingConfig',
     'oscar.apps.catalogue.apps.CatalogueConfig',
     'oscar.apps.catalogue.reviews.apps.CatalogueReviewsConfig',
+    'oscar.apps.communication.apps.CommunicationConfig',
     'oscar.apps.partner.apps.PartnerConfig',
     'oscar.apps.basket.apps.BasketConfig',
     'oscar.apps.payment.apps.PaymentConfig',

src/oscar/apps/checkout/mixins.py

@@ -1,7 +1,6 @@
 import logging
 
 from django.contrib.sites.models import Site
-from django.contrib.sites.shortcuts import get_current_site
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import HttpResponseRedirect
 from django.urls import NoReverseMatch, reverse
@@ -10,7 +9,7 @@ from oscar.apps.checkout.signals import post_checkout
 from oscar.core.loading import get_class, get_model
 
 OrderCreator = get_class('order.utils', 'OrderCreator')
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+OrderDispatcher = get_class('order.utils', 'OrderDispatcher')
 CheckoutSessionMixin = get_class('checkout.session', 'CheckoutSessionMixin')
 BillingAddress = get_model('order', 'BillingAddress')
 ShippingAddress = get_model('order', 'ShippingAddress')
@@ -20,7 +19,6 @@ PaymentEvent = get_model('order', 'PaymentEvent')
 PaymentEventQuantity = get_model('order', 'PaymentEventQuantity')
 UserAddress = get_model('address', 'UserAddress')
 Basket = get_model('basket', 'Basket')
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
 
 # Standard logger for checkout events
 logger = logging.getLogger('oscar.checkout')
@@ -42,9 +40,6 @@ class OrderPlacementMixin(CheckoutSessionMixin):
     # handle_payment method.
     _payment_events = None
 
-    # Default code for the email to send after successful checkout
-    communication_type_code = 'ORDER_PLACED'
-
     view_signal = post_checkout
 
     # Payment handling methods
@@ -248,7 +243,7 @@ class OrderPlacementMixin(CheckoutSessionMixin):
         order is submitted.
         """
         # Send confirmation message (normally an email)
-        self.send_confirmation_message(order, self.communication_type_code)
+        self.send_order_placed_email(order)
 
         # Flush all session data
         self.checkout_session.flush()
@@ -268,44 +263,15 @@ class OrderPlacementMixin(CheckoutSessionMixin):
     def get_success_url(self):
         return reverse('checkout:thank-you')
 
-    def send_confirmation_message(self, order, code, **kwargs):
-        try:
-            ctx = self.get_message_context(order, code)
-        except TypeError:
-            # It seems like the get_message_context method was overridden and
-            # it does not support the code argument yet
-            logger.warning(
-                'The signature of the get_message_context method has changed, '
-                'please update it in your codebase'
-            )
-            ctx = self.get_message_context(order)
-
-        try:
-            event_type = CommunicationEventType.objects.get(code=code)
-        except CommunicationEventType.DoesNotExist:
-            # No event-type in database, attempt to find templates for this
-            # type and render them immediately to get the messages.  Since we
-            # have not CommunicationEventType to link to, we can't create a
-            # CommunicationEvent instance.
-            messages = CommunicationEventType.objects.get_and_render(code, ctx)
-            event_type = None
-        else:
-            messages = event_type.get_messages(ctx)
-
-        if messages and messages['body']:
-            logger.info("Order #%s - sending %s messages", order.number, code)
-            dispatcher = Dispatcher(logger)
-            dispatcher.dispatch_order_messages(order, messages,
-                                               event_type, **kwargs)
-        else:
-            logger.warning("Order #%s - no %s communication event type",
-                           order.number, code)
+    def send_order_placed_email(self, order):
+        extra_context = self.get_message_context(order)
+        dispatcher = OrderDispatcher(logger=logger)
+        dispatcher.send_order_placed_email_for_user(order, extra_context)
 
-    def get_message_context(self, order, code=None):
+    def get_message_context(self, order):
         ctx = {
             'user': self.request.user,
             'order': order,
-            'site': get_current_site(self.request),
             'lines': order.lines.all()
         }
 

src/oscar/apps/communication/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'oscar.apps.communication.apps.CommunicationConfig'

src/oscar/apps/communication/abstract_models.py

@@ -0,0 +1,210 @@
+from django.conf import settings
+from django.core.validators import RegexValidator
+from django.db import models
+from django.template import engines
+from django.template.exceptions import TemplateDoesNotExist
+from django.template.loader import get_template
+from django.utils.translation import gettext_lazy as _
+
+from oscar.apps.communication.managers import CommunicationTypeManager
+from oscar.core.compat import AUTH_USER_MODEL
+from oscar.models.fields import AutoSlugField
+
+
+class AbstractEmail(models.Model):
+    """
+    This is a record of an email sent to a customer.
+    """
+    user = models.ForeignKey(
+        AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='emails',
+        verbose_name=_("User"),
+        null=True)
+    email = models.EmailField(_('Email Address'), null=True, blank=True)
+    subject = models.TextField(_('Subject'), max_length=255)
+    body_text = models.TextField(_("Body Text"))
+    body_html = models.TextField(_("Body HTML"), blank=True)
+    date_sent = models.DateTimeField(_("Date Sent"), auto_now_add=True)
+
+    class Meta:
+        abstract = True
+        app_label = 'communication'
+        verbose_name = _('Email')
+        verbose_name_plural = _('Emails')
+
+    def __str__(self):
+        if self.user:
+            return _("Email to %(user)s with subject '%(subject)s'") % {
+                'user': self.user.get_username(), 'subject': self.subject}
+        else:
+            return _("Email to %(email)s with subject '%(subject)s'") % {
+                'email': self.email, 'subject': self.subject}
+
+
+class AbstractCommunicationEventType(models.Model):
+    """
+    A 'type' of communication.  Like an order confirmation email.
+    """
+
+    #: Code used for looking up this event programmatically.
+    # e.g. PASSWORD_RESET. AutoSlugField uppercases the code for us because
+    # it's a useful convention that's been enforced in previous Oscar versions
+    code = AutoSlugField(
+        _('Code'), max_length=128, unique=True, populate_from='name',
+        separator='_', uppercase=True, editable=True,
+        validators=[
+            RegexValidator(
+                regex=r'^[A-Z_][0-9A-Z_]*$',
+                message=_(
+                    "Code can only contain the uppercase letters (A-Z), "
+                    "digits, and underscores, and can't start with a digit."))],
+        help_text=_("Code used for looking up this event programmatically"))
+
+    #: Name is the friendly description of an event for use in the admin
+    name = models.CharField(_('Name'), max_length=255)
+
+    # We allow communication types to be categorised
+    # For backwards-compatibility, the choice values are quite verbose
+    ORDER_RELATED = 'Order related'
+    USER_RELATED = 'User related'
+    CATEGORY_CHOICES = (
+        (ORDER_RELATED, _('Order related')),
+        (USER_RELATED, _('User related'))
+    )
+
+    category = models.CharField(
+        _('Category'), max_length=255, default=ORDER_RELATED,
+        choices=CATEGORY_CHOICES)
+
+    # Template content for emails
+    # NOTE: There's an intentional distinction between None and ''. None
+    # instructs Oscar to look for a file-based template, '' is just an empty
+    # template.
+    email_subject_template = models.CharField(
+        _('Email Subject Template'), max_length=255, blank=True, null=True)
+    email_body_template = models.TextField(
+        _('Email Body Template'), blank=True, null=True)
+    email_body_html_template = models.TextField(
+        _('Email Body HTML Template'), blank=True, null=True,
+        help_text=_("HTML template"))
+
+    # Template content for SMS messages
+    sms_template = models.CharField(_('SMS Template'), max_length=170,
+                                    blank=True, null=True,
+                                    help_text=_("SMS template"))
+
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True)
+
+    objects = CommunicationTypeManager()
+
+    # File templates
+    email_subject_template_file = 'oscar/communication/emails/commtype_%s_subject.txt'
+    email_body_template_file = 'oscar/communication/emails/commtype_%s_body.txt'
+    email_body_html_template_file = 'oscar/communication/emails/commtype_%s_body.html'
+    sms_template_file = 'oscar/communication/sms/commtype_%s_body.txt'
+
+    class Meta:
+        abstract = True
+        app_label = 'communication'
+        verbose_name = _("Communication event type")
+        verbose_name_plural = _("Communication event types")
+
+    def get_messages(self, ctx=None):
+        """
+        Return a dict of templates with the context merged in
+
+        We look first at the field templates but fail over to
+        a set of file templates that follow a conventional path.
+        """
+        code = self.code.lower()
+
+        # Build a dict of message name to Template instances
+        templates = {'subject': 'email_subject_template',
+                     'body': 'email_body_template',
+                     'html': 'email_body_html_template',
+                     'sms': 'sms_template'}
+        for name, attr_name in templates.items():
+            field = getattr(self, attr_name, None)
+            if field is not None:
+                # Template content is in a model field
+                templates[name] = engines['django'].from_string(field)
+            else:
+                # Model field is empty - look for a file template
+                template_name = getattr(self, "%s_file" % attr_name) % code
+                try:
+                    templates[name] = get_template(template_name)
+                except TemplateDoesNotExist:
+                    templates[name] = None
+
+        # Pass base URL for serving images within HTML emails
+        if ctx is None:
+            ctx = {}
+        ctx['static_base_url'] = getattr(
+            settings, 'OSCAR_STATIC_BASE_URL', None)
+
+        messages = {}
+        for name, template in templates.items():
+            messages[name] = template.render(ctx) if template else ''
+
+        # Ensure the email subject doesn't contain any newlines
+        messages['subject'] = messages['subject'].replace("\n", "")
+        messages['subject'] = messages['subject'].replace("\r", "")
+
+        return messages
+
+    def __str__(self):
+        return self.name
+
+    def is_order_related(self):
+        return self.category == self.ORDER_RELATED
+
+    def is_user_related(self):
+        return self.category == self.USER_RELATED
+
+
+class AbstractNotification(models.Model):
+    recipient = models.ForeignKey(
+        AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='notifications')
+
+    # Not all notifications will have a sender.
+    sender = models.ForeignKey(
+        AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        null=True)
+
+    # HTML is allowed in this field as it can contain links
+    subject = models.CharField(max_length=255)
+    body = models.TextField()
+
+    INBOX, ARCHIVE = 'Inbox', 'Archive'
+    choices = (
+        (INBOX, _('Inbox')),
+        (ARCHIVE, _('Archive')))
+    location = models.CharField(max_length=32, choices=choices,
+                                default=INBOX)
+
+    date_sent = models.DateTimeField(auto_now_add=True)
+    date_read = models.DateTimeField(blank=True, null=True)
+
+    class Meta:
+        abstract = True
+        app_label = 'communication'
+        ordering = ('-date_sent',)
+        verbose_name = _('Notification')
+        verbose_name_plural = _('Notifications')
+
+    def __str__(self):
+        return self.subject
+
+    def archive(self):
+        self.location = self.ARCHIVE
+        self.save()
+    archive.alters_data = True
+
+    @property
+    def is_read(self):
+        return self.date_read is not None

src/oscar/apps/customer/admin.py → src/oscar/apps/communication/admin.py

@@ -2,8 +2,8 @@ from django.contrib import admin
 
 from oscar.core.loading import get_model
 
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
-Email = get_model('customer', 'Email')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+Email = get_model('communication', 'Email')
 
 
 admin.site.register(Email)

src/oscar/apps/communication/app.py

@@ -0,0 +1,72 @@
+from django.conf.urls import url
+from django.contrib.auth.decorators import login_required
+from django.views import generic
+
+from oscar.core.application import Application
+from oscar.core.loading import get_class
+
+
+class CommunicationApplication(Application):
+    name = 'communication'
+
+    alert_list_view = get_class(
+        'communication.alerts.views', 'ProductAlertListView')
+    alert_create_view = get_class(
+        'communication.alerts.views', 'ProductAlertCreateView')
+    alert_confirm_view = get_class(
+        'communication.alerts.views', 'ProductAlertConfirmView')
+    alert_cancel_view = get_class(
+        'communication.alerts.views', 'ProductAlertCancelView')
+
+    notification_inbox_view = get_class(
+        'communication.notifications.views', 'InboxView')
+    notification_archive_view = get_class(
+        'communication.notifications.views', 'ArchiveView')
+    notification_update_view = get_class(
+        'communication.notifications.views', 'UpdateView')
+    notification_detail_view = get_class(
+        'communication.notifications.views', 'DetailView')
+
+    def get_urls(self):
+        urls = [
+            # Alerts
+            # Alerts can be setup by anonymous users: some views do not
+            # require login
+            url(r'^alerts/$',
+                login_required(self.alert_list_view.as_view()),
+                name='alerts-list'),
+            url(r'^alerts/create/(?P<pk>\d+)/$',
+                self.alert_create_view.as_view(),
+                name='alert-create'),
+            url(r'^alerts/confirm/(?P<key>[a-z0-9]+)/$',
+                self.alert_confirm_view.as_view(),
+                name='alerts-confirm'),
+            url(r'^alerts/cancel/key/(?P<key>[a-z0-9]+)/$',
+                self.alert_cancel_view.as_view(),
+                name='alerts-cancel-by-key'),
+            url(r'^alerts/cancel/(?P<pk>[a-z0-9]+)/$',
+                login_required(self.alert_cancel_view.as_view()),
+                name='alerts-cancel-by-pk'),
+
+            # Notifications
+            # Redirect to notification inbox
+            url(r'^notifications/$', generic.RedirectView.as_view(
+                url='/accounts/notifications/inbox/', permanent=False)),
+            url(r'^notifications/inbox/$',
+                login_required(self.notification_inbox_view.as_view()),
+                name='notifications-inbox'),
+            url(r'^notifications/archive/$',
+                login_required(self.notification_archive_view.as_view()),
+                name='notifications-archive'),
+            url(r'^notifications/update/$',
+                login_required(self.notification_update_view.as_view()),
+                name='notifications-update'),
+            url(r'^notifications/(?P<pk>\d+)/$',
+                login_required(self.notification_detail_view.as_view()),
+                name='notifications-detail'),
+        ]
+
+        return self.post_process_urls(urls)
+
+
+application = CommunicationApplication()

src/oscar/apps/communication/apps.py

@@ -0,0 +1,9 @@
+from django.utils.translation import gettext_lazy as _
+
+from oscar.core.application import OscarConfig
+
+
+class CommunicationConfig(OscarConfig):
+    label = 'communication'
+    name = 'oscar.apps.communication'
+    verbose_name = _('Communication')

src/oscar/apps/communication/config.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class CommunicationConfig(AppConfig):
+    label = 'communication'
+    name = 'oscar.apps.communication'
+    verbose_name = _('Communication')
+
+    def ready(self):
+        from .alerts import receivers  # noqa

src/oscar/apps/communication/migrations/0001_initial.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.10 on 2018-02-18 10:32
+from __future__ import unicode_literals
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import oscar.models.fields.autoslugfield
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('catalogue', '0013_auto_20170821_1548'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('customer', '0005_auto_20181115_1953'),
+    ]
+
+    state_operations = [
+        migrations.CreateModel(
+            name='CommunicationEventType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', oscar.models.fields.autoslugfield.AutoSlugField(blank=True, editable=False, help_text='Code used for looking up this event programmatically', max_length=128, populate_from='name', separator='_', unique=True, validators=[django.core.validators.RegexValidator(message="Code can only contain the letters a-z, A-Z, digits, and underscores, and can't start with a digit.", regex='^[a-zA-Z_][0-9a-zA-Z_]*$')], verbose_name='Code')),
+                ('name', models.CharField(max_length=255, verbose_name='Name')),
+                ('category', models.CharField(choices=[('Order related', 'Order related'), ('User related', 'User related')], default='Order related', max_length=255, verbose_name='Category')),
+                ('email_subject_template', models.CharField(blank=True, max_length=255, null=True, verbose_name='Email Subject Template')),
+                ('email_body_template', models.TextField(blank=True, null=True, verbose_name='Email Body Template')),
+                ('email_body_html_template', models.TextField(blank=True, help_text='HTML template', null=True, verbose_name='Email Body HTML Template')),
+                ('sms_template', models.CharField(blank=True, help_text='SMS template', max_length=170, null=True, verbose_name='SMS Template')),
+                ('date_created', models.DateTimeField(auto_now_add=True, verbose_name='Date Created')),
+                ('date_updated', models.DateTimeField(auto_now=True, verbose_name='Date Updated')),
+            ],
+            options={
+                'verbose_name': 'Communication event type',
+                'verbose_name_plural': 'Communication event types',
+                'db_table': 'customer_communicationeventtype',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Email',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('email', models.EmailField(blank=True, max_length=254, null=True, verbose_name='Email Address')),
+                ('subject', models.TextField(max_length=255, verbose_name='Subject')),
+                ('body_text', models.TextField(verbose_name='Body Text')),
+                ('body_html', models.TextField(blank=True, verbose_name='Body HTML')),
+                ('date_sent', models.DateTimeField(auto_now_add=True, verbose_name='Date Sent')),
+                ('user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='emails', to=settings.AUTH_USER_MODEL, verbose_name='User')),
+            ],
+            options={
+                'verbose_name': 'Email',
+                'verbose_name_plural': 'Emails',
+                'db_table': 'customer_email',
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Notification',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('subject', models.CharField(max_length=255)),
+                ('body', models.TextField()),
+                ('category', models.CharField(blank=True, max_length=255)),
+                ('location', models.CharField(choices=[('Inbox', 'Inbox'), ('Archive', 'Archive')], default='Inbox', max_length=32)),
+                ('date_sent', models.DateTimeField(auto_now_add=True)),
+                ('date_read', models.DateTimeField(blank=True, null=True)),
+                ('recipient', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='notifications', to=settings.AUTH_USER_MODEL)),
+                ('sender', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'Notification',
+                'verbose_name_plural': 'Notifications',
+                'db_table': 'customer_notification',
+                'ordering': ('-date_sent',),
+                'abstract': False,
+            },
+        ),
+    ]
+
+    operations = [
+        migrations.SeparateDatabaseAndState(
+            state_operations=state_operations
+        ),
+    ]

src/oscar/apps/communication/migrations/0002_reset_table_names.py

@@ -0,0 +1,30 @@
+# Generated by Django 2.0.13 on 2019-04-30 16:35
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    atomic = False
+
+    dependencies = [
+        ('communication', '0001_initial'),
+        ('order', '0008_auto_20190301_1035'),
+    ]
+
+    operations = [
+        # Alter the names of the tables migrated from the customer app
+        # to the Django defaults.
+        migrations.AlterModelTable(
+            name='communicationeventtype',
+            table=None,
+        ),
+        migrations.AlterModelTable(
+            name='email',
+            table=None,
+        ),
+        migrations.AlterModelTable(
+            name='notification',
+            table=None,
+        ),
+    ]

src/oscar/apps/communication/migrations/0003_remove_notification_category_make_code_uppercase.py

@@ -0,0 +1,23 @@
+# Generated by Django 2.0.13 on 2019-05-26 08:03
+import django.core.validators
+from django.db import migrations
+import oscar.models.fields.autoslugfield
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('communication', '0002_reset_table_names'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='notification',
+            name='category',
+        ),
+        migrations.AlterField(
+            model_name='communicationeventtype',
+            name='code',
+            field=oscar.models.fields.autoslugfield.AutoSlugField(blank=True, editable=False, help_text='Code used for looking up this event programmatically', max_length=128, populate_from='name', separator='_', unique=True, validators=[django.core.validators.RegexValidator(message="Code can only contain the uppercase letters (A-Z), digits, and underscores, and can't start with a digit.", regex='^[A-Z_][0-9A-Z_]*$')], verbose_name='Code'),
+        ),
+    ]

src/oscar/apps/communication/models.py

@@ -0,0 +1,26 @@
+from oscar.core.loading import is_model_registered
+
+from .abstract_models import *  # noqa
+
+__all__ = []
+
+
+if not is_model_registered('communication', 'Email'):
+    class Email(AbstractEmail):
+        pass
+
+    __all__.append('Email')
+
+
+if not is_model_registered('communication', 'CommunicationEventType'):
+    class CommunicationEventType(AbstractCommunicationEventType):
+        pass
+
+    __all__.append('CommunicationEventType')
+
+
+if not is_model_registered('communication', 'Notification'):
+    class Notification(AbstractNotification):
+        pass
+
+    __all__.append('Notification')

src/oscar/apps/customer/notifications/context_processors.py → src/oscar/apps/communication/notifications/context_processors.py

@@ -1,6 +1,6 @@
 from oscar.core.loading import get_model
 
-Notification = get_model('customer', 'Notification')
+Notification = get_model('communication', 'Notification')
 
 
 def notifications(request):

src/oscar/apps/customer/notifications/views.py → src/oscar/apps/communication/notifications/views.py

@@ -11,12 +11,12 @@ from oscar.core.utils import redirect_to_referrer
 from oscar.views.generic import BulkEditMixin
 
 PageTitleMixin = get_class('customer.mixins', 'PageTitleMixin')
-Notification = get_model('customer', 'Notification')
+Notification = get_model('communication', 'Notification')
 
 
 class NotificationListView(PageTitleMixin, generic.ListView):
     model = Notification
-    template_name = 'oscar/customer/notifications/list.html'
+    template_name = 'oscar/communication/notifications/list.html'
     context_object_name = 'notifications'
     paginate_by = settings.OSCAR_NOTIFICATIONS_PER_PAGE
     page_title = _("Notifications")
@@ -48,7 +48,7 @@ class ArchiveView(NotificationListView):
 
 class DetailView(PageTitleMixin, generic.DetailView):
     model = Notification
-    template_name = 'oscar/customer/notifications/detail.html'
+    template_name = 'oscar/communication/notifications/detail.html'
     context_object_name = 'notification'
     active_tab = 'notifications'
 
@@ -81,7 +81,7 @@ class UpdateView(BulkEditMixin, generic.RedirectView):
 
     def get_success_response(self):
         return redirect_to_referrer(
-            self.request, 'customer:notifications-inbox')
+            self.request, 'communication:notifications-inbox')
 
     def archive(self, request, notifications):
         for notification in notifications:

src/oscar/apps/communication/utils.py

@@ -0,0 +1,173 @@
+import logging
+
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.mail import EmailMessage, EmailMultiAlternatives
+
+from oscar.core.loading import get_model
+
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+Email = get_model('communication', 'Email')
+Notification = get_model('communication', 'Notification')
+
+
+class Dispatcher(object):
+
+    def __init__(self, logger=None, mail_connection=None):
+        if not logger:
+            logger = logging.getLogger(__name__)
+        self.logger = logger
+        # Supply a mail_connection if you want the dispatcher to use that
+        # instead of opening a new one.
+        self.mail_connection = mail_connection
+
+    # Public API methods
+
+    def dispatch_direct_messages(self, recipient_email, messages, attachments=None):
+        """
+        Dispatch one-off messages to explicitly specified recipient email.
+        """
+        if messages['subject'] and (messages['body'] or messages['html']):
+            return self.send_email_messages(recipient_email, messages, attachments=attachments)
+
+    def dispatch_anonymous_messages(self, email, messages, attachments=None):
+        dispatched_messages = {}
+        if email:
+            dispatched_messages['email'] = self.send_email_messages(email, messages, attachments=attachments), None
+        return dispatched_messages
+
+    def dispatch_user_messages(self, user, messages, attachments=None):
+        """
+        Send messages to a site user
+        """
+        dispatched_messages = {}
+        if messages['subject'] and (messages['body'] or messages['html']):
+            dispatched_messages['email'] = self.send_user_email_messages(user, messages, attachments)
+        if messages['sms']:
+            dispatched_messages['sms'] = self.send_text_message(user, messages['sms'])
+        return dispatched_messages
+
+    def notify_user(self, user, subject, **kwargs):
+        """
+        Send a simple notification to a user
+        """
+        Notification.objects.create(recipient=user, subject=subject, **kwargs)
+
+    def notify_users(self, users, subject, **kwargs):
+        """
+        Send a simple notification to an iterable of users
+        """
+        for user in users:
+            self.notify_user(user, subject, **kwargs)
+
+    # Internal
+
+    def create_email(self, user, messages, email):
+        """
+        Create ``Email`` instance in database for logging purposes.
+        """
+        if email and user.is_authenticated:
+            return Email.objects.create(
+                user=user,
+                email=user.email,
+                subject=email.subject,
+                body_text=email.body,
+                body_html=messages['html'],
+            )
+
+    def send_user_email_messages(self, user, messages, attachments=None):
+        """
+        Send message to the registered user / customer and collect data in database.
+        """
+        if not user.email:
+            self.logger.warning("Unable to send email messages as user #%d has"
+                                " no email address", user.id)
+            return None
+
+        email = self.send_email_messages(user.email, messages, attachments=attachments)
+
+        if settings.OSCAR_SAVE_SENT_EMAILS_TO_DB:
+            self.create_email(user, messages, email)
+
+        return email
+
+    def send_email_messages(self, recipient_email, messages, from_email=None, attachments=None):
+        """
+        Send email to recipient, HTML attachment optional.
+        """
+        from_email = from_email or settings.OSCAR_FROM_EMAIL
+
+        content_attachments, file_attachments = self.prepare_attachments(attachments)
+
+        # Determine whether we are sending a HTML version too
+        if messages['html']:
+            email = EmailMultiAlternatives(
+                messages['subject'],
+                messages['body'],
+                from_email=from_email,
+                to=[recipient_email],
+                attachments=content_attachments,
+            )
+            email.attach_alternative(messages['html'], "text/html")
+        else:
+            email = EmailMessage(
+                messages['subject'],
+                messages['body'],
+                from_email=from_email,
+                to=[recipient_email],
+                attachments=content_attachments,
+            )
+        for attachment in file_attachments:
+            email.attach_file(attachment)
+
+        self.logger.info("Sending email to %s" % recipient_email)
+
+        if self.mail_connection:
+            self.mail_connection.send_messages([email])
+        else:
+            email.send()
+
+        return email
+
+    def send_text_message(self, user, event_type):
+        raise NotImplementedError
+
+    def prepare_attachments(self, attachments):
+        """
+        Two types of attachments can be attached to emails:
+
+            * "Content" attachment is one of:
+                * instance of ``MIMEBase`` (from ``email.mime.base``);
+                * list ``[filename, content, mimetype]``;
+
+            * "File" attachment is a path to file from an instance of
+              ``FileField`` based fields.
+
+        "Content" and "file" attachments attached to emails differently.
+        """
+        content_attachments = []
+        file_attachments = []
+        if attachments is not None:
+            for attachment in attachments:
+                if isinstance(attachment, str):
+                    file_attachments.append(attachment)
+                else:
+                    content_attachments.append(attachment)
+
+        return content_attachments, file_attachments
+
+    def get_base_context(self):
+        """
+        Return context that is common to all emails
+        """
+        return {'site': Site.objects.get_current()}
+
+    def get_messages(self, event_code, extra_context=None):
+        """
+        Return rendered messages
+        """
+        context = self.get_base_context()
+        if extra_context is not None:
+            context.update(extra_context)
+        msgs = CommunicationEventType.objects.get_and_render(event_code, context)
+        return msgs

src/oscar/apps/customer/abstract_models.py

@@ -1,20 +1,12 @@
-from django.conf import settings
 from django.contrib.auth import models as auth_models
 from django.core.mail import send_mail
-from django.core.validators import RegexValidator
 from django.db import models
-from django.template import TemplateDoesNotExist, engines
-from django.template.loader import get_template
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.crypto import get_random_string
 from django.utils.translation import gettext_lazy as _
 
 from oscar.core.compat import AUTH_USER_MODEL
-from oscar.core.loading import get_class
-from oscar.models.fields import AutoSlugField
-
-CommunicationTypeManager = get_class('customer.managers', 'CommunicationTypeManager')
 
 
 class UserManager(auth_models.BaseUserManager):
@@ -121,213 +113,6 @@ class AbstractUser(auth_models.AbstractBaseUser,
         self._migrate_alerts_to_user()
 
 
-class AbstractEmail(models.Model):
-    """
-    This is a record of all emails sent to a customer.
-    Normally, we only record order-related emails.
-    """
-    user = models.ForeignKey(
-        AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        related_name='emails',
-        verbose_name=_("User"),
-        null=True)
-    email = models.EmailField(_('Email Address'), null=True, blank=True)
-    subject = models.TextField(_('Subject'), max_length=255)
-    body_text = models.TextField(_("Body Text"))
-    body_html = models.TextField(_("Body HTML"), blank=True)
-    date_sent = models.DateTimeField(_("Date Sent"), auto_now_add=True)
-
-    class Meta:
-        abstract = True
-        app_label = 'customer'
-        verbose_name = _('Email')
-        verbose_name_plural = _('Emails')
-
-    def __str__(self):
-        if self.user:
-            return _("Email to %(user)s with subject '%(subject)s'") % {
-                'user': self.user.get_username(), 'subject': self.subject}
-        else:
-            return _("Anonymous email to %(email)s with subject '%(subject)s'") % {
-                'email': self.email, 'subject': self.subject}
-
-
-class AbstractCommunicationEventType(models.Model):
-    """
-    A 'type' of communication.  Like an order confirmation email.
-    """
-
-    #: Code used for looking up this event programmatically.
-    # e.g. PASSWORD_RESET. AutoSlugField uppercases the code for us because
-    # it's a useful convention that's been enforced in previous Oscar versions
-    code = AutoSlugField(
-        _('Code'), max_length=128, unique=True, populate_from='name',
-        separator="_", uppercase=True, editable=True,
-        validators=[
-            RegexValidator(
-                regex=r'^[a-zA-Z_][0-9a-zA-Z_]*$',
-                message=_(
-                    "Code can only contain the letters a-z, A-Z, digits, "
-                    "and underscores, and can't start with a digit."))],
-        help_text=_("Code used for looking up this event programmatically"))
-
-    #: Name is the friendly description of an event for use in the admin
-    name = models.CharField(
-        _('Name'), max_length=255,
-        help_text=_("This is just used for organisational purposes"))
-
-    # We allow communication types to be categorised
-    # For backwards-compatibility, the choice values are quite verbose
-    ORDER_RELATED = 'Order related'
-    USER_RELATED = 'User related'
-    CATEGORY_CHOICES = (
-        (ORDER_RELATED, _('Order related')),
-        (USER_RELATED, _('User related'))
-    )
-
-    category = models.CharField(
-        _('Category'), max_length=255, default=ORDER_RELATED,
-        choices=CATEGORY_CHOICES)
-
-    # Template content for emails
-    # NOTE: There's an intentional distinction between None and ''. None
-    # instructs Oscar to look for a file-based template, '' is just an empty
-    # template.
-    email_subject_template = models.CharField(
-        _('Email Subject Template'), max_length=255, blank=True, null=True)
-    email_body_template = models.TextField(
-        _('Email Body Template'), blank=True, null=True)
-    email_body_html_template = models.TextField(
-        _('Email Body HTML Template'), blank=True, null=True,
-        help_text=_("HTML template"))
-
-    # Template content for SMS messages
-    sms_template = models.CharField(_('SMS Template'), max_length=170,
-                                    blank=True, null=True,
-                                    help_text=_("SMS template"))
-
-    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
-    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True)
-
-    objects = CommunicationTypeManager()
-
-    # File templates
-    email_subject_template_file = 'oscar/customer/emails/commtype_%s_subject.txt'
-    email_body_template_file = 'oscar/customer/emails/commtype_%s_body.txt'
-    email_body_html_template_file = 'oscar/customer/emails/commtype_%s_body.html'
-    sms_template_file = 'oscar/customer/sms/commtype_%s_body.txt'
-
-    class Meta:
-        abstract = True
-        app_label = 'customer'
-        verbose_name = _("Communication event type")
-        verbose_name_plural = _("Communication event types")
-
-    def get_messages(self, ctx=None):
-        """
-        Return a dict of templates with the context merged in
-
-        We look first at the field templates but fail over to
-        a set of file templates that follow a conventional path.
-        """
-        code = self.code.lower()
-
-        # Build a dict of message name to Template instances
-        templates = {'subject': 'email_subject_template',
-                     'body': 'email_body_template',
-                     'html': 'email_body_html_template',
-                     'sms': 'sms_template'}
-        for name, attr_name in templates.items():
-            field = getattr(self, attr_name, None)
-            if field is not None:
-                # Template content is in a model field
-                templates[name] = engines['django'].from_string(field)
-            else:
-                # Model field is empty - look for a file template
-                template_name = getattr(self, "%s_file" % attr_name) % code
-                try:
-                    templates[name] = get_template(template_name)
-                except TemplateDoesNotExist:
-                    templates[name] = None
-
-        # Pass base URL for serving images within HTML emails
-        if ctx is None:
-            ctx = {}
-        ctx['static_base_url'] = getattr(
-            settings, 'OSCAR_STATIC_BASE_URL', None)
-
-        messages = {}
-        for name, template in templates.items():
-            messages[name] = template.render(ctx) if template else ''
-
-        # Ensure the email subject doesn't contain any newlines
-        messages['subject'] = messages['subject'].replace("\n", "")
-        messages['subject'] = messages['subject'].replace("\r", "")
-
-        return messages
-
-    def __str__(self):
-        return self.name
-
-    def is_order_related(self):
-        return self.category == self.ORDER_RELATED
-
-    def is_user_related(self):
-        return self.category == self.USER_RELATED
-
-
-class AbstractNotification(models.Model):
-    recipient = models.ForeignKey(
-        AUTH_USER_MODEL,
-        db_index=True,
-        on_delete=models.CASCADE,
-        related_name='notifications')
-
-    # Not all notifications will have a sender.
-    sender = models.ForeignKey(
-        AUTH_USER_MODEL,
-        on_delete=models.CASCADE,
-        null=True)
-
-    # HTML is allowed in this field as it can contain links
-    subject = models.CharField(max_length=255)
-    body = models.TextField()
-
-    # Some projects may want to categorise their notifications.  You may want
-    # to use this field to show a different icons next to the notification.
-    category = models.CharField(max_length=255, blank=True)
-
-    INBOX, ARCHIVE = 'Inbox', 'Archive'
-    choices = (
-        (INBOX, _('Inbox')),
-        (ARCHIVE, _('Archive')))
-    location = models.CharField(max_length=32, choices=choices,
-                                default=INBOX)
-
-    date_sent = models.DateTimeField(auto_now_add=True, db_index=True)
-    date_read = models.DateTimeField(blank=True, null=True)
-
-    class Meta:
-        abstract = True
-        app_label = 'customer'
-        ordering = ('-date_sent',)
-        verbose_name = _('Notification')
-        verbose_name_plural = _('Notifications')
-
-    def __str__(self):
-        return self.subject
-
-    def archive(self):
-        self.location = self.ARCHIVE
-        self.save()
-    archive.alters_data = True
-
-    @property
-    def is_read(self):
-        return self.date_read is not None
-
-
 class AbstractProductAlert(models.Model):
     """
     An alert for when a product comes back in stock
@@ -342,7 +127,6 @@ class AbstractProductAlert(models.Model):
     user = models.ForeignKey(
         AUTH_USER_MODEL,
         blank=True,
-        db_index=True,
         null=True,
         on_delete=models.CASCADE,
         related_name="alerts",

src/oscar/apps/customer/alerts/receivers.py

@@ -7,8 +7,8 @@ from oscar.core.loading import get_model
 def send_product_alerts(sender, instance, created, **kwargs):
     if kwargs.get('raw', False):
         return
-    from oscar.apps.customer.alerts import utils
-    utils.send_product_alerts(instance.product)
+    from oscar.apps.customer.alerts.utils import AlertsDispatcher
+    AlertsDispatcher().send_product_alert_email_for_user(instance.product)
 
 
 if settings.OSCAR_EAGER_ALERTS:

src/oscar/apps/customer/alerts/utils.py

@@ -1,134 +1,163 @@
 import logging
+import warnings
 
-from django.contrib.sites.models import Site
-from django.core import mail
 from django.db.models import Max
 from django.template import loader
 
-from oscar.apps.customer.notifications import services
 from oscar.core.loading import get_class, get_model
+from oscar.utils.deprecation import RemovedInOscar22Warning
 
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
 ProductAlert = get_model('customer', 'ProductAlert')
 Product = get_model('catalogue', 'Product')
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+Dispatcher = get_class('communication.utils', 'Dispatcher')
 Selector = get_class('partner.strategy', 'Selector')
 
-logger = logging.getLogger('oscar.alerts')
+alerts_logger = logging.getLogger('oscar.alerts')
 
 
-def send_alerts():
+class AlertsDispatcher:
     """
-    Send out product alerts
+    Dispatcher to send concrete product alerts related emails
+    and notifications.
     """
-    products = Product.objects.filter(
-        productalert__status=ProductAlert.ACTIVE
-    ).distinct()
-    logger.info("Found %d products with active alerts", products.count())
-    for product in products:
-        send_product_alerts(product)
 
+    # Event codes
+    PRODUCT_ALERT_EVENT_CODE = 'PRODUCT_ALERT'
+    PRODUCT_ALERT_CONFIRMATION_EVENT_CODE = 'PRODUCT_ALERT_CONFIRMATION'
+
+    def __init__(self, logger=None, mail_connection=None):
+        self.dispatcher = Dispatcher(
+            logger=logger or alerts_logger,
+            mail_connection=mail_connection,
+        )
+
+    def send_alerts(self):
+        """
+        Check all products with active product alerts for
+        availability and send out email alerts when a product is
+        available to buy.
+        """
+        products = Product.browsable.filter(productalert__status=ProductAlert.ACTIVE).distinct()
+        self.dispatcher.logger.info("Found %d products with active alerts", products.count())
+        for product in products:
+            self.send_product_alert_email_for_user(product)
+
+    def send_product_alert_email_for_user(self, product):  # noqa: C901 too complex
+        """
+        Check for notifications for this product and send email to users
+        if the product is back in stock. Add a little 'hurry' note if the
+        amount of in-stock items is less then the number of notifications.
+        """
+        stockrecords = product.stockrecords.all()
+        num_stockrecords = len(stockrecords)
+        if not num_stockrecords:
+            return
+
+        self.dispatcher.logger.info("Sending alerts for '%s'", product)
+        alerts = ProductAlert.objects.filter(
+            product_id__in=(product.id, product.parent_id),
+            status=ProductAlert.ACTIVE,
+        )
+
+        # Determine 'hurry mode'
+        if num_stockrecords == 1:
+            num_in_stock = stockrecords[0].num_in_stock
+        else:
+            result = stockrecords.aggregate(max_in_stock=Max('num_in_stock'))
+            num_in_stock = result['max_in_stock']
+
+        # 'hurry_mode' is false if 'num_in_stock' is None
+        hurry_mode = num_in_stock is not None and alerts.count() > num_in_stock
+
+        messages_to_send = []
+        user_messages_to_send = []
+        num_notifications = 0
+        selector = Selector()
+        for alert in alerts:
+            # Check if the product is available to this user
+            strategy = selector.strategy(user=alert.user)
+            data = strategy.fetch_for_product(product)
+            if not data.availability.is_available_to_buy:
+                continue
+
+            extra_context = {
+                'alert': alert,
+                'hurry': hurry_mode,
+            }
+            if alert.user:
+                # Send a site notification
+                num_notifications += 1
+                self.notify_user_about_product_alert(alert.user, extra_context)
+
+            messages = self.dispatcher.get_messages(self.PRODUCT_ALERT_EVENT_CODE, extra_context)
+
+            if messages and messages['body']:
+                if alert.user:
+                    user_messages_to_send.append((alert.user, messages))
+                else:
+                    messages_to_send.append((alert.get_email_address(), messages))
+            alert.close()
+
+        if messages_to_send or user_messages_to_send:
+            for message in messages_to_send:
+                self.dispatcher.dispatch_direct_messages(*message)
+            for message in user_messages_to_send:
+                self.dispatcher.dispatch_user_messages(*message)
+
+        self.dispatcher.logger.info(
+            "Sent %d notifications and %d messages",
+            num_notifications, len(messages_to_send) + len(user_messages_to_send)
+        )
+
+    def send_product_alert_confirmation_email_for_user(self, alert, extra_context=None):
+        """
+        Send an alert confirmation email.
+        """
+        if extra_context is None:
+            extra_context = {'alert': alert}
+        messages = self.dispatcher.get_messages(self.PRODUCT_ALERT_CONFIRMATION_EVENT_CODE, extra_context)
+        self.dispatcher.dispatch_direct_messages(alert.email, messages)
+
+    def notify_user_about_product_alert(self, user, context):
+        subj_tpl = loader.get_template('oscar/customer/alerts/message_subject.html')
+        message_tpl = loader.get_template('oscar/customer/alerts/message.html')
+        self.dispatcher.notify_user(
+            user,
+            subj_tpl.render(context).strip(),
+            body=message_tpl.render(context).strip()
+        )
 
-def send_alert_confirmation(alert):
-    """
-    Send an alert confirmation email.
-    """
-    ctx = {
-        'alert': alert,
-        'site': Site.objects.get_current(),
-    }
 
-    code = 'PRODUCT_ALERT_CONFIRMATION'
-    messages = CommunicationEventType.objects.get_and_render(code, ctx)
+def send_alerts():
+    warnings.warn(
+        'Use of `send_alerts` is deprecated. Please use `send_alerts` '
+        'method of `AlertsDispatcher`.',
+        RemovedInOscar22Warning,
+        stacklevel=2,
+    )
 
-    if messages and messages['body']:
-        Dispatcher().dispatch_direct_messages(alert.email, messages)
+    AlertsDispatcher().send_alerts()
 
 
-def send_product_alerts(product):   # noqa C901 too complex
-    """
-    Check for notifications for this product and send email to users
-    if the product is back in stock. Add a little 'hurry' note if the
-    amount of in-stock items is less then the number of notifications.
-    """
-    stockrecords = product.stockrecords.all()
-    num_stockrecords = len(stockrecords)
-    if not num_stockrecords:
-        return
-
-    logger.info("Sending alerts for '%s'", product)
-    alerts = ProductAlert.objects.filter(
-        product_id__in=(product.id, product.parent_id),
-        status=ProductAlert.ACTIVE,
+def send_alert_confirmation(alert):
+    warnings.warn(
+        'Use of `send_alert_confirmation` is deprecated. Please use '
+        '`send_product_alert_confirmation_email_for_user` method of '
+        '`AlertsDispatcher`.',
+        RemovedInOscar22Warning,
+        stacklevel=2,
     )
 
-    # Determine 'hurry mode'
-    if num_stockrecords == 1:
-        num_in_stock = stockrecords[0].num_in_stock
-    else:
-        result = stockrecords.aggregate(max_in_stock=Max('num_in_stock'))
-        num_in_stock = result['max_in_stock']
-
-    # hurry_mode is false if num_in_stock is None
-    hurry_mode = num_in_stock is not None and alerts.count() > num_in_stock
-
-    code = 'PRODUCT_ALERT'
-    try:
-        event_type = CommunicationEventType.objects.get(code=code)
-    except CommunicationEventType.DoesNotExist:
-        event_type = CommunicationEventType.objects.model(code=code)
-
-    messages_to_send = []
-    user_messages_to_send = []
-    num_notifications = 0
-    selector = Selector()
-    for alert in alerts:
-        # Check if the product is available to this user
-        strategy = selector.strategy(user=alert.user)
-        data = strategy.fetch_for_product(product)
-        if not data.availability.is_available_to_buy:
-            continue
-
-        ctx = {
-            'alert': alert,
-            'site': Site.objects.get_current(),
-            'hurry': hurry_mode,
-        }
-        if alert.user:
-            # Send a site notification
-            num_notifications += 1
-            subj_tpl = loader.get_template('oscar/customer/alerts/message_subject.html')
-            message_tpl = loader.get_template('oscar/customer/alerts/message.html')
-            services.notify_user(
-                alert.user,
-                subj_tpl.render(ctx).strip(),
-                body=message_tpl.render(ctx).strip()
-            )
-
-        # Build message and add to list
-        messages = event_type.get_messages(ctx)
-
-        if messages and messages['body']:
-            if alert.user:
-                user_messages_to_send.append(
-                    (alert.user, messages)
-                )
-            else:
-                messages_to_send.append(
-                    (alert.get_email_address(), messages)
-                )
-        alert.close()
-
-    # Send all messages using one SMTP connection to avoid opening lots of them
-    if messages_to_send or user_messages_to_send:
-        connection = mail.get_connection()
-        connection.open()
-        disp = Dispatcher(mail_connection=connection)
-        for message in messages_to_send:
-            disp.dispatch_direct_messages(*message)
-        for message in user_messages_to_send:
-            disp.dispatch_user_messages(*message)
-        connection.close()
-
-    logger.info("Sent %d notifications and %d messages", num_notifications,
-                len(messages_to_send) + len(user_messages_to_send))
+    AlertsDispatcher().send_product_alert_confirmation_email_for_user(alert)
+
+
+def send_product_alerts(product):
+    warnings.warn(
+        'Use of `send_product_alerts` is deprecated. '
+        'Please use `send_product_alert_email_for_user` '
+        'method of `AlertsDispatcher`.',
+        RemovedInOscar22Warning,
+        stacklevel=2,
+    )
+
+    AlertsDispatcher().send_product_alert_email_for_user(product)

src/oscar/apps/customer/alerts/views.py

@@ -5,7 +5,7 @@ from django.shortcuts import get_object_or_404
 from django.utils.translation import gettext_lazy as _
 from django.views import generic
 
-from oscar.apps.customer.alerts import utils
+from oscar.apps.customer.alerts.utils import AlertsDispatcher
 from oscar.core.loading import get_class, get_model
 
 Product = get_model('catalogue', 'Product')
@@ -60,7 +60,7 @@ class ProductAlertCreateView(generic.CreateView):
     def form_valid(self, form):
         response = super().form_valid(form)
         if self.object.is_anonymous:
-            utils.send_alert_confirmation(self.object)
+            AlertsDispatcher().send_product_alert_confirmation_email_for_user(self.object)
         return response
 
     def get_success_url(self):

src/oscar/apps/customer/apps.py

@@ -42,13 +42,13 @@ class CustomerConfig(OscarConfig):
         self.profile_delete_view = get_class('customer.views', 'ProfileDeleteView')
         self.change_password_view = get_class('customer.views', 'ChangePasswordView')
 
-        self.notification_inbox_view = get_class('customer.notifications.views',
+        self.notification_inbox_view = get_class('communication.notifications.views',
                                                  'InboxView')
-        self.notification_archive_view = get_class('customer.notifications.views',
+        self.notification_archive_view = get_class('communication.notifications.views',
                                                    'ArchiveView')
-        self.notification_update_view = get_class('customer.notifications.views',
+        self.notification_update_view = get_class('communication.notifications.views',
                                                   'UpdateView')
-        self.notification_detail_view = get_class('customer.notifications.views',
+        self.notification_detail_view = get_class('communication.notifications.views',
                                                   'DetailView')
 
         self.alert_list_view = get_class('customer.alerts.views',

src/oscar/apps/customer/forms.py

@@ -17,8 +17,7 @@ from oscar.core.compat import existing_user_fields, get_user_model
 from oscar.core.loading import get_class, get_model, get_profile_class
 from oscar.forms import widgets
 
-Dispatcher = get_class('customer.utils', 'Dispatcher')
-CommunicationEventType = get_model('customer', 'communicationeventtype')
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
 ProductAlert = get_model('customer', 'ProductAlert')
 User = get_user_model()
 
@@ -38,10 +37,8 @@ class PasswordResetForm(auth_forms.PasswordResetForm):
     """
     This form takes the same structure as its parent from :py:mod:`django.contrib.auth`
     """
-    communication_type_code = "PASSWORD_RESET"
 
-    def save(self, domain_override=None, use_https=False, request=None,
-             **kwargs):
+    def save(self, domain_override=None, request=None, **kwargs):
         """
         Generates a one-use only link for resetting password and sends to the
         user.
@@ -53,24 +50,15 @@ class PasswordResetForm(auth_forms.PasswordResetForm):
         active_users = User._default_manager.filter(
             email__iexact=email, is_active=True)
         for user in active_users:
-            reset_url = self.get_reset_url(site, request, user, use_https)
-            ctx = {
-                'user': user,
-                'site': site,
-                'reset_url': reset_url}
-            messages = CommunicationEventType.objects.get_and_render(
-                code=self.communication_type_code, context=ctx)
-            Dispatcher().dispatch_user_messages(user, messages)
-
-    def get_reset_url(self, site, request, user, use_https):
-        # the request argument isn't used currently, but implementors might
-        # need it to determine the correct subdomain
-        reset_url = "%s://%s%s" % (
-            'https' if use_https else 'http',
-            site.domain,
-            get_password_reset_url(user))
-
-        return reset_url
+            self.send_password_reset_email(site, user)
+
+    def send_password_reset_email(self, site, user):
+        extra_context = {
+            'user': user,
+            'site': site,
+            'reset_url': get_password_reset_url(user),
+        }
+        CustomerDispatcher().send_password_reset_email_for_user(user, extra_context)
 
 
 class EmailAuthenticationForm(AuthenticationForm):

src/oscar/apps/customer/migrations/0006_auto_20190430_1736.py

@@ -0,0 +1,40 @@
+# Generated by Django 2.0.13 on 2019-04-30 16:36
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('customer', '0005_auto_20181115_1953'),
+    ]
+
+    state_operations = [
+        migrations.DeleteModel(
+            name='CommunicationEventType',
+        ),
+        migrations.RemoveField(
+            model_name='email',
+            name='user',
+        ),
+        migrations.RemoveField(
+            model_name='notification',
+            name='recipient',
+        ),
+        migrations.RemoveField(
+            model_name='notification',
+            name='sender',
+        ),
+        migrations.DeleteModel(
+            name='Email',
+        ),
+        migrations.DeleteModel(
+            name='Notification',
+        ),
+    ]
+
+    operations = [
+        migrations.SeparateDatabaseAndState(
+            state_operations=state_operations
+        ),
+    ]

src/oscar/apps/customer/mixins.py

@@ -3,15 +3,14 @@ import logging
 from django.conf import settings
 from django.contrib.auth import authenticate
 from django.contrib.auth import login as auth_login
-from django.contrib.sites.shortcuts import get_current_site
 
 from oscar.apps.customer.signals import user_registered
 from oscar.core.compat import get_user_model
 from oscar.core.loading import get_class, get_model
 
 User = get_user_model()
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
 
 logger = logging.getLogger('oscar.customer')
 
@@ -38,7 +37,6 @@ class PageTitleMixin(object):
 
 
 class RegisterUserMixin(object):
-    communication_type_code = 'REGISTRATION'
 
     def register_user(self, form):
         """
@@ -84,10 +82,5 @@ class RegisterUserMixin(object):
         return user
 
     def send_registration_email(self, user):
-        code = self.communication_type_code
-        ctx = {'user': user,
-               'site': get_current_site(self.request)}
-        messages = CommunicationEventType.objects.get_and_render(
-            code, ctx)
-        if messages and messages['body']:
-            Dispatcher().dispatch_user_messages(user, messages)
+        extra_context = {'user': user}
+        CustomerDispatcher().send_registration_email_for_user(user, extra_context)

src/oscar/apps/customer/models.py

@@ -4,28 +4,6 @@ from oscar.core.loading import is_model_registered
 __all__ = []
 
 
-if not is_model_registered('customer', 'Email'):
-    class Email(abstract_models.AbstractEmail):
-        pass
-
-    __all__.append('Email')
-
-
-if not is_model_registered('customer', 'CommunicationEventType'):
-    class CommunicationEventType(
-            abstract_models.AbstractCommunicationEventType):
-        pass
-
-    __all__.append('CommunicationEventType')
-
-
-if not is_model_registered('customer', 'Notification'):
-    class Notification(abstract_models.AbstractNotification):
-        pass
-
-    __all__.append('Notification')
-
-
 if not is_model_registered('customer', 'ProductAlert'):
     class ProductAlert(abstract_models.AbstractProductAlert):
         pass

src/oscar/apps/customer/notifications/services.py

@@ -1,18 +1,26 @@
-from oscar.core.loading import get_model
+import warnings
 
-Notification = get_model('customer', 'Notification')
+from oscar.core.loading import get_class
+from oscar.utils.deprecation import RemovedInOscar22Warning
+
+Dispatcher = get_class('communication.utils', 'Dispatcher')
 
 
 def notify_user(user, subject, **kwargs):
-    """
-    Send a simple notification to a user
-    """
-    Notification.objects.create(recipient=user, subject=subject, **kwargs)
+    warnings.warn(
+        'Use of `notify_user` is deprecated. Please use `notify_user` '
+        'method of `communications.utils.Dispatcher`.',
+        RemovedInOscar22Warning,
+        stacklevel=2,
+    )
+    Dispatcher().notify_user(user, subject, **kwargs)
 
 
 def notify_users(users, subject, **kwargs):
-    """
-    Send a simple notification to an iterable of users
-    """
-    for user in users:
-        notify_user(user, subject, **kwargs)
+    warnings.warn(
+        'Use of `notify_users` is deprecated. Please use `notify_users` '
+        'method of `communications.utils.Dispatcher`.',
+        RemovedInOscar22Warning,
+        stacklevel=2,
+    )
+    Dispatcher().notify_users(users, subject, **kwargs)

src/oscar/apps/customer/utils.py

@@ -1,130 +1,44 @@
-import logging
-
-from django.conf import settings
 from django.contrib.auth.tokens import default_token_generator
-from django.core.mail import EmailMessage, EmailMultiAlternatives
 from django.urls import reverse
 from django.utils.encoding import force_bytes
 
 from oscar.core.compat import urlsafe_base64_encode
-from oscar.core.loading import get_model
-
-CommunicationEvent = get_model('order', 'CommunicationEvent')
-Email = get_model('customer', 'Email')
-
-
-class Dispatcher(object):
-    def __init__(self, logger=None, mail_connection=None):
-        if not logger:
-            logger = logging.getLogger(__name__)
-        self.logger = logger
-        # Supply a mail_connection if you want the dispatcher to use that
-        # instead of opening a new one.
-        self.mail_connection = mail_connection
-
-    # Public API methods
-
-    def dispatch_direct_messages(self, recipient, messages):
-        """
-        Dispatch one-off messages to explicitly specified recipient.
-        """
-        if messages['subject'] and (messages['body'] or messages['html']):
-            return self.send_email_messages(recipient, messages)
-
-    def dispatch_order_messages(self, order, messages, event_type=None, **kwargs):
-        """
-        Dispatch order-related messages to the customer.
-        """
-        if order.is_anonymous:
-            email = kwargs.get('email_address', order.guest_email)
-            dispatched_messages = self.dispatch_anonymous_messages(email, messages)
-        else:
-            dispatched_messages = self.dispatch_user_messages(order.user, messages)
+from oscar.core.loading import get_class
 
-        self.create_communication_event(order, event_type, dispatched_messages)
+Dispatcher = get_class('communication.utils', 'Dispatcher')
+Selector = get_class('partner.strategy', 'Selector')
 
-    def dispatch_anonymous_messages(self, email, messages):
-        dispatched_messages = {}
-        if email:
-            dispatched_messages['email'] = self.send_email_messages(email, messages), None
-        return dispatched_messages
 
-    def dispatch_user_messages(self, user, messages):
-        """
-        Send messages to a site user
-        """
-        dispatched_messages = {}
-        if messages['subject'] and (messages['body'] or messages['html']):
-            dispatched_messages['email'] = self.send_user_email_messages(user, messages)
-        if messages['sms']:
-            dispatched_messages['sms'] = self.send_text_message(user, messages['sms'])
-        return dispatched_messages
-
-    # Internal
-
-    def create_communication_event(self, order, event_type, dispatched_messages):
-        """
-        Create order communications event for audit
-        """
-        if dispatched_messages and event_type is not None:
-            CommunicationEvent._default_manager.create(order=order, event_type=event_type)
-
-    def create_customer_email(self, user, messages, email):
-        """
-        Create Email instance in database for logging purposes.
-        """
-        # Is user is signed in, record the event for audit
-        if email and user.is_authenticated:
-            return Email._default_manager.create(user=user,
-                                                 email=user.email,
-                                                 subject=email.subject,
-                                                 body_text=email.body,
-                                                 body_html=messages['html'])
-
-    def send_user_email_messages(self, user, messages):
-        """
-        Send message to the registered user / customer and collect data in database.
-        """
-        if not user.email:
-            self.logger.warning("Unable to send email messages as user #%d has"
-                                " no email address", user.id)
-            return None, None
+class CustomerDispatcher:
+    """
+    Dispatcher to send concrete customer related emails.
+    """
 
-        email = self.send_email_messages(user.email, messages)
-        return email, self.create_customer_email(user, messages, email)
+    # Event codes
+    REGISTRATION_EVENT_CODE = 'REGISTRATION'
+    PASSWORD_RESET_EVENT_CODE = 'PASSWORD_RESET'
+    PASSWORD_CHANGED_EVENT_CODE = 'PASSWORD_CHANGED'
+    EMAIL_CHANGED_EVENT_CODE = 'EMAIL_CHANGED'
 
-    def send_email_messages(self, recipient, messages):
-        """
-        Send email to recipient, HTML attachment optional.
-        """
-        if hasattr(settings, 'OSCAR_FROM_EMAIL'):
-            from_email = settings.OSCAR_FROM_EMAIL
-        else:
-            from_email = None
+    def __init__(self, logger=None, mail_connection=None):
+        self.dispatcher = Dispatcher(logger=logger, mail_connection=mail_connection)
 
-        # Determine whether we are sending a HTML version too
-        if messages['html']:
-            email = EmailMultiAlternatives(messages['subject'],
-                                           messages['body'],
-                                           from_email=from_email,
-                                           to=[recipient])
-            email.attach_alternative(messages['html'], "text/html")
-        else:
-            email = EmailMessage(messages['subject'],
-                                 messages['body'],
-                                 from_email=from_email,
-                                 to=[recipient])
-        self.logger.info("Sending email to %s" % recipient)
+    def send_registration_email_for_user(self, user, extra_context):
+        messages = self.dispatcher.get_messages(self.REGISTRATION_EVENT_CODE, extra_context)
+        self.dispatcher.dispatch_user_messages(user, messages)
 
-        if self.mail_connection:
-            self.mail_connection.send_messages([email])
-        else:
-            email.send()
+    def send_password_reset_email_for_user(self, user, extra_context):
+        messages = self.dispatcher.get_messages(self.PASSWORD_RESET_EVENT_CODE, extra_context)
+        self.dispatcher.dispatch_user_messages(user, messages)
 
-        return email
+    def send_password_changed_email_for_user(self, user, extra_context):
+        messages = self.dispatcher.get_messages(self.PASSWORD_CHANGED_EVENT_CODE, extra_context)
+        self.dispatcher.dispatch_user_messages(user, messages)
 
-    def send_text_message(self, user, event_type):
-        raise NotImplementedError
+    def send_email_changed_email_for_user(self, user, extra_context):
+        messages = self.dispatcher.get_messages(
+            self.EMAIL_CHANGED_EVENT_CODE, extra_context)
+        self.dispatcher.dispatch_user_messages(user, messages)
 
 
 def get_password_reset_url(user, token_generator=default_token_generator):

src/oscar/apps/customer/views.py

@@ -5,7 +5,6 @@ from django.contrib.auth import login as auth_login
 from django.contrib.auth import logout as auth_logout
 from django.contrib.auth import update_session_auth_hash
 from django.contrib.auth.forms import PasswordChangeForm
-from django.contrib.sites.shortcuts import get_current_site
 from django.core.exceptions import ObjectDoesNotExist
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse, reverse_lazy
@@ -23,7 +22,7 @@ from . import signals
 
 PageTitleMixin, RegisterUserMixin = get_classes(
     'customer.mixins', ['PageTitleMixin', 'RegisterUserMixin'])
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
 EmailAuthenticationForm, EmailUserCreationForm, OrderSearchForm = get_classes(
     'customer.forms', ['EmailAuthenticationForm', 'EmailUserCreationForm',
                        'OrderSearchForm'])
@@ -31,11 +30,8 @@ ProfileForm, ConfirmPasswordForm = get_classes(
     'customer.forms', ['ProfileForm', 'ConfirmPasswordForm'])
 UserAddressForm = get_class('address.forms', 'UserAddressForm')
 Order = get_model('order', 'Order')
-Line = get_model('basket', 'Line')
-Basket = get_model('basket', 'Basket')
 UserAddress = get_model('address', 'UserAddress')
-Email = get_model('customer', 'Email')
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
+Email = get_model('communication', 'Email')
 
 User = get_user_model()
 
@@ -305,7 +301,6 @@ class ProfileView(PageTitleMixin, generic.TemplateView):
 class ProfileUpdateView(PageTitleMixin, generic.FormView):
     form_class = ProfileForm
     template_name = 'oscar/customer/profile/profile_form.html'
-    communication_type_code = 'EMAIL_CHANGED'
     page_title = _('Edit Profile')
     active_tab = 'profile'
     success_url = reverse_lazy('customer:profile-view')
@@ -334,19 +329,20 @@ class ProfileUpdateView(PageTitleMixin, generic.FormView):
             # Email address has changed - send a confirmation email to the old
             # address including a password reset link in case this is a
             # suspicious change.
-            ctx = {
-                'user': self.request.user,
-                'site': get_current_site(self.request),
-                'reset_url': get_password_reset_url(old_user),
-                'new_email': new_email,
-            }
-            msgs = CommunicationEventType.objects.get_and_render(
-                code=self.communication_type_code, context=ctx)
-            Dispatcher().dispatch_user_messages(old_user, msgs)
+            self.send_email_changed_email(old_user, new_email)
 
         messages.success(self.request, _("Profile updated"))
         return redirect(self.get_success_url())
 
+    def send_email_changed_email(self, old_user, new_email):
+        user = self.request.user
+        extra_context = {
+            'user': user,
+            'reset_url': get_password_reset_url(old_user),
+            'new_email': new_email,
+        }
+        CustomerDispatcher().send_email_changed_email_for_user(old_user, extra_context)
+
 
 class ProfileDeleteView(PageTitleMixin, generic.FormView):
     form_class = ConfirmPasswordForm
@@ -371,7 +367,6 @@ class ProfileDeleteView(PageTitleMixin, generic.FormView):
 class ChangePasswordView(PageTitleMixin, generic.FormView):
     form_class = PasswordChangeForm
     template_name = 'oscar/customer/profile/change_password_form.html'
-    communication_type_code = 'PASSWORD_CHANGED'
     page_title = _('Change Password')
     active_tab = 'profile'
     success_url = reverse_lazy('customer:profile-view')
@@ -386,17 +381,18 @@ class ChangePasswordView(PageTitleMixin, generic.FormView):
         update_session_auth_hash(self.request, self.request.user)
         messages.success(self.request, _("Password updated"))
 
-        ctx = {
-            'user': self.request.user,
-            'site': get_current_site(self.request),
-            'reset_url': get_password_reset_url(self.request.user),
-        }
-        msgs = CommunicationEventType.objects.get_and_render(
-            code=self.communication_type_code, context=ctx)
-        Dispatcher().dispatch_user_messages(self.request.user, msgs)
+        self.send_password_changed_email()
 
         return redirect(self.get_success_url())
 
+    def send_password_changed_email(self):
+        user = self.request.user
+        extra_context = {
+            'user': user,
+            'reset_url': get_password_reset_url(self.request.user),
+        }
+        CustomerDispatcher().send_password_changed_email_for_user(user, extra_context)
+
 
 # =============
 # Email history
@@ -404,7 +400,7 @@ class ChangePasswordView(PageTitleMixin, generic.FormView):
 
 class EmailHistoryView(PageTitleMixin, generic.ListView):
     context_object_name = "emails"
-    template_name = 'oscar/customer/email/email_list.html'
+    template_name = 'oscar/communication/email/email_list.html'
     paginate_by = settings.OSCAR_EMAILS_PER_PAGE
     page_title = _('Email History')
     active_tab = 'emails'
@@ -419,7 +415,7 @@ class EmailHistoryView(PageTitleMixin, generic.ListView):
 
 class EmailDetailView(PageTitleMixin, generic.DetailView):
     """Customer email"""
-    template_name = "oscar/customer/email/email_detail.html"
+    template_name = "oscar/communication/email/email_detail.html"
     context_object_name = 'email'
     active_tab = 'emails'
 

src/oscar/apps/dashboard/communications/forms.py

@@ -5,7 +5,7 @@ from django.utils.translation import gettext_lazy as _
 from oscar.apps.customer.utils import normalise_email
 from oscar.core.loading import get_model
 
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
 Order = get_model('order', 'Order')
 
 

src/oscar/apps/dashboard/communications/views.py

@@ -6,10 +6,10 @@ from django.views import generic
 
 from oscar.core.loading import get_class, get_model
 
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
 CommunicationEventTypeForm = get_class('dashboard.communications.forms',
                                        'CommunicationEventTypeForm')
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+Dispatcher = get_class('communication.utils', 'Dispatcher')
 
 
 class ListView(generic.ListView):

src/oscar/apps/order/abstract_models.py

@@ -472,7 +472,7 @@ class AbstractCommunicationEvent(models.Model):
         related_name="communication_events",
         verbose_name=_("Order"))
     event_type = models.ForeignKey(
-        'customer.CommunicationEventType',
+        'communication.CommunicationEventType',
         on_delete=models.CASCADE,
         verbose_name=_("Event Type"))
     date_created = models.DateTimeField(_("Date"), auto_now_add=True, db_index=True)

src/oscar/apps/order/migrations/0008_auto_20190301_1035.py

@@ -0,0 +1,20 @@
+# Generated by Django 2.1.7 on 2019-03-01 10:35
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('order', '0007_auto_20181115_1953'),
+        ('communication', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='communicationevent',
+            name='event_type',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='communication.CommunicationEventType', verbose_name='Event Type'),
+        ),
+    ]

src/oscar/apps/order/utils.py

@@ -6,13 +6,16 @@ from django.db import transaction
 from django.utils.translation import gettext_lazy as _
 
 from oscar.apps.order.signals import order_placed
-from oscar.core.loading import get_model
+from oscar.core.loading import get_class, get_model
 
 from . import exceptions
 
 Order = get_model('order', 'Order')
 Line = get_model('order', 'Line')
 OrderDiscount = get_model('order', 'OrderDiscount')
+CommunicationEvent = get_model('order', 'CommunicationEvent')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+Dispatcher = get_class('communication.utils', 'Dispatcher')
 
 
 class OrderNumberGenerator(object):
@@ -260,3 +263,45 @@ class OrderCreator(object):
         Updates the models that care about this voucher.
         """
         voucher.record_usage(order, user)
+
+
+class OrderDispatcher:
+    """
+    Dispatcher to send concrete order related emails.
+    """
+
+    # Event codes
+    ORDER_PLACED_EVENT_CODE = 'ORDER_PLACED'
+
+    def __init__(self, logger=None, mail_connection=None):
+        self.dispatcher = Dispatcher(logger=logger, mail_connection=mail_connection)
+
+    def dispatch_order_messages(self, order, messages, event_code, attachments=None, **kwargs):
+        """
+        Dispatch order-related messages to the customer.
+        """
+        self.dispatcher.logger.info("Order #%s - sending %s messages", order.number, event_code)
+        if order.is_anonymous:
+            email = kwargs.get('email_address', order.guest_email)
+            dispatched_messages = self.dispatcher.dispatch_anonymous_messages(email, messages, attachments)
+        else:
+            dispatched_messages = self.dispatcher.dispatch_user_messages(order.user, messages, attachments)
+
+        try:
+            event_type = CommunicationEventType.objects.get(code=event_code)
+        except CommunicationEventType.DoesNotExist:
+            event_type = None
+
+        self.create_communication_event(order, event_type, dispatched_messages)
+
+    def create_communication_event(self, order, event_type, dispatched_messages):
+        """
+        Create order communications event for audit.
+        """
+        if dispatched_messages and event_type is not None:
+            CommunicationEvent._default_manager.create(order=order, event_type=event_type)
+
+    def send_order_placed_email_for_user(self, order, extra_context, attachments=None):
+        event_code = self.ORDER_PLACED_EVENT_CODE
+        messages = self.dispatcher.get_messages(event_code, extra_context)
+        self.dispatch_order_messages(order, messages, event_code, attachments=attachments)

src/oscar/core/loading.py

@@ -1,5 +1,6 @@
 import sys
 import traceback
+import warnings
 from importlib import import_module
 
 from django.apps import apps
@@ -11,6 +12,16 @@ from django.utils.module_loading import import_string
 
 from oscar.core.exceptions import (
     AppNotFoundError, ClassNotFoundError, ModuleNotFoundError)
+from oscar.utils.deprecation import RemovedInOscar22Warning
+
+# To preserve backwards compatibility of loading classes which moved
+# from one Oscar module to another, we look into the dictionary below
+# for the moved items during loading.
+MOVED_MODELS = {
+    'customer': (
+        'communication', ('communicationeventtype', 'email', 'notification')
+    )
+}
 
 
 def get_class(module_label, classname, module_prefix='oscar.apps'):
@@ -224,6 +235,15 @@ def get_model(app_label, model_name):
     registry not being ready yet.
     Raises LookupError if model isn't found.
     """
+    oscar_moved_model = MOVED_MODELS.get(app_label, None)
+    if oscar_moved_model:
+        if model_name.lower() in oscar_moved_model[1]:
+            original_app_label = app_label
+            app_label = oscar_moved_model[0]
+            warnings.warn(
+                'Model %s has recently moved from %s to the application %s, '
+                'please update your imports.' % (model_name, original_app_label, app_label),
+                RemovedInOscar22Warning, stacklevel=2)
     try:
         return apps.get_model(app_label, model_name)
     except AppRegistryNotReady:

src/oscar/defaults.py

@@ -245,3 +245,7 @@ OSCAR_SEARCH_FACETS = {
 OSCAR_PRODUCT_SEARCH_HANDLER = None
 
 OSCAR_THUMBNAILER = 'oscar.core.thumbnails.SorlThumbnail'
+
+OSCAR_URL_SCHEMA = 'http'
+
+OSCAR_SAVE_SENT_EMAILS_TO_DB = True

src/oscar/management/commands/oscar_generate_email_content.py

@@ -1,10 +1,9 @@
 from django.core.management.base import BaseCommand, CommandError
 
-from oscar.core.loading import get_class, get_model
+from oscar.core.loading import get_model
 
 Order = get_model('order', 'Order')
-CommunicationEventType = get_model('customer', 'CommunicationEventType')
-Dispatcher = get_class('customer.utils', 'Dispatcher')
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
 
 
 class Command(BaseCommand):

src/oscar/management/commands/oscar_send_alerts.py

@@ -3,7 +3,7 @@ import logging
 from django.core.management.base import BaseCommand
 from django.utils.translation import gettext_lazy as _
 
-from oscar.apps.customer.alerts import utils
+from oscar.apps.customer.alerts.utils import AlertsDispatcher
 
 logger = logging.getLogger(__name__)
 
@@ -22,4 +22,4 @@ class Command(BaseCommand):
         availability and send out email alerts when a product is
         available to buy.
         """
-        utils.send_alerts()
+        AlertsDispatcher().send_alerts()

src/oscar/templates/oscar/customer/emails/commtype_email_changed_body.html → src/oscar/templates/oscar/communication/emails/commtype_email_changed_body.html

@@ -1,5 +1,6 @@
-{% extends "oscar/customer/emails/base.html" %}
+{% extends "oscar/communication/emails/base.html" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block tbody %}
 <tr>
@@ -16,7 +17,7 @@
 
 <tr>
     <td class="content-block">
-        <a href="http://{{ site.domain }}{{ reset_url }}" class="btn-primary">Reset password</a>
+        <a href="{% absolute_url site.domain reset_url %}" class="btn-primary">Reset password</a>
     </td>
 </tr>
 

src/oscar/templates/oscar/customer/emails/commtype_email_changed_body.txt → src/oscar/templates/oscar/communication/emails/commtype_email_changed_body.txt

@@ -1,10 +1,11 @@
-{% extends "oscar/customer/emails/base.txt" %}
+{% extends "oscar/communication/emails/base.txt" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block body %}{% autoescape off %}{% blocktrans with email=new_email %}You're receiving this email because your email address has been changed to {{ email }}.{% endblocktrans %}
 
 {% trans "If it wasn't you who changed it, please reset your password immediately and correct your email address:" %}
-http://{{ site.domain }}{{ reset_url }}
+{% absolute_url site.domain reset_url %}
 
 {% trans "If it was you who changed the email address, you can ignore this email." %}
 {% endautoescape %}{% endblock %}

src/oscar/templates/oscar/customer/emails/commtype_order_placed_body.html → src/oscar/templates/oscar/communication/emails/commtype_order_placed_body.html

@@ -1,4 +1,4 @@
-{% extends "oscar/customer/emails/base.html" %}
+{% extends "oscar/communication/emails/base.html" %}
 {% load currency_filters i18n %}
 
 {% block tbody %}

src/oscar/templates/oscar/customer/emails/commtype_password_changed_body.html → src/oscar/templates/oscar/communication/emails/commtype_password_changed_body.html

@@ -1,5 +1,6 @@
-{% extends "oscar/customer/emails/base.html" %}
+{% extends "oscar/communication/emails/base.html" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block tbody %}
     <tr>
@@ -16,7 +17,7 @@
 
     <tr>
         <td class="content-block">
-            <a href="http://{{ site.domain }}{{ reset_url }}" class="btn-primary">Reset password</a>
+            <a href="{% absolute_url site.domain reset_url %}" class="btn-primary">Reset password</a>
         </td>
     </tr>
 

src/oscar/templates/oscar/customer/emails/commtype_password_changed_body.txt → src/oscar/templates/oscar/communication/emails/commtype_password_changed_body.txt

@@ -1,12 +1,13 @@
-{% extends "oscar/customer/emails/base.txt" %}
+{% extends "oscar/communication/emails/base.txt" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block body %}{% autoescape off %}{% blocktrans with name=site.name %}
 You're receiving this email because your password has been changed at {{ name }}.
 {% endblocktrans %}
 
 {% trans "If it wasn't you who changed it, please reset your password immediately:" %}
-http://{{ site.domain }}{{ reset_url }}
+{% absolute_url site.domain reset_url %}
 
 {% trans "Otherwise, you can ignore this email." %}
 

src/oscar/templates/oscar/customer/emails/commtype_password_reset_body.html → src/oscar/templates/oscar/communication/emails/commtype_password_reset_body.html

@@ -1,5 +1,6 @@
-{% extends "oscar/customer/emails/base.html" %}
+{% extends "oscar/communication/emails/base.html" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block tbody %}
 <tr>
@@ -16,7 +17,7 @@
 
 <tr>
     <td class="content-block">
-        <a href="{{ reset_url }}" class="btn-primary">Reset password</a>
+        <a href="{% absolute_url site.domain reset_url %}" class="btn-primary">Reset password</a>
     </td>
 </tr>
 

src/oscar/templates/oscar/customer/emails/commtype_password_reset_body.txt → src/oscar/templates/oscar/communication/emails/commtype_password_reset_body.txt

@@ -1,8 +1,9 @@
-{% extends "oscar/customer/emails/base.txt" %}
+{% extends "oscar/communication/emails/base.txt" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block body %}{% autoescape off %}
 {% blocktrans with name=site.name %}You're receiving this e-mail because you requested a password reset for your user account at {{ name }}.{% endblocktrans %}
 
 {% trans "Please go to the following page and choose a new password:" %}
-{{ reset_url }}{% endautoescape %}{% endblock %}
+{% absolute_url site.domain reset_url %}{% endautoescape %}{% endblock %}

src/oscar/templates/oscar/customer/emails/commtype_product_alert_body.html → src/oscar/templates/oscar/communication/emails/commtype_product_alert_body.html

@@ -1,5 +1,6 @@
-{% extends "oscar/customer/emails/base.html" %}
+{% extends "oscar/communication/emails/base.html" %}
 {% load i18n %}
+{% load url_tags %}
 
 {% block body %}
     <p>
@@ -11,9 +12,10 @@
     </p>
 
     <p>
-        {% blocktrans with title=alert.product.get_title|safe path=alert.product.get_absolute_url %}
+        {% absolute_url site.domain alert.product.get_absolute_url as url %}
+        {% blocktrans with title=alert.product.get_title|safe url=url %}
             We are happy to inform you that our product '{{ title }}' is back in stock:
-            http://{{ site }}{{ path }}
+            {{ url }}
         {% endblocktrans %}
     </p>
 
@@ -26,7 +28,7 @@
     {% endif %}
 
     <p>
-        {% blocktrans with site_name=site.name %}
+        {% blocktrans %}
             With this email we have disabled your alert automatically and you will not
             receive any further email regarding this product.
         {% endblocktrans %}

src/oscar/templates/oscar/customer/emails/commtype_product_alert_body.txt → src/oscar/templates/oscar/communication/emails/commtype_product_alert_body.txt

@@ -1,7 +1,8 @@
-{% load i18n %}{% if alert.user and alert.user.get_short_name %}{% blocktrans with name=alert.user.get_short_name %}Dear {{ name }},{% endblocktrans %}{% else %}{% trans "Hello," %}{% endif %}
-{% blocktrans with title=alert.product.get_title|safe path=alert.product.get_absolute_url %}
+{% load i18n %}{% load url_tags %}{% if alert.user and alert.user.get_short_name %}{% blocktrans with name=alert.user.get_short_name %}Dear {{ name }},{% endblocktrans %}{% else %}{% trans "Hello," %}{% endif %}
+{% absolute_url site.domain alert.product.get_absolute_url as url %}
+{% blocktrans with title=alert.product.get_title|safe url=url %}
 We are happy to inform you that our product '{{ title }}' is back in stock:
-http://{{ site }}{{ path }}
+{{ url }}
 {% endblocktrans %}{% if hurry %}{% blocktrans %}
 Beware that the amount of items in stock is limited. Be quick or someone might get there first.
 {% endblocktrans %}{% endif %}{% blocktrans with site_name=site.name %}

src/oscar/templates/oscar/communication/emails/commtype_product_alert_confirmation_body.html

@@ -0,0 +1,23 @@
+{% extends "oscar/communication/emails/base.html" %}
+{% load i18n %}
+{% load url_tags %}
+
+{% block body %}
+    {% absolute_url site.domain alert.get_confirm_url as confirm_url %}
+    {% absolute_url site.domain alert.get_cancel_url as cancel_url %}
+    {% blocktrans with title=alert.product.get_title|safe confirm_url=confirm_url cancel_url=cancel_url %}
+        Hello,
+        <p>
+            Somebody (hopefully you) has requested an email alert when '{{ title }}' is back in stock.
+            Please click the following link to confirm: {{ confirm_url }}
+        </p>
+        <p>
+            You can cancel this alert at any time by clicking the following link: {{ cancel_url }}
+        </p>
+
+        <p>
+            Thanks for your interest,
+            The {{ site }} Team
+        </p>
+    {% endblocktrans %}
+{% endblock %}

src/oscar/templates/oscar/communication/emails/commtype_product_alert_confirmation_body.txt

@@ -0,0 +1,17 @@
+{% load i18n %}
+{% load url_tags %}
+{% absolute_url site.domain alert.get_confirm_url as confirm_url %}
+{% absolute_url site.domain alert.get_cancel_url as cancel_url %}
+{% blocktrans with title=alert.product.get_title|safe confirm_url=confirm_url cancel_url=cancel_url %}
+Hello,
+
+Somebody (hopefully you) has requested an email alert when
+'{{ title }}' is back in stock.  Please click the following link
+to confirm: {{ confirm_url }}
+
+You can cancel this alert at any time by clicking the following link:
+{{ cancel_url }}
+
+Thanks for your interest,
+The {{ site }} Team
+{% endblocktrans %}

src/oscar/templates/oscar/customer/emails/commtype_product_alert_confirmation_body.txt

@@ -1,13 +0,0 @@
-{% load i18n %}{% blocktrans with title=alert.product.get_title|safe domain=site.domain confirm_path=alert.get_confirm_url cancel_path=alert.get_cancel_url %}Hello,
-
-Somebody (hopefully you) has requested an email alert when
-'{{ title }}' is back in stock.  Please click the following link
-to confirm:
-http://{{ domain }}{{ confirm_path }}
-
-You can cancel this alert at any time by clicking the following link:
-http://{{ domain }}{{ cancel_path }}
-
-Thanks for your interest,
-The {{ site }} Team
-{% endblocktrans %}

src/oscar/templatetags/url_tags.py

@@ -0,0 +1,13 @@
+from django import template
+from django.conf import settings
+
+register = template.Library()
+
+
+@register.simple_tag
+def absolute_url(domain, path):
+    return '{schema}://{domain}{path}'.format(
+        schema=settings.OSCAR_URL_SCHEMA,
+        domain=domain,
+        path=path
+    )

src/oscar/test/utils.py

@@ -8,6 +8,7 @@ from django.conf import settings
 from django.contrib.auth.models import AnonymousUser
 from django.contrib.messages.storage.fallback import FallbackStorage
 from django.contrib.sessions.backends.db import SessionStore
+from django.core import mail
 from django.core.signing import Signer
 from django.db import connection
 from django.test import RequestFactory as BaseRequestFactory
@@ -15,7 +16,7 @@ from sorl.thumbnail.conf import settings as sorl_settings
 
 from oscar.core.loading import get_class, get_model
 from oscar.core.thumbnails import get_thumbnailer
-from oscar.test.factories import ProductImageFactory
+from oscar.test.factories import ProductImageFactory, UserFactory
 
 OSCAR_IMAGE_FOLDER_FORMATTED = 'images/products/{0}/{1:02d}/'.format(date.today().year, date.today().month)
 FULL_PATH_TO_IMAGES_FOLDER = os.path.join(settings.MEDIA_ROOT, OSCAR_IMAGE_FOLDER_FORMATTED)
@@ -97,6 +98,29 @@ class ThumbnailMixin:
             assert not os.path.isfile(path)
 
 
+class EmailsMixin:
+
+    def setUp(self):
+        super().setUp()
+        self.user = UserFactory()
+
+    def _test_send_plain_text_and_html(self, outboxed_email):
+        email = outboxed_email
+
+        assert '</p>' not in email.body  # Plain text body (because w/o </p> tags)
+
+        html_content = email.alternatives[0][0]
+        assert '</p>' in html_content
+
+        mimetype = email.alternatives[0][1]
+        assert mimetype == 'text/html'
+
+    def _test_common_part(self):
+        assert len(mail.outbox) == 1
+        assert mail.outbox[0].to == [self.user.email]
+        self._test_send_plain_text_and_html(mail.outbox[0])
+
+
 class RequestFactory(BaseRequestFactory):
     Basket = get_model('basket', 'basket')
     selector = get_class('partner.strategy', 'Selector')()

src/oscar/utils/deprecation.py

@@ -1,2 +1,6 @@
 class RemovedInOscar21Warning(DeprecationWarning):
     pass
+
+
+class RemovedInOscar22Warning(DeprecationWarning):
+    pass

tests/_site/apps/customer/migrations/0006_auto_20190430_1736.py

@@ -0,0 +1,40 @@
+# Generated by Django 2.0.13 on 2019-04-30 16:36
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('customer', '0005_auto_20181115_1953'),
+    ]
+
+    state_operations = [
+        migrations.DeleteModel(
+            name='CommunicationEventType',
+        ),
+        migrations.RemoveField(
+            model_name='email',
+            name='user',
+        ),
+        migrations.RemoveField(
+            model_name='notification',
+            name='recipient',
+        ),
+        migrations.RemoveField(
+            model_name='notification',
+            name='sender',
+        ),
+        migrations.DeleteModel(
+            name='Email',
+        ),
+        migrations.DeleteModel(
+            name='Notification',
+        ),
+    ]
+
+    operations = [
+        migrations.SeparateDatabaseAndState(
+            state_operations=state_operations
+        ),
+    ]

tests/functional/checkout/test_customer_checkout.py

@@ -1,5 +1,4 @@
 from http import client as http_client
-from unittest.mock import patch
 
 from django.urls import reverse
 
@@ -247,24 +246,3 @@ class TestThankYouView(CheckoutMixin, WebTestCase):
         test_url = '%s?order_id=%s' % (reverse('checkout:thank-you'), order.pk)
         response = self.get(test_url, status='*', user=user)
         self.assertEqual(response.status_code, http_client.NOT_FOUND)
-
-
-class TestOrderPlacementMixin(CheckoutMixin, WebTestCase):
-
-    @patch('oscar.apps.checkout.mixins.logger')
-    def test_get_message_context_with_no_code(self, mock_logger):
-        original_get_message_context = OrderPlacementMixin.get_message_context
-
-        def get_message_context(self_, order):
-            get_message_context.called = True
-            return original_get_message_context(self_, order)
-        get_message_context.called = False
-
-        with patch.object(OrderPlacementMixin, 'get_message_context',
-                          get_message_context):
-            self.add_product_to_basket()
-            self.enter_shipping_address()
-            self.place_order()
-
-        self.assertTrue(mock_logger.warning.called)
-        self.assertTrue(get_message_context.called)

tests/functional/customer/test_alert.py

@@ -6,15 +6,17 @@ from django.test import TestCase
 from django.urls import reverse
 from django_webtest import WebTest
 
-from oscar.apps.customer.alerts.utils import (
-    send_alert_confirmation, send_product_alerts)
 from oscar.apps.customer.forms import ProductAlertForm
 from oscar.apps.customer.models import ProductAlert
+from oscar.core.loading import get_class
 from oscar.test.factories import (
     ProductAlertFactory, UserFactory, create_product, create_stockrecord)
 
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
+AlertsDispatcher = get_class('customer.alerts.utils', 'AlertsDispatcher')
 
-class TestAUser(WebTest):
+
+class TestProductAlert(WebTest):
 
     def setUp(self):
         self.user = UserFactory()
@@ -26,10 +28,10 @@ class TestAUser(WebTest):
         form.submit()
 
         alerts = ProductAlert.objects.filter(user=self.user)
-        self.assertEqual(1, len(alerts))
+        assert len(alerts) == 1
         alert = alerts[0]
-        self.assertEqual(ProductAlert.ACTIVE, alert.status)
-        self.assertEqual(alert.product, self.product)
+        assert ProductAlert.ACTIVE == alert.status
+        assert alert.product == self.product
 
     def test_cannot_create_multiple_alerts_for_one_product(self):
         ProductAlertFactory(user=self.user, product=self.product,
@@ -37,10 +39,8 @@ class TestAUser(WebTest):
         # Alert form should not allow creation of additional alerts.
         form = ProductAlertForm(user=self.user, product=self.product, data={})
 
-        self.assertFalse(form.is_valid())
-        self.assertIn(
-            "You already have an active alert for this product",
-            form.errors['__all__'][0])
+        assert not form.is_valid()
+        assert "You already have an active alert for this product" in form.errors['__all__'][0]
 
 
 class TestAUserWithAnActiveStockAlert(WebTest):
@@ -56,34 +56,34 @@ class TestAUserWithAnActiveStockAlert(WebTest):
 
     def test_can_cancel_it(self):
         alerts = ProductAlert.objects.filter(user=self.user)
-        self.assertEqual(1, len(alerts))
+        assert len(alerts) == 1
         alert = alerts[0]
-        self.assertFalse(alert.is_cancelled)
+        assert not alert.is_cancelled
         self.app.get(
             reverse('customer:alerts-cancel-by-pk', kwargs={'pk': alert.pk}),
             user=self.user)
 
         alerts = ProductAlert.objects.filter(user=self.user)
-        self.assertEqual(1, len(alerts))
+        assert len(alerts) == 1
         alert = alerts[0]
-        self.assertTrue(alert.is_cancelled)
+        assert alert.is_cancelled
 
     def test_gets_notified_when_it_is_back_in_stock(self):
         self.stockrecord.num_in_stock = 10
         self.stockrecord.save()
-        self.assertEqual(1, self.user.notifications.all().count())
+        assert self.user.notifications.all().count() == 1
 
     def test_gets_emailed_when_it_is_back_in_stock(self):
         self.stockrecord.num_in_stock = 10
         self.stockrecord.save()
-        self.assertEqual(1, len(mail.outbox))
+        assert len(mail.outbox) == 1
 
     def test_does_not_get_emailed_when_it_is_saved_but_still_zero_stock(self):
         self.stockrecord.num_in_stock = 0
         self.stockrecord.save()
-        self.assertEqual(0, len(mail.outbox))
+        assert len(mail.outbox) == 0
 
-    @mock.patch('oscar.apps.customer.alerts.utils.services.notify_user')
+    @mock.patch('oscar.apps.communication.utils.Dispatcher.notify_user')
     def test_site_notification_sent(self, mock_notify):
         self.stockrecord.num_in_stock = 10
         self.stockrecord.save()
@@ -94,7 +94,7 @@ class TestAUserWithAnActiveStockAlert(WebTest):
                 self.product.get_absolute_url(), self.product.title)
         )
 
-    @mock.patch('oscar.apps.customer.alerts.utils.services.notify_user')
+    @mock.patch('oscar.apps.communication.utils.Dispatcher.notify_user')
     def test_product_title_truncated_in_alert_notification_subject(self, mock_notify):
         self.product.title = ('Aut nihil dignissimos perspiciatis. Beatae sed consequatur odit incidunt. '
                               'Quaerat labore perferendis quasi aut sunt maxime accusamus laborum. '
@@ -122,10 +122,10 @@ class TestAnAnonymousUser(WebTest):
         form.submit()
 
         alerts = ProductAlert.objects.filter(email='john@smith.com')
-        self.assertEqual(1, len(alerts))
+        assert len(alerts) == 1
         alert = alerts[0]
-        self.assertEqual(ProductAlert.UNCONFIRMED, alert.status)
-        self.assertEqual(alert.product, product)
+        assert ProductAlert.UNCONFIRMED == alert.status
+        assert alert.product == product
 
     def test_can_cancel_unconfirmed_stock_alert(self):
         alert = ProductAlertFactory(
@@ -133,7 +133,7 @@ class TestAnAnonymousUser(WebTest):
         self.app.get(
             reverse('customer:alerts-cancel-by-key', kwargs={'key': alert.key}))
         alert.refresh_from_db()
-        self.assertTrue(alert.is_cancelled)
+        assert alert.is_cancelled
 
     def test_cannot_create_multiple_alerts_for_one_product(self):
         product = create_product(num_in_stock=0)
@@ -146,10 +146,8 @@ class TestAnAnonymousUser(WebTest):
         form = ProductAlertForm(user=AnonymousUser(), product=product,
                                 data={'email': 'john@smith.com'})
 
-        self.assertFalse(form.is_valid())
-        self.assertIn(
-            "There is already an active stock alert for john@smith.com",
-            form.errors['__all__'][0])
+        assert not form.is_valid()
+        assert "There is already an active stock alert for john@smith.com" in form.errors['__all__'][0]
 
     def test_cannot_create_multiple_unconfirmed_alerts(self):
         # Create an unconfirmed alert
@@ -163,10 +161,9 @@ class TestAnAnonymousUser(WebTest):
             data={'email': 'john@smith.com'},
         )
 
-        self.assertFalse(form.is_valid())
-        self.assertIn(
-            "john@smith.com has been sent a confirmation email for another "
-            "product alert on this site.", form.errors['__all__'][0])
+        assert not form.is_valid()
+        message = "john@smith.com has been sent a confirmation email for another product alert on this site."
+        assert message in form.errors['__all__'][0]
 
 
 class TestHurryMode(TestCase):
@@ -174,18 +171,17 @@ class TestHurryMode(TestCase):
     def setUp(self):
         self.user = UserFactory()
         self.product = create_product()
+        self.dispatcher = AlertsDispatcher()
 
     def test_hurry_mode_not_set_when_stock_high(self):
         # One alert, 5 items in stock. No need to hurry.
         create_stockrecord(self.product, num_in_stock=5)
         ProductAlert.objects.create(user=self.user, product=self.product)
 
-        send_product_alerts(self.product)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
 
-        self.assertEqual(1, len(mail.outbox))
-        self.assertNotIn(
-            'Beware that the amount of items in stock is limited',
-            mail.outbox[0].body)
+        assert len(mail.outbox) == 1
+        assert 'Beware that the amount of items in stock is limited' not in mail.outbox[0].body
 
     def test_hurry_mode_set_when_stock_low(self):
         # Two alerts, 1 item in stock. Hurry mode should be set.
@@ -193,12 +189,10 @@ class TestHurryMode(TestCase):
         ProductAlert.objects.create(user=self.user, product=self.product)
         ProductAlert.objects.create(user=UserFactory(), product=self.product)
 
-        send_product_alerts(self.product)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
 
-        self.assertEqual(2, len(mail.outbox))
-        self.assertIn(
-            'Beware that the amount of items in stock is limited',
-            mail.outbox[0].body)
+        assert len(mail.outbox) == 2
+        assert 'Beware that the amount of items in stock is limited' in mail.outbox[0].body
 
     def test_hurry_mode_not_set_multiple_stockrecords(self):
         # Two stockrecords, 5 items in stock for one. No need to hurry.
@@ -206,11 +200,9 @@ class TestHurryMode(TestCase):
         create_stockrecord(self.product, num_in_stock=5)
         ProductAlert.objects.create(user=self.user, product=self.product)
 
-        send_product_alerts(self.product)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
 
-        self.assertNotIn(
-            'Beware that the amount of items in stock is limited',
-            mail.outbox[0].body)
+        assert 'Beware that the amount of items in stock is limited' not in mail.outbox[0].body
 
     def test_hurry_mode_set_multiple_stockrecords(self):
         # Two stockrecords, low stock on both. Hurry mode should be set.
@@ -219,11 +211,9 @@ class TestHurryMode(TestCase):
         ProductAlert.objects.create(user=self.user, product=self.product)
         ProductAlert.objects.create(user=UserFactory(), product=self.product)
 
-        send_product_alerts(self.product)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
 
-        self.assertIn(
-            'Beware that the amount of items in stock is limited',
-            mail.outbox[0].body)
+        assert 'Beware that the amount of items in stock is limited' in mail.outbox[0].body
 
 
 class TestAlertMessageSending(TestCase):
@@ -232,8 +222,9 @@ class TestAlertMessageSending(TestCase):
         self.user = UserFactory()
         self.product = create_product()
         create_stockrecord(self.product, num_in_stock=1)
+        self.dispatcher = AlertsDispatcher()
 
-    @mock.patch('oscar.apps.customer.utils.Dispatcher.dispatch_direct_messages')
+    @mock.patch('oscar.apps.communication.utils.Dispatcher.dispatch_direct_messages')
     def test_alert_confirmation_uses_dispatcher(self, mock_dispatch):
         alert = ProductAlert.objects.create(
             email='test@example.com',
@@ -241,18 +232,18 @@ class TestAlertMessageSending(TestCase):
             status=ProductAlert.UNCONFIRMED,
             product=self.product
         )
-        send_alert_confirmation(alert)
-        self.assertEqual(mock_dispatch.call_count, 1)
-        self.assertEqual(mock_dispatch.call_args[0][0], 'test@example.com')
+        AlertsDispatcher().send_product_alert_confirmation_email_for_user(alert)
+        assert mock_dispatch.call_count == 1
+        assert mock_dispatch.call_args[0][0] == 'test@example.com'
 
-    @mock.patch('oscar.apps.customer.utils.Dispatcher.dispatch_user_messages')
+    @mock.patch('oscar.apps.communication.utils.Dispatcher.dispatch_user_messages')
     def test_alert_uses_dispatcher(self, mock_dispatch):
         ProductAlert.objects.create(user=self.user, product=self.product)
-        send_product_alerts(self.product)
-        self.assertEqual(mock_dispatch.call_count, 1)
-        self.assertEqual(mock_dispatch.call_args[0][0], self.user)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
+        assert mock_dispatch.call_count == 1
+        assert mock_dispatch.call_args[0][0] == self.user
 
     def test_alert_creates_email_obj(self):
         ProductAlert.objects.create(user=self.user, product=self.product)
-        send_product_alerts(self.product)
-        self.assertEqual(self.user.emails.count(), 1)
+        self.dispatcher.send_product_alert_email_for_user(self.product)
+        assert self.user.emails.count() == 1

tests/functional/customer/test_emails.py

@@ -0,0 +1,114 @@
+from django.contrib.sites.models import Site
+from django.core import mail
+from django.test import TestCase
+
+from oscar.core.loading import get_class
+from oscar.test.factories import (
+    ProductAlertFactory, UserFactory, create_product)
+from oscar.test.utils import EmailsMixin
+
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
+AlertsDispatcher = get_class('customer.alerts.utils', 'AlertsDispatcher')
+
+
+class TestCustomerConcreteEmailsSending(EmailsMixin, TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.dispatcher = CustomerDispatcher()
+
+    def test_send_registration_email_for_user(self):
+        extra_context = {'user': self.user}
+        self.dispatcher.send_registration_email_for_user(self.user, extra_context)
+
+        self._test_common_part()
+        self.assertEqual('Thank you for registering.', mail.outbox[0].subject)
+        self.assertIn('Thank you for registering.', mail.outbox[0].body)
+
+    def test_send_password_reset_email_for_user(self):
+        extra_context = {
+            'user': self.user,
+            'reset_url': '/django-oscar/django-oscar',
+        }
+        self.dispatcher.send_password_reset_email_for_user(self.user, extra_context)
+
+        self._test_common_part()
+        expected_subject = 'Resetting your password at {}.'.format(Site.objects.get_current())
+        self.assertEqual(expected_subject, mail.outbox[0].subject)
+        self.assertIn('Please go to the following page and choose a new password:', mail.outbox[0].body)
+        self.assertIn('http://example.com/django-oscar/django-oscar', mail.outbox[0].body)
+
+    def test_send_password_changed_email_for_user(self):
+        extra_context = {
+            'user': self.user,
+            'reset_url': '/django-oscar/django-oscar',
+        }
+        self.dispatcher.send_password_changed_email_for_user(self.user, extra_context)
+
+        self._test_common_part()
+        expected_subject = 'Your password changed at {}.'.format(Site.objects.get_current())
+        self.assertEqual(expected_subject, mail.outbox[0].subject)
+        self.assertIn('your password has been changed', mail.outbox[0].body)
+        self.assertIn('http://example.com/django-oscar/django-oscar', mail.outbox[0].body)
+
+    def test_send_email_changed_email_for_user(self):
+        extra_context = {
+            'user': self.user,
+            'reset_url': '/django-oscar/django-oscar',
+            'new_email': 'some_new@mail.com',
+        }
+        self.dispatcher.send_email_changed_email_for_user(self.user, extra_context)
+
+        self._test_common_part()
+        expected_subject = 'Your email address has changed at {}.'.format(Site.objects.get_current())
+        self.assertEqual(expected_subject, mail.outbox[0].subject)
+        self.assertIn('your email address has been changed', mail.outbox[0].body)
+        self.assertIn('http://example.com/django-oscar/django-oscar', mail.outbox[0].body)
+        self.assertIn('some_new@mail.com', mail.outbox[0].body)
+
+
+class TestAlertsConcreteEmailsSending(EmailsMixin, TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.dispatcher = AlertsDispatcher()
+
+    def test_send_product_alert_email_for_user(self):
+        product = create_product(num_in_stock=5)
+        ProductAlertFactory(product=product, user=self.user)
+
+        self.dispatcher.send_product_alert_email_for_user(product)
+
+        self._test_common_part()
+        expected_subject = u'{} is back in stock'.format(product.title)
+        self.assertEqual(expected_subject, mail.outbox[0].subject)
+        self.assertIn('We are happy to inform you that our product', mail.outbox[0].body)
+        # No `hurry_mode`
+        self.assertNotIn('Beware that the amount of items in stock is limited.', mail.outbox[0].body)
+
+    def test_send_product_alert_email_for_user_with_hurry_mode(self):
+        another_user = UserFactory(email='another_user@mail.com')
+        product = create_product(num_in_stock=1)
+        ProductAlertFactory(product=product, user=self.user, email=self.user.email)
+        ProductAlertFactory(product=product, user=another_user, email=another_user.email)
+
+        self.dispatcher.send_product_alert_email_for_user(product)
+        self.assertEqual(len(mail.outbox), 2)  # Separate email for each user
+        expected_subject = u'{} is back in stock'.format(product.title)
+        self.assertEqual(expected_subject, mail.outbox[0].subject)
+        for outboxed_email in mail.outbox:
+            self.assertEqual(expected_subject, outboxed_email.subject)
+            self.assertIn('We are happy to inform you that our product', outboxed_email.body)
+            self.assertIn('Beware that the amount of items in stock is limited.', outboxed_email.body)
+
+    def test_send_product_alert_confirmation_email_for_user(self):
+        product = create_product(num_in_stock=5)
+        alert = ProductAlertFactory(product=product, user=self.user, email=self.user.email, key='key00042')
+
+        self.dispatcher.send_product_alert_confirmation_email_for_user(alert)
+
+        self._test_common_part()
+        self.assertEqual('Confirmation required for stock alert', mail.outbox[0].subject)
+        self.assertIn('Somebody (hopefully you) has requested an email alert', mail.outbox[0].body)
+        self.assertIn(alert.get_confirm_url(), mail.outbox[0].body)
+        self.assertIn(alert.get_cancel_url(), mail.outbox[0].body)

tests/functional/customer/test_notification.py

@@ -2,17 +2,19 @@ from http import client as http_client
 
 from django.urls import reverse
 
-from oscar.apps.customer.models import Notification
-from oscar.apps.customer.notifications import services
+from oscar.core.loading import get_class, get_model
 from oscar.test.factories import UserFactory
 from oscar.test.testcases import WebTestCase
 
+Dispatcher = get_class('communication.utils', 'Dispatcher')
+Notification = get_model('communication', 'Notification')
+
 
 class TestAUserWithUnreadNotifications(WebTestCase):
 
     def setUp(self):
         self.user = UserFactory()
-        services.notify_user(self.user, "Test message")
+        Dispatcher().notify_user(self.user, "Test message")
 
     def test_can_see_them_in_page_header(self):
         homepage = self.app.get('/', user=self.user)

tests/functional/dashboard/test_communication.py

@@ -1,10 +1,12 @@
 from django.core import mail
 from django.urls import reverse
 
-from oscar.apps.customer.models import CommunicationEventType
+from oscar.core.loading import get_model
 from oscar.test.factories import UserFactory
 from oscar.test.testcases import WebTestCase
 
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+
 
 class TestAnAdmin(WebTestCase):
 
@@ -15,19 +17,19 @@ class TestAnAdmin(WebTestCase):
             category=CommunicationEventType.USER_RELATED)
 
     def test_can_preview_an_email(self):
-        list_page = self.app.get(reverse('dashboard:comms-list'),
-                                 user=self.staff)
+        list_page = self.app.get(
+            reverse('dashboard:comms-list'), user=self.staff)
         update_page = list_page.click('Edit')
         form = update_page.form
         form['email_subject_template'] = 'Hello {{ user.username }}'
         form['email_body_template'] = 'Hello {{ user.username }}'
         form['email_body_html_template'] = 'Hello {{ user.username }}'
         preview = form.submit('show_preview')
-        self.assertTrue('Hello 1234' in preview.content.decode('utf8'))
+        assert 'Hello 1234' in preview.content.decode('utf8')
 
     def test_can_send_a_preview_email(self):
-        list_page = self.app.get(reverse('dashboard:comms-list'),
-                                 user=self.staff)
+        list_page = self.app.get(
+            reverse('dashboard:comms-list'), user=self.staff)
         update_page = list_page.click('Edit')
         form = update_page.form
         form['email_subject_template'] = 'Hello {{ user.username }}'
@@ -36,4 +38,4 @@ class TestAnAdmin(WebTestCase):
         form['preview_email'] = 'testing@example.com'
         form.submit('send_preview')
 
-        self.assertEqual(len(mail.outbox), 1)
+        assert len(mail.outbox) == 1

tests/functional/dashboard/test_user.py

@@ -3,12 +3,13 @@ from django.urls import reverse, reverse_lazy
 from django.utils.translation import gettext_lazy as _
 from webtest import AppError
 
-from oscar.apps.customer.models import ProductAlert
 from oscar.core.compat import get_user_model
+from oscar.core.loading import get_model
 from oscar.test.factories import ProductAlertFactory, UserFactory
 from oscar.test.testcases import WebTestCase
 
 User = get_user_model()
+ProductAlert = get_model('customer', 'ProductAlert')
 
 
 class IndexViewTests(WebTestCase):

tests/functional/order/test_emails.py

@@ -0,0 +1,61 @@
+import os
+
+from django.core import mail
+from django.test import TestCase
+
+from oscar.core.loading import get_class
+from oscar.test.factories import ProductImageFactory, create_order
+from oscar.test.utils import EmailsMixin, remove_image_folders
+
+OrderDispatcher = get_class('order.utils', 'OrderDispatcher')
+
+
+class TestConcreteEmailsSending(EmailsMixin, TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.dispatcher = OrderDispatcher()
+
+    def test_send_order_placed_email_for_user(self):
+        order_number = 'SOME-NUM00042'
+        order = create_order(number=order_number, user=self.user)
+
+        extra_context = {
+            'order': order,
+            'lines': order.lines.all()
+        }
+        self.dispatcher.send_order_placed_email_for_user(order, extra_context)
+
+        self._test_common_part()
+        expected_subject = 'Confirmation of order {}'.format(order_number)
+        assert expected_subject == mail.outbox[0].subject
+        assert 'Your order contains:' in mail.outbox[0].body
+        product_title = order.lines.first().title
+        assert product_title in mail.outbox[0].body
+
+    def test_send_order_placed_email_with_attachments_for_user(self):
+        remove_image_folders()
+
+        order_number = 'SOME-NUM00042'
+        order = create_order(number=order_number, user=self.user)
+
+        extra_context = {
+            'order': order,
+            'lines': order.lines.all()
+        }
+        line = order.lines.first()
+        product_image = ProductImageFactory(product=line.product)
+        attachments = [
+            ['fake_file.html', b'file_content', 'text/html'],
+            ['fake_image.png', b'file_content', 'image/png'],
+            product_image.original.path,  # To test sending file from `FileField` based field
+        ]
+        self.dispatcher.send_order_placed_email_for_user(order, extra_context, attachments)
+
+        # All attachments were sent with email
+        assert len(mail.outbox[0].attachments) == 3
+        expected_attachments = ['fake_file.html', 'fake_image.png', 'test_image.jpg']
+        assert [attachment[0] for attachment in mail.outbox[0].attachments] == expected_attachments
+
+        # Remove test file
+        os.remove(product_image.original.path)

tests/integration/communication/test_communicationeventtype.py

@@ -0,0 +1,65 @@
+import pytest
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+
+from oscar.core.compat import get_user_model
+from oscar.core.loading import get_model
+
+User = get_user_model()
+
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+
+
+class CommunicationTypeTest(TestCase):
+    keys = ('body', 'html', 'sms', 'subject')
+    expected_error_message = (
+        'Code can only contain the uppercase letters (A-Z), '
+        'digits, and underscores, and can\'t start with a digit.'
+    )
+
+    def test_no_templates_returns_empty_string(self):
+        et = CommunicationEventType()
+        messages = et.get_messages()
+        for key in self.keys:
+            assert messages[key] == ''
+
+    def test_field_template_render(self):
+        et = CommunicationEventType(email_subject_template='Hello {{ name }}')
+        ctx = {'name': 'world'}
+        messages = et.get_messages(ctx)
+        assert 'Hello world' == messages['subject']
+
+    def test_new_line_in_subject_is_removed(self):
+        subjects = [
+            ('Subject with a newline\r\n', 'Subject with a newline'),
+            ('New line is in \n the middle', 'New line is in  the middle'),
+            ('\rStart with the new line', 'Start with the new line'),
+        ]
+
+        for original, modified in subjects:
+            et = CommunicationEventType(email_subject_template=original)
+            messages = et.get_messages()
+            assert modified == messages['subject']
+
+    def test_code_field_forbids_hyphens(self):
+        et = CommunicationEventType(code='A-B')
+
+        with pytest.raises(ValidationError) as exc_info:
+            et.full_clean()
+
+        assert self.expected_error_message in str(exc_info.value)
+
+    def test_code_field_forbids_lowercase_letters(self):
+        et = CommunicationEventType(name='Test name *** - 123')
+        et.save()
+
+        # Automatically created code is uppercased
+        expected_code = 'TEST_NAME_123'
+        assert et.code == expected_code
+
+        # Lowercased code is not valid
+        et.code = 'lower_case_code'
+        with pytest.raises(ValidationError) as exc_info:
+            et.full_clean()
+
+        assert self.expected_error_message in str(exc_info.value)

tests/integration/communication/test_dispatcher.py

@@ -0,0 +1,67 @@
+from django.core import mail
+from django.test import TestCase
+
+from oscar.apps.customer.utils import get_password_reset_url
+from oscar.core.compat import get_user_model
+from oscar.core.loading import get_class, get_model
+from oscar.test.factories import SiteFactory
+
+User = get_user_model()
+
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+Email = get_model('communication', 'Email')
+Dispatcher = get_class('communication.utils', 'Dispatcher')
+CustomerDispatcher = get_class('customer.utils', 'CustomerDispatcher')
+
+
+class TestDispatcher(TestCase):
+
+    def _dispatch_user_messages(self, user, event_code, ctx, subject):
+        msgs = CommunicationEventType.objects.get_and_render(code=event_code, context=ctx)
+        Dispatcher().dispatch_user_messages(user, msgs)
+        assert len(mail.outbox) == 1
+        assert mail.outbox[0].subject == subject
+        assert Email.objects.count() == 1
+        email = Email.objects.last()
+        assert email.user.id == user.id
+        assert email.email == 'testuser@example.com'
+
+    def test_dispatch_email_changed_user_message(self):
+        user = User.objects.create_user('testuser', 'testuser@example.com', 'somesimplepassword')
+        event_code = CustomerDispatcher.EMAIL_CHANGED_EVENT_CODE
+        CommunicationEventType.objects.create(
+            code=event_code,
+            name='Email Changed',
+            category=CommunicationEventType.USER_RELATED,
+        )
+        ctx = {
+            'user': user,
+            'site': SiteFactory(name='Test Site'),
+            'reset_url': get_password_reset_url(user),
+            'new_email': 'newtestuser@example.com',
+        }
+        self._dispatch_user_messages(
+            user, event_code, ctx, 'Your email address has changed at Test Site.'
+        )
+
+    def test_dispatch_registration_email_message(self):
+        user = User.objects.create_user('testuser', 'testuser@example.com', 'somesimplepassword')
+        event_code = CustomerDispatcher.REGISTRATION_EVENT_CODE
+        CommunicationEventType.objects.create(
+            code=event_code,
+            name='Registration',
+            category=CommunicationEventType.USER_RELATED,
+        )
+        ctx = {'user': user,
+               'site': SiteFactory()}
+        self._dispatch_user_messages(user, event_code, ctx, 'Thank you for registering.')
+
+    def test_dispatcher_uses_email_connection(self):
+        connection = mail.get_connection()
+        disp = Dispatcher(mail_connection=connection)
+        disp.dispatch_direct_messages('test@example.com', {
+            'subject': 'Test',
+            'body': 'This is a test.',
+            'html': '',
+        })
+        assert len(mail.outbox) == 1

tests/integration/customer/test_notification.py → tests/integration/communication/test_notification.py

@@ -1,12 +1,14 @@
 from django.test import TestCase
 
-from oscar.apps.customer.models import Notification
-from oscar.apps.customer.notifications import services
+from oscar.apps.communication.models import Notification
 from oscar.core.compat import get_user_model
+from oscar.core.loading import get_class
 from oscar.test.factories import UserFactory
 
 User = get_user_model()
 
+Dispatcher = get_class('communication.utils', 'Dispatcher')
+
 
 class TestANewNotification(TestCase):
 
@@ -16,10 +18,10 @@ class TestANewNotification(TestCase):
             subject="Hello")
 
     def test_is_in_a_users_inbox(self):
-        self.assertEqual(Notification.INBOX, self.notification.location)
+        assert Notification.INBOX == self.notification.location
 
     def test_is_not_read(self):
-        self.assertFalse(self.notification.is_read)
+        assert not self.notification.is_read
 
 
 class TestANotification(TestCase):
@@ -31,7 +33,7 @@ class TestANotification(TestCase):
 
     def test_can_be_archived(self):
         self.notification.archive()
-        self.assertEqual(Notification.ARCHIVE, self.notification.location)
+        assert Notification.ARCHIVE == self.notification.location
 
 
 class NotificationServiceTestCase(TestCase):
@@ -41,18 +43,18 @@ class NotificationServiceTestCase(TestCase):
         subj = "Hello you!"
         body = "This is the notification body."
 
-        services.notify_user(user, subj, body=body)
+        Dispatcher().notify_user(user, subj, body=body)
         user_notification = Notification.objects.get(recipient=user)
-        self.assertEqual(user_notification.subject, subj)
-        self.assertEqual(user_notification.body, body)
+        assert user_notification.subject == subj
+        assert user_notification.body == body
 
     def test_notify_a_set_of_users(self):
         users = UserFactory.create_batch(3)
         subj = "Hello everyone!"
         body = "This is the notification body."
 
-        services.notify_users(User.objects.all(), subj, body=body)
+        Dispatcher().notify_users(User.objects.all(), subj, body=body)
         for user in users:
             user_notification = Notification.objects.get(recipient=user)
-            self.assertEqual(user_notification.subject, subj)
-            self.assertEqual(user_notification.body, body)
+            assert user_notification.subject == subj
+            assert user_notification.body == body

tests/integration/customer/test_alert.py

@@ -12,8 +12,7 @@ class TestAnAlertForARegisteredUser(TestCase):
     def setUp(self):
         user = UserFactory()
         product = create_product()
-        self.alert = ProductAlert.objects.create(user=user,
-                                                 product=product)
+        self.alert = ProductAlert.objects.create(user=user, product=product)
 
     def test_defaults_to_active(self):
-        self.assertTrue(self.alert.is_active)
+        assert self.alert.is_active

tests/integration/customer/test_custom_user_model.py

@@ -2,7 +2,7 @@ from django.test import TestCase
 
 from oscar.apps.customer.forms import ProfileForm
 from oscar.core.compat import existing_user_fields, get_user_model
-from oscar.test.factories.customer import ProductAlertFactory, UserFactory
+from oscar.test.factories import ProductAlertFactory, UserFactory
 
 
 class TestACustomUserModel(TestCase):

tests/integration/customer/test_customer.py

@@ -1,34 +0,0 @@
-from django.test import TestCase
-
-from oscar.apps.customer.models import CommunicationEventType
-from oscar.core.compat import get_user_model
-
-User = get_user_model()
-
-
-class CommunicationTypeTest(TestCase):
-    keys = ('body', 'html', 'sms', 'subject')
-
-    def test_no_templates_returns_empty_string(self):
-        et = CommunicationEventType()
-        messages = et.get_messages()
-        for key in self.keys:
-            self.assertEqual('', messages[key])
-
-    def test_field_template_render(self):
-        et = CommunicationEventType(email_subject_template='Hello {{ name }}')
-        ctx = {'name': 'world'}
-        messages = et.get_messages(ctx)
-        self.assertEqual('Hello world', messages['subject'])
-
-    def test_new_line_in_subject_is_removed(self):
-        subjects = [
-            ('Subject with a newline\r\n', 'Subject with a newline'),
-            ('New line is in \n the middle', 'New line is in  the middle'),
-            ('\rStart with the new line', 'Start with the new line'),
-        ]
-
-        for original, modified in subjects:
-            et = CommunicationEventType(email_subject_template=original)
-            messages = et.get_messages()
-            self.assertEqual(modified, messages['subject'])

tests/integration/customer/test_dispatcher.py

@@ -1,99 +0,0 @@
-from django.core import mail
-from django.test import TestCase
-
-from oscar.apps.customer.models import CommunicationEventType, Email
-from oscar.apps.customer.utils import Dispatcher, get_password_reset_url
-from oscar.apps.order.models import CommunicationEvent
-from oscar.core.compat import get_user_model
-from oscar.test.factories import SiteFactory, create_order
-
-User = get_user_model()
-
-
-class TestDispatcher(TestCase):
-
-    def _dispatch_order_messages(self, order_number, order, email=None):
-        et = CommunicationEventType.objects.create(code="ORDER_PLACED",
-                                                   name="Order Placed",
-                                                   category=CommunicationEventType.ORDER_RELATED)
-
-        messages = et.get_messages({
-            'order': order,
-            'lines': order.lines.all()
-        })
-
-        self.assertIn(order_number, messages['body'])
-        self.assertIn(order_number, messages['html'])
-
-        dispatcher = Dispatcher()
-        dispatcher.dispatch_order_messages(order, messages, et)
-
-        self.assertEqual(CommunicationEvent.objects.filter(order=order, event_type=et).count(), 1)
-
-        self.assertEqual(len(mail.outbox), 1)
-
-        message = mail.outbox[0]
-        self.assertIn(order_number, message.body)
-
-        # test sending messages to emails without account and text body
-        messages['body'] = ''
-        dispatcher.dispatch_direct_messages(email, messages)
-        self.assertEqual(len(mail.outbox), 2)
-
-    def _dispatch_user_messages(self, user, event_code, ctx, subject):
-        msgs = CommunicationEventType.objects.get_and_render(
-            code=event_code, context=ctx)
-        Dispatcher().dispatch_user_messages(user, msgs)
-        self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].subject, subject)
-        self.assertEqual(Email.objects.count(), 1)
-        email = Email.objects.last()
-        self.assertEqual(email.user.id, user.id)
-        self.assertEqual(email.email, 'testuser@example.com')
-
-    def test_dispatch_order_messages(self):
-        email = 'testuser@example.com'
-        user = User.objects.create_user('testuser', email,
-                                        'somesimplepassword')
-        order = create_order(number='12345', user=user)
-        self.assertFalse(order.is_anonymous)
-        self._dispatch_order_messages(order_number='12345', order=order, email=email)
-
-    def test_dispatch_anonymous_order_messages(self):
-        order = create_order(number='12346', guest_email='testguest@example.com')
-        self.assertTrue(order.is_anonymous)
-        self._dispatch_order_messages(order_number='12346', order=order, email='testguest@example.com', )
-
-    def test_dispatch_email_changed_user_message(self):
-        user = User.objects.create_user('testuser', 'testuser@example.com', 'somesimplepassword')
-        CommunicationEventType.objects.create(code='EMAIL_CHANGED',
-                                              name='Email Changed',
-                                              category=CommunicationEventType.USER_RELATED)
-        ctx = {
-            'user': user,
-            'site': SiteFactory(name='Test Site'),
-            'reset_url': get_password_reset_url(user),
-            'new_email': 'newtestuser@example.com',
-        }
-        self._dispatch_user_messages(
-            user, 'EMAIL_CHANGED', ctx, 'Your email address has changed at Test Site.'
-        )
-
-    def test_dispatch_registration_email_message(self):
-        user = User.objects.create_user('testuser', 'testuser@example.com', 'somesimplepassword')
-        CommunicationEventType.objects.create(code='REGISTRATION',
-                                              name='Registration',
-                                              category=CommunicationEventType.USER_RELATED)
-        ctx = {'user': user,
-               'site': SiteFactory()}
-        self._dispatch_user_messages(user, 'REGISTRATION', ctx, 'Thank you for registering.')
-
-    def test_dispatcher_uses_email_connection(self):
-        connection = mail.get_connection()
-        disp = Dispatcher(mail_connection=connection)
-        disp.dispatch_direct_messages('test@example.com', {
-            'subject': 'Test',
-            'body': 'This is a test.',
-            'html': '',
-        })
-        self.assertEqual(len(mail.outbox), 1)

tests/integration/customer/test_models.py

@@ -1,10 +0,0 @@
-import pytest
-from django.core import exceptions
-
-from oscar.apps.customer import models
-
-
-def test_communication_event_type_code_forbids_hyphens():
-    ctype = models.CommunicationEventType(code="A-B")
-    with pytest.raises(exceptions.ValidationError):
-        ctype.full_clean()

tests/integration/order/test_order_dispatcher.py

@@ -0,0 +1,61 @@
+from django.core import mail
+from django.test import TestCase
+
+from oscar.core.compat import get_user_model
+from oscar.core.loading import get_class, get_model
+from oscar.test.factories import create_order
+
+User = get_user_model()
+
+CommunicationEventType = get_model('communication', 'CommunicationEventType')
+CommunicationEvent = get_model('order', 'CommunicationEvent')
+Email = get_model('communication', 'Email')
+Dispatcher = get_class('communication.utils', 'Dispatcher')
+OrderDispatcher = get_class('order.utils', 'OrderDispatcher')
+
+
+class TestDispatcher(TestCase):
+
+    def _dispatch_order_messages(self, order_number, order, email=None):
+        event_code = OrderDispatcher.ORDER_PLACED_EVENT_CODE
+        et = CommunicationEventType.objects.create(
+            code=event_code,
+            name="Order Placed",
+            category=CommunicationEventType.ORDER_RELATED,
+        )
+
+        messages = et.get_messages({
+            'order': order,
+            'lines': order.lines.all()
+        })
+
+        assert order_number in messages['body']
+        assert order_number in messages['html']
+
+        order_dispatcher = OrderDispatcher()
+        order_dispatcher.dispatch_order_messages(order, messages, event_code)
+
+        assert CommunicationEvent.objects.filter(order=order, event_type=et).count() == 1
+
+        assert len(mail.outbox) == 1
+
+        message = mail.outbox[0]
+        assert order_number in message.body
+
+        # Test sending messages to emails without account and text body
+        messages['body'] = ''
+        dispatcher = Dispatcher()
+        dispatcher.dispatch_direct_messages(email, messages)
+        assert len(mail.outbox) == 2
+
+    def test_dispatch_order_messages(self):
+        email = 'testuser@example.com'
+        user = User.objects.create_user('testuser', email, 'somesimplepassword')
+        order = create_order(number='12345', user=user)
+        assert not order.is_anonymous
+        self._dispatch_order_messages(order_number='12345', order=order, email=email)
+
+    def test_dispatch_anonymous_order_messages(self):
+        order = create_order(number='12346', guest_email='testguest@example.com')
+        assert order.is_anonymous
+        self._dispatch_order_messages(order_number='12346', order=order, email='testguest@example.com', )

tests/integration/templatetags/test_url_tags.py

@@ -0,0 +1,35 @@
+from django import template
+from django.contrib.sites.models import Site
+from django.test import TestCase
+
+
+class TestUrlTags(TestCase):
+
+    def test_absolute_url_tag(self):
+        tmpl = template.Template(
+            '{% load i18n %}'
+            '{% load url_tags %}'
+            '{% absolute_url site.domain path %}.'
+        )
+        out = tmpl.render(template.Context({
+            'site': Site.objects.get_current(),
+            'path': '/some/test/path',
+        }))
+        assert out == 'http://example.com/some/test/path.'
+
+    def test_absolute_url_tag_with_blocktrans(self):
+        tmpl = template.Template(
+            '{% load i18n %}'
+            '{% load url_tags %}'
+            '{% absolute_url site.domain path_1 as url_1 %}'
+            '{% absolute_url site.domain path_2 as url_2 %}'
+            '{% blocktrans with test_url_1=url_1 test_url_2=url_2 %}'
+            '1st - {{ test_url_1 }}. 2nd - {{ test_url_2 }}.'
+            '{% endblocktrans %}'
+        )
+        out = tmpl.render(template.Context({
+            'site': Site.objects.get_current(),
+            'path_1': '/some/test/path',
+            'path_2': '/some/another/test/path',
+        }))
+        assert out == '1st - http://example.com/some/test/path. 2nd - http://example.com/some/another/test/path.'