Personalised products now work with the basket sub-app.

oscar/basket/abstract_models.py

 from decimal import Decimal
+import zlib
 
 from django.contrib.auth.models import User
 from django.db import models
     def flush(self):
         self.lines.all().delete()
     
-    def add_product(self, item, quantity=1):
+    def add_product(self, item, quantity=1, options=[]):
         """
         Convenience method for adding products to a basket
         """
+        line_ref = self._get_line_reference(item, options)
         try:
-            line = self.lines.get(product=item)
+            line = self.lines.get(line_reference=line_ref)
             line.quantity += quantity
             line.save()
         except ObjectDoesNotExist:
-            self.lines.create(basket=self, product=item, quantity=quantity)
+            line = self.lines.create(basket=self, line_reference=line_ref, product=item, quantity=quantity)
+            for option_dict in options:
+                o =line.attributes.create(line=line, option=option_dict['option'], value=option_dict['value'])
     
     def add_line(self, line):
         """
         For adding a line from another basket to this one
         """
-        line.basket = self
-        line.save()
+        try:
+            # Line already exists - bump its quantity and delete the old
+            existing_line = self.lines.get(line_reference=line.line_reference)
+            existing_line.quantity += line.quantity
+            existing_line.save()
+            line.delete()
+        except ObjectDoesNotExist:
+            # Line does not already exist - reassign its basket
+            line.basket = self
+            line.save()
+    
+    def _get_line_reference(self, item, options):
+        if not options:
+            return item.id
+        return "%d_%s" % (item.id, zlib.crc32(str(options)))
     
     # ==========
     # Properties
     def line_price_incl_tax(self):
         return self.quantity * self.unit_price_incl_tax
     
+    @property
+    def description(self):
+        d = str(self.product)
+        ops = []
+        for attribute in self.attributes.all():
+            ops.append("%s = '%s'" % (attribute.option.name, attribute.value))
+        if ops:
+            d = "%s (%s)" % (d, ", ".join(ops))
+        return d
+    
     def save(self, *args, **kwargs):
         if self.quantity == 0:
             return self.delete(*args, **kwargs)
     An attribute of a basket line
     """
     line = models.ForeignKey('basket.Line', related_name='attributes')
-    type = models.CharField(_("Type"), max_length=128)
+    option = models.ForeignKey('product.option')
     value = models.CharField(_("Value"), max_length=255)    
     
-    def get_hash(self):
-        return zlib.crc32(self.type + self.value)
-    
     class Meta:
         abstract = True
     

oscar/basket/factory.py

 def _get_basket(request, cookie_key, manager):
     b = None
     if request.user.is_authenticated():
-        b = manager.get(owner=request.user)
+        try:
+            b = manager.get(owner=request.user)
+        except basket_models.Basket.DoesNotExist, e:
+            pass
     else:
         b = _get_cookie_basket(request, cookie_key, manager)
     return b    
         # new one and store the id and hash in a cookie.
         basket = manager.create()
         cookie = "%s_%s" % (basket.id, _get_basket_hash(basket.id))
-        response.set_cookie(cookie_key, cookie, max_age=COOKIE_LIFETIME)
+        response.set_cookie(cookie_key, cookie, max_age=COOKIE_LIFETIME, httponly=True)
     else:
         basket = anon_basket
     return basket 
                 b = manager.get(pk=basket_id)
             except basket_models.Basket.DoesNotExist, e:
                 b = None
+        else:
+            response.delete_cookie(cookie_key)
     return b  
 
 def _get_basket_hash(id):

oscar/basket/forms.py

 from django import forms
 
-class AddToBasketForm(forms.Form):
-    action = forms.CharField(widget=forms.HiddenInput(), initial='add')
-    product_id = forms.IntegerField(widget=forms.HiddenInput())
-    quantity = forms.IntegerField(min_value=1)
+
+class FormFactory(object):
+    
+    def create(self, item, values=None):
+        """
+        For dynamically creating add-to-basket forms for a given product
+        """
+        self.values = values
+        if item.is_group:
+            return self._create_group_product_form(item)
+        return self._create_product_form(item)
+
+    def _create_group_product_form(self, item):
+        pass
+    
+    def _create_product_form(self, item):
+        # See http://www.b-list.org/weblog/2008/nov/09/dynamic-forms/ for 
+        # advice on how this works.
+        self.fields = {'action': forms.CharField(widget=forms.HiddenInput(), initial='add'),
+                       'product_id': forms.IntegerField(widget=forms.HiddenInput(), min_value=1),
+                       'quantity': forms.IntegerField(min_value=1)}
+        if not self.values:
+            self.values = {'action': 'add', 
+                           'product_id': item.id, 
+                           'quantity': 1}
+            
+        for option in item.options.all():
+            self._add_option_field(item, option)
+            
+        form_class = type('AddToBasketForm', (forms.BaseForm,), {'base_fields': self.fields})
+        return form_class(self.values)
+    
+    def _add_option_field(self, item, option):
+        """
+        Creates the appropriate form field for the product option.
+        
+        This is designed to be overridden so that specific widgets can be used for 
+        certain types of options.
+        """
+        self.fields[option.code] = forms.CharField()
+    
+
+    

oscar/basket/managers.py

 
 
 class OpenBasketManager(models.Manager):
+    
     def get_query_set(self):
         return super(OpenBasketManager, self).get_query_set().filter(status="Open")
     
+    def get_or_create(self, **kwargs):
+        return self.get_query_set().get_or_create(status="Open", **kwargs)
+    
 class SavedBasketManager(models.Manager):
+    
     def get_query_set(self):
-        return super(SavedBasketManager, self).get_query_set().filter(status="Saved")
+        return super(SavedBasketManager, self).get_query_set().filter(status="Saved")
+    
+    def create(self, **kwargs):
+        return self.get_query_set().create(status="Saved", **kwargs)
+    
+    def get_or_create(self, **kwargs):
+        return self.get_query_set().get_or_create(status="Saved", **kwargs)

oscar/basket/templates/basket/summary.html

     </tr>
     {% for line in basket.lines.all %}
     <tr>
-        <td><a href="{{ line.product.get_absolute_url }}">{{ line.product }}</a></td>
+        <td><a href="{{ line.product.get_absolute_url }}">{{ line.description }}</a></td>
         <td>
             <form action="{% url oscar-basket-line line.line_reference %}" method="post">
                 {% csrf_token %}
     </tr>
     {% for line in saved_basket.lines.all %}
     <tr>
-        <td><a href="{{ line.product.get_absolute_url }}">{{ line.product }}</a></td>
+        <td><a href="{{ line.product.get_absolute_url }}">{{ line.description }}</a></td>
         <td>
             <form action="{% url oscar-saved-basket-line line.line_reference %}" method="post">
                 {% csrf_token %}

oscar/basket/urls.py

     return BasketView()(request, *args, **kwargs)
 
 urlpatterns = patterns('oscar.basket.views',
-    url(r'^line/(?P<line_reference>\w+)/$', line_view, name='oscar-basket-line'),
+    url(r'^line/(?P<line_reference>[\w-]+)/$', line_view, name='oscar-basket-line'),
     url(r'^saved-line/(?P<line_reference>\w+)/$', saved_line_view, name='oscar-saved-basket-line'),
     url(r'^$', basket_view, name='oscar-basket'),
 )

oscar/basket/views.py

 
 # Using dynamic loading
 basket_models = import_module('basket.models', ['Basket', 'Line', 'InvalidBasketLineError'])
-basket_forms = import_module('basket.forms', ['AddToBasketForm'])
+basket_forms = import_module('basket.forms', ['FormFactory'])
 basket_factory = import_module('basket.factory', ['get_or_create_open_basket', 'get_open_basket', 
                                                   'get_or_create_saved_basket', 'get_saved_basket'])
 product_models = import_module('product.models', ['Item'])
         messages.info(self.request, "Your basket has been emptied")
         
     def do_add(self, basket):
-        form = basket_forms.AddToBasketForm(self.request.POST)
+        item = get_object_or_404(product_models.Item.objects, pk=self.request.POST['product_id'])
+        factory = basket_forms.FormFactory()
+        form = factory.create(item, self.request.POST)
         if not form.is_valid():
-            messages.error("Unable to add your item to the basket - submission not valid")
+            # @todo Put form errors in session and redirect back to product page
+            messages.error(self.request, "Unable to add your item to the basket - submission not valid")
         else:
-            product = get_object_or_404(product_models.Item.objects, pk=form.cleaned_data['product_id'])
-            basket.add_product(product, form.cleaned_data['quantity'])
+            # Extract product options from POST
+            options = []
+            for option in item.options.all():
+                if option.code in form.cleaned_data:
+                    options.append({'option': option, 'value': form.cleaned_data[option.code]})
+            basket.add_product(item, form.cleaned_data['quantity'], options)
             messages.info(self.request, "'%s' (quantity %d) has been added to your basket" %
-                          (product.get_title(), form.cleaned_data['quantity']))
+                          (item.get_title(), form.cleaned_data['quantity']))
  
 
 class LineView(object):

oscar/product/abstract_models.py

 from django.utils.translation import ugettext_lazy as _
 from django.template.defaultfilters import slugify
 from django.core.urlresolvers import reverse
+from django.core.exceptions import ObjectDoesNotExist
 
 from oscar.product.managers import BrowsableItemManager
 
     For converting a string in CamelCase or normal text with spaces
     to the normal underscored variety
     """
-    without_whitespace = re.sub('\s*', '_', str.strip())
+    without_whitespace = re.sub('\s+', '_', str.strip())
     s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', without_whitespace)
     return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
 
     """
     name = models.CharField(_('name'), max_length=128)
     slug = models.SlugField(max_length=128, unique=True)
-    options = models.ManyToManyField('product.Option')
+    options = models.ManyToManyField('product.Option', blank=True)
 
     class Meta:
         abstract = True
     item_class = models.ForeignKey('product.ItemClass', verbose_name=_('item class'), null=True,
         help_text="""Choose what type of product this is""")
     attribute_types = models.ManyToManyField('product.AttributeType', through='ItemAttributeValue')
-    options = models.ManyToManyField('product.Option')
+    options = models.ManyToManyField('product.Option', blank=True)
     date_created = models.DateTimeField(auto_now_add=True)
     date_updated = models.DateTimeField(auto_now=True, null=True, default=None)
 
     objects = models.Manager()
     browsable = BrowsableItemManager()
 
+    # Properties
+
     @property
     def is_top_level(self):
         return self.parent == None
     def is_variant(self):
         return not self.is_top_level
 
+    @property
+    def min_variant_price_incl_tax(self):
+        return self._min_variant_price('price_incl_tax')
+    
+    @property
+    def min_variant_price_excl_tax(self):
+        return self._min_variant_price('price_excl_tax')
+
+    @property
+    def has_stockrecord(self):
+        try:
+            sr = self.stockrecord
+            return True
+        except ObjectDoesNotExist:
+            return False
+
     def attribute_summary(self):
         return ", ".join([attribute.__unicode__() for attribute in self.attributes.all()])
 
             return self.parent.item_class
         return None
 
+    # Helpers
+    
+    def _min_variant_price(self, property):
+        prices = []
+        for variant in self.variants.all():
+            if variant.has_stockrecord:
+                prices.append(getattr(variant.stockrecord, property))
+        if not prices:
+            return None
+        prices.sort()
+        return prices[0]
+
     class Meta:
         abstract = True
         ordering = ['-date_created']

oscar/product/admin.py

 class ItemClassAdmin(admin.ModelAdmin):
     prepopulated_fields = {"slug": ("name",)}
     
-class OptionInline(admin.TabularInline):
-    model = Item.options.through    
-
 class ItemAdmin(admin.ModelAdmin):
     list_display = ('get_title', 'upc', 'get_item_class', 'is_top_level', 'is_group', 'is_variant', 'attribute_summary', 'date_created')
     prepopulated_fields = {"slug": ("title",)}
-    inlines = [AttributeInline, OptionInline]
+    inlines = [AttributeInline]
 
 admin.site.register(ItemClass, ItemClassAdmin)
 admin.site.register(Item, ItemAdmin)

oscar/product/templates/product/browse.html

 
 {% block content %}
 
+{% if products.count %}
+
 <ol>
-{% for product in products.object_list %}
+{% for product in products %}
 <li>
     <a href="{{ product.get_absolute_url }}">{{ product.get_title }}</a><br/>
-    {% if product.stockrecord %} 
-        &pound;{{ product.stockrecord.price_incl_tax }}<br/>
-        {{ product.stockrecord.availability }}
+    {% if product.is_group %}
+        From &pound;{{ product.min_variant_price_incl_tax }}
     {% else %}
-        Not available
+        {% if product.has_stockrecord %} 
+            &pound;{{ product.stockrecord.price_incl_tax }}<br/>
+            {{ product.stockrecord.availability }}
+        {% else %}
+            Not available    
+        {% endif %}
     {% endif %}    
 </li>
 {% endfor %}
 
 <div class="pagination">
     <span class="step-links">
-        {% if products.has_previous %}
-            <a href="?page={{ products.previous_page_number }}">previous</a>
+    
+        {% if page_obj.has_previous %}
+            <a href="?page={{ page_obj.previous_page_number }}">previous</a>
         {% endif %}
 
         <span class="current">
-            Page {{ products.number }} of {{ products.paginator.num_pages }}.
+            Page {{ page_obj.number }} of {{ paginator.num_pages }}.
         </span>
 
-        {% if products.has_next %}
-            <a href="?page={{ products.next_page_number }}">next</a>
+        {% if page_obj.has_next %}
+            <a href="?page={{ page_obj.next_page_number }}">next</a>
         {% endif %}
     </span>
 </div>
 
+{% else %}
+
+<p>No products found.</p>
+
+{% endif %}
+
 {% endblock content %}
 

oscar/product/templates/product/item.html

     </form>
 {% else %}
 
-<form action="/shop/basket/" method="post">
+<form action="{% url oscar-basket %}" method="post">
     {% csrf_token %}
     {{ form.as_p }}
     <input type="submit" value="Add to basket" />

oscar/product/urls.py

 from django.conf.urls.defaults import *
+from oscar.product.views import ItemDetailView, ProductListView, ItemClassListView
 
 urlpatterns = patterns('oscar.product.views',
-    url(r'(?P<item_class_slug>[\w-]+)/(?P<item_slug>[\w-]*)-(?P<item_id>\d+)/$', 'item', name='oscar-product-item'),
-    url(r'(?P<item_class_slug>[\w-]+)/$', 'item_class', name='oscar-product-item-class'),
-    url(r'$', 'all', name='oscar-products'),
+    url(r'(?P<item_class_slug>[\w-]+)/(?P<item_slug>[\w-]*)-(?P<item_id>\d+)/$', ItemDetailView.as_view(), name='oscar-product-item'),
+    url(r'(?P<item_class_slug>[\w-]+)/$', ItemClassListView.as_view(), name='oscar-product-item-class'),
+    url(r'^$', ProductListView.as_view(), name='oscar-products'),
 )

oscar/product/views.py

 from django.conf import settings
 from django.http import HttpResponse, Http404, HttpResponseRedirect
 from django.template import Context, loader, RequestContext
-from django.shortcuts import render_to_response, get_object_or_404
+from django.shortcuts import render, get_object_or_404
 from django.core.urlresolvers import reverse
 from django.core.paginator import Paginator, InvalidPage, EmptyPage
+from django.views.generic import ListView, DetailView
 
 from oscar.services import import_module
 
 product_models = import_module('product.models', ['Item', 'ItemClass'])
-basket_forms = import_module('basket.forms', ['AddToBasketForm'])
+basket_forms = import_module('basket.forms', ['FormFactory'])
 
 
-def item(request, item_class_slug, item_slug, item_id, template_file='product/item.html'):
-    """ 
-    Single product page
+class ItemDetailView(DetailView):
     """
-    item = get_object_or_404(product_models.Item, pk=item_id)
-    form = basket_forms.AddToBasketForm({'product_id': item_id, 'quantity': 1, 'action': 'add'})
-    return render_to_response(template_file, locals(), context_instance=RequestContext(request))
-
-
-def item_class(request, item_class_slug, template_file='product/browse-all.html', results_per_page=20):
-    item_class = get_object_or_404(product_models.ItemClass, slug=item_class_slug)
-    product_list = product_models.Item.browsable.filter(item_class=item_class)
-    paginator = Paginator(product_list, results_per_page)
-    
-    # Make sure page request is an int. If not, deliver first page.
-    try:
-        page = int(request.GET.get('page', '1'))
-    except ValueError:
-        page = 1
-    try:
-        products = paginator.page(page)
-    except (EmptyPage, InvalidPage):
-        products = paginator.page(paginator.num_pages)
-    
-    return render_to_response(template_file, locals())
-
-
-def all(request, template_file='product/browse.html', results_per_page=20):
-    if 'q' in request.GET and request.GET['q']:
-        query = request.GET['q'].strip()
-        product_list = product_models.Item.browsable.filter(title__icontains=query)
-        summary = "Products matching '%s'" % query
-    else:
-        product_list = product_models.Item.browsable.all()
-        summary = "All products"
-    paginator = Paginator(product_list, results_per_page)
+    View a single product.
+    """
+    template_name = "product/item.html"
     
-    # Make sure page request is an int. If not, deliver first page.
-    try:
-        page = int(request.GET.get('page', '1'))
-    except ValueError:
-        page = 1
-    try:
-        products = paginator.page(page)
-    except (EmptyPage, InvalidPage):
-        products = paginator.page(paginator.num_pages)
+    def get_object(self):
+        return get_object_or_404(product_models.Item, pk=self.kwargs['item_id'])
     
-    return render_to_response(template_file, locals())
+    def get_context_data(self, **kwargs):
+        context = super(ItemDetailView, self).get_context_data(**kwargs)
+        
+        # Add add-to-basket form for this product
+        factory = basket_forms.FormFactory()
+        context['form'] = factory.create(self.object)
+        
+        return context
+
+
+class ItemClassListView(ListView):
+    """
+    View products filtered by item-class.
+    """
+    context_object_name = "products"
+    template_name = 'product/browse.html'
+    paginate_by = 20
+
+    def get_queryset(self):
+        item_class = get_object_or_404(product_models.ItemClass, slug=self.kwargs['item_class_slug'])
+        return product_models.Item.browsable.filter(item_class=item_class)
+
+
+class ProductListView(ListView):
+
+    context_object_name = "products"
+    template_name = 'product/browse.html'
+    paginate_by = 20
+
+    def get_search_query(self):
+        q = None
+        if 'q' in self.request.GET and self.request.GET['q']:
+            q = self.request.GET['q'].strip()
+        return q
 
+    def get_queryset(self):
+        q = self.get_search_query()
+        if q:
+            return product_models.Item.browsable.filter(title__icontains=q)
+        else:
+            return product_models.Item.browsable.all()
+        
+    def get_context_data(self, **kwargs):
+        context = super(ProductListView, self).get_context_data(**kwargs)
+        q = self.get_search_query()
+        if not q:
+            context['summary'] = 'All products'
+        else:
+            context['summary'] = "Products matching '%s'" % q
+        return context