Updated product management to allow shipping events to be set

oscar/basket/views.py

 from django.core.urlresolvers import reverse
 from django.contrib import messages
 
+from oscar.views import ModelView
 from oscar.services import import_module
 
 basket_models = import_module('basket.models', ['Basket', 'Line', 'InvalidBasketLineError'])
 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'])
-
-
-class ModelView(object):
-    """
-    A generic view for models which can recieve GET and POST requests
-    
-    The __init__ method of subclasses should set the default response 
-    variable.
-    """
-    template_file = None
-    response = None
-        
-    def __call__(self, request, *args, **kwargs):
-        
-        self.request = request
-        self.args = args
-        self.kwargs = kwargs
-        
-        try:
-            method_name = "handle_%s" % request.method.upper()
-            getattr(self, method_name)()
-        except AttributeError:
-            # This class doesn't implement this HTTP method
-            messages.error(request, "Invalid action")
-        return self.response
-        
-    def handle_GET(self):
-        """
-        Default implementation of model view is to do nothing.
-        """ 
-        pass
-    
-    def handle_POST(self):
-        """
-        Handle a POST request to this resource.
-        
-        This will forward on request to a method of form "do_%s" where the
-        second part needs to be specified as an "action" name within the
-        request.
-        
-        If you don't want to handle POSTs this way, just override this method
-        """
-        if 'action' in self.request.POST:
-            model = self.get_model()
-            getattr(self, "do_%s" % self.request.POST['action'].lower())(model)
-            
-    def get_model(self):
-        """
-        Responsible for loading the model that is being acted on
-        """
-        pass
     
         
 class BasketView(ModelView):
     def get_model(self):
         return basket_factory.get_or_create_open_basket(self.request, self.response)
     
-    def handle_GET(self):
+    def handle_GET(self, basket):
         basket = basket_factory.get_open_basket(self.request)
         saved_basket = basket_factory.get_saved_basket(self.request)
         if not basket:
             basket = basket_models.Basket()
         self.response = render(self.request, self.template_file, locals())
         
-    def handle_POST(self):
+    def handle_POST(self, basket):
         try:
-            super(BasketView, self).handle_POST()
+            super(BasketView, self).handle_POST(basket)
         except basket_models.Basket.DoesNotExist:
             messages.error(self.request, "Unable to find your basket")
         except basket_models.InvalidBasketLineError, e:

oscar/checkout/views.py

         order.save()
         return order
     
-    def _create_line_model(self, order, batch, line):
-        batch_line = order_models.BatchLine.objects.create(batch=batch, 
-                                                           product=line.product, 
-                                                           quantity=line.quantity, 
-                                                           line_price_excl_tax=line.line_price_excl_tax, 
-                                                           line_price_incl_tax=line.line_price_incl_tax)
-        order_models.BatchLinePrice.objects.create(line=batch_line, quantity=line.quantity, 
-                                                   price_incl_tax=line.unit_price_incl_tax,
-                                                   price_excl_tax=line.unit_price_excl_tax)
+    def _create_line_model(self, order, batch, basket_line):
+        batch_line = order_models.BatchLine.objects.create(order=order,
+                                                           batch=batch, 
+                                                           product=basket_line.product, 
+                                                           quantity=basket_line.quantity, 
+                                                           line_price_excl_tax=basket_line.line_price_excl_tax, 
+                                                           line_price_incl_tax=basket_line.line_price_incl_tax)
+        self._create_line_price_model(batch_line, basket_line)
+        
+    def _create_line_price_model(self, batch_line, basket_line):
+        order_models.BatchLinePrice.objects.create(line=batch_line, 
+                                                   quantity=batch_line.quantity, 
+                                                   price_incl_tax=basket_line.unit_price_incl_tax,
+                                                   price_excl_tax=basket_line.unit_price_excl_tax)
     
     def _get_or_create_batch_for_line(self, order, line):
          partner = self._get_partner_for_product(line.product)

oscar/order/abstract_models.py

 from django.db import models
 from django.contrib.auth.models import User
+from django.template.defaultfilters import slugify
 from django.utils.translation import ugettext_lazy as _
 
+
+
+
 class AbstractOrder(models.Model):
     """
     An order
     Not using a line model as it's difficult to capture and payment 
     information when it splits across a line.
     """
+    order = models.ForeignKey('order.Order', related_name='lines')
     batch = models.ForeignKey('order.Batch', related_name='lines')
     product = models.ForeignKey('product.Item')
     quantity = models.PositiveIntegerField(default=1)
 
 class AbstractPaymentEventType(models.Model):
     """ 
-    Payment events are things like 'OrderPlaced', 'Acknowledged', 'Dispatched', 'Refunded'
+    Payment events are things like 'Paid', 'Failed', 'Refunded'
     """
     # Code is used in forms
     code = models.CharField(max_length=128)
     # The normal order in which these shipping events take place
     order = models.PositiveIntegerField(default=0)
     
+    def save(self, *args, **kwargs):
+        if not self.code:
+            self.code = slugify(self.name)
+        super(AbstractPaymentEventType, self).save(*args, **kwargs)
+    
     class Meta:
         abstract = True
         verbose_name_plural = _("Payment event types")
+        ordering = ('order',)
         
     def __unicode__(self):
         return self.name
         verbose_name_plural = _("Shipping events")
         
     def __unicode__(self):
-        return u"Order #%d, batch #%d, line %s: %d items %s" % (
-            self.line.batch.order.number, self.line.batch.id, self.line.line_id, self.quantity, self.event_type)
+        return u"Order #%d, line %s: %d items set to '%s'" % (
+            self.line.batch.order.number, self.line.batch.id, self.line.id, self.quantity, self.event_type)
 
 
 class AbstractShippingEventType(models.Model):
     # The normal order in which these shipping events take place
     order = models.PositiveIntegerField(default=0)
     
+    def save(self, *args, **kwargs):
+        if not self.code:
+            self.code = slugify(self.name)
+        super(AbstractShippingEventType, self).save(*args, **kwargs)
+    
     class Meta:
         abstract = True
         verbose_name_plural = _("Shipping event types")

oscar/order/admin.py

 class BatchLineAdmin(admin.ModelAdmin):
     list_display = ('batch', 'product', 'quantity')
 
+class ShippingEventTypeAdmin(admin.ModelAdmin):
+    exclude = ('code',)
+    
+class PaymentEventTypeAdmin(admin.ModelAdmin):
+    exclude = ('code',)
+
 admin.site.register(Order)
 admin.site.register(BillingAddress)
 admin.site.register(Batch, BatchAdmin)
 admin.site.register(BatchLine, BatchLineAdmin)
 admin.site.register(BatchLinePrice)
 admin.site.register(ShippingEvent)
-admin.site.register(ShippingEventType)
+admin.site.register(ShippingEventType, ShippingEventTypeAdmin)
 admin.site.register(PaymentEvent)
-admin.site.register(PaymentEventType)
+admin.site.register(PaymentEventType, PaymentEventTypeAdmin)
 admin.site.register(BatchLineAttribute)
 

oscar/order/fixtures/initial_data.json

-[{"pk": 1, "model": "order.shippingeventtype", "fields": {"code": "order_placed", "name": "Order placed", "order": 0}}, {"pk": 2, "model": "order.shippingeventtype", "fields": {"code": "dispatched", "name": "Dispatched", "order": 1}}, {"pk": 4, "model": "order.shippingeventtype", "fields": {"code": "returned", "name": "Returned", "order": 4}}, {"pk": 3, "model": "order.shippingeventtype", "fields": {"code": "cancelled", "name": "Cancelled", "order": 10}}]
+[{"pk": 1, "model": "order.shippingeventtype", "fields": {"code": "order_placed", "name": "Order placed", "order": 0}}, {"pk": 2, "model": "order.shippingeventtype", "fields": {"code": "dispatched", "name": "Dispatched", "order": 1}}, {"pk": 4, "model": "order.shippingeventtype", "fields": {"code": "returned", "name": "Returned", "order": 4}}, {"pk": 3, "model": "order.shippingeventtype", "fields": {"code": "cancelled", "name": "Cancelled", "order": 10}}, {"pk": 1, "model": "order.paymenteventtype", "fields": {"code": "paid-for", "name": "Paid for", "order": 0}}, {"pk": 2, "model": "order.paymenteventtype", "fields": {"code": "payment-failed", "name": "Payment failed", "order": 1}}, {"pk": 3, "model": "order.paymenteventtype", "fields": {"code": "refunded", "name": "Refunded", "order": 2}}]

oscar/order_management/templates/order_management/order.html

 
 {% block content %}
 
+<h3>Order contents</h3>
+<form action="{% url oscar-order-management-order order.number %}" method="post">
+{% csrf_token %}
 <table>
     <tr>
+        <th></th>
         <th>Product</th>
         <th>Availability</th>
         <th>Quantity</th>
     {% for batch in order.batches.all %}
         {% for line in batch.lines.all %}
         <tr>
+            <th><input type="checkbox" name="order_line" value="{{ line.id }}"/></th>
             <td><a href="{{ line.product.get_absolute_url }}">{{ line.description }}</a></td>
             <td>{{ line.product.stockrecord.availability }}</td>
             <td>{{ line.quantity }}</td>
         {% endfor %}
     {% endfor %}
     <tr>
-        <td colspan="3">Basket total</td>
+        <th colspan="3">Basket total</th>
         <td>{{ order.basket_total_excl_tax|floatformat:2 }}</td>
         <td>{{ order.basket_total_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
-        <td colspan="3">Shipping charge</td>
+        <th colspan="3">Shipping charge</th>
         <td>{{ order.shipping_excl_tax|floatformat:2 }}</td>
         <td>{{ order.shipping_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
-        <td colspan="4">Order total</td>
+        <th colspan="4">Order total</th>
         <td>{{ order.total_incl_tax|floatformat:2 }}</td>
     </tr>
 </table>
 
+<p>Update SHIPPING STATUS of selected lines to:
+   <select name="shipping_event">
+       <option value="">[Choose option]</option>
+       {% for type in shipping_options %}
+       <option value="{{ type.code }}">{{type.name}}</option>
+       {% endfor %}
+   </select>  
+   <input type="submit" value="Save" />
+</p>
+<p>Update PAYMENT STATUS of selected lines to:
+    <select name="payment_event">
+        <option value="">[Choose option]</option>
+        {% for type in payment_options %}
+           <option value="{{ type.code }}">{{type.name}}</option>
+        {% endfor %}
+    </select>  
+    <input type="submit" value="Save" />
+</p>
+</form>
+
+
+
 {% endblock content %}
 

oscar/order_management/urls.py

 from django.conf.urls.defaults import *
 
-from oscar.order_management.views import OrderListView, OrderDetailView
+from oscar.views import class_based_view
+from oscar.order_management.views import OrderListView, OrderView
 
 urlpatterns = patterns('oscar.order_management.views',
     url(r'^$', OrderListView.as_view(), name='oscar-order-management-list'),
-    url(r'^order/(?P<order_number>[\w-]*)$', OrderDetailView.as_view(), name='oscar-order-management-order'),
+    url(r'^order/(?P<order_number>[\w-]*)/$', class_based_view(OrderView), name='oscar-order-management-order'),
 )
 

oscar/order_management/views.py

 from django.core.paginator import Paginator, InvalidPage, EmptyPage
 from django.views.generic import ListView, DetailView
 
+from oscar.views import ModelView
 from oscar.services import import_module
-order_models = import_module('order.models', ['Order'])
+order_models = import_module('order.models', ['Order', 'BatchLine', 'ShippingEvent', 'ShippingEventType', 'PaymentEventType'])
 
 
 class OrderListView(ListView):
         return order_models.Order.objects.all()
     
     
-class OrderDetailView(DetailView):
-    """
-    View a single order.
-    """
-    context_object_name = "order"
-    template_name = "order_management/order.html"
+class OrderView(ModelView):
+    template_file = "order_management/order.html"
     
-    def get_object(self):
+    def get_model(self):
         return get_object_or_404(order_models.Order, number=self.kwargs['order_number'])
+    
+    def handle_GET(self, order):
+        shipping_options = order_models.ShippingEventType.objects.all()
+        payment_options = order_models.PaymentEventType.objects.all()
+        
+        self.response = render(self.request, self.template_file, locals())
+        
+    def handle_POST(self, order):
+        
+        self.response = HttpResponseRedirect(reverse('oscar-order-management-order', kwargs={'order_number': order.number}))
+        
+        line_ids = self.request.POST.getlist('order_line')
+        
+        # Need to determine what kind of event update this is
+        if self.request.POST['shipping_event']:
+            # Load event type obj
+            event_type = order_models.ShippingEventType.objects.get(code=self.request.POST['shipping_event'])
+            
+            # Need to load lines in a way that checks they are from the order 
+            lines = order_models.BatchLine.objects.in_bulk(line_ids)
+            for line in lines.values():
+                order_models.ShippingEvent.objects.create(line=line, quantity=line.quantity, event_type=event_type)
+        
+        
+    

oscar/views.py

 from django.template import Context, loader, RequestContext
 from django.shortcuts import render_to_response, get_object_or_404
 from django.core.urlresolvers import reverse
+from django.contrib import messages
+
 
 def class_based_view(class_obj):
     """
     return _instantiate_view_class
 
 
+class ModelView(object):
+    """
+    A generic view for models which can recieve GET and POST requests
+    
+    The __init__ method of subclasses should set the default response 
+    variable.
+    """
+    template_file = None
+    response = None
+        
+    def __call__(self, request, *args, **kwargs):
+        
+        self.request = request
+        self.args = args
+        self.kwargs = kwargs
+        
+        method_name = "handle_%s" % request.method.upper()
+        model = self.get_model()
+        getattr(self, method_name)(model)
+        
+        return self.response
+        
+    def handle_GET(self, model):
+        """
+        Default implementation of model view is to do nothing.
+        """ 
+        pass
+    
+    def handle_POST(self, model):
+        """
+        Handle a POST request to this resource.
+        
+        This will forward on request to a method of form "do_%s" where the
+        second part needs to be specified as an "action" name within the
+        request.
+        
+        If you don't want to handle POSTs this way, just override this method
+        """
+        if 'action' in self.request.POST:
+            getattr(self, "do_%s" % self.request.POST['action'].lower())(model)
+            
+    def get_model(self):
+        """
+        Responsible for loading the model that is being acted on
+        """
+        return None
+
+
 def home(request):
     """ 
     Oscar home page