Add OSCAR_MAX_BASKET_QUANTITY_THRESHOLD

oscar/apps/basket/forms.py

 from django import forms
+from django.conf import settings
 from django.db.models import get_model
 from django.utils.translation import gettext_lazy as _
 
 
 class BasketLineForm(forms.ModelForm):
     save_for_later = forms.BooleanField(initial=False, required=False)
-    
+
     class Meta:
         model = basketline_model
         exclude = ('basket', 'product', 'line_reference', )
 
 class SavedLineForm(forms.ModelForm):
     move_to_basket = forms.BooleanField(initial=False, required=False)
-    
+
     class Meta:
         model = basketline_model
         exclude = ('basket', 'product', 'line_reference', 'quantity', )
 
 class BasketVoucherForm(forms.Form):
     code = forms.CharField(max_length=128)
-    
+
     def __init__(self, *args, **kwargs):
         return super(BasketVoucherForm, self).__init__(*args,**kwargs)
-        
+
 
 class ProductSelectionForm(forms.Form):
     product_id = forms.IntegerField(min_value=1)
-    
+
     def clean_product_id(self):
         id = self.cleaned_data['product_id']
 
 class AddToBasketForm(forms.Form):
     product_id = forms.IntegerField(widget=forms.HiddenInput(), min_value=1)
     quantity = forms.IntegerField(initial=1, min_value=1)
-    
-    def __init__(self, instance, *args, **kwargs):
+
+    def __init__(self, basket, instance, *args, **kwargs):
         super(AddToBasketForm, self).__init__(*args, **kwargs)
+        self.basket = basket
         self.instance = instance
         if instance:
             if instance.is_group:
                 self._create_group_product_fields(instance)
             else:
                 self._create_product_fields(instance)
-    
+
     def clean_product_id(self):
         id = self.cleaned_data['product_id']
         product = Product.objects.get(id=id)
             raise forms.ValidationError(_("This product is not available for purchase"))
         return id
 
+    def clean_quantity(self):
+        qty = self.cleaned_data['quantity']
+        basket_threshold = settings.OSCAR_MAX_BASKET_QUANTITY_THRESHOLD
+        if basket_threshold:
+            total_basket_quantity = self.basket.num_items
+            max_allowed = basket_threshold - total_basket_quantity
+            if qty > max_allowed:
+                raise forms.ValidationError(
+                    _("Due to technical limitations we are not able to ship"
+                      " more than %(threshold)d items in one order. Your basket"
+                      " currently has %(basket)d items.") % {
+                            'threshold': basket_threshold,
+                            'basket': total_basket_quantity,
+                    })
+        return qty
+
     def _create_group_product_fields(self, item):
         """
         Adds the fields for a "group"-type product (eg, a parent product with a
         choices = []
         for variant in item.variants.all():
             if variant.has_stockrecord:
-                summary = u"%s (%s) - %.2f" % (variant.get_title(), variant.attribute_summary(), 
+                summary = u"%s (%s) - %.2f" % (variant.get_title(), variant.attribute_summary(),
                                                variant.stockrecord.price_incl_tax)
                 choices.append((variant.id, summary))
         self.fields['product_id'] = forms.ChoiceField(choices=tuple(choices))
-    
+
     def _create_product_fields(self, item):
         u"""Add the product option fields."""
         for option in item.options:
             self._add_option_field(item, option)
-    
+
     def _add_option_field(self, item, option):
         u"""
         Creates the appropriate form field for the product option.
-        
-        This is designed to be overridden so that specific widgets can be used for 
+
+        This is designed to be overridden so that specific widgets can be used for
         certain types of options.
         """
-        self.fields[option.code] = forms.CharField()    
-    
+        self.fields[option.code] = forms.CharField()
+
 

oscar/apps/basket/tests.py

 from decimal import Decimal as D
 
-from django.utils import unittest
-from django.test.client import Client
+from django.conf import settings
 from django.core.urlresolvers import reverse
+from django.test import TestCase
 
-from oscar.apps.basket.models import Basket, Line 
+from oscar.apps.basket.models import Basket, Line
 from oscar.test.helpers import create_product, TwillTestCase
 
 
         self.assertPageTitleMatches('Oscar')
 
 
-class BasketModelTest(unittest.TestCase):
-    
+class BasketModelTest(TestCase):
+
     def setUp(self):
         self.basket = Basket.objects.create()
         self.dummy_product = create_product()
-    
+
     def test_empty_baskets_have_zero_lines(self):
         self.assertTrue(Basket().num_lines == 0)
-        
+
     def test_new_baskets_are_empty(self):
         self.assertTrue(Basket().is_empty)
-        
+
     def test_basket_have_with_one_line(self):
         Line.objects.create(basket=self.basket, product=self.dummy_product)
         self.assertTrue(self.basket.num_lines == 1)
-        
+
     def test_add_product_creates_line(self):
         self.basket.add_product(self.dummy_product)
         self.assertTrue(self.basket.num_lines == 1)
-        
+
     def test_adding_multiproduct_line_returns_correct_number_of_items(self):
         self.basket.add_product(self.dummy_product, 10)
         self.assertEqual(self.basket.num_items, 10)
-       
-        
-class BasketViewsTest(unittest.TestCase):
-    
-    def setUp(self):
-        self.client = Client()
-    
+
+
+class BasketViewsTest(TestCase):
+
     def test_empty_basket_view(self):
         url = reverse('basket:summary')
         response = self.client.get(url)
         self.assertEquals(200, response.status_code)
         self.assertEquals(0, response.context['basket'].num_lines)
-        
+
     def test_anonymous_add_to_basket_creates_cookie(self):
         dummy_product = create_product(price=D('10.00'))
         url = reverse('basket:add')
                        'quantity': 1}
         response = self.client.post(url, post_params)
         self.assertTrue('oscar_open_basket' in response.cookies)
+
+class BasketThresholdTest(TestCase):
+
+    def setUp(self):
+        self._old_threshold = settings.OSCAR_MAX_BASKET_QUANTITY_THRESHOLD
+        settings.OSCAR_MAX_BASKET_QUANTITY_THRESHOLD = 3
+
+    def tearDown(self):
+        settings.OSCAR_MAX_BASKET_QUANTITY_THRESHOLD = self._old_threshold
+
+    def test_adding_more_than_threshold_raises(self):
+        dummy_product = create_product(price=D('10.00'))
+        url = reverse('basket:add')
+        post_params = {'product_id': dummy_product.id,
+                       'action': 'add',
+                       'quantity': 2}
+        response = self.client.post(url, post_params)
+        self.assertTrue('oscar_open_basket' in response.cookies)
+        post_params = {'product_id': dummy_product.id,
+                       'action': 'add',
+                       'quantity': 2}
+        response = self.client.post(url, post_params)
+        self.assertTrue('Your basket currently has 2 items.' in
+                        response.cookies['messages'].value)

oscar/apps/basket/views.py

     extra = 0
     can_delete = True
     template_name='basket/basket.html'
-    
+
     def get_queryset(self):
         return self.request.basket.lines.all()
-    
+
     def get_context_data(self, **kwargs):
         context = super(BasketView, self).get_context_data(**kwargs)
         context['voucher_form'] = BasketVoucherForm()
-        
+
         if self.request.user.is_authenticated():
             try:
                 saved_basket = self.basket_model.saved.get(owner=self.request.user)
             except self.basket_model.DoesNotExist:
                 pass
         return context
-    
+
     def get_success_url(self):
         return self.request.META.get('HTTP_REFERER', reverse('basket:summary'))
 
                 line = form.instance
                 if self.request.user.is_authenticated():
                     self.move_line_to_saved_basket(line)
-                    messages.info(self.request, _(u"'%(title)s' has been saved for later" % {'title': line.product}))   
+                    messages.info(self.request, _(u"'%(title)s' has been saved for later" % {'title': line.product}))
                 else:
                     needs_auth = True
         if needs_auth:
-            messages.error(self.request, "You can't save an item for later if you're not logged in!")     
+            messages.error(self.request, "You can't save an item for later if you're not logged in!")
         return super(BasketView, self).formset_valid(formset)
 
     def move_line_to_saved_basket(self, line):
 
 class BasketAddView(FormView):
     """
-    Handles the add-to-basket operation, shouldn't be accessed via 
+    Handles the add-to-basket operation, shouldn't be accessed via
     GET because there's nothing sensible to render.
     """
     form_class = AddToBasketForm
     product_select_form_class = ProductSelectionForm
     product_model = get_model('catalogue', 'product')
     add_signal = basket_addition
-    
+
     def get(self, request, *args, **kwargs):
         return HttpResponseRedirect(reverse('basket:summary'))
-    
-    def get_form_kwargs(self): 
+
+    def get_form_kwargs(self):
         kwargs = super(BasketAddView, self).get_form_kwargs()
         product_select_form = self.product_select_form_class(self.request.POST)
 
         if product_select_form.is_valid():
             kwargs['instance'] = product_select_form.cleaned_data['product_id']
         else:
-             raise Http404()
+            raise Http404()
+        kwargs['basket'] = self.request.basket
         return kwargs
-    
+
     def get_success_url(self):
         return self.request.META.get('HTTP_REFERER', reverse('basket:summary'))
 
                 options.append({'option': option, 'value': form.cleaned_data[option.code]})
         self.request.basket.add_product(form.instance, form.cleaned_data['quantity'], options)
         messages.info(self.request, _(u"'%(title)s' (quantity %(quantity)d) has been added to your basket" %
-                {'title': form.instance.get_title(), 
+                {'title': form.instance.get_title(),
                  'quantity': form.cleaned_data['quantity']}))
-        
+
         # Send signal for basket addition
         self.add_signal.send(sender=self, product=form.instance, user=self.request.user)
-        
+
         return super(BasketAddView, self).form_valid(form)
-    
+
     def form_invalid(self, form):
         msgs = []
         for error in form.errors.values():
-            msgs.append(error.as_text()) 
+            msgs.append(error.as_text())
         messages.error(self.request, ",".join(msgs))
         return HttpResponseRedirect(self.request.META.get('HTTP_REFERER',reverse('basket:summary')))
 
     model = get_model('voucher', 'voucher')
     can_delete = True
     extra = 0
-    
+
     def get_queryset(self):
         self.request.basket.vouchers.all()
 
 class VoucherAddView(FormView):
     form_class = BasketVoucherForm
     voucher_model = get_model('voucher', 'voucher')
-    
+
     def get(self, request, *args, **kwargs):
         return HttpResponseRedirect(reverse('basket:summary'))
-    
+
     def apply_voucher_to_basket(self, voucher):
         if not voucher.is_active():
             messages.error(self.request, _("The '%(code)s' voucher has expired" % {'code': voucher.code}))
             return
-        
+
         is_available, message = voucher.is_available_to_user(self.request.user)
         if not is_available:
             messages.error(self.request, message)
             return
-        
+
         self.request.basket.vouchers.add(voucher)
-        
+
         # Recalculate discounts to see if the voucher gives any
         discounts_before = self.request.basket.get_discounts()
         self.request.basket.remove_discounts()
         Applicator().apply(self.request, self.request.basket)
         discounts_after = self.request.basket.get_discounts()
-        
+
         # Look for discounts from this new voucher
         found_discount = False
         for discount in discounts_after:
             self.request.basket.vouchers.remove(voucher)
         else:
             messages.info(self.request, _("Voucher '%(code)s' added to basket" % {'code': voucher.code}))
-    
+
     def form_valid(self, form):
         code = form.cleaned_data['code']
         if not self.request.basket.id:
                 voucher = self.voucher_model._default_manager.get(code=code)
             except self.voucher_model.DoesNotExist:
                 messages.error(self.request, _("No voucher found with code '%(code)s'" % {'code': code}))
-            else:        
+            else:
                 self.apply_voucher_to_basket(voucher)
         return HttpResponseRedirect(self.request.META.get('HTTP_REFERER', reverse('basket:summary')))
 
     def form_invalid(self, form):
         return HttpResponseRedirect(reverse('basket:summary'))
-    
+
 
 class VoucherRemoveView(View):
     voucher_model = get_model('voucher', 'voucher')
-    
+
     def get(self, request, *args, **kwargs):
         return HttpResponseRedirect(reverse('basket:summary'))
-    
+
     def post(self, request, *args, **kwargs):
         voucher_id = int(kwargs.pop('pk'))
         if not request.basket.id:
             return saved_basket.lines.all().select_related('product', 'product__stockrecord')
         except self.basket_model.DoesNotExist:
             return []
-        
+
     def get_success_url(self):
         return self.request.META.get('HTTP_REFERER', reverse('basket:summary'))
 
         for form in formset:
             if form.cleaned_data['move_to_basket']:
                 msg = "'%s' has been moved back to your basket" % form.instance.product
-                messages.info(self.request, msg)                
+                messages.info(self.request, msg)
                 real_basket = self.request.basket
                 real_basket.merge_line(form.instance)
         return super(SavedView, self).formset_valid(formset)

oscar/defaults.py

 # Offers
 OSCAR_OFFER_BLACKLIST_PRODUCT = None
 
+# Max total number of items in basket
+OSCAR_MAX_BASKET_QUANTITY_THRESHOLD = None