Move basket status constants onto the Basket class

It was a mistake to have them at module level as it meant it was a pain
to import them when they were needed for filtering.  Having them on
the basket is much nicer as they available whenever the Basket class is.

This commit may cause a few gremlins for people updating to 0.4 but I
think it's a necessary pain at this stage.  It's trivial to fix too.

oscar/apps/basket/abstract_models.py

 from oscar.apps.basket.managers import OpenBasketManager, SavedBasketManager
 from oscar.templatetags.currency_filters import currency
 
-# Basket statuses
-# - Frozen is for when a basket is in the process of being submitted
-#   and we need to prevent any changes to it.
-OPEN, MERGED, SAVED, FROZEN, SUBMITTED = (
-    "Open", "Merged", "Saved", "Frozen", "Submitted")
-
 
 class AbstractBasket(models.Model):
     """
     Basket object
     """
-    # Baskets can be anonymously owned (which are merged if the user signs in)
+    # Baskets can be anonymously owned - hence this field is nullable.  When a
+    # anon user signs in, their two baskets are merged.
     owner = models.ForeignKey('auth.User', related_name='baskets',
                               null=True, verbose_name=_("Owner"))
+
+    # Basket statuses
+    # - Frozen is for when a basket is in the process of being submitted
+    #   and we need to prevent any changes to it.
+    OPEN, MERGED, SAVED, FROZEN, SUBMITTED = (
+    "Open", "Merged", "Saved", "Frozen", "Submitted")
     STATUS_CHOICES = (
         (OPEN, _("Open - currently active")),
         (MERGED, _("Merged - superceded by another basket")),
     )
     status = models.CharField(_("Status"), max_length=128, default=OPEN,
                               choices=STATUS_CHOICES)
+
     vouchers = models.ManyToManyField('voucher.Voucher', null=True,
                                       verbose_name=_("Vouchers"))
 
-    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
-    date_merged = models.DateTimeField(_("Date Merged"), null=True, blank=True)
-    date_submitted = models.DateTimeField(_("Date Submitted"), null=True,
+    date_created = models.DateTimeField(_("Date created"), auto_now_add=True)
+    date_merged = models.DateTimeField(_("Date merged"), null=True, blank=True)
+    date_submitted = models.DateTimeField(_("Date submitted"), null=True,
                                           blank=True)
 
     # Only if a basket is in one of these statuses can it be edited
 
     def flush(self):
         """Remove all lines from basket."""
-        if self.status == FROZEN:
+        if self.status == self.FROZEN:
             raise PermissionDenied("A frozen basket cannot be flushed")
         self.lines.all().delete()
         self._lines = None
         """
         for line_to_merge in basket.all_lines():
             self.merge_line(line_to_merge, add_quantities)
-        basket.status = MERGED
+        basket.status = self.MERGED
         basket.date_merged = now()
         basket.save()
         self._lines = None
         """
         Freezes the basket so it cannot be modified.
         """
-        self.status = FROZEN
+        self.status = self.FROZEN
         self.save()
 
     def thaw(self):
         """
         Unfreezes a basket so it can be modified again
         """
-        self.status = OPEN
+        self.status = self.OPEN
         self.save()
 
     def set_as_submitted(self):
         """Mark this basket as submitted."""
-        self.status = SUBMITTED
+        self.status = self.SUBMITTED
         self.date_submitted = now()
         self.save()
 
             return 0
 
     def is_submitted(self):
-        return self.status == SUBMITTED
+        return self.status == self.SUBMITTED
 
 
 class AbstractLine(models.Model):

oscar/apps/basket/middleware.py

 from django.db.models import get_model
 
 from oscar.core.loading import get_class
-from oscar.apps.basket.abstract_models import OPEN
 
 Applicator = get_class('offer.utils', 'Applicator')
 Basket = get_model('basket', 'basket')
             if basket_hash == self.get_basket_hash(basket_id):
                 try:
                     basket = Basket.objects.get(pk=basket_id, owner=None,
-                                                status=OPEN)
+                                                status=Basket.OPEN)
                 except Basket.DoesNotExist:
                     request.cookies_to_delete.append(cookie_key)
             else:

oscar/apps/basket/models.py

 from oscar.apps.basket.abstract_models import (
-    AbstractBasket, AbstractLine, AbstractLineAttribute,
-    OPEN, MERGED, SAVED, SUBMITTED)
+    AbstractBasket, AbstractLine, AbstractLineAttribute)
 
 
 class InvalidBasketLineError(Exception):

oscar/apps/basket/reports.py

 
 from django.db.models import get_model
 from django.utils.translation import gettext_lazy as _
-from oscar.core.loading import get_class, get_classes
+from oscar.core.loading import get_class
 
 ReportGenerator = get_class('dashboard.reports.reports', 'ReportGenerator')
 ReportCSVFormatter = get_class('dashboard.reports.reports',
 ReportHTMLFormatter = get_class('dashboard.reports.reports',
                                 'ReportHTMLFormatter')
 Basket = get_model('basket', 'Basket')
-OPEN, SUBMITTED = get_classes('basket.models', ['OPEN', 'SUBMITTED'])
 
 
 class OpenBasketReportCSVFormatter(ReportCSVFormatter):
         additional_data = {
             'start_date': self.start_date,
             'end_date': self.end_date}
-        baskets = Basket._default_manager.filter(status=OPEN)
+        baskets = Basket._default_manager.filter(status=Basket.OPEN)
         return self.formatter.generate_response(baskets, **additional_data)
 
 
         additional_data = {
             'start_date': self.start_date,
             'end_date': self.end_date}
-        baskets = Basket._default_manager.filter(status=SUBMITTED)
+        baskets = Basket._default_manager.filter(status=Basket.SUBMITTED)
         return self.formatter.generate_response(baskets, **additional_data)

oscar/apps/dashboard/views.py

 from django.db.models import Avg, Sum, Count
 from django.contrib.auth.models import User
 
-from oscar.apps.basket.abstract_models import OPEN as basket_OPEN
 from oscar.apps.promotions.models import AbstractPromotion
 
 ConditionalOffer = get_model('offer', 'ConditionalOffer')
         """
         if filters is None:
             filters = {}
-        filters['status'] = basket_OPEN
+        filters['status'] = Basket.OPEN
         return Basket.objects.filter(**filters)
 
     def get_hourly_report(self, hours=24, segments=10):