Major rewrite of stock alerts

* They are now known as 'stock alerts' instead of notifications.
* They have been moved into the customer app largely (instead of their
  own one).
* The model implementation has been simplified.

oscar/__init__.py

@@ -37,7 +37,6 @@ OSCAR_CORE_APPS = [
     'oscar.apps.shipping',
     'oscar.apps.catalogue',
     'oscar.apps.catalogue.reviews',
-    'oscar.apps.catalogue.notification',
     'oscar.apps.basket',
     'oscar.apps.payment',
     'oscar.apps.offer',

oscar/apps/catalogue/app.py

@@ -3,7 +3,6 @@ from django.conf.urls import patterns, url, include
 from oscar.core.application import Application
 from oscar.apps.catalogue.views import ProductDetailView, ProductListView, ProductCategoryView
 from oscar.apps.catalogue.reviews.app import application as reviews_app
-from oscar.apps.catalogue.notification.app import application as notification_app
 
 
 class BaseCatalogueApplication(Application):
@@ -37,20 +36,7 @@ class ReviewsApplication(Application):
         return self.post_process_urls(urlpatterns)
 
 
-class NotificationsApplication(Application):
-    name = None
-    notification_app = notification_app
-
-    def get_urls(self):
-        urlpatterns = super(NotificationsApplication, self).get_urls()
-        urlpatterns += patterns('',
-            url(r'^(?P<product_slug>[\w-]*)_(?P<pk>\d+)/notify-me/',
-                include(self.notification_app.urls)),
-        )
-        return self.post_process_urls(urlpatterns)
-
-
-class CatalogueApplication(BaseCatalogueApplication, ReviewsApplication, NotificationsApplication):
+class CatalogueApplication(BaseCatalogueApplication, ReviewsApplication):
     """
     Composite class combining Products with Reviews
     """

oscar/apps/catalogue/notification/abstract_models.py

@@ -1,157 +0,0 @@
-import sha
-import random
-
-from django.db import models
-from django.contrib.auth.models import User
-from django.utils.translation import ugettext as _
-
-Product = models.get_model('catalogue', 'Product')
-
-
-class AbstractProductNotification(models.Model):
-    """
-    Abstract class of a product notification
-    A notification can have two different statuses for authenticated
-    users (``ACTIVE`` and ``INACTIVE`` and anonymous users have an
-    additional status ``UNCONFIRMED``. For anonymous users a confirmation
-    and unsubscription key are generated when an instance is saved for
-    the first time and can be used to confirm and unsubscribe the
-    notifications.
-    """
-    KEY_LENGTH = 40
-    product_url_index = 'catalogue:detail'
-
-    # a user is only required if the notification is created by a
-    # registered user, anonymous users will only have an email address
-    # attached to the notification
-    user = models.ForeignKey(User, db_index=True, blank=True, null=True,
-                             related_name="product_notifications")
-    product = models.ForeignKey(Product, db_index=True)
-
-    # These fields only apply to unauthenticated users and are empty
-    # if the user is registered.
-    email = models.EmailField(db_index=True, blank=True, null=True)
-    confirm_key = models.CharField(max_length=KEY_LENGTH, null=True)
-    unsubscribe_key = models.CharField(max_length=KEY_LENGTH, null=True)
-
-    UNCONFIRMED, ACTIVE, INACTIVE = ('unconfirmed', 'active', 'inactive')
-    STATUS_TYPES = (
-        (UNCONFIRMED, _('Not yet confirmed')),
-        (ACTIVE, _('Active')),
-        (INACTIVE, _('Inactive')),
-    )
-    status = models.CharField(max_length=20, choices=STATUS_TYPES,
-                              default=INACTIVE)
-
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_modified = models.DateTimeField(auto_now=True)
-    date_notified = models.DateTimeField(blank=True, null=True)
-
-    def is_active(self):
-        """
-        Check if the notification is active or not.
-        Returns ``True`` if notification is active, ``False`` otherwise.
-        """
-        return self.status == self.ACTIVE
-
-    def is_confirmed(self):
-        """
-        Check if the notification is confirmed or not.
-        Returns ``True`` if notification is confirmed, ``False`` otherwise.
-        """
-        return self.status == self.ACTIVE
-
-    def get_random_key(self):
-        """
-        Get a random generated key based on SHA-1 and the notification
-        email provided in this instance of the notification.
-        """
-        salt = sha.new(str(random.random())).hexdigest()
-        return sha.new(salt + self.get_notification_email()).hexdigest()
-
-    def get_notification_email(self):
-        """
-        Return the notification email address of the user subscribed to
-        this notification. Return the user's email for an authenticated
-        user and the email property for an anonymous user.
-        """
-        if self.user:
-            return self.user.email
-        return self.email
-
-    def transfer_to_user(self, user):
-        """
-        Convenience function that allows for assigning a notification
-        to a user. This is aimed at the situation when a user has
-        notifications available as anonymous user but decides to sign
-        up. In this case, the notification will be transfered to the
-        specific user account.
-        """
-        if not self.user:
-            self.user = user
-            self.email = None
-            self.confirm_key, self.unsubscribe_key = None, None
-            self.save()
-
-    @models.permalink
-    def get_confirm_url(self):
-        """
-        Get confirmation URL for this notification.
-        """
-        kwargs = self._get_url_kwargs()
-        kwargs['key'] = self.confirm_key
-        return ('catalogue:notification-confirm', (), kwargs)
-
-    @models.permalink
-    def get_unsubscribe_url(self):
-        """
-        Get unsubscribe URL for this notification.
-        """
-        kwargs = self._get_url_kwargs()
-        kwargs['key'] = self.unsubscribe_key
-        return ('catalogue:notification-unsubscribe', (), kwargs)
-
-    @models.permalink
-    def get_absolute_item_url(self):
-        """
-        Get the absolute URL for the item referenced by this
-        notification. The URL patterns uses the ``item_url_index``
-        attribute specified in the class definition.
-        """
-        kwargs = self._get_url_kwargs()
-        return (self.product_url_index, (), kwargs)
-
-    def save(self, *args, **kwargs):
-        """
-        Save the current notification instance. If the user is not
-        a registered/authenticated user, a confirmation and
-        unsubscription key will be generated for the notification.
-        """
-        if self.email and not self.user:
-            if not self.confirm_key:
-                self.confirm_key = self.get_random_key()
-            if not self.unsubscribe_key:
-                self.unsubscribe_key = self.get_random_key()
-        return super(AbstractProductNotification, self).save(*args, **kwargs)
-
-    def _get_url_kwargs(self):
-        """
-        Get the keyword arguments for the confirmation URL reverse
-        lookup. This provides the item specific arguments for slug
-        and primary key.
-        """
-        return {
-            'product_slug': self.product.slug,
-            'pk': self.product.id,
-        }
-
-    def __unicode__(self):
-        """ Unicode representation of this notification """
-        return _(u'Notification for %(user)s - %(email)s') % {
-            'user': self.user or _("anonymous"),
-            'email': self.email
-        }
-
-    class Meta:
-        abstract = True
-        app_label = 'notification'

oscar/apps/catalogue/notification/app.py

@@ -1,38 +0,0 @@
-from django.db.models import get_model
-from django.conf.urls.defaults import patterns, url
-from django.contrib.auth.decorators import login_required
-
-from oscar.core.application import Application
-from oscar.apps.catalogue.notification import views
-
-ProductNotification = get_model('notification', 'productnotification')
-
-
-class ProductNotificationApplication(Application):
-    confirm_view = views.NotificationConfirmView
-    unsubscribe_view = views.NotificationUnsubscribeView
-    create_view = views.ProductNotificationCreateView
-    update_view = views.ProductNotificationSetStatusView
-
-    def get_urls(self):
-        urlpatterns = patterns('',
-            url(r'^confirm/(?P<key>[a-z0-9]{40})/$',
-                self.confirm_view.as_view(),
-                name='notification-confirm'),
-            url(r'^unsubscribe/(?P<key>[a-z0-9]{40})/$',
-                self.unsubscribe_view.as_view(),
-                name='notification-unsubscribe'),
-            url(r'^create/$', self.create_view.as_view(),
-                name='notification-create'),
-            # Make sure that only valid status values are allowed in the
-            # URL pattern
-            url(r'^(?P<notification_pk>\d+)/set-status/(?P<status>%s)/$' % (
-                    '|'.join([x[0] for x in ProductNotification.STATUS_TYPES])
-                ),
-                login_required(self.update_view.as_view()),
-                name='notification-set-status'),
-        )
-        return urlpatterns
-
-
-application = ProductNotificationApplication()

oscar/apps/catalogue/notification/forms.py

@@ -1,25 +0,0 @@
-from django import forms
-from django.utils.translation import ugettext_lazy as _
-
-
-class ProductNotificationForm(forms.Form):
-    """
-    Form providing a single email field for signing up to a notification. If
-    ``email`` or ``user`` are provided as initial values these values are
-    used to update the ``email`` field. If ``user`` is specified and the
-    user is registered and logged in, the ``email`` field is hidden in the
-    HTML template.
-    """
-    email = forms.EmailField(required=True, label=_(u'Send notification to'),
-                             widget=forms.TextInput(attrs={
-                                 'placeholder': _('Enter Your Email')
-                             }))
-
-    def __init__(self, *args, **kwargs):
-        super(ProductNotificationForm, self).__init__(*args, **kwargs)
-        user = self.initial.get('user', None)
-        if user and user.is_authenticated():
-            self.fields['email'].widget = forms.HiddenInput()
-
-            if not self.initial.get('email', None):
-                self.initial['email'] = user.email

oscar/apps/catalogue/notification/models.py

@@ -1,8 +0,0 @@
-from oscar.apps.catalogue.notification import abstract_models
-
-
-class ProductNotification(abstract_models.AbstractProductNotification):
-    pass
-
-
-from oscar.apps.catalogue.notification.receivers import *

oscar/apps/catalogue/notification/receivers.py

@@ -1,23 +0,0 @@
-from django.conf import settings
-
-from oscar.core.loading import get_class
-from oscar.apps.catalogue.notification import utils
-
-# use get_class instead of get_model as this module get imported
-# in the models module of notification. That means models are not
-# available at this point in time.
-StockRecord = get_class('partner.models', 'StockRecord')
-
-
-def send_email_notifications(sender, instance, created, **kwargs):
-    """
-    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.
-    """
-    utils.send_email_notifications_for_product(instance.product)
-
-
-if settings.OSCAR_INSTANT_NOTIFICATION_ENABLED:
-    from django.db.models.signals import post_save
-    post_save.connect(send_email_notifications, sender=StockRecord)

oscar/apps/catalogue/notification/utils.py

@@ -1,96 +0,0 @@
-import datetime
-
-from django.core import mail
-from django.conf import settings
-from django.template import loader, Context
-from django.contrib.sites.models import Site
-from django.utils.translation import ugettext as _
-
-from oscar.core.loading import get_class
-
-# use get_class instead of get_model as this module get imported
-# in the models module of notification. That means models are not
-# available at this point in time.
-StockRecord = get_class('partner.models', 'StockRecord')
-ProductNotification = get_class('catalogue.notification.models',
-                                'ProductNotification')
-
-
-def create_email_from_context(email, template, context):
-    """
-    Create ``EmailMessage`` with message body composed as HTML from
-    *template* rendered with *context*. The email address to send the
-    message to is provided by *email*. The content subtype of the
-    message is set to ``html``.
-
-    Returns a ``EmailMessage`` instance.
-    """
-    subject = _("[Product Notification] Product '%(title)s' back in stock!")
-    subject = subject % {'title': context['product'].title}
-
-    msg = mail.EmailMessage(
-        template.render(context),
-        subject,
-        settings.OSCAR_FROM_EMAIL,
-        [email],
-    )
-    msg.content_subtype = "html",
-    return msg
-
-
-def send_email_notifications_for_product(product):
-    """
-    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.
-    """
-    notifications = ProductNotification.objects.filter(
-        product=product,
-        status=ProductNotification.ACTIVE,
-    )
-
-    # ignore the rest if no notifications for this stockrecord
-    if not len(notifications):
-        return
-
-    # add a hurry disclaimer if less products in stock then
-    # notifications requested
-    context = Context({
-        'product': product,
-        'site': Site.objects.get(pk=getattr(settings, 'SITE_ID', 1)),
-        'hurry': len(notifications) <= product.stockrecord.num_in_stock,
-    })
-
-    template_file = getattr(settings, 'OSCAR_NOTIFICATION_EMAIL_TEMPLATE',
-                            'notification/notification_email.html')
-    template = loader.get_template(template_file)
-
-    email_messages = []
-    # generate personalised emails for registered users first
-    for notification in notifications.exclude(user=None):
-        context['user'] = notification.user
-        email_messages.append(create_email_from_context(
-            notification.get_notification_email(),
-            template,
-            context
-        ))
-
-    # generate the same email for all anonymous users
-    for notification in notifications.filter(user=None):
-        email_messages.append(create_email_from_context(
-            notification.get_notification_email(),
-            template,
-            context
-        ))
-
-    # send all emails in one go to prevent multiple SMTP
-    # connections to be opened
-    connection = mail.get_connection()
-    connection.send_messages(email_messages)
-    connection.close()
-
-    # set the notified date for all notifications and deactivate them
-    for notification in notifications:
-        notification.status = ProductNotification.INACTIVE
-        notification.date_notified = datetime.datetime.now()
-        notification.save()

oscar/apps/catalogue/notification/views.py

@@ -1,295 +0,0 @@
-from django.conf import settings
-from django.views import generic
-from django.http import HttpResponseRedirect, Http404
-
-from django.core import mail
-from django.contrib import messages
-from django.db.models import get_model
-from django.template import loader, Context
-from django.contrib.auth.models import User
-from django.core.urlresolvers import reverse
-from django.contrib.sites.models import Site
-from django.shortcuts import get_object_or_404
-from django.utils.translation import ugettext as _
-
-from oscar.apps.catalogue.notification.forms import ProductNotificationForm
-
-Product = get_model('catalogue', 'product')
-ProductNotification = get_model('notification', 'productnotification')
-
-
-class NotificationUnsubscribeView(generic.RedirectView):
-    """
-    View to unsubscribe from a notification based on the provided
-    unsubscribe key. The notification is set to ``INACTIVE`` instead
-    of being deleted for analytical purposes.
-    """
-    model = ProductNotification
-    context_object_name = 'notification'
-
-    def get_object(self, queryset=None):
-        """ Get notification object that matches the unsubscribe key. """
-        try:
-            return self.model.objects.get(
-                unsubscribe_key=self.kwargs.get('key', 'invalid')
-            )
-        except self.model.DoesNotExist:
-            raise Http404
-
-    def get(self, *args, **kwargs):
-        notification = self.get_object()
-        notification.status = ProductNotification.INACTIVE
-        notification.save()
-        messages.info(self.request,
-            _("You have successfully unsubscribed from this notification.")
-        )
-        kwargs['notification'] = notification
-        return super(NotificationUnsubscribeView, self).get(*args, **kwargs)
-
-    def get_redirect_url(self, **kwargs):
-        return kwargs.get('notification').get_absolute_item_url()
-
-
-class NotificationConfirmView(generic.RedirectView):
-    """
-    View to confirm the email address of an anonymous user used to
-    sign up for a product notification.
-    """
-    model = ProductNotification
-    context_object_name = 'notification'
-
-    def get_object(self, queryset=None):
-        """ Get notification object that matches the confirmation key. """
-        try:
-            return self.model.objects.get(
-                confirm_key=self.kwargs.get('key', 'invalid')
-            )
-        except self.model.DoesNotExist:
-            raise Http404
-
-    def get(self, *args, **kwargs):
-        notification = self.get_object()
-        notification.status = self.model.ACTIVE
-        notification.save()
-        messages.info(self.request,
-            _("Yeah! You have confirmed your subscription. We'll notify "
-              "you as soon as the product is back in stock.")
-        )
-        kwargs['notification'] = notification
-        return super(NotificationConfirmView, self).get(*args, **kwargs)
-
-    def get_redirect_url(self, **kwargs):
-        return kwargs.get('notification').get_absolute_item_url()
-
-
-class ProductNotificationCreateView(generic.FormView):
-    """
-    View to create a new product notification based on a registered user
-    or an email address provided by an anonymous user.
-    """
-    product_model = Product
-    form_class = ProductNotificationForm
-    template_name = 'notification/notification.html'
-    email_template = 'notification/email.html'
-
-    def get_form_kwargs(self):
-        """
-        Get keywords to instantiate the view's form with. If the current
-        user is authenticated as registered user, their email address is
-        added to the ``initial`` dictionary as ``email`` which prepopulates
-        the ``email`` form field.
-        """
-        kwargs = super(ProductNotificationCreateView, self).get_form_kwargs()
-
-        user = self.request.user
-        if user.is_authenticated():
-            kwargs['initial'].update({'email': user.email})
-        return kwargs
-
-    def get_product(self):
-        """
-        Get product from primary key specified in URL patterns as
-        ``pk``. Raises a 404 if product does not exist.
-        """
-        return get_object_or_404(self.product_model, pk=self.kwargs['pk'])
-
-    def get_context_data(self, *args, **kwargs):
-        """
-        Get context data including ``product`` representing the product
-        related to this product notification.
-        """
-        ctx = super(ProductNotificationCreateView, self).get_context_data(
-            *args,
-            **kwargs
-        )
-        ctx['product'] = self.get_product()
-        return ctx
-
-    def get_notification_for_anonymous_user(self, email):
-        """
-        Get a the ``ProductNotification`` for the given product and anonymous
-        users email address. If no notification exists, a new
-        ``ProductNotification`` will be created for the product. A newly
-        created ``ProductNotification`` will be set to status ``UNCONFIRMED``
-        and need confirmation of the email address.
-        """
-        notification, created = ProductNotification.objects.get_or_create(
-            email=email,
-            product=self.product,
-        )
-
-        if created:
-            notification.status = ProductNotification.UNCONFIRMED
-            notification.save()
-        return notification, created
-
-    def get_notification_for_authenticated_user(self):
-        """
-        Get a the ``ProductNotification`` for the given product and anonymous
-        users email address. If no notification exists, a new
-        ``ProductNotification`` will be created for the product. A newly
-        created ``ProductNotification`` will be set to status ``ACTIVE``
-        immediately.
-        """
-        notification, created = ProductNotification.objects.get_or_create(
-            user=self.request.user,
-            product=self.product,
-        )
-
-        if created:
-            notification.status = ProductNotification.ACTIVE
-            notification.save()
-        return notification, created
-
-    def send_confirmation_email(self, notification):
-        """
-        Send email message to unregistered user's email address containing
-        a confirmation URL and a unsubscribe URL. This is the only means
-        for the user to active and deactivate their notification.
-        """
-        template = loader.get_template(self.email_template)
-        context = Context({
-            'site': Site.objects.get_current(),
-            'notification': notification,
-            'product': self.product,
-        })
-
-        msg = mail.EmailMessage(
-            _("[Confirmation] Please confirm the notification for "
-              "product %s") % (self.product.title,),
-            template.render(context),
-            settings.OSCAR_FROM_EMAIL,
-            [notification.email],
-        )
-        msg.send()
-        messages.info(self.request,
-                      _("Confirmation email send successfully, "
-                        "please check your email."))
-
-    def form_valid(self, form):
-        """
-        Handle creating a new ``ProductNotification`` when no errors
-        have been found in form. If a user has already signed up for
-        this ``ProductNotification``, no new notification will be
-        created but the user will receive confirmation that the notification
-        was created successfully. This reduces the complexity of handling
-        this situation differently from a new notification and the user
-        does not get annoyed by realising that they have already signed
-        up and just forgot about it.
-        If a new notification is created for an unregistered user, an
-        email is sent out with a confirmation and unsubscibe URL. A
-        registered users notification is activated immediately.
-
-        NOTE: a registered user that is not logged in will be redirected
-        to the login page. This is achieved by checking if an anonymous
-        email address is already part of a registered customer account.
-        """
-        is_authenticated = self.request.user.is_authenticated()
-        self.product = self.get_product()
-
-        # first check if the anonymous user provided an email address
-        # that belongs to a registered user. If that is the case the
-        # user will be redirected to the login/register page
-        if not is_authenticated:
-            try:
-                User.objects.get(email=form.cleaned_data['email'])
-                redirect_url = "%s?next=%s" % (reverse('customer:login'),
-                                               self.get_success_url())
-                return HttpResponseRedirect(redirect_url)
-            except User.DoesNotExist:
-                pass
-
-        if is_authenticated:
-            notification, created = self.get_notification_for_authenticated_user()
-        else:
-            notification, created = self.get_notification_for_anonymous_user(
-                form.cleaned_data['email']
-            )
-
-        if not created:
-            messages.success(self.request,
-                     _("you have signed up for a "
-                       "notification of '%s' already") % self.product.title)
-            return HttpResponseRedirect(self.get_success_url())
-
-        if created and not is_authenticated:
-            self.send_confirmation_email(notification)
-
-        messages.success(self.request,
-                _("%s was added to your notifications") % self.product.title)
-
-        return HttpResponseRedirect(self.get_success_url())
-
-    def get_success_url(self):
-        """
-        Get success URL to redirect to the product's detail page.
-        """
-        return reverse('catalogue:detail', kwargs={
-            'product_slug':self.product.slug,
-            'pk': self.product.pk
-        })
-
-
-class ProductNotificationSetStatusView(generic.TemplateView):
-    """
-    View to change the status of a product notification. The status can
-    be changed from ``active`` to ``inactive`` and vice versa.
-    """
-    model = ProductNotification
-    status_types = [map[0] for map in ProductNotification.STATUS_TYPES]
-    pk_url_kwarg = 'notification_pk'
-
-    def get(self, *args, **kwargs):
-        """
-        Handle GET request for this view. Extract the product and notification
-        from the URL as well as the new status. If the status is not ``active``
-        or ``inactive`` a HTTP redirect is returned without changing the
-        notification. Otherwise the notification status is updated
-        """
-        self.product = get_object_or_404(Product, pk=kwargs.get('pk'))
-        status = kwargs.get('status', None)
-
-        if status in (self.status_types):
-            notification = get_object_or_404(self.model, pk=kwargs.get('pk'))
-            notification.status = status
-            notification.save()
-
-        return HttpResponseRedirect(self.get_success_url())
-
-    def post(self, *args, **kwargs):
-        """
-        Handle POST request for this view similar to the GET request. Ignores
-        any POST request parameters. Extract the product and notification
-        from the URL as well as the new status. If the status is not ``active``
-        or ``inactive`` a HTTP redirect is returned without changing the
-        notification. Otherwise the notification status is updated
-        """
-        return self.get(*args, **kwargs)
-
-    def get_success_url(self):
-        """
-        Get URL to redirect to after successful status change.
-        """
-        detail_url = reverse('catalogue:detail',
-                             args=(self.product.slug, self.product.pk))
-        return self.request.META.get('HTTP_REFERER', detail_url)

oscar/apps/catalogue/views.py

@@ -9,8 +9,8 @@ from oscar.apps.catalogue.signals import product_viewed, product_search
 Product = get_model('catalogue', 'product')
 ProductReview = get_model('reviews', 'ProductReview')
 Category = get_model('catalogue', 'category')
-ProductNotificationForm = get_class('catalogue.notification.forms',
-                                    'ProductNotificationForm')
+ProductAlertForm = get_class('customer.forms',
+                             'ProductAlertForm')
 
 
 class ProductDetailView(DetailView):
@@ -29,12 +29,13 @@ class ProductDetailView(DetailView):
     def get_context_data(self, **kwargs):
         ctx = super(ProductDetailView, self).get_context_data(**kwargs)
         ctx['reviews'] = self.get_reviews()
-        ctx['notification_form'] = ProductNotificationForm(initial={
-            'user': self.request.user,
-            'email': getattr(self.request.user, 'email', ''),
-        })
+        ctx['alert_form'] = self.get_alert_form()
         return ctx
 
+    def get_alert_form(self):
+        return ProductAlertForm(user=self.request.user,
+                                product=self.object)
+
     def get_reviews(self):
         return self.object.reviews.filter(status=ProductReview.APPROVED)
 
@@ -153,7 +154,4 @@ class ProductListView(ListView):
         else:
             context['summary'] = _("Products matching '%(query)s'") % {'query': q}
             context['search_term'] = q
-        context['notification_form'] = ProductNotificationForm(initial={
-            'user':self.request.user,
-        })
         return context

oscar/apps/customer/abstract_models.py

@@ -1,8 +1,13 @@
+import sha
+import random
+
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 from django.template import Template, Context, TemplateDoesNotExist
 from django.template.loader import get_template
 from django.conf import settings
+from django.utils.timezone import now
+from django.core.urlresolvers import reverse
 
 from oscar.apps.customer.managers import CommunicationTypeManager
 
@@ -157,3 +162,116 @@ class AbstractNotification(models.Model):
     @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
+    """
+    product = models.ForeignKey('catalogue.Product')
+
+    # A user is only required if the notification is created by a
+    # registered user, anonymous users will only have an email address
+    # attached to the notification
+    user = models.ForeignKey('auth.User', db_index=True, blank=True, null=True,
+                             related_name="alerts", verbose_name=_('User'))
+    email = models.EmailField(_("Email"), db_index=True, blank=True, null=True)
+
+    # This key are used to confirm and cancel alerts for anon users
+    key = models.CharField(_("Key"), max_length=128, null=True, db_index=True)
+
+    # An alert can have two different statuses for authenticated
+    # users (``ACTIVE`` and ``INACTIVE`` and anonymous users have an
+    # additional status ``UNCONFIRMED``. For anonymous users a confirmation
+    # and unsubscription key are generated when an instance is saved for
+    # the first time and can be used to confirm and unsubscribe the
+    # notifications.
+    UNCONFIRMED, ACTIVE, CANCELLED, CLOSED = (
+        'Unconfirmed', 'Active', 'Cancelled', 'Closed')
+    STATUS_CHOICES = (
+        (UNCONFIRMED, _('Not yet confirmed')),
+        (ACTIVE, _('Active')),
+        (CANCELLED, _('Cancelled')),
+        (CLOSED, _('Closed')),
+    )
+    status = models.CharField(_("Status"), max_length=20,
+                              choices=STATUS_CHOICES, default=ACTIVE)
+
+    date_created = models.DateTimeField(_("Date created"), auto_now_add=True)
+    date_confirmed = models.DateTimeField(_("Date confirmed"), blank=True,
+                                          null=True)
+    date_cancelled = models.DateTimeField(_("Date cancelled"), blank=True,
+                                          null=True)
+    date_closed = models.DateTimeField(_("Date closed"), blank=True, null=True)
+
+    class Meta:
+        abstract = True
+
+    @property
+    def is_anonymous(self):
+        return self.user is None
+
+    @property
+    def can_be_confirmed(self):
+        return self.status == self.UNCONFIRMED
+
+    @property
+    def can_be_cancelled(self):
+        return self.status == self.ACTIVE
+
+    @property
+    def is_cancelled(self):
+        return self.status == self.CANCELLED
+
+    @property
+    def is_active(self):
+        return self.status == self.ACTIVE
+
+    def confirm(self):
+        self.status = self.ACTIVE
+        self.date_confirmed = now()
+        self.save()
+
+    def cancel(self):
+        self.status = self.CANCELLED
+        self.date_cancelled = now()
+        self.save()
+
+    def close(self):
+        self.status = self.CLOSED
+        self.date_closed = now()
+        self.save()
+
+    def get_email_address(self):
+        if self.user:
+            return self.user.email
+        else:
+            return self.email
+
+    def save(self, *args, **kwargs):
+        if not self.id and not self.user:
+            self.key = self.get_random_key()
+            self.status = self.UNCONFIRMED
+        # Ensure date fields get updated when saving from modelform (which just
+        # calls save, and doesn't call the methods cancel(), confirm() etc).
+        if self.status == self.CANCELLED and self.date_cancelled is None:
+            self.date_cancelled = now()
+        if not self.user and self.status == self.ACTIVE and self.date_confirmed is None:
+            self.date_confirmed = now()
+        if self.status == self.CLOSED and self.date_closed is None:
+            self.date_closed = now()
+
+        return super(AbstractProductAlert, self).save(*args, **kwargs)
+
+    def get_random_key(self):
+        """
+        Get a random generated key based on SHA-1 and email address
+        """
+        salt = sha.new(str(random.random())).hexdigest()
+        return sha.new(salt + self.email).hexdigest()
+
+    def get_confirm_url(self):
+        return reverse('customer:alerts-confirm', kwargs={'key': self.key})
+
+    def get_cancel_url(self):
+        return reverse('customer:alerts-cancel', kwargs={'key': self.key})

oscar/apps/customer/alerts/receivers.py

@@ -0,0 +1,28 @@
+from django.conf import settings
+from django.db.models import get_model
+from django.db.models.signals import post_save
+from django.contrib.auth.models import User
+
+
+def send_product_alerts(sender, instance, created, **kwargs):
+    from oscar.apps.customer.alerts import utils
+    utils.send_product_alerts(instance.product)
+
+
+def migrate_alerts_to_user(sender, instance, created, **kwargs):
+    """
+    Transfer any active alerts linked to a user's email address to the newly
+    registered user.
+    """
+    if created:
+        ProductAlert = get_model('customer', 'ProductAlert')
+        alerts = ProductAlert.objects.filter(email=instance.email, status=ProductAlert.ACTIVE)
+        alerts.update(user=instance, key=None, email=None)
+
+
+post_save.connect(migrate_alerts_to_user, sender=User)
+
+
+if settings.OSCAR_EAGER_ALERTS:
+    StockRecord = get_model('partner', 'StockRecord')
+    post_save.connect(send_product_alerts, sender=StockRecord)

oscar/apps/customer/alerts/utils.py

@@ -0,0 +1,103 @@
+import logging
+
+from django.core import mail
+from django.conf import settings
+from django.template import loader, Context
+from django.contrib.sites.models import Site
+from django.db.models import get_model
+
+from oscar.apps.customer.notifications import services
+
+ProductAlert = get_model('customer', 'ProductAlert')
+Product = get_model('catalogue', 'Product')
+
+logger = logging.getLogger(__file__)
+
+
+def send_alerts():
+    """
+    Send out product alerts
+    """
+    products = Product.objects.filter(
+        productalert__status=ProductAlert.ACTIVE
+    ).distinct()
+    logger.info("Found %d products with active alerts", products.count())
+    for product in products:
+        if product.is_available_to_buy:
+            send_product_alerts(product)
+
+
+def send_alert_confirmation(alert):
+    """
+    Send an alert confirmation email.
+    """
+    ctx = Context({
+        'alert': alert,
+        'site': Site.objects.get_current(),
+    })
+    subject_tpl = loader.get_template('customer/alerts/emails/confirmation_subject.txt')
+    body_tpl = loader.get_template('customer/alerts/emails/confirmation_body.txt')
+    mail.send_mail(
+        subject_tpl.render(ctx).strip(),
+        body_tpl.render(ctx),
+        settings.OSCAR_FROM_EMAIL,
+        [alert.email],
+    )
+
+
+def send_product_alerts(product):
+    """
+    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.
+    """
+    if not product.has_stockrecord:
+        return
+    num_in_stock = product.stockrecord.num_in_stock
+    if num_in_stock == 0:
+        return
+
+    logger.info("Sending alerts for '%s'", product)
+    alerts = ProductAlert.objects.filter(
+        product=product,
+        status=ProductAlert.ACTIVE,
+    )
+    hurry_mode = alerts.count() < product.stockrecord.num_in_stock
+
+    # Load templates
+    message_tpl = loader.get_template('customer/alerts/message.html')
+    email_subject_tpl = loader.get_template('customer/alerts/emails/alert_subject.txt')
+    email_body_tpl = loader.get_template('customer/alerts/emails/alert_body.txt')
+
+    emails = []
+    num_notifications = 0
+    for alert in alerts:
+        ctx = Context({
+            'alert': alert,
+            'site': Site.objects.get_current(),
+            'hurry': hurry_mode,
+        })
+        if alert.user:
+            # Send a site notification
+            num_notifications += 1
+            services.notify_user(alert.user, message_tpl.render(ctx))
+
+        # Build email and add to list
+        emails.append(
+            mail.EmailMessage(
+                email_subject_tpl.render(ctx).strip(),
+                email_body_tpl.render(ctx),
+                settings.OSCAR_FROM_EMAIL,
+                [alert.get_email_address()],
+            )
+        )
+
+        alert.close()
+
+    # Send all emails in one go to prevent multiple SMTP
+    # connections to be opened
+    connection = mail.get_connection()
+    connection.send_messages(emails)
+    connection.close()
+
+    logger.info("Sent %d notifications and %d emails", num_notifications, len(emails))

oscar/apps/customer/alerts/views.py

@@ -0,0 +1,90 @@
+from django.views import generic
+from django.db.models import get_model
+from django.shortcuts import get_object_or_404
+from django.contrib import messages
+from django.utils.translation import ugettext_lazy as _
+from django import http
+
+from oscar.core.loading import get_class
+from oscar.apps.customer.alerts import utils
+
+Product = get_model('catalogue', 'Product')
+ProductAlert = get_model('customer', 'ProductAlert')
+ProductAlertForm = get_class('customer.forms', 'ProductAlertForm')
+
+
+class ProductAlertCreateView(generic.CreateView):
+    """
+    View to create a new product alert based on a registered user
+    or an email address provided by an anonymous user.
+    """
+    model = ProductAlert
+    form_class = ProductAlertForm
+    template_name = 'customer/alerts/form.html'
+
+    def get_context_data(self, **kwargs):
+        ctx = super(ProductAlertCreateView, self).get_context_data(**kwargs)
+        ctx['product'] = self.product
+        ctx['alert_form'] = ctx.pop('form')
+        return ctx
+
+    def get(self, request, *args, **kwargs):
+        product = get_object_or_404(Product, pk=self.kwargs['pk'])
+        return http.HttpResponseRedirect(product.get_absolute_url())
+
+    def post(self, request, *args, **kwargs):
+        self.product = get_object_or_404(Product, pk=self.kwargs['pk'])
+        return super(ProductAlertCreateView, self).post(request, *args, **kwargs)
+
+    def get_form_kwargs(self):
+        kwargs = super(ProductAlertCreateView, self).get_form_kwargs()
+        kwargs['user'] = self.request.user
+        kwargs['product'] = self.product
+        return kwargs
+
+    def form_valid(self, form):
+        response = super(ProductAlertCreateView, self).form_valid(form)
+        if self.object.is_anonymous:
+            utils.send_alert_confirmation(self.object)
+        return response
+
+    def get_success_url(self):
+        if self.object.user:
+            msg = _("An alert has been created")
+        else:
+            msg = _("An email has been sent to %s for confirmation") % self.object.email
+        messages.success(self.request, msg)
+        return self.object.product.get_absolute_url()
+
+
+class ProductAlertRedirectView(generic.RedirectView):
+    permanent = False
+
+    def get(self, request, *args, **kwargs):
+        self.alert = get_object_or_404(ProductAlert, key=kwargs['key'])
+        self.update_alert()
+        return super(ProductAlertRedirectView, self).get(request, *args, **kwargs)
+
+    def get_redirect_url(self, **kwargs):
+        return self.alert.product.get_absolute_url()
+
+
+class ProductAlertConfirmView(ProductAlertRedirectView):
+    permanent = False
+
+    def update_alert(self):
+        if self.alert.can_be_confirmed:
+            self.alert.confirm()
+            messages.success(self.request, _("Your stock alert is now active"))
+        else:
+            messages.error(self.request, _("Your stock alert cannot be confirmed"))
+
+
+class ProductAlertCancelView(ProductAlertRedirectView):
+
+    def update_alert(self):
+        if self.alert.can_be_cancelled:
+            self.alert.cancel()
+            messages.success(self.request, _("Your stock alert has been cancelled"))
+        else:
+            messages.error(self.request, _("Your stock alert cannot be cancelled"))

oscar/apps/customer/app.py

@@ -4,6 +4,7 @@ from django.views import generic
 
 from oscar.apps.customer import views
 from oscar.apps.customer.notifications import views as notification_views
+from oscar.apps.customer.alerts import views as alert_views
 from oscar.core.application import Application
 
 
@@ -30,6 +31,10 @@ class CustomerApplication(Application):
     notification_archive_view = notification_views.ArchiveView
     notification_update_view = notification_views.UpdateView
 
+    alert_create_view = alert_views.ProductAlertCreateView
+    alert_confirm_view = alert_views.ProductAlertConfirmView
+    alert_cancel_view = alert_views.ProductAlertCancelView
+
     def get_urls(self):
         urlpatterns = patterns('',
             url(r'^$', login_required(self.summary_view.as_view()),
@@ -92,6 +97,16 @@ class CustomerApplication(Application):
             url(r'^notifications/update/$',
                 login_required(self.notification_update_view.as_view()),
                 name='notifications-update'),
+
+            # Alerts
+            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/(?P<key>[a-z0-9]+)/$',
+                self.alert_cancel_view.as_view(),
+                name='alerts-cancel'),
             )
         return self.post_process_urls(urlpatterns)
 

oscar/apps/customer/forms.py

@@ -18,6 +18,7 @@ from oscar.core.loading import get_profile_class, get_class
 
 Dispatcher = get_class('customer.utils', 'Dispatcher')
 CommunicationEventType = get_model('customer', 'communicationeventtype')
+ProductAlert = get_model('customer', 'ProductAlert')
 
 
 def generate_username():
@@ -275,3 +276,60 @@ if hasattr(settings, 'AUTH_PROFILE_MODULE'):
     ProfileForm = UserAndProfileForm
 else:
     ProfileForm = UserForm
+
+
+class ProductAlertForm(forms.ModelForm):
+    email = forms.EmailField(required=True, label=_(u'Send notification to'),
+                             widget=forms.TextInput(attrs={
+                                 'placeholder': _('Enter your email')
+                             }))
+
+    def __init__(self, user, product, *args, **kwargs):
+        self.user = user
+        self.product = product
+        super(ProductAlertForm, self).__init__(*args, **kwargs)
+
+        # Only show email field to unauthenticated users
+        if user and user.is_authenticated():
+            self.fields['email'].widget = forms.HiddenInput()
+            self.fields['email'].required = False
+
+    def save(self, commit=True):
+        alert = super(ProductAlertForm, self).save(commit=False)
+        if self.user.is_authenticated():
+            alert.user = self.user
+        alert.product = self.product
+        if commit:
+            alert.save()
+        return alert
+
+    def clean(self):
+        cleaned_data = self.cleaned_data
+        email = cleaned_data.get('email')
+        if email:
+            try:
+                ProductAlert.objects.get(
+                    product=self.product, email=email,
+                    status=ProductAlert.ACTIVE)
+            except ProductAlert.DoesNotExist:
+                pass
+            else:
+                raise forms.ValidationError(_(
+                    "There is already an active stock alert for %s") % email)
+        elif self.user.is_authenticated():
+            try:
+                ProductAlert.objects.get(product=self.product,
+                                         user=self.user,
+                                         status=ProductAlert.ACTIVE)
+            except ProductAlert.DoesNotExist:
+                pass
+            else:
+                raise forms.ValidationError(_(
+                    "You already have an active alert for this product"))
+        return cleaned_data
+
+    class Meta:
+        model = ProductAlert
+        exclude = ('user', 'key',
+                   'status', 'date_confirmed', 'date_cancelled', 'date_closed',
+                   'product')

oscar/apps/catalogue/notification/migrations/0001_initial.py → oscar/apps/customer/migrations/0003_auto__add_productalert.py

@@ -1,32 +1,33 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 import datetime
 from south.db import db
 from south.v2 import SchemaMigration
 from django.db import models
 
-
 class Migration(SchemaMigration):
 
     def forwards(self, orm):
-        # Adding model 'ProductNotification'
-        db.create_table('notification_productnotification', (
+
+        # Adding model 'ProductAlert'
+        db.create_table('customer_productalert', (
             ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
-            ('user', self.gf('django.db.models.fields.related.ForeignKey')(blank=True, related_name='product_notifications', null=True, to=orm['auth.User'])),
             ('product', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['catalogue.Product'])),
+            ('user', self.gf('django.db.models.fields.related.ForeignKey')(blank=True, related_name='alerts', null=True, to=orm['auth.User'])),
             ('email', self.gf('django.db.models.fields.EmailField')(db_index=True, max_length=75, null=True, blank=True)),
-            ('confirm_key', self.gf('django.db.models.fields.CharField')(max_length=40, null=True)),
-            ('unsubscribe_key', self.gf('django.db.models.fields.CharField')(max_length=40, null=True)),
-            ('status', self.gf('django.db.models.fields.CharField')(default='inactive', max_length=20)),
+            ('key', self.gf('django.db.models.fields.CharField')(max_length=128, null=True, db_index=True)),
+            ('status', self.gf('django.db.models.fields.CharField')(default='Active', max_length=20)),
             ('date_created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
-            ('date_modified', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
-            ('date_notified', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
+            ('date_confirmed', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
+            ('date_cancelled', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
+            ('date_closed', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
         ))
-        db.send_create_signal('notification', ['ProductNotification'])
+        db.send_create_signal('customer', ['ProductAlert'])
 
 
     def backwards(self, orm):
-        # Deleting model 'ProductNotification'
-        db.delete_table('notification_productnotification')
+
+        # Deleting model 'ProductAlert'
+        db.delete_table('customer_productalert')
 
 
     models = {
@@ -45,7 +46,7 @@ class Migration(SchemaMigration):
         },
         'auth.user': {
             'Meta': {'object_name': 'User'},
-            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 9, 26, 13, 49, 39, 401244)'}),
             'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
             'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
             'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
@@ -53,7 +54,7 @@ class Migration(SchemaMigration):
             'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
             'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
             'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
-            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 9, 26, 13, 49, 39, 401151)'}),
             'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
             'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
             'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
@@ -63,14 +64,14 @@ class Migration(SchemaMigration):
             'Meta': {'object_name': 'AttributeEntity'},
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
-            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '255', 'blank': 'True'}),
+            'slug': ('django.db.models.fields.SlugField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
             'type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'entities'", 'to': "orm['catalogue.AttributeEntityType']"})
         },
         'catalogue.attributeentitytype': {
             'Meta': {'object_name': 'AttributeEntityType'},
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
-            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '255', 'blank': 'True'})
+            'slug': ('django.db.models.fields.SlugField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'})
         },
         'catalogue.attributeoption': {
             'Meta': {'object_name': 'AttributeOption'},
@@ -93,11 +94,11 @@ class Migration(SchemaMigration):
             'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
             'numchild': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
             'path': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
-            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '1024'})
+            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '1024', 'db_index': 'True'})
         },
         'catalogue.option': {
             'Meta': {'object_name': 'Option'},
-            'code': ('django.db.models.fields.SlugField', [], {'max_length': '128'}),
+            'code': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '128', 'db_index': 'True'}),
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
             'type': ('django.db.models.fields.CharField', [], {'default': "'Required'", 'max_length': '128'})
@@ -117,14 +118,14 @@ class Migration(SchemaMigration):
             'recommended_products': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['catalogue.Product']", 'symmetrical': 'False', 'through': "orm['catalogue.ProductRecommendation']", 'blank': 'True'}),
             'related_products': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'relations'", 'blank': 'True', 'to': "orm['catalogue.Product']"}),
             'score': ('django.db.models.fields.FloatField', [], {'default': '0.0', 'db_index': 'True'}),
-            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '255'}),
+            'slug': ('django.db.models.fields.SlugField', [], {'max_length': '255', 'db_index': 'True'}),
             'status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '128', 'null': 'True', 'blank': 'True'}),
             'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
             'upc': ('django.db.models.fields.CharField', [], {'max_length': '64', 'unique': 'True', 'null': 'True', 'blank': 'True'})
         },
         'catalogue.productattribute': {
             'Meta': {'ordering': "['code']", 'object_name': 'ProductAttribute'},
-            'code': ('django.db.models.fields.SlugField', [], {'max_length': '128'}),
+            'code': ('django.db.models.fields.SlugField', [], {'max_length': '128', 'db_index': 'True'}),
             'entity_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['catalogue.AttributeEntityType']", 'null': 'True', 'blank': 'True'}),
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
@@ -160,7 +161,8 @@ class Migration(SchemaMigration):
             'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
             'options': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['catalogue.Option']", 'symmetrical': 'False', 'blank': 'True'}),
             'requires_shipping': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
-            'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '128'})
+            'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '128', 'db_index': 'True'}),
+            'track_stock': ('django.db.models.fields.BooleanField', [], {'default': 'True'})
         },
         'catalogue.productrecommendation': {
             'Meta': {'object_name': 'ProductRecommendation'},
@@ -176,19 +178,53 @@ class Migration(SchemaMigration):
             'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
         },
-        'notification.productnotification': {
-            'Meta': {'object_name': 'ProductNotification'},
-            'confirm_key': ('django.db.models.fields.CharField', [], {'max_length': '40', 'null': 'True'}),
+        'customer.communicationeventtype': {
+            'Meta': {'object_name': 'CommunicationEventType'},
+            'category': ('django.db.models.fields.CharField', [], {'default': "u'Order related'", 'max_length': '255'}),
+            'code': ('django.db.models.fields.SlugField', [], {'max_length': '128', 'db_index': 'True'}),
+            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'date_updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
+            'email_body_html_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'email_body_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'email_subject_template': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'sms_template': ('django.db.models.fields.CharField', [], {'max_length': '170', 'blank': 'True'})
+        },
+        'customer.email': {
+            'Meta': {'object_name': 'Email'},
+            'body_html': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'body_text': ('django.db.models.fields.TextField', [], {}),
+            'date_sent': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'subject': ('django.db.models.fields.TextField', [], {'max_length': '255'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'emails'", 'to': "orm['auth.User']"})
+        },
+        'customer.notification': {
+            'Meta': {'ordering': "('-date_sent',)", 'object_name': 'Notification'},
+            'body': ('django.db.models.fields.TextField', [], {}),
+            'category': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True'}),
+            'date_read': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
+            'date_sent': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'location': ('django.db.models.fields.CharField', [], {'default': "'Inbox'", 'max_length': '32'}),
+            'recipient': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'notifications'", 'to': "orm['auth.User']"}),
+            'sender': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True'}),
+            'subject': ('django.db.models.fields.CharField', [], {'max_length': '255'})
+        },
+        'customer.productalert': {
+            'Meta': {'object_name': 'ProductAlert'},
+            'date_cancelled': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'date_closed': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'date_confirmed': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
             'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
-            'date_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
-            'date_notified': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
             'email': ('django.db.models.fields.EmailField', [], {'db_index': 'True', 'max_length': '75', 'null': 'True', 'blank': 'True'}),
             'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'db_index': 'True'}),
             'product': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['catalogue.Product']"}),
-            'status': ('django.db.models.fields.CharField', [], {'default': "'inactive'", 'max_length': '20'}),
-            'unsubscribe_key': ('django.db.models.fields.CharField', [], {'max_length': '40', 'null': 'True'}),
-            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'product_notifications'", 'null': 'True', 'to': "orm['auth.User']"})
+            'status': ('django.db.models.fields.CharField', [], {'default': "'Active'", 'max_length': '20'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'alerts'", 'null': 'True', 'to': "orm['auth.User']"})
         }
     }
 
-    complete_apps = ['notification']
+    complete_apps = ['customer']

oscar/apps/customer/models.py

@@ -1,17 +1,21 @@
-from oscar.apps.customer.abstract_models import (
-    AbstractEmail, AbstractCommunicationEventType, AbstractNotification)
+from oscar.apps.customer import abstract_models
 
 
-class Email(AbstractEmail):
+class Email(abstract_models.AbstractEmail):
     pass
 
 
-class CommunicationEventType(AbstractCommunicationEventType):
+class CommunicationEventType(abstract_models.AbstractCommunicationEventType):
     pass
 
 
-class Notification(AbstractNotification):
+class Notification(abstract_models.AbstractNotification):
     pass
 
 
-from oscar.apps.customer.history_helpers import *
+class ProductAlert(abstract_models.AbstractProductAlert):
+    pass
+
+
+from oscar.apps.customer.history_helpers import *
+from oscar.apps.customer.alerts.receivers import *

oscar/apps/customer/views.py

@@ -33,7 +33,7 @@ UserAddress = get_model('address', 'UserAddress')
 Email = get_model('customer', 'email')
 UserAddress = get_model('address', 'UserAddress')
 CommunicationEventType = get_model('customer', 'communicationeventtype')
-ProductNotification = get_model('notification', 'productnotification')
+ProductAlert = get_model('customer', 'ProductAlert')
 
 
 class LogoutView(RedirectView):
@@ -79,7 +79,7 @@ class AccountSummaryView(TemplateView):
         ctx['default_billing_address'] = self.get_default_billing_address(self.request.user)
         ctx['orders'] = self.get_orders(self.request.user)
         ctx['emails'] = self.get_emails(self.request.user)
-        ctx['notification_list'] = self.get_product_notifications(self.request.user)
+        ctx['alerts'] = self.get_product_alerts(self.request.user)
         self.add_profile_fields(ctx)
 
         ctx['active_tab'] = self.request.GET.get('tab', 'profile')
@@ -113,38 +113,30 @@ class AccountSummaryView(TemplateView):
         ctx['profile'] = profile
 
     def post(self, request, *args, **kwargs):
-        if 'deactivate' in request.POST:
-            notification_id = request.POST.get('deactivate')
-            status = ProductNotification.INACTIVE
-            success_msg = _("Notification deactivated")
-        elif 'activate' in request.POST:
-            notification_id = request.POST.get('activate')
-            status = ProductNotification.ACTIVE
-            success_msg = _("Notification activated")
+        # A POST means an attempt to change the status of an alert
+        if 'cancel_alert' in request.POST:
+            return self.cancel_alert(request.POST.get('cancel_alert'))
+        return super(AccountSummaryView, self).post(request, *args, **kwargs)
 
+    def cancel_alert(self, alert_id):
         try:
-            notification = ProductNotification.objects.get(pk=notification_id,
-                                                           user=request.user)
-        except ProductNotification.DoesNotExist:
-            messages.error(_("Cannot change notification status, notification "
-                             "does not exist"))
+            alert = ProductAlert.objects.get(user=self.request.user, pk=alert_id)
+        except ProductAlert.DoesNotExist:
+            messages.error(self.request, _("No alert found"))
         else:
-            messages.success(request, success_msg)
-            notification.status = status
-            notification.save()
-
+            alert.cancel()
+            messages.success(self.request, _("Alert cancelled"))
         return HttpResponseRedirect(
-            reverse('customer:summary')+'?tab=notifications'
+            reverse('customer:summary')+'?tab=alerts'
         )
 
     def get_emails(self, user):
         return Email.objects.filter(user=user)
 
-    def get_product_notifications(self, user):
-        # Only show notifications that have not been processed
-        return ProductNotification.objects.select_related().filter(
+    def get_product_alerts(self, user):
+        return ProductAlert.objects.select_related().filter(
             user=self.request.user,
-            date_notified=None,
+            date_closed=None,
         )
 
     def get_default_billing_address(self, user):
@@ -238,10 +230,6 @@ class AccountRegistrationView(TemplateView):
         ``OSCAR_SEND_REGISTRATION_EMAIL`` is set to ``True`` a
         registration email will be send to the provided email address.
         A new user account is created and the user is then logged in.
-
-        If the user has anonymous ``Notifications`` subscriptions
-        from before they registered, these notifications will be updated
-        to be connected with their newly created user account.
         """
         user = form.save()
 
@@ -269,17 +257,6 @@ class AccountRegistrationView(TemplateView):
         if self.request.session.test_cookie_worked():
             self.request.session.delete_test_cookie()
 
-        # check if there are notifications for this user's
-        # email address and change them from anonymous to this
-        # user's account
-        #FIXME: Needs to implement base class of all notifications
-        notifications = ProductNotification.objects.filter(
-            email=user.email,
-            user=None
-        )
-        for notification in notifications:
-            notification.transfer_to_user(user)
-
 
 class AccountAuthView(AccountRegistrationView):
     template_name = 'customer/login_registration.html'

oscar/apps/dashboard/users/app.py

@@ -8,7 +8,7 @@ from oscar.apps.dashboard.nav import register, Node
 
 node = Node(_('Customers'))
 node.add_child(Node(_('Customers'), 'dashboard:users-index'))
-node.add_child(Node(_('Notifications'), 'dashboard:user-notification-list'))
+node.add_child(Node(_('Alerts'), 'dashboard:user-alert-list'))
 register(node, 30)
 
 
@@ -16,24 +16,28 @@ class UserManagementApplication(Application):
     name = None
     index_view = views.IndexView
     user_detail_view = views.UserDetailView
-    notification_list_view = views.ProductNotificationListView
-    notification_update_view = views.ProductNotificationUpdateView
-    notification_delete_view = views.ProductNotificationDeleteView
+    alert_list_view = views.ProductAlertListView
+    alert_update_view = views.ProductAlertUpdateView
+    alert_delete_view = views.ProductAlertDeleteView
 
     def get_urls(self):
         urlpatterns = patterns('',
             url(r'^$', self.index_view.as_view(), name='users-index'),
-            url(r'^notifications/(?P<pk>\d+)/delete/$',
-                self.notification_delete_view.as_view(),
-                name='user-notification-delete'),
-            url(r'^notifications/(?P<pk>\d+)/update/$',
-                self.notification_update_view.as_view(),
-                name='user-notification-update'),
-            url(r'^notifications/$',
-                self.notification_list_view.as_view(),
-                name='user-notification-list'),
+
+            # Alerts
+            url(r'^alerts/(?P<pk>\d+)/delete/$',
+                self.alert_delete_view.as_view(),
+                name='user-alert-delete'),
+            url(r'^alerts/(?P<pk>\d+)/update/$',
+                self.alert_update_view.as_view(),
+                name='user-alert-update'),
+            url(r'^alerts/$',
+                self.alert_list_view.as_view(),
+                name='user-alert-list'),
+
             url(r'^(?P<pk>[-\w]+)/$',
                 self.user_detail_view.as_view(), name='user-detail'),
+
         )
         return self.post_process_urls(urlpatterns)
 

oscar/apps/dashboard/users/forms.py

@@ -3,7 +3,7 @@ from django.db.models.loading import get_model
 from django.utils.translation import ugettext_lazy as _
 
 User = get_model('user', 'User')
-ProductNotification = get_model('notification', 'productnotification')
+ProductAlert = get_model('customer', 'ProductAlert')
 
 
 class UserSearchForm(forms.Form):
@@ -11,16 +11,28 @@ class UserSearchForm(forms.Form):
     name = forms.CharField(required=False, label=_("Name"))
 
 
-class ProductNotificationUpdateForm(forms.ModelForm):
+class ProductAlertUpdateForm(forms.ModelForm):
+
+    def __init__(self, *args, **kwargs):
+        super(ProductAlertUpdateForm, self).__init__(*args, **kwargs)
+        alert = kwargs['instance']
+        if alert.user:
+            # Remove 'unconfirmed' from list of available choices when editing
+            # an alert for a real user
+            choices = self.fields['status'].choices
+            del choices[0]
+            self.fields['status'].choices = choices
+
     class Meta:
-        model = ProductNotification
-        exclude = ('confirm_key', 'unsubscribe_key')
+        model = ProductAlert
+        exclude = ('product', 'user', 'email', 'key',
+                   'date_confirmed', 'date_cancelled', 'date_closed')
 
 
-class ProductNotificationSearchForm(forms.Form):
+class ProductAlertSearchForm(forms.Form):
     STATUS_CHOICES = (
         ('', '------------'),
-    ) + ProductNotification.STATUS_TYPES
+    ) + ProductAlert.STATUS_CHOICES
 
     status = forms.ChoiceField(required=False, choices=STATUS_CHOICES)
     name = forms.CharField(required=False)

oscar/apps/dashboard/users/views.py

@@ -6,10 +6,13 @@ from django.http import HttpResponseRedirect
 from django.core.urlresolvers import reverse
 from django.views.generic import ListView, DetailView, DeleteView, UpdateView
 
-from oscar.apps.dashboard.users import forms
 from oscar.views.generic import BulkEditMixin
+from oscar.core.loading import get_classes
 
-ProductNotification = get_model('notification', 'productnotification')
+UserSearchForm, ProductAlertSearchForm, ProductAlertUpdateForm  = get_classes(
+    'dashboard.users.forms', ('UserSearchForm', 'ProductAlertSearchForm',
+                              'ProductAlertUpdateForm'))
+ProductAlert = get_model('customer', 'ProductAlert')
 
 
 class IndexView(ListView, BulkEditMixin):
@@ -18,7 +21,7 @@ class IndexView(ListView, BulkEditMixin):
     model = User
     actions = ('make_active', 'make_inactive', )
     current_view = 'dashboard:users-index'
-    form_class = forms.UserSearchForm
+    form_class = UserSearchForm
     desc_template = _('%(main_filter)s %(email_filter)s %(name_filter)s')
     description = ''
 
@@ -88,15 +91,13 @@ class UserDetailView(DetailView):
         return context
 
 
-class ProductNotificationListView(ListView, BulkEditMixin):
-    model = ProductNotification
-    form_class = forms.ProductNotificationSearchForm
-    context_object_name = 'notification_list'
-    template_name = 'dashboard/notification/list.html'
-    paginate = 25
-    actions = ('update_selected_notification_status',)
-    base_description = _('All notifications')
-    checkbox_object_name = 'notification'
+class ProductAlertListView(ListView):
+    model = ProductAlert
+    form_class = ProductAlertSearchForm
+    context_object_name = 'alerts'
+    template_name = 'dashboard/users/alerts/list.html'
+    paginate_by = 20
+    base_description = _('All Alerts')
     description = ''
 
     def get_queryset(self):
@@ -138,35 +139,29 @@ class ProductNotificationListView(ListView, BulkEditMixin):
 
         return queryset
 
-    def update_selected_notification_status(self, request, notifications):
-        new_status = request.POST.get('status')
-        for notification in notifications:
-            notification.status = new_status
-            notification.save()
-        return HttpResponseRedirect(reverse('dashboard:user-notification-list'))
-
     def get_context_data(self, **kwargs):
-        context = super(ProductNotificationListView, self).get_context_data(**kwargs)
+        context = super(ProductAlertListView, self).get_context_data(**kwargs)
         context['form'] = self.form
-        context['notification_form'] = forms.ProductNotificationUpdateForm
         context['queryset_description'] = self.description
         return context
 
 
-class ProductNotificationUpdateView(UpdateView):
-    template_name = 'dashboard/notification/update.html'
-    model = ProductNotification
-    form_class = forms.ProductNotificationUpdateForm
-    context_object_name = 'notification'
+class ProductAlertUpdateView(UpdateView):
+    template_name = 'dashboard/users/alerts/update.html'
+    model = ProductAlert
+    form_class = ProductAlertUpdateForm
+    context_object_name = 'alert'
 
     def get_success_url(self):
-        return reverse('dashboard:user-notification-list')
+        messages.success(self.request, _("Product alert saved"))
+        return reverse('dashboard:user-alert-list')
 
 
-class ProductNotificationDeleteView(DeleteView):
-    model = ProductNotification
-    template_name = 'dashboard/notification/delete.html'
-    context_object_name = 'notification'
+class ProductAlertDeleteView(DeleteView):
+    model = ProductAlert
+    template_name = 'dashboard/users/alerts/delete.html'
+    context_object_name = 'alert'
 
     def get_success_url(self):
-        return reverse('dashboard:user-notification-list')
+        messages.warning(self.request, _("Product alert deleted"))
+        return reverse('dashboard:user-alert-list')

oscar/defaults.py

@@ -44,18 +44,16 @@ OSCAR_PROMOTION_MERCHANDISING_BLOCK_TYPES = (
 OSCAR_ALLOW_ANON_REVIEWS = True
 OSCAR_MODERATE_REVIEWS = False
 
-# Notifications
-OSCAR_NOTIFICATION_EMAIL_TEMPLATE = 'notification/notification_email.html'
-# This enables sending notification emails
+# This enables sending alert notifications/emails
 # instantly when products get back in stock
 # by listening to stock record update signals
 # this might impact performace for large numbers
 # stock record updates.
 # Alternatively, the management command
-# ``oscar_send_notifications`` can be used to
+# ``oscar_send_alerts`` can be used to
 # run periodically, e.g. as a cronjob. In this case
-# instant notifications should be disabled.
-OSCAR_INSTANT_NOTIFICATION_ENABLED = True
+# instant alerts should be disabled.
+OSCAR_EAGER_ALERTS = True
 
 # Registration
 OSCAR_SEND_REGISTRATION_EMAIL = True

oscar/management/commands/oscar_cleanup_notifications.py → oscar/management/commands/oscar_cleanup_alerts.py

@@ -1,56 +1,54 @@
 import logging
-
 from optparse import make_option
-from datetime import datetime, timedelta
+from datetime import timedelta
 
 from django.db.models import get_model
+from django.utils.timezone import now
 from django.core.management.base import BaseCommand
 
-ProductNotification = get_model('notification', 'productnotification')
+ProductAlert = get_model('customer', 'ProductAlert')
 
 logger = logging.getLogger(__name__)
 
 
 class Command(BaseCommand):
     """
-    Command to remove all notifications derived from
-    ``Notification`` that are in status ``UNCONFIRMED`` and
-    have been created before a threshold date and time. The threshold
-    can be specified as options ``days`` and ``hours`` and is
-    calculated relative to the current date and time.
+    Command to remove all stale unconfirmed alerts
     """
-    help = "Check unconfirmed notifications and clean them up"
+    help = "Check unconfirmed alerts and clean them up"
+
     option_list = BaseCommand.option_list + (
         make_option('--days',
             dest='days',
             default=0,
-            help='cleanup notifications older then DAYS from now.'),
+            help='cleanup alerts older then DAYS from now.'),
         make_option('--hours',
             dest='hours',
             default=0,
-            help='cleanup notifications older then HOURS from now.'),
+            help='cleanup alerts older then HOURS from now.'),
         )
 
     def handle(self, *args, **options):
         """
         Generate a threshold date from the input options or 24 hours
-        if no options specified. All notifications that have the
+        if no options specified. All alerts that have the
         status ``UNCONFIRMED`` and have been created before the
         threshold date will be removed assuming that the emails
         are wrong or the customer changed their mind.
         """
         delta = timedelta(days=int(options['days']),
                           hours=int(options['hours']))
-
         if not delta:
             delta = timedelta(hours=24)
 
-        threshold_date = datetime.now() - delta
+        threshold_date = now() - delta
 
-        logger.info('cleaning up unconfirmed notifications older than %s',
+        logger.info('Deleting unconfirmed alerts older than %s',
                     threshold_date.strftime("%Y-%m-%d %H:%M"))
 
-        ProductNotification.objects.filter(
-            status=ProductNotification.UNCONFIRMED,
+        qs = ProductAlert.objects.filter(
+            status=ProductAlert.UNCONFIRMED,
             date_created__lt=threshold_date
-        ).delete()
+        )
+        logger.info("Found %d stale alerts to delete", qs.count())
+        qs.delete()

oscar/management/commands/oscar_send_alerts.py

@@ -0,0 +1,25 @@
+import logging
+
+from django.utils.translation import ugettext_lazy as _
+from django.core.management.base import BaseCommand
+
+from oscar.apps.customer.alerts import utils
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    """
+    Check stock records of products for availability and send out alerts
+    to customers that have registered for an alert.
+    """
+    help = _("Check check for products that are back in "
+             "stock and send out alerts")
+
+    def handle(self, **options):
+        """
+        Check all products with active product alerts for
+        availability and send out email alerts when a product is
+        available to buy.
+        """
+        utils.send_alerts()

oscar/management/commands/oscar_send_notifications.py

@@ -1,40 +0,0 @@
-import logging
-
-from django.db.models import get_model
-from django.utils.translation import ugettext_lazy as _
-from django.core.management.base import NoArgsCommand
-
-from oscar.apps.catalogue.notification import utils
-
-Product = get_model('catalogue', 'product')
-ProductNotification = get_model('notification', 'productnotification')
-
-logger = logging.getLogger(__name__)
-
-
-class Command(NoArgsCommand):
-    """
-    Check stock records of products for availability and send out notifications
-    to customers that have subscribed to a notification email. Notifications
-    for available products are disabled after an email has been send out.
-    """
-    help = _("Check check for notifications of products that are back in "
-             "stock, send out emails and deactivate the notifications")
-
-    def handle_noargs(self, **options):
-        """
-        Check all products with active product notifications for
-        availability and send out email notifications when a product is
-        available to buy.
-        """
-        logger.info('start searching for updated stock records')
-
-        products = Product.objects.filter(
-            productnotification__status=ProductNotification.ACTIVE
-        )
-
-        for product in products:
-            logger.info('checking product availability for %s', product)
-            if product.is_available_to_buy:
-                logger.info('sending notifications for product %s', product)
-                utils.send_email_notifications_for_product(product)

oscar/templates/oscar/catalogue/browse.html

@@ -69,7 +69,7 @@
 		<section>
 			<div class="mod">
 				{% if page_obj %}
-					{% include "partials/pagination.html" %}
+					{% include "catalogue/partials/pagination.html" %}
 				{% endif %}
 				<ol class="products four">
 					{% for product in products %}
@@ -77,7 +77,7 @@
 					{% endfor %}
 				</ol>
 				{% if page_obj %}
-					{% include "partials/pagination.html" %}
+					{% include "catalogue/partials/pagination.html" %}
 				{% endif %}
 			</div>
 		</section>

oscar/templates/oscar/catalogue/detail.html

@@ -60,10 +60,9 @@
 					{% endfor %}
 				</ul>
 			{% else %}
-			<p class="star">{% trans "No Rating" %}
-			
-			<a href="{% url catalogue:reviews-add product.slug product.id %}#addreview">{% trans "Add review" %}</a>
-			</p>
+				<p class="star">
+					<a href="{% url catalogue:reviews-add product.slug product.id %}#addreview">{% trans "Add review" %}</a>
+				</p>
 			{% endif %}
              
             <hr/>

oscar/templates/oscar/catalogue/partials/add_to_basket_form.html

@@ -10,4 +10,11 @@
 			<button type="submit" class="btn btn-large btn-primary" value="Add to basket">{% trans "Add to basket" %}</button>
         </div>
     </form>
+{% else %}
+	<form id="alert_form" method="post" action="{% url customer:alert-create product.id %}">
+        {% csrf_token %}
+		<p>{% trans "You can get an email alert when this product is back in stock." %}</p>
+        {% include "partials/form_fields.html" with form=alert_form %}
+        <button type="submit" class="btn btn-large btn-info">{% trans "Notify me" %}</button>
+    </form>
 {% endif %}

oscar/templates/oscar/catalogue/partials/product.html

@@ -28,7 +28,7 @@
     <h3><a href="{{ product.get_absolute_url }}">{{ product.get_title|truncatewords:7 }}</a></h3>
     
     <div class="product_price">
-        {% include "catalogue/partials/stock_record.html" with anon_notifications="hide" %}
+        {% include "catalogue/partials/stock_record.html" %}
         {% include "catalogue/partials/add_to_basket_form_compact.html" %}
    </div>
 </article>

oscar/templates/oscar/catalogue/partials/stock_record.html

@@ -1,19 +1,14 @@
 {% load currency_filters %}
 {% load i18n %}
-{% load notification_tags %}
 
 {% if product.is_group %}
     <h2 class="price_color">{% blocktrans with product.min_variant_price_incl_tax|currency as price %}From {{ price }}{% endblocktrans %}</h2>
 {% else %}
     {% if product.is_available_to_buy %} 
+
         <h2 class="price_color">{{ product.stockrecord.price_incl_tax|currency }}</h2>
         <p class="app-ico {{ product.stockrecord.availability_code }} availability ">{{ product.stockrecord.availability|truncatewords:2 }}</p>
-        {% has_product_notification user product as notification_exists %}
-        {% if not notification_exists %}
-            <p>{% include "notification/partials/notification_form.html" with form=notification_form anon_notifications=anon_notifications %}</p>
-        {% else %}
-	    <p class="alert alert-success">{% trans "You will be notified when this product is available." %}</p>
-        {% endif %}
+
     {% else %}
 		<p class="app-ico avaliability outofstock">{% trans "Not available" %}</p>
     {% endif %}

oscar/templates/oscar/customer/alerts/emails/alert_body.txt

@@ -0,0 +1,13 @@
+{% load i18n %}{% if alert.user and alert.user.first_name %}{% blocktrans with name=alert.user.first_name %}Dear {{ name }},{% endblocktrans %}{% else %}{% trans "Hello," %}{% endif %}
+{% blocktrans with product=alert.product path=alert.product.get_absolute_url %}
+We are happy to inform you that our product '{{ product }}' is back in stock:
+http://{{ site }}{{ path }}
+{% endblocktrans %}{% if hurry %}{% blocktrans with product_url=product_url %}
+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 %}
+With this email we have disabled your alert automatically and you will not
+receive any further email regarding this product.
+
+Thanks for your interest,
+The {{ site_name }} Team
+{% endblocktrans %}

oscar/templates/oscar/customer/alerts/emails/alert_subject.txt

@@ -0,0 +1 @@
+{% load i18n %}{% blocktrans with title=product.get_title  %}{{ title }} is back in stock{% endblocktrans %}

oscar/templates/oscar/customer/alerts/emails/confirmation_body.txt

@@ -0,0 +1,13 @@
+{% load i18n %}{% blocktrans with product=alert.product 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
+'{{ product }}' 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 %}

oscar/templates/oscar/customer/alerts/emails/confirmation_subject.txt

@@ -0,0 +1 @@
+{% load i18n %}{% blocktrans %}Confirmation required for stock alert{% endblocktrans %}

oscar/templates/oscar/customer/alerts/form.html

@@ -0,0 +1 @@
+{% extends 'catalogue/detail.html' %}

oscar/templates/oscar/customer/alerts/message.html

@@ -0,0 +1,4 @@
+{% load i18n %}
+{% blocktrans with url=product.get_absolute_url title=product.get_title %}
+<a href="{{ url }}">{{ title }}</a> is back in stock
+{% endblocktrans %}

oscar/templates/oscar/customer/profile.html

@@ -31,7 +31,7 @@
         <li {% if active_tab == 'orders' %}class="active"{% endif %}><a href="#orders" data-toggle="tab">{% trans 'Order History' %}</a></li>
         <li {% if active_tab == 'addresses' %}class="active"{% endif %}><a href="#addresses" data-toggle="tab">{% trans 'Address Book' %}</a></li>
         <li {% if active_tab == 'emails' %}class="active"{% endif %}><a href="#emails" data-toggle="tab">{% trans 'Email History' %}</a></li>
-        <li {% if active_tab == 'notifications' %}class="active"{% endif %}><a href="#notifications" data-toggle="tab">{% trans "Notifications" %}</a></li>
+        <li {% if active_tab == 'alerts' %}class="active"{% endif %}><a href="#alerts" data-toggle="tab">{% trans "Alerts" %}</a></li>
         {% block extra_tabs_nav %}
         {% endblock %}
     </ul>
@@ -181,9 +181,45 @@
 			{% endblock %}
         </div>
 
-        <div class="tab-pane {% if active_tab == 'notifications' %}active{% endif %}" id="notifications">
-            {% block tab_notifications %}
-                {% include "notification/partials/notification_pane.html" with edit_enabled="yes" %}
+        <div class="tab-pane {% if active_tab == 'alerts' %}active{% endif %}" id="alerts">
+            {% block tab_alerts %}
+            <div class="sub-header">
+			    <h3>{% trans "Alerts" %}</h3>
+			</div>
+
+			{% if not alerts %}
+			<p>{% trans "You do not have any active alerts for out-of-stock products." %}</p>
+			{% else %}
+			    <form action="." method="post" id="alerts_form">
+			    {% csrf_token %}
+			        <table class="table table-stiped table-bordered">
+			            <tr>
+			                <th>{% trans "Product" %}</th>
+			                <th>{% trans "Status" %}</th>
+			                <th>{% trans "Date created" %}</th>
+			                <th></th>
+			            </tr>
+
+			            {% for alert in alerts %}
+			            <tr>
+			                <td>
+			                    {% with product=alert.product %}
+			                    <a href="{{ product.get_absolute_url }}">{{ product.get_title }}</a>
+			                    {% endwith %}
+			                </td>
+			                <td>{{ alert.status }}</td>
+			                <td>{{ alert.date_created }}</td>
+			                <td>
+			                    {% if alert.can_be_cancelled %}
+			                        <button class="btn btn-danger" type='submit' name='cancel_alert' value='{{ alert.id }}'>{% trans "Cancel" %}</button>
+			                    {% endif %}
+			                </td>
+			            </tr>
+			            {% endfor %}
+			        </table>
+			    </form>
+			{% endif %}
+
             {% endblock %}
         </div>
 

oscar/templates/oscar/dashboard/notification/delete.html

@@ -1,61 +0,0 @@
-{% extends 'dashboard/layout.html' %}
-{% load i18n %}
-
-{% block body_class %}users{% endblock %}
-
-{% block title %}
-{% blocktrans with id=notification.id %}Notification #{{ id }}{% endblocktrans %} | {{ block.super }}
-{% endblock %}
-
-{% block breadcrumbs %}
-<ul class="breadcrumb">
-    <li>
-    <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
-        <span class="divider">/</span>
-    </li>
-    <li>
-    <a href="{% url dashboard:user-notification-list %}">{% trans "Notifications" %}</a>
-        <span class="divider">/</span>
-    </li>
-    <li class="active"><a href=".">{% blocktrans with id=notification.id %}Notification #{{ id }}{% endblocktrans %}</a></li>
-</ul>
-{% endblock %}
-
-{% block header %}
-    <div class="page-header">
-        <h1>{% blocktrans with id=notification.id %}Delete Notification #{{ id }}?{% endblocktrans %}</h1>
-    </div>
-{% endblock header %}
-
-{% block dashboard_content %}
-    {% trans "Are you sure that you want to delete this notification:" %}
-    <form action="." method="post">
-        {% csrf_token %}
-        <table class="table table-bordered">
-            <tr>
-                <th>{% trans "Product title" %}</th>
-                <td>{{ notification.product.get_title }}</td>
-            </tr>
-            <tr>
-                <th>{% trans "User" %}</th>
-                <td>{% include "notification/partials/user_link.html" %}</td>
-            </tr>
-            <tr>
-                <th>{% trans "Email" %}</th>
-                <td>{{ notification.get_notification_email }}</td>
-            </tr>
-            <tr>
-                <th>{% trans "Date created" %}</th>
-                <td>{{ notification.date_created|date }}</td>
-            </tr>
-            <tr>
-                <th>{% trans "Date notified" %}</th>
-                <td>{% include "notification/partials/notified_date.html" %}</td>
-            </tr>
-        </table>
-        <div class="form-actions">
-            <button type='submit' class="btn btn-danger">{% trans "Delete" %}</button> or
-            <a href="{% url dashboard:user-notification-list %}">{% trans "cancel" %}</a>
-        </div>
-    </form>
-{% endblock dashboard_content %}

oscar/templates/oscar/dashboard/notification/list.html

@@ -1,98 +0,0 @@
-{% extends 'dashboard/layout.html' %}
-{% load i18n %}
-{% load currency_filters %}
-{% load notification_tags %}
-
-{% block body_class %}users{% endblock %}
-
-{% block title %}
-{% trans "Notification management" %} | {{ block.super }}
-{% endblock %}
-
-{% block breadcrumbs %}
-<ul class="breadcrumb">
-    <li>
-        <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
-        <span class="divider">/</span>
-    </li>
-    <li class="active">
-        <a href="{% url dashboard:user-notification-list %}">{% trans "Notifications" %}</a>
-    </li>
-</ul>
-{% endblock %}
-
-{% block header %}
-<div class="page-header action">
-    <h1>{% trans "Notification management" %}</h1>
-</div>
-{% endblock header %}
-
-{% block dashboard_content %}
-
-<div class="well well-info">
-    <h3 class="app-ico ico_magnify icon">{% trans "Search product notifications" %}</h3>
-    <form action="." method="get" class="form-inline">
-		{% include "partials/form_fields_inline.html" with form=form %}
-    <button type="submit" class="btn btn-primary">{% trans "Search" %}</button>
-    </form>
-</div>
-
-<div class="sub-header">
-    <h2>{{ queryset_description }}</h2>
-</div>
-
-{% if notification_list.all|length > 0 %}
-    <form action="." method="post">
-        {% csrf_token %}
-    <table class="table table-striped table-bordered">
-        <tr>
-            <th></th>
-            <th>{% trans "Product" %}</th>
-            <th>{% trans "User" %}</th>
-            <th>{% trans "Status" %}</th>
-            <th>{% trans "Date created" %}</th>
-            <th>{% trans "Date notified" %}</th>
-            <th></th>
-        </tr>
-        {% for notification in notification_list %}
-        <tr>
-            <td>
-                <input type="checkbox" name="selected_notification" class="selected_notification" value="{{ notification.id }}" />
-            </td>
-            <td>
-				<a href="{{ notification.product.get_absolute_url }}">{{ notification.product }}</a>
-            </td>
-            <td>
-                {% include "notification/partials/user_link.html" %}
-            </td>
-            <td>
-                {% include "notification/partials/status.html" %}
-            </td>
-            <td>{{ notification.date_created|date }}</td>
-            <td>{% include "notification/partials/notified_date.html" %}</td>
-            <td>
-                <a href="{% url dashboard:user-notification-update notification.id %}" class="btn btn-info">{% trans "Edit" %}</a>
-                <a href="{% url dashboard:user-notification-delete notification.id %}" class="btn btn-danger">{% trans "Delete" %}</a>
-            </td>
-        </tr>
-        {% endfor %}
-    </table>
-
-    <div class="well well-danger">
-        {% trans "Update status of selected notifications to:" %}
-        {{ notification_form.status }}
-	<input type="hidden" name="action" value="update_selected_notification_status" />
-        <button type="submit" class="btn btn-primary">{% trans "Update" %}</button>
-    </div>
-
-    {% if page_obj %}
-        {% include "catalogue/partials/pagination.html" %}
-    {% endif %}
-
-    </form>
-
-{% else %}
-<p>{% trans "No notifications found." %}</p>
-{% endif %}
-
-{% endblock dashboard_content %}

oscar/templates/oscar/dashboard/notification/update.html

@@ -1,40 +0,0 @@
-{% extends 'dashboard/layout.html' %}
-{% load i18n %}
-
-{% block body_class %}users{% endblock %}
-
-{% block title %}
-{% blocktrans with id=notification.id %}Update notification #{{ id }}{% endblocktrans %} | {{ block.super }}
-{% endblock %}
-
-{% block breadcrumbs %}
-<ul class="breadcrumb">
-    <li>
-        <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
-        <span class="divider">/</span>
-    </li>
-    <li>
-        <a href="{% url dashboard:user-notification-list %}">{% trans "Notifications" %}</a>
-        <span class="divider">/</span>
-    </li>
-    <li class="active"><a href=".">{% blocktrans with id=notification.id %}Notification #{{ id }}{% endblocktrans %}</a></li>
-</ul>
-{% endblock %}
-
-{% block header %}
-    <div class="page-header">
-        <h1>{% blocktrans with id=notification.id %}Notification #{{ id }}{% endblocktrans %}</h1>
-    </div>
-{% endblock header %}
-
-{% block dashboard_content %}
-<form action="." method="post">
-    {% csrf_token %}
-
-	{% include 'partials/form_fields.html' with form=form %}
-    <div class="form-actions">
-        <button type='submit' class="btn btn-large btn-primary">{% trans "Save" %}</button> or
-        <a href="{% url dashboard:user-notification-list %}">{% trans "cancel" %}</a>
-    </div>
-</form>
-{% endblock dashboard_content %}

oscar/templates/oscar/dashboard/users/alerts/delete.html

@@ -0,0 +1,40 @@
+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+
+{% block body_class %}users{% endblock %}
+
+{% block title %}
+{% blocktrans with id=alert.id %}Alert #{{ id }}{% endblocktrans %} | {{ block.super }}
+{% endblock %}
+
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+    <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
+        <span class="divider">/</span>
+    </li>
+    <li>
+    <a href="{% url dashboard:user-alert-list %}">{% trans "Product alerts" %}</a>
+        <span class="divider">/</span>
+    </li>
+    <li class="active"><a href=".">{% blocktrans with id=alert.id %}Alert #{{ id }}{% endblocktrans %}</a></li>
+</ul>
+{% endblock %}
+
+{% block header %}
+    <div class="page-header">
+        <h1>{% blocktrans with id=alert.id %}Delete alert #{{ id }}?{% endblocktrans %}</h1>
+    </div>
+{% endblock header %}
+
+{% block dashboard_content %}
+    {% include 'dashboard/users/alerts/partials/alert.html' %}
+    <form action="." method="post">
+        {% csrf_token %}
+        <div class="form-actions">
+		<p>{% trans "Are you sure that you want to delete this alert?" %}</p>
+            <button type='submit' class="btn btn-large btn-danger">{% trans "Delete" %}</button> or
+            <a href="{% url dashboard:user-alert-list %}">{% trans "cancel" %}</a>
+        </div>
+    </form>
+{% endblock dashboard_content %}

oscar/templates/oscar/dashboard/users/alerts/list.html

@@ -0,0 +1,89 @@
+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+{% load currency_filters %}
+
+{% block body_class %}users{% endblock %}
+
+{% block title %}
+{% trans "Product alerts" %} | {{ block.super }}
+{% endblock %}
+
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
+        <span class="divider">/</span>
+    </li>
+    <li class="active">
+        <a href="{% url dashboard:user-alert-list %}">{% trans "Product alerts" %}</a>
+    </li>
+</ul>
+{% endblock %}
+
+{% block header %}
+<div class="page-header action">
+    <h1>{% trans "Product alerts" %}</h1>
+</div>
+{% endblock header %}
+
+{% block dashboard_content %}
+
+<div class="well well-info">
+    <h3 class="app-ico ico_magnify icon">{% trans "Search product alerts" %}</h3>
+    <form action="." method="get" class="form-inline">
+		{% include "partials/form_fields_inline.html" with form=form %}
+	<button type="submit" class="btn btn-primary">{% trans "Search" %}</button>
+	{% trans "or" %}
+		<a href="{% url dashboard:user-alert-list %}" class="btn">{% trans "reset" %}</a>
+    </form>
+</div>
+
+<div class="sub-header">
+    <h2>{{ queryset_description }}</h2>
+</div>
+
+{% if alerts %}
+    <table class="table table-striped table-bordered">
+        <tr>
+            <th></th>
+            <th>{% trans "Product" %}</th>
+            <th>{% trans "User" %}</th>
+            <th>{% trans "Status" %}</th>
+            <th>{% trans "Date created" %}</th>
+            <th>{% trans "Date alert sent" %}</th>
+            <th></th>
+        </tr>
+        {% for alert in alerts %}
+        <tr>
+            <td>
+				<a href="{{ alert.product.get_absolute_url }}">{{ alert.product }}</a>
+            </td>
+            <td>
+                {% if alert.user %}
+				<a href="{% url dashboard:user-detail alert.user.id %}">{{ alert.user.email }}</a>
+				{% else %}
+				{{ alert.email }} {% trans "(Anonymous)" %}
+				{% endif %}
+            </td>
+            <td>
+                {{ alert.status }}
+            </td>
+            <td>{{ alert.date_created }}</td>
+            <td>{{ alert.date_closed|default:"-" }}</td>
+            <td>
+                <a href="{% url dashboard:user-alert-update alert.id %}" class="btn btn-info">{% trans "Edit" %}</a>
+                <a href="{% url dashboard:user-alert-delete alert.id %}" class="btn btn-danger">{% trans "Delete" %}</a>
+            </td>
+        </tr>
+        {% endfor %}
+    </table>
+
+    {% if page_obj %}
+        {% include "catalogue/partials/pagination.html" %}
+    {% endif %}
+
+{% else %}
+	<p>{% trans "No alerts found." %}</p>
+{% endif %}
+
+{% endblock dashboard_content %}

oscar/templates/oscar/dashboard/users/alerts/partials/alert.html

@@ -0,0 +1,44 @@
+{% load i18n %}
+<table class="table">
+	<tbody>
+		<tr>
+			<th>{% trans "Product" %}</th>
+			<td><a href="{{ alert.product.get_absolute_url }}">{{ alert.product }}</a></td>
+		</tr>
+		<tr>
+			<th>{% trans "User" %}</th>
+			<td>
+				{% if alert.user %}
+					{{ alert.user }}
+				{% else %}
+					{{ alert.email }}
+				{% endif %}
+			</td>
+		</tr>
+		<tr>
+			<th>{% trans "Status" %}</th>
+			<td>{{ alert.status }}</td>
+		</tr>
+		<tr>
+			<th>{% trans "Date created" %}</th>
+			<td>{{ alert.date_created }}</td>
+		</tr>
+		{% if not alert.user %}
+		<tr>
+			<th>{% trans "Date confirmed" %}</th>
+			<td>{{ alert.date_confirmed|default:"-" }}</td>
+		</tr>
+		{% endif %}
+		{% if alert.is_cancelled %}
+		<tr>
+			<th>{% trans "Date cancelled" %}</th>
+			<td>{{ alert.date_cancelled }}</td>
+		</tr>
+		{% else %}
+		<tr>
+			<th>{% trans "Date alert sent" %}</th>
+			<td>{{ alert.date_closed|default:"-" }}</td>
+		</tr>
+		{% endif %}
+	</tbody>
+</table>

oscar/templates/oscar/dashboard/users/alerts/update.html

@@ -0,0 +1,43 @@
+{% extends 'dashboard/layout.html' %}
+{% load i18n %}
+
+{% block body_class %}users{% endblock %}
+
+{% block title %}
+{% blocktrans with id=alert.id %}Update alert #{{ id }}{% endblocktrans %} | {{ block.super }}
+{% endblock %}
+
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url dashboard:index %}">{% trans "Dashboard" %}</a>
+        <span class="divider">/</span>
+    </li>
+    <li>
+        <a href="{% url dashboard:user-alert-list %}">{% trans "Product alerts" %}</a>
+        <span class="divider">/</span>
+    </li>
+    <li class="active"><a href=".">{% blocktrans with id=alert.id %}Alert #{{ id }}{% endblocktrans %}</a></li>
+</ul>
+{% endblock %}
+
+{% block header %}
+    <div class="page-header">
+        <h1>{% blocktrans with id=alert.id %}Product alert #{{ id }}{% endblocktrans %}</h1>
+    </div>
+{% endblock header %}
+
+{% block dashboard_content %}
+{% include 'dashboard/users/alerts/partials/alert.html' %}
+
+<h2>{% trans "Change status" %}</h2>
+<form action="." method="post">
+    {% csrf_token %}
+
+	{% include 'partials/form_fields.html' %}
+    <div class="form-actions">
+		<button type='submit' class="btn btn-large btn-primary">{% trans "Save" %}</button> {% trans "or" %}
+        <a href="{% url dashboard:user-alert-list %}">{% trans "cancel" %}</a>
+    </div>
+</form>
+{% endblock dashboard_content %}

oscar/templates/oscar/notification/email.html

@@ -1,32 +0,0 @@
-{% load i18n %}
-
-<p>
-{% blocktrans with site_domain=site.domain product=product site_name=site.name %}
-You have just signed up for a notification to {{ product }} on our
-website <a href="http://{{ site_domain }}">{{ site_name }}</a>. If this was you,
-please feel confirm your email address by clicking the following link or
-copying it into the address bar of your favourite browser.
-{% endblocktrans %}
-</p>
-<p>
-<a href="http://{{ site.domain }}{{ notification.get_confirm_url }}">http://{{ site.domain }}{{ notification.get_confirm_url }}</a>
-</p>
-<p>
-{% url catalogue:detail product.slug product.id as product_url %}
-
-{% blocktrans with email=notification.email product_title=product.title product_url=product_url %}
-We will send you an email to {{ email }} as soon as
-<a href="http://{{ site.domain }}{{ product_url }}">{{ product_title }}</a> is back in stock.
-{% endblocktrans %}
-</p>
-
-<p>
-{% blocktrans %}
-If you want to disable your notification at any point in time, use the
-following link to unsubscribe:
-{% endblocktrans %}
-</p>
-
-<p><a href="http://{{ site.domain }}{{ notification.get_unsubscribe_url }}">http://{{ site.domain }}{{ notification.get_unsubscribe_url }}</a></p>
-
-<strong>{% trans "Thank you very much for your interest." %}</strong>

oscar/templates/oscar/notification/notification.html

@@ -1,59 +0,0 @@
-{% extends "catalogue/detail.html" %}
-{% load currency_filters %}
-{% load history_tags %}
-{% load i18n %}
-
-{% block content %}
-<article class="product_page"><!-- Start of product page -->
-    <div class="row-fluid">
-        <div class="span6">
-            {% include "catalogue/partials/gallery.html" %}
-        </div><!-- /span6 -->
-
-        <div class="span6">
-            <h1>
-            {% blocktrans with product_title=product.get_title %}
-            Notification for {{ product_title }}
-            {% endblocktrans %}
-            </h1>
-
-            {% include "notification/partials/notification_form.html" with form=form %}
-
-            {% if reviews %}
-                    <ul class="review_count">
-                            {% for review in reviews %}
-                            <li class="{{ review.score }}">{{ review.score }}</li>
-            {% endfor %}
-                    </ul>
-            {% else %}
-            <p class="star">{% trans "No Rating" %}
-
-            <a href="{% url catalogue:reviews-add product.slug product.id %}#addreview">{% trans "Add review" %}</a>
-            </p>
-            {% endif %}
-
-            <p><strong>{% trans "Product Code:" %}</strong> <code>{{ product.upc }}</code></p>
-
-            <hr/>
-
-			{% if product.description %}
-            <ul>
-				<li><a href="#product_description">{% trans "Read the full description" %}</a></li>
-            </ul>
-			{% endif %}
-
-            {% include "catalogue/partials/add_to_basket_form.html" %}
-        </div><!-- /span6 -->
-    </div><!-- /row-fluid -->
-
-	{% block product_description %}
-	{% if product.description %}
-    <div id="product_description" class="sub-header">
-		<h2>{% trans "Product Description" %}</h2>
-    </div>
-    <p>{{ product.description }}</p>
-	{% endif %}
-	{% endblock %}
-
-</article><!-- End of product page -->
-{% endblock content %}

oscar/templates/oscar/notification/notification_email.html

@@ -1,30 +0,0 @@
-{% load i18n %}
-
-{% if user and user.get_full_name %}
-	{% blocktrans with full_name=user.get_full_name %}
-	Dear {{ full_name }},
-	{% endblocktrans %}
-{% else %}
-	{% trans "Dear Customer," %}
-{% endif %}
-
-{% url catalogue:detail product.slug product.id as product_url %}
-{% blocktrans with product_url=product_url product_title=product.title %}
-we are happy to inform you that our product <strong><a href="{{ product_url }}">
-{{ product_title }}</a></strong> is back in stock.
-{% endblocktrans %}
-
-{% if hurry %}
-{% blocktrans with product_url=product_url %}
-The amount of items in stock is limited. Head over to <a href="{{ product_url }}">
-order the product</a> now, before someone else get's there first.
-{% endblocktrans %}
-{% endif %}
-
-{% blocktrans with site_name=site.name %}
-With this email we have disabled your notification automatically and you will not
-receive any further email regarding this product.
-
-Thanks for your interest,
-Your {{ site_name }} Team
-{% endblocktrans %}

oscar/templates/oscar/notification/partials/notification_form.html

@@ -1,12 +0,0 @@
-{% load i18n %}
-
-{% if product.stockrecord.num_in_stock == 0 %}
-    {% if user.is_authenticated or anon_notifications != "hide" %}
-    <form method="post" action="{% url catalogue:notification-create product.slug product.id %}">
-        {% csrf_token %}
-		<p>{% trans "You can get an email notification when this product is in stock." %}</p>
-        {% include "partials/form_fields.html" with form=form %}
-        <button type="submit" class="btn btn-info">{% trans "Notify me" %}</button>
-    </form>
-    {% endif %}
-{% endif %}

oscar/templates/oscar/notification/partials/notification_pane.html

@@ -1,54 +0,0 @@
-{% load i18n %}
-<div class="sub-header">
-    <h3>{% trans "Notifications" %}</h3>
-</div>
-{% if not notification_list %}
-<p>{% trans "You do not have any notifications for out-of-stock products." %}</p>
-{% else %}
-    <form action="." method="POST">
-    {% csrf_token %}
-        <table class="table table-stiped table-bordered">
-            <tr>
-                <th>{% trans "Product Title" %}</th>
-                <th>{% trans "Product Availability" %}</th>
-                <th>{% trans "Status" %}</th>
-                <th>{% trans "Date Subscribed" %}</th>
-                {% if edit_enabled %}
-                <th></th>
-                {% endif %}
-            </tr>
-
-            {% for notification in notification_list %}
-            <tr>
-                <td>
-                    {% with product=notification.product %}
-                    <a href="{% url catalogue:detail product.slug product.id %}">
-                        {{ product.title }}
-                    </a>
-                    {% endwith %}
-                </td>
-                <td>
-                    {% if notification.product.stock_record.num_in_stock > 0 %}
-                        {{ notification.product.stock_record.num_in_stock }}
-                    {% else %}
-                        {% trans "Not in Stock" %}
-                    {% endif %}
-                </td>
-                <td>
-                    {% include "notification/partials/status.html" %}
-                </td>
-                <td>{{ notification.date_created|date }}</td>
-                {% if edit_enabled == 'yes' %}
-                <td>
-                    {% if not notification.is_active %}
-                        <button class="btn btn-success" type='submit' name='activate' value='{{ notification.id }}'>{% trans "Activate" %}</button>
-                    {% else %}
-                        <button class="btn btn-danger" type='submit' name='deactivate' value='{{ notification.id }}'>{% trans "Deactivate" %}</button>
-                    {% endif %}
-                </td>
-                {% endif %}
-            </tr>
-            {% endfor %}
-        </table>
-    </form>
-{% endif %}

oscar/templates/oscar/notification/partials/notified_date.html

@@ -1,6 +0,0 @@
-{% load i18n %}
-{% if notification.date_notified %}
-    {{ notification.date_notified|date }}
-{% else %}
-    {% trans "Not yet notified" %}
-{% endif %}

oscar/templates/oscar/notification/partials/status.html

@@ -1,7 +0,0 @@
-{% if notification.is_active %}
-<span class="label label-success">
-{% else %}
-<span class="label label-important">
-{% endif %}
-    {{ notification.get_status_display }}
-</span>

oscar/templates/oscar/notification/partials/user_link.html

@@ -1,7 +0,0 @@
-{% load i18n %}
-
-{% if notification.user %}
-    <a href="{% url dashboard:user-detail notification.user.id %}">{{ notification.user.email }}</a>
-{% else %}
-    {% blocktrans with email=notification.get_notification_email %}{{ email }} (anonymous){% endblocktrans %}
-{% endif %}

oscar/templatetags/notification_tags.py

@@ -1,21 +0,0 @@
-from django import template
-from django.db.models import get_model
-
-ProductNotification = get_model('notification', 'productnotification')
-
-register = template.Library()
-
-
-@register.assignment_tag
-def has_product_notification(user, product):
-    """
-    Check if the user has already signed up to receive a notification
-    for this product. Anonymous users are ignored. If a registered
-    user has signed up for a notification the tag returns ``True``.
-    It returns ``False`` in all other cases.
-    """
-    if not user.is_authenticated():
-        return False
-
-    return ProductNotification.objects.filter(user=user,
-                                              product=product).count() > 0

sites/sandbox/recreate_db.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-DATABASE=db.sqlite
-
-rm $DATABASE
-./manage.py syncdb --noinput
-./manage.py migrate
-
-echo "Loading fixtures"
-./manage.py loaddata countries.json ../_fixtures/pages.json
-
-echo "Importing products"
-./manage.py oscar_import_catalogue ../_fixtures/books-catalogue.csv
-
-echo "Importing Images"
-./manage.py oscar_import_catalogue_images ../_fixtures/books-images.tar.gz
-
-echo "Creating superuser"
-./manage.py createsuperuser --username=admin --email=admin@test.com

tests/functional/catalogue/catalogue_tests.py

@@ -1,21 +1,48 @@
 import httplib
 
-from django.test import TestCase
-from django.test.client import Client
 from django.core.urlresolvers import reverse
 
+from oscar.test import WebTestCase
 from oscar.test.helpers import create_product
+from oscar.apps.catalogue.views import ProductListView
 
 
-class TestProductDetailView(TestCase):
-
-    def setUp(self):
-        self.client = Client()
+class TestProductDetailView(WebTestCase):
 
     def test_enforces_canonical_url(self):
         p = create_product()
-        args = {'product_slug': 'wrong-slug',
-                'pk': p.id}
-        wrong_url = reverse('catalogue:detail', kwargs=args)
-        response = self.client.get(wrong_url)
+        kwargs = {'product_slug': 'wrong-slug',
+                  'pk': p.id}
+        wrong_url = reverse('catalogue:detail', kwargs=kwargs)
+
+        response = self.app.get(wrong_url)
         self.assertEquals(httplib.MOVED_PERMANENTLY, response.status_code)
+
+
+class TestProductListView(WebTestCase):
+
+    def test_shows_add_to_basket_button_for_available_product(self):
+        product = create_product()
+
+        page = self.app.get(reverse('catalogue:index'))
+
+        self.assertContains(page, product.title)
+        self.assertContains(page, "Add to basket")
+
+    def test_shows_not_available_for_out_of_stock_product(self):
+        product = create_product(num_in_stock=0)
+
+        page = self.app.get(reverse('catalogue:index'))
+
+        self.assertContains(page, product.title)
+        self.assertContains(page, "Not available")
+
+    def test_shows_pagination_navigation_for_multiple_pages(self):
+        per_page = ProductListView.paginate_by
+        title = "Product #%d"
+        for idx in range(0, int(1.5 * per_page)):
+            create_product(title=title % idx)
+
+        page = self.app.get(reverse('catalogue:index'))
+
+        self.assertContains(page, "Page 1 of 2")

tests/functional/catalogue/notification_command_tests.py

@@ -1,122 +0,0 @@
-from datetime import datetime, timedelta
-
-from django.core import mail
-from django.test import TestCase
-from django.core.management import call_command
-
-from oscar.apps.catalogue.models import Product
-from oscar.apps.partner.models import StockRecord, Partner
-from oscar.apps.catalogue.notification.models import ProductNotification
-
-from django_dynamic_fixture import get as G
-
-
-class TestCleanNotificationsCommand(TestCase):
-
-    def setUp(self):
-        self.date_now = datetime.now()
-        status_date_mapping = [
-            (ProductNotification.UNCONFIRMED,
-             self.date_now - timedelta(minutes=45)),
-            (ProductNotification.ACTIVE,
-             self.date_now),
-            (ProductNotification.UNCONFIRMED,
-             self.date_now - timedelta(days=1, hours=3)),
-            (ProductNotification.UNCONFIRMED,
-             self.date_now - timedelta(hours=7)),
-            (ProductNotification.UNCONFIRMED,
-             self.date_now - timedelta(days=2, hours=1)),
-            (ProductNotification.INACTIVE,
-             self.date_now - timedelta(days=2)),
-            (ProductNotification.ACTIVE,
-             self.date_now - timedelta(days=2)),
-        ]
-
-        for status, date in status_date_mapping:
-            notification = G(ProductNotification, status=status)
-            notification.date_created = date
-            notification.save()
-
-    def test_cleans_up_unconfirmed_notifications_with_default_settings(self):
-        # Test removing all notifications that have status UNCONFIRMED and
-        # are older then 24 hours which is the default
-        self.assertEquals(ProductNotification.objects.count(), 7)
-        call_command('oscar_cleanup_notifications', *[], **{})
-
-        self.assertEquals(ProductNotification.objects.count(), 5)
-
-    def test_cleans_up_unconfirmed_notifications_older_than_two_days(self):
-        # Test removing all notifications that have status ``UNCONFIRMED``
-        # and remove the ones older then 2 days.
-        self.assertEquals(ProductNotification.objects.count(), 7)
-        call_command('oscar_cleanup_notifications', *[], **{'days': '2'})
-
-        self.assertEquals(ProductNotification.objects.count(), 6)
-
-    def test_cleans_up_unconfirmed_notifications_older_than_6_hours(self):
-        # Test removing all notifications that have status ``UNCONFIRMED``
-        # and remove the ones older then 6 hours.
-        self.assertEquals(ProductNotification.objects.count(), 7)
-        call_command('oscar_cleanup_notifications', *[], **{'hours': '6'})
-
-        self.assertEquals(ProductNotification.objects.count(), 4)
-
-    def test_cleans_up_unconfirmed_notifications_older_than_1_day_2_hours(self):
-        # Test removing all notifications that have status ``UNCONFIRMED``
-        # and remove the ones older then 6 hours.
-        self.assertEquals(ProductNotification.objects.count(), 7)
-        call_command('oscar_cleanup_notifications',
-                     *[], **{'days': 1, 'hours': '2'})
-
-        self.assertEquals(ProductNotification.objects.count(), 5)
-
-
-class TestSendNotificationsCommand(TestCase):
-
-    def setUp(self):
-        mail.outbox = []
-        partner = Partner.objects.create(name="Partner")
-
-        self.product1 = G(Product)
-        G(StockRecord, product=self.product1, partner=partner, num_in_stock=50)
-
-        self.product2 = G(Product)
-        G(StockRecord, product=self.product2, partner=partner, num_in_stock=0)
-
-        self.product3 = G(Product)
-        G(StockRecord, product=self.product3, partner=partner, num_in_stock=1)
-
-    def test_sends_notifications_for_products_back_in_stock(self):
-        active_notif1 = G(ProductNotification, status=ProductNotification.ACTIVE,
-                         product=self.product1, date_notified=None)
-        active_notif2 = G(ProductNotification, status=ProductNotification.ACTIVE,
-                         product=self.product1, date_notified=None)
-        active_notif3 = G(ProductNotification, status=ProductNotification.ACTIVE,
-                         product=self.product2, date_notified=None)
-        active_notif4 = G(ProductNotification, status=ProductNotification.ACTIVE,
-                         product=self.product3, date_notified=None)
-
-        inactive_notif1 = G(ProductNotification, status=ProductNotification.INACTIVE,
-                         product=self.product1, date_notified=None)
-        inactive_notif2 = G(ProductNotification, status=ProductNotification.INACTIVE,
-                         product=self.product2, date_notified=None)
-
-        self.assertEquals(mail.outbox, [])
-
-        call_command('oscar_send_notifications')
-
-        for pk in [active_notif1.pk, active_notif2.pk, active_notif4.pk]:
-            notif = ProductNotification.objects.get(pk=pk)
-            self.assertEquals(notif.status, ProductNotification.INACTIVE)
-            self.assertNotEqual(notif.date_notified, None)
-
-        notif = ProductNotification.objects.get(pk=active_notif3.pk)
-        self.assertEquals(notif.status, ProductNotification.ACTIVE)
-        self.assertEquals(notif.date_notified, None)
-
-        self.assertEquals(len(mail.outbox), 3)
-
-        for pk in [inactive_notif1.pk, inactive_notif2.pk]:
-            notif = ProductNotification.objects.get(pk=pk)
-            self.assertEquals(notif.status, ProductNotification.INACTIVE)
-            self.assertEquals(notif.date_notified, None)

tests/functional/catalogue/notification_tests.py

@@ -1,308 +0,0 @@
-import itertools
-
-from django.core import mail
-from django.db.models import get_model
-from django.contrib.auth.models import User
-from django.core.urlresolvers import reverse
-from django_dynamic_fixture import get
-
-from webtest.app import AppError
-from django_webtest import WebTest
-from django_dynamic_fixture import get as G
-
-from oscar.apps.catalogue.models import Product, ProductClass
-from oscar.apps.partner.models import StockRecord
-from oscar.apps.catalogue.notification.models import ProductNotification
-
-Partner = get_model('partner', 'partner')
-
-
-class NotificationWebTest(WebTest):
-    product_counter = itertools.count()
-    username = 'testuser'
-    password = 'somerandompassword'
-    email = 'testuser@example.com'
-    is_anonymous = True
-
-    def setUp(self):
-        self.user = None
-
-        if not self.is_anonymous:
-            self.user = User.objects.create(username=self.username,
-                                            password=self.password,
-                                            email=self.email)
-
-    def create_product_class(self, name='books'):
-        self.product_class = ProductClass.objects.create(name=name)
-
-    def create_product(self):
-        product_id = self.product_counter.next()
-        product = get(Product, product_class=self.product_class,
-                      title='product_%s' % product_id,
-                      upc='00000000000%s' % product_id, parent=None)
-
-        G(StockRecord, product=product, num_in_stock=0)
-        return product
-
-    def get(self, *args, **kwargs):
-        if self.user and not 'user' in kwargs:
-            kwargs['user'] = self.user
-        return self.app.get(*args, **kwargs)
-
-    def post(self, *args, **kwargs):
-        if self.user and not 'user' in kwargs:
-            kwargs['user'] = self.user
-        return self.app.post(*args, **kwargs)
-
-
-class TestNotifyMeButtons(NotificationWebTest):
-
-    def setUp(self):
-        self.create_product_class()
-        self.product = self.create_product()
-
-    def test_are_displayed_on_unavailable_product_page(self):
-
-        url = reverse('catalogue:detail', args=(self.product.slug,
-                                                self.product.id))
-        page = self.app.get(url)
-        self.assertContains(page, 'notify-me', status_code=200)
-
-    def test_are_not_displayed_on_available_product_page(self):
-        self.product.stockrecord.num_in_stock = 20
-        self.product.stockrecord.save()
-
-        url = reverse('catalogue:detail', args=(self.product.slug,
-                                                self.product.id))
-        page = self.app.get(url)
-        self.assertNotContains(page, 'notify-me', status_code=200)
-
-        self.product.stockrecord.num_in_stock = 1
-        self.product.stockrecord.save()
-
-        page = self.app.get(url)
-        self.assertNotContains(page, 'notify-me', status_code=200)
-
-
-class TestAnAnonymousUserRequestingANotification(NotificationWebTest):
-    is_anonymous = True
-    email = 'anonymous@email.com'
-
-    def setUp(self):
-        super(TestAnAnonymousUserRequestingANotification, self).setUp()
-        self.create_product_class()
-        self.out_of_stock_product = self.create_product()
-
-    def create_notification(self):
-        page = self.get(reverse('catalogue:detail', args=(
-            self.out_of_stock_product.slug,
-            self.out_of_stock_product.id,
-        )))
-        notify_form = page.forms[1]
-        notify_form['email'] = self.email
-        return notify_form.submit()
-
-    def test_submitting_an_invalid_email_redirects_back_to_page(self):
-        page = self.get(reverse('catalogue:detail', args=(
-            self.out_of_stock_product.slug,
-            self.out_of_stock_product.id,
-        )))
-        notify_form = page.forms[1]
-        notify_form['email'] = u"invalid_email.com"
-        page = notify_form.submit()
-
-        self.assertContains(page, "Enter a valid e-mail address.")
-
-    def test_creates_an_unconfirmed_notification_and_sends_confirmation_email(self):
-        # Test creating a notification for an anonymous user. A notification
-        # is generated for the user with confirmation and unsubscribe code.
-        # The notification is set to UNCONFIRMED and a email is sent to the
-        # user. The confirmation of the notification is handled by a link
-        # that will activate the notification.
-        self.create_notification()
-
-        notifications = ProductNotification.objects.filter(email=self.email)
-        self.assertEquals(notifications.count(), 1)
-
-        self.assertEquals(len(mail.outbox), 1)
-        self.assertTrue("confirm" in mail.outbox[0].body)
-        self.assertTrue("unsubscribe" in mail.outbox[0].body)
-
-
-    def test_can_activate_an_unconfirmed_notification(self):
-        self.test_creates_an_unconfirmed_notification_and_sends_confirmation_email()
-
-        notification = ProductNotification.objects.get(email=self.email)
-        product = notification.product
-
-        self.assertEquals(notification.status, ProductNotification.UNCONFIRMED)
-
-        page = self.get(notification.get_confirm_url())
-        self.assertRedirects(
-            page,
-            reverse('catalogue:detail', args=(product.slug, product.id)),
-            status_code=301
-        )
-
-        notification = ProductNotification.objects.get(id=notification.id)
-        self.assertEquals(notification.status, ProductNotification.ACTIVE)
-
-    def test_can_unsubscribe_from_a_notification(self):
-        # Test that unsubscribing from a notification inactivates the
-        # notification. This does not delete the notification as it might be
-        # used for analytical purposes later on by the site owner.
-        self.create_notification()
-
-        notification = ProductNotification.objects.get(email=self.email)
-        product = notification.product
-
-        self.assertEquals(notification.status, ProductNotification.UNCONFIRMED)
-
-        page = self.get(notification.get_unsubscribe_url())
-        self.assertRedirects(
-            page,
-            reverse('catalogue:detail', args=(product.slug, product.id)),
-            status_code=301
-        )
-
-        notification = ProductNotification.objects.get(email=self.email)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-
-
-class TestARegisteredUserRequestingANotification(NotificationWebTest):
-    is_anonymous = False
-    email = 'testuser@oscar.com'
-
-    def setUp(self):
-        super(TestARegisteredUserRequestingANotification, self).setUp()
-        self.create_product_class()
-        self.product = self.create_product()
-
-    def test_sees_email_on_product_page(self):
-        product_url = reverse('catalogue:detail',
-                              args=(self.product.slug, self.product.id))
-        page = self.get(product_url)
-
-        self.assertContains(page, self.email, status_code=200)
-
-    def test_creates_a_notification_object(self):
-        # Test creating a notification for an authenticated user with the
-        # providing the account email address in the (hidden) signup form.
-        self.assertEquals(self.user.product_notifications.count(), 0)
-
-        page = self.get(reverse('catalogue:detail', args=(self.product.slug,
-                                                          self.product.id)))
-        notification_form = page.forms[1]
-        notification_form['email'] = self.email
-        page = notification_form.submit().follow()
-
-        self.assertContains(page, self.product.title, status_code=200)
-        self.assertEquals(self.user.product_notifications.count(), 1)
-
-        notification = self.user.product_notifications.all()[0]
-        self.assertEquals(notification.get_notification_email(),
-                          self.user.email)
-        self.assertEquals(notification.confirm_key, None)
-        self.assertEquals(notification.unsubscribe_key, None)
-
-    def test_can_specify_an_alternative_email_address(self):
-        # Test creating a notification with an email address that is different
-        # from the user's account email. This should set the account email
-        # address instead of the provided email in POST data.
-        page = self.get(reverse('catalogue:detail', args=(self.product.slug,
-                                                          self.product.id)))
-        notification_form = page.forms[1]
-        notification_form['email'] = 'someother@oscar.com'
-        page = notification_form.submit().follow()
-
-        self.assertContains(page, 'notified', status_code=200)
-
-        self.assertEquals(self.user.product_notifications.count(), 1)
-
-        notification = self.user.product_notifications.all()[0]
-        self.assertEquals(notification.product.id, self.product.id)
-        self.assertEquals(notification.get_notification_email(),
-                          self.user.email)
-        self.assertEquals(notification.confirm_key, None)
-        self.assertEquals(notification.unsubscribe_key, None)
-
-    def test_cannot_create_duplicate_notifications(self):
-        # Test creating a notification when the user has already signed up for
-        # this product notification. The user should be redirected to the product
-        # page with a notification that he has already signed up.
-        get(ProductNotification, product=self.product, user=self.user)
-
-        page = self.get(reverse('catalogue:detail', args=(self.product.slug,
-                                                          self.product.id)))
-        self.assertContains(
-            page,
-            "You will be notified when this product is available",
-        )
-
-
-class TestAnAnonymousButExistingUserRequestingANotification(NotificationWebTest):
-    is_anonymous = True
-    email = 'testuser@oscar.com'
-    username = 'testuser'
-    password = 'somerandompassword'
-
-    def setUp(self):
-        super(TestAnAnonymousButExistingUserRequestingANotification, self).setUp()
-        User.objects.create(username=self.username, password=self.password,
-                            email=self.email)
-        self.create_product_class()
-        self.product = self.create_product()
-
-    def test_gets_redirected_to_login_page(self):
-        # Test creating a notification when a registered user is not yet logged
-        # in. The email address in the form is checked against all users. If a
-        # user profile has this email address set, the user will be redirected
-        # to the login page and from there right back to the product detail
-        # page where the user hits the 'Notify Me' button again.
-        product_url = reverse('catalogue:detail', args=(self.product.slug,
-                                                        self.product.id))
-        page = self.app.get(product_url)
-        notification_form = page.forms[1]
-        notification_form['email'] = self.email
-        page = notification_form.submit()
-
-        redirect_url = "%s?next=%s" % (reverse('customer:login'), product_url)
-        self.assertRedirects(page, redirect_url)
-
-
-class TestASignedInUser(NotificationWebTest):
-    is_anonymous = False
-    email = 'testuser@oscar.com'
-    username = 'testuser'
-    password = 'password'
-
-    def setUp(self):
-        super(TestASignedInUser, self).setUp()
-        self.create_product_class()
-        self.product = self.create_product()
-        self.notification = ProductNotification.objects.create(
-            user=self.user,
-            product=self.product,
-            status=ProductNotification.ACTIVE)
-
-    def test_gets_a_404_when_accessing_invalid_url(self):
-        self.assertEquals(self.notification.status, ProductNotification.ACTIVE)
-
-        try:
-            self.get('/products/40-2/notify-me/set-status/1/invalid/')
-            self.fail('expected 404 but did not happen')
-        except AppError:
-            pass
-
-    def test_can_deactivate_a_notification_from_the_account_section(self):
-        self.assertEquals(self.notification.status, ProductNotification.ACTIVE)
-
-        notification_tab_url = reverse('customer:summary')+"?tab=notifications"
-        page = self.get(notification_tab_url)
-        notification_form = page.forms[1]
-        page = notification_form.submit('deactivate', index=0)
-
-        self.assertRedirects(page, notification_tab_url)
-
-        notification = ProductNotification.objects.get(id=self.notification.id)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)

tests/functional/customer/alert_tests.py

@@ -0,0 +1,77 @@
+from django_webtest import WebTest
+from django.contrib.auth.models import User
+from django.core.urlresolvers import reverse
+from django.core import mail
+from django_dynamic_fixture import G
+
+from oscar.test.helpers import create_product
+from oscar.apps.customer.models import ProductAlert
+
+
+class TestAUser(WebTest):
+
+    def test_can_create_a_stock_alert(self):
+        user = G(User)
+        product = create_product(num_in_stock=0)
+        product_page = self.app.get(product.get_absolute_url(), user=user)
+        form = product_page.forms['alert_form']
+        form.submit()
+
+        alerts = ProductAlert.objects.filter(user=user)
+        self.assertEqual(1, len(alerts))
+        alert = alerts[0]
+        self.assertEqual(ProductAlert.ACTIVE, alert.status)
+        self.assertEqual(alert.product, product)
+
+
+class TestAUserWithAnActiveStockAlert(WebTest):
+
+    def setUp(self):
+        self.user = G(User)
+        self.product = create_product(num_in_stock=0)
+        product_page = self.app.get(self.product.get_absolute_url(),
+                                    user=self.user)
+        form = product_page.forms['alert_form']
+        form.submit()
+
+    def test_can_cancel_it(self):
+        account_page = self.app.get(reverse('customer:summary'),
+                                    user=self.user)
+        form = account_page.forms['alerts_form']
+        form.submit('cancel_alert')
+
+        alerts = ProductAlert.objects.filter(user=self.user)
+        self.assertEqual(1, len(alerts))
+        alert = alerts[0]
+        self.assertTrue(alert.is_cancelled)
+
+    def test_gets_notified_when_it_is_back_in_stock(self):
+        self.product.stockrecord.num_in_stock = 10
+        self.product.stockrecord.save()
+        self.assertEqual(1, self.user.notifications.all().count())
+
+    def test_gets_emailed_when_it_is_back_in_stock(self):
+        self.product.stockrecord.num_in_stock = 10
+        self.product.stockrecord.save()
+        self.assertEqual(1, len(mail.outbox))
+
+    def test_does_not_get_emailed_when_it_is_saved_but_still_zero_stock(self):
+        self.product.stockrecord.num_in_stock = 0
+        self.product.stockrecord.save()
+        self.assertEqual(0, len(mail.outbox))
+
+
+class TestAnAnonymousUser(WebTest):
+
+    def test_can_create_a_stock_alert(self):
+        product = create_product(num_in_stock=0)
+        product_page = self.app.get(product.get_absolute_url())
+        form = product_page.forms['alert_form']
+        form['email'] = 'john@smith.com'
+        form.submit()
+
+        alerts = ProductAlert.objects.filter(email='john@smith.com')
+        self.assertEqual(1, len(alerts))
+        alert = alerts[0]
+        self.assertEqual(ProductAlert.UNCONFIRMED, alert.status)
+        self.assertEqual(alert.product, product)

tests/functional/customer/notification_tests.py

@@ -1,10 +1,7 @@
 from django.contrib.auth.models import User
-from django.core.urlresolvers import reverse
 from django_dynamic_fixture import G
 
 from oscar.test import WebTestCase
-from oscar.apps.catalogue.models import Product
-from oscar.apps.catalogue.notification.models import ProductNotification
 from oscar.apps.customer.notifications import services
 
 
@@ -18,49 +15,3 @@ class TestAUserWithUnreadNotifications(WebTestCase):
         homepage = self.app.get('/', user=self.user)
         self.assertTrue('num_unread_notifications' in homepage.context)
         self.assertEqual(1, homepage.context['num_unread_notifications'])
-
-
-class TestChangingNotificationStatusByUser(WebTestCase):
-
-    def setUp(self):
-        self.user = User.objects.create(username='testuser',
-                                        password='something',
-                                        email='testuser@example.com')
-
-        product = G(Product)
-        self.notification1 = ProductNotification.objects.create(user=self.user,
-                                                               product=product,
-                                                               status='active')
-        self.notification2 = ProductNotification.objects.create(user=self.user,
-                                                               product=product,
-                                                               status='inactive')
-
-    def test_deactivating_an_active_product_notification(self):
-        self.assertEquals(self.notification1.status, ProductNotification.ACTIVE)
-        self.assertEquals(self.notification2.status, ProductNotification.INACTIVE)
-
-        page = self.app.get(reverse("customer:summary"),
-                            params={'tab': 'notification'}, user=self.user)
-        notification_form = page.forms[1]
-        notification_form.submit('deactivate', index=0)
-
-        notification = ProductNotification.objects.get(pk=self.notification1.id)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-
-        notification = ProductNotification.objects.get(pk=self.notification2.id)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-
-    def test_activating_an_inactive_product_notification(self):
-        self.assertEquals(self.notification1.status, ProductNotification.ACTIVE)
-        self.assertEquals(self.notification2.status, ProductNotification.INACTIVE)
-
-        page = self.app.get(reverse("customer:summary"),
-                            params={'tab': 'notification'}, user=self.user)
-        notification_form = page.forms[1]
-        notification_form.submit('activate', index=0)
-
-        notification = ProductNotification.objects.get(pk=self.notification2.id)
-        self.assertEquals(notification.status, ProductNotification.ACTIVE)
-
-        notification = ProductNotification.objects.get(pk=self.notification1.id)
-        self.assertEquals(notification.status, ProductNotification.ACTIVE)

tests/unit/customer/alert_tests.py

@@ -0,0 +1,18 @@
+from django.test import TestCase
+from django.contrib.auth.models import User
+from django_dynamic_fixture import G
+
+from oscar.apps.customer.models import ProductAlert
+from oscar.test.helpers import create_product
+
+
+class TestAnAlertForARegisteredUser(TestCase):
+
+    def setUp(self):
+        user = G(User)
+        product = create_product()
+        self.alert = ProductAlert.objects.create(user=user,
+                                            product=product)
+
+    def test_defaults_to_active(self):
+        self.assertTrue(self.alert.is_active)

tests/unit/notification_tests.py

@@ -1,119 +0,0 @@
-from django.core import mail
-from django.test import TestCase
-from django.contrib.auth.models import User
-from django_dynamic_fixture import get
-
-from oscar.apps.catalogue.models import Product, ProductClass
-from oscar.apps.partner.models import StockRecord
-from oscar.apps.catalogue.notification.models import ProductNotification
-
-
-class TestANotificationForARegisteredUser(TestCase):
-
-    def setUp(self):
-        self.product = get(Product)
-        self.user = get(User)
-        self.notification = ProductNotification.objects.create(
-            user=self.user,
-            product=self.product)
-
-    def test_uses_the_users_email_for_notifications(self):
-        self.assertEquals(self.notification.get_notification_email(),
-                          self.user.email)
-
-    def test_defaults_to_inactive_status(self):
-        self.assertFalse(self.notification.is_active())
-
-    def test_defaults_to_unconfirmed(self):
-        self.assertFalse(self.notification.is_confirmed())
-
-
-class TestANotificationForAnAnonymousUser(TestCase):
-
-    def setUp(self):
-        self.product = get(Product)
-        self.email = 'test@oscarcommerce.com'
-        self.notification = ProductNotification.objects.create(
-            email=self.email,
-            product=self.product)
-
-    def test_uses_the_specified_email_for_notifications(self):
-        self.assertEquals(self.notification.get_notification_email(),
-                          self.email)
-
-
-class TestNotificationEmails(TestCase):
-
-    def setUp(self):
-        self.product_class = ProductClass.objects.create(name='books')
-        self.product = get(Product, product_class=self.product_class,
-                           title='product', upc='000000000001')
-        self.reference_product = get(Product, product_class=self.product_class,
-                           title='reference product', upc='000000000002')
-
-        self.first_user = get(User, email='firstuser@one.com')
-        self.second_user = get(User, email='seconduser@two.com')
-
-        get(StockRecord, product=self.product, num_in_stock=0)
-
-    def test_are_not_sent_when_stock_level_remains_0(self):
-        stock_record = StockRecord.objects.get(id=1)
-        self.assertEquals(stock_record.num_in_stock, 0)
-        stock_record.save()
-        self.assertEquals(stock_record.num_in_stock, 0)
-
-        self.assertEquals(len(mail.outbox), 0)
-
-    def test_are_not_sent_when_there_are_no_notifications(self):
-        stock_record = StockRecord.objects.get(id=1)
-        self.assertEquals(stock_record.num_in_stock, 0)
-
-        stock_record.num_in_stock = 20
-        stock_record.save()
-
-        self.assertEquals(len(mail.outbox), 0)
-
-    def test_are_sent_correctly_when_there_are_notifications(self):
-        ProductNotification.objects.create(user=self.first_user,
-                                           product=self.product,
-                                           status=ProductNotification.ACTIVE)
-        ProductNotification.objects.create(user=self.second_user,
-                                           product=self.product,
-                                           status=ProductNotification.ACTIVE)
-        ProductNotification.objects.create(user=None,
-                                           email='anonymous@test.com',
-                                           product=self.product,
-                                           status=ProductNotification.ACTIVE)
-        ProductNotification.objects.create(user=self.second_user,
-                                           product=self.reference_product,
-                                           status=ProductNotification.ACTIVE)
-        ProductNotification.objects.create(product=self.product,
-                                           status=ProductNotification.INACTIVE)
-
-        stock_record = StockRecord.objects.get(id=1)
-        self.assertEquals(stock_record.num_in_stock, 0)
-
-        stock_record.num_in_stock = 20
-        stock_record.save()
-
-        self.assertEquals(len(mail.outbox), 3)
-        self.assertItemsEqual(
-            [e.to[0] for e in mail.outbox],
-            [self.first_user.email, self.second_user.email, 'anonymous@test.com'],
-        )
-
-        notification = ProductNotification.objects.get(id=1)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-        self.assertNotEquals(notification.date_notified, None)
-
-        notification = ProductNotification.objects.get(id=2)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-        self.assertNotEquals(notification.date_notified, None)
-
-        notification = ProductNotification.objects.get(id=3)
-        self.assertEquals(notification.status, ProductNotification.INACTIVE)
-        self.assertNotEquals(notification.date_notified, None)
-
-        notification = ProductNotification.objects.get(id=4)
-        self.assertEquals(notification.status, ProductNotification.ACTIVE)
-        self.assertEquals(notification.date_notified, None)