Now including the new voucher app

oscar/apps/voucher/abstract_models.py

@@ -0,0 +1,111 @@
+from decimal import Decimal
+import datetime
+
+from django.core import exceptions
+from django.db import models
+from django.utils.translation import ugettext as _
+
+
+class AbstractVoucher(models.Model):
+    """
+    A voucher.  This is simply a link to a collection of offers
+
+    Note that there are three possible "usage" models:
+    (a) Single use
+    (b) Multi-use
+    (c) Once per customer
+    """
+    name = models.CharField(_("Name"), max_length=128,
+        help_text=_("""This will be shown in the checkout and basket once the voucher is entered"""))
+    code = models.CharField(_("Code"), max_length=128, db_index=True, unique=True,
+        help_text=_("""Case insensitive / No spaces allowed"""))
+    offers = models.ManyToManyField('offer.ConditionalOFfer', related_name='vouchers', 
+                                    limit_choices_to={'offer_type': "Voucher"})
+
+    SINGLE_USE, MULTI_USE, ONCE_PER_CUSTOMER = ('Single use', 'Multi-use', 'Once per customer')
+    USAGE_CHOICES = (
+        (SINGLE_USE, _("Can only be used by one customer")),
+        (MULTI_USE, _("Can only be used any number of times")),
+        (ONCE_PER_CUSTOMER, _("Can be used once by each customer")),
+    )
+    usage = models.CharField(_("Usage"), max_length=128, choices=USAGE_CHOICES, default=MULTI_USE)
+
+    start_date = models.DateField()
+    end_date = models.DateField()
+
+    # Summary information
+    num_basket_additions = models.PositiveIntegerField(default=0)
+    num_orders = models.PositiveIntegerField(default=0)
+    total_discount = models.DecimalField(decimal_places=2, max_digits=12, default=Decimal('0.00'))
+    
+    date_created = models.DateField(auto_now_add=True)
+
+    class Meta:
+        get_latest_by = 'date_created'
+        abstract = True
+
+    def __unicode__(self):
+        return self.name
+
+    def clean(self):
+        if self.start_date and self.end_date and self.start_date > self.end_date:
+            raise exceptions.ValidationError(_('End date should be later than start date'))
+
+    def save(self, *args, **kwargs):
+        self.code = self.code.upper()
+        super(AbstractVoucher, self).save(*args, **kwargs)
+
+    def is_active(self, test_date=None):
+        """
+        Tests whether this voucher is currently active.
+        """
+        if not test_date:
+            test_date = datetime.date.today()
+        return self.start_date <= test_date and test_date < self.end_date
+
+    def is_available_to_user(self, user=None):
+        """
+        Tests whether this voucher is available to the passed user.
+        
+        Returns a tuple of a boolean for whether it is successulf, and a message
+        """
+        is_available, message = False, ''
+        if self.usage == self.SINGLE_USE:
+            is_available = self.applications.count() == 0
+            if not is_available:
+                message = "This voucher has already been used"
+        elif self.usage == self.MULTI_USE:
+            is_available = True
+        elif self.usage == self.ONCE_PER_CUSTOMER:
+            if not user.is_authenticated():
+                is_available = False
+                message = "This voucher is only available to signed in users"
+            else:
+                is_available = self.applications.filter(voucher=self, user=user).count() == 0
+                if not is_available:
+                    message = "You have already used this voucher in a previous order"
+        return is_available, message
+    
+    def record_usage(self, order, user):
+        """
+        Records a usage of this voucher in an order.
+        """
+        self.applications.create(voucher=self, order=order, user=user)
+        
+        
+class AbstractVoucherApplication(models.Model):
+    """
+    For tracking how often a voucher has been used
+    """
+    voucher = models.ForeignKey('voucher.Voucher', related_name="applications")
+    # It is possible for an anonymous user to apply a voucher so we need to allow
+    # the user to be nullable
+    user = models.ForeignKey('auth.User', blank=True, null=True)
+    order = models.ForeignKey('order.Order')
+    date_created = models.DateField(auto_now_add=True)
+
+    class Meta:
+        abstract = True
+
+    def __unicode__(self):
+        return u"'%s' used by '%s'" % (self.voucher, self.user)        

oscar/apps/voucher/admin.py

@@ -0,0 +1,29 @@
+from django.contrib import admin
+
+from oscar.core.loading import import_module
+import_module('voucher.models', ['Voucher', 'VoucherApplication'], locals())
+
+    
+class VoucherAdmin(admin.ModelAdmin):
+    list_display = ('name', 'code', 'usage', 'num_basket_additions', 'num_orders', 'total_discount')    
+    readonly_fields = ('num_basket_additions', 'num_orders', 'total_discount')
+    fieldsets = (
+        (None, {
+            'fields': ('name', 'code', 'usage', 'start_date', 'end_date')
+        }),
+        ('Benefit', {
+            'fields': ('offers',)
+        }),
+        ('Usage', {
+            'fields': ('num_basket_additions', 'num_orders', 'total_discount')
+        }),
+        
+    )
+    
+class VoucherApplicationAdmin(admin.ModelAdmin):
+    list_display = ('voucher', 'user', 'order', 'date_created')
+    readonly_fields = ('voucher', 'user', 'order')        
+
+
+admin.site.register(Voucher, VoucherAdmin)
+admin.site.register(VoucherApplication, VoucherApplicationAdmin)

oscar/apps/voucher/models.py

@@ -0,0 +1,11 @@
+from oscar.apps.voucher.abstract_models import AbstractVoucher, AbstractVoucherApplication
+
+
+class Voucher(AbstractVoucher):
+    pass
+
+
+class VoucherApplication(AbstractVoucherApplication):
+    pass
+
+

oscar/apps/voucher/tests.py

@@ -0,0 +1,33 @@
+import datetime
+
+from django.test import TestCase
+
+from oscar.apps.voucher.models import Voucher
+
+
+class VoucherTest(TestCase):
+    
+    def test_is_active(self):
+        start = datetime.date(2011, 01, 01)
+        test = datetime.date(2011, 01, 10)
+        end = datetime.date(2011, 02, 01)
+        voucher = Voucher(start_date=start, end_date=end)
+        self.assertTrue(voucher.is_active(test))
+
+    def test_is_inactive(self):
+        start = datetime.date(2011, 01, 01)
+        test = datetime.date(2011, 03, 10)
+        end = datetime.date(2011, 02, 01)
+        voucher = Voucher(start_date=start, end_date=end)
+        self.assertFalse(voucher.is_active(test))
+        
+    def test_codes_are_saved_as_uppercase(self):
+        start = datetime.date(2011, 01, 01)
+        end = datetime.date(2011, 02, 01)
+        voucher = Voucher(name="Dummy voucher", code="lowercase", start_date=start, end_date=end)
+        voucher.save()
+        self.assertEquals("LOWERCASE", voucher.code)
+        
+
+    
+