Rewrote submit order as a class.

Split all the steps into separate methods.
Also finished removing all references to "delivery"

README.md

 
 Look in the TODO file for things to hack on...
     
-
+### Conventions
+* URLs use hyphens not underscores
 

examples/defaultshop/settings.py

     'django.middleware.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.transaction.TransactionMiddleware',
 )
 
 ROOT_URLCONF = 'urls'

oscar/address/abstract_models.py

     Core address object
     
     This is normally subclassed and extended to provide models for 
-    delivery and billing addresses.
+    shipping and billing addresses.
     """
     # @todo: Need a way of making these choice lists configurable 
     # per project
         return " ".join([part for part in [self.title, self.first_name, self.last_name] if part])
         
     def __unicode__(self):
-        parts = (self.get_salutation(), self.line1, self.line2, self.line3, self.line4,
+        parts = (self.salutation(), self.line1, self.line2, self.line3, self.line4,
                  self.postcode, self.country)
         return u", ".join([part for part in parts if part])
 
 
-class AbstractDeliveryAddress(AbstractAddress):
-    """
-    Delivery address 
+class AbstractShippingAddress(AbstractAddress):
+    u"""
+    Shipping address 
     """
     phone_number = models.CharField(max_length=32, blank=True, null=True)
     notes = models.TextField(blank=True, null=True) 
     
     class Meta:
         abstract = True
-        verbose_name_plural = "Delivery addresses"
+        verbose_name_plural = "shipping addresses"
         
         
-class AbstractUserAddress(AbstractDeliveryAddress):
-    """
+class AbstractUserAddress(AbstractShippingAddress):
+    u"""
     A user address which forms an "AddressBook".
     
-    We use a separate model to delivery and billing (even though there will be
-    some data duplication) because we don't want delivery/billing addresses changed
+    We use a separate model to shipping and billing (even though there will be
+    some data duplication) because we don't want shipping/billing addresses changed
     or deleted once an order has been placed.  By having a separate model, we allow
     users  
     """
     user = models.ForeignKey('auth.User', related_name='addresses')
-    is_primary = models.BooleanField(max_length=32, default=False)
+    
+    # We keep track of the number of times an address has been used
+    # as a shipping address so we can show the most popular ones 
+    # first at the checkout.
+    num_orders = models.PositiveIntegerField(default=0)
     hash = models.CharField(max_length=255, db_index=True)
     date_created = models.DateTimeField(auto_now_add=True)
     
     def generate_hash(self):
-        return zlib.crc32(self.summary())
-    
+        # We use an uppercase version of the summary
+        return zlib.crc32(self.summary().strip().upper())
+
     def save(self, *args, **kwargs):
         # Save a hash of the address fields so we can check whether two 
         # addresses are the same to avoid saving duplicates
     class Meta:
         abstract = True
         verbose_name_plural = "User addresses"
+        ordering = ['-num_orders']
 
 
 class AbstractBillingAddress(AbstractAddress):

oscar/basket/models.py

     pass
 
 # Example signal handler to enforce stock rules
-#@receiver(pre_save, sender=Line)
-#def handle_line_save(sender, **kwargs):
-#    if 'instance' in kwargs:
-#        quantity = int(kwargs['instance'].quantity)
-#        if quantity > 4:
-#            raise InvalidBasketLineError("You are only allowed to purchase a maximum of 4 of these")
+@receiver(pre_save, sender=Line)
+def handle_line_save(sender, **kwargs):
+    if 'instance' in kwargs:
+        quantity = int(kwargs['instance'].quantity)
+        if quantity > 4:
+            raise InvalidBasketLineError("You are only allowed to purchase a maximum of 4 of these")

oscar/basket/views.py

         try:
             super(BasketView, self).handle_POST()
         except basket_models.Basket.DoesNotExist:
-            messages.error(request, "Unable to find your basket")
+            messages.error(self.request, "Unable to find your basket")
         except basket_models.InvalidBasketLineError, e:
-            messages.error(request, str(e))
+            messages.error(self.request, str(e))
             
     def do_flush(self, basket):
         basket.flush()
         try:
             super(LineView, self).handle_POST()
         except basket_models.Basket.DoesNotExist:
-                messages.error(request, "You don't have a basket to adjust the lines of")
+                messages.error(self.request, "You don't have a basket to adjust the lines of")
         except basket_models.Line.DoesNotExist:
-            messages.error(request, "Unable to find a line with reference %s in your basket" % self.kwargs['line_reference'])
+            messages.error(self.request, "Unable to find a line with reference %s in your basket" % self.kwargs['line_reference'])
         except basket_models.InvalidBasketLineError, e:
-            messages.error(request, str(e))
+            messages.error(self.request, str(e))
             
     def _get_quantity(self):
         if 'quantity' in self.request.POST:

oscar/checkout/calculators.py

     def __init__(self, request):
         # We store a reference to the request as the total may 
         # depend on the user or the other checkout data in the session.
-        # Further, it is very likely that it will as delivery method
+        # Further, it is very likely that it will as shipping method
         # always changes the order total.
         self.request = request
     

oscar/checkout/forms.py

 
 from oscar.services import import_module
 
-order_models = import_module('order.models', ['DeliveryAddress'])
+order_models = import_module('order.models', ['ShippingAddress'])
 
 
-class DeliveryAddressForm(ModelForm):
+class ShippingAddressForm(ModelForm):
     
     class Meta:
-        model = order_models.DeliveryAddress
+        model = order_models.ShippingAddress
         exclude = ('user',)
 

oscar/checkout/templates/checkout/gateway.html

            order is viewable in your order history.</p>
     </dl>
     <dt>
-        <a href="{% url oscar-checkout-delivery-address %}">Checkout anonymously</a>
+        <a href="{% url oscar-checkout-shipping-address %}">Checkout anonymously</a>
     </dt>
     <dl>
         <p>You can checkout without signing in or registering.  You will be given the opportunity to 

oscar/checkout/templates/checkout/preview.html

 
 {% block content %}
 
-<h3>Delivery address</h3>
+<h3>Shipping address</h3>
 <hr />
 <table>
     <tr>
         <th>Address</th>
         <td>
-            {% for field in delivery_addr.active_address_fields %}
+            {% for field in shipping_addr.active_address_fields %}
             {{ field }}<br/>
             {% endfor %}
         </td>
     </tr>
-    {% if delivery_addr.phone_number %}
+    {% if shipping_addr.phone_number %}
     <tr>
         <th>Concact number</th>
-        <td>delivery_addr.phone_number</td>
+        <td>shipping_addr.phone_number</td>
     </tr>
     {% endif %}
-    {% if delivery_addr.notes %}
+    {% if shipping_addr.notes %}
     <tr>
-        <th>Delivery notes</th>
-        <td>delivery_addr.notes</td>
+        <th>Shipping notes</th>
+        <td>shipping_addr.notes</td>
     </tr>
     {% endif %} 
 </table>
-<a href="{% url oscar-checkout-delivery-address %}">Change delivery address</a>
+<a href="{% url oscar-checkout-shipping-address %}">Change shipping address</a>
 
-<h3>Delivery method</h3>
+<h3>Shipping method</h3>
 <hr />
 
 <h3>Payment</h3>
         <td>{{ basket.total_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
-        <td colspan="5">Delivery charge</td>
-        <td>{{ delivery_total_excl_tax|floatformat:2 }}</td>
-        <td>{{ delivery_total_incl_tax|floatformat:2 }}</td>
+        <td colspan="5">Shipping charge</td>
+        <td>{{ shipping_total_excl_tax|floatformat:2 }}</td>
+        <td>{{ shipping_total_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
         <td colspan="6">Order total</td>

oscar/checkout/templates/checkout/delivery_address.html → oscar/checkout/templates/checkout/shipping_address.html

 
 
 {% block content %}
-<h3>Delivery address</h3>
+<h3>Shipping address</h3>
 <hr />
 
 {% if addresses %}
-<h4>Choose a delivery address</h4>
+<h4>Choose a shipping address</h4>
 <ul>
     {% for address in addresses %}
     <li>
     {{ address.summary }}
-        <form action="{% url oscar-checkout-delivery-address %}" method="post">
+        <form action="{% url oscar-checkout-shipping-address %}" method="post">
             {% csrf_token %}
-            <input type="hidden" name="action" value="deliver_to" />
+            <input type="hidden" name="action" value="ship_to" />
             <input type="hidden" name="address_id" value="{{ address.id }}" />
-            <input type="submit" value="Delivery to this address" />
+            <input type="submit" value="Ship to this address" />
         </form>
-        <form action="{% url oscar-checkout-delivery-address %}" method="post">
+        <form action="{% url oscar-checkout-shipping-address %}" method="post">
             {% csrf_token %}
             <input type="hidden" name="action" value="delete" />
             <input type="hidden" name="address_id" value="{{ address.id }}" />
 </form>
 {% endif %}
     
-<h4>Enter a delivery address</h4>
-<form action="{% url oscar-checkout-delivery-address %}" method="post">
+<h4>Enter a shipping address</h4>
+<form action="{% url oscar-checkout-shipping-address %}" method="post">
     {% csrf_token %}
     {{ form.as_p }}
-    <p><label><input type="checkbox" id="save_as_default" name="save_as_default"/>Save as default delivery address</label></p>
-    <p><input type="submit" value="Save delivery address" /></p>
+    <p><input type="submit" value="Save shipping address" /></p>
 </form>
 
-<h3>Delivery method</h3>
+<h3>Shipping method</h3>
 <hr />
 
 <h3>Payment</h3>
         <td>{{ basket.total_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
-        <td colspan="5">Delivery charge</td>
-        <td>{{ delivery_total_excl_tax|floatformat:2 }}</td>
-        <td>{{ delivery_total_incl_tax|floatformat:2 }}</td>
+        <td colspan="5">shipping charge</td>
+        <td>{{ shipping_total_excl_tax|floatformat:2 }}</td>
+        <td>{{ shipping_total_incl_tax|floatformat:2 }}</td>
     </tr>
     <tr>
         <td colspan="6">Order total</td>

oscar/checkout/urls.py

 from django.conf.urls.defaults import *
 
+from oscar.checkout.views import SubmitView
+
+def submit_view(request, *args, **kwargs):
+    return SubmitView()(request, *args, **kwargs)
+
 urlpatterns = patterns('oscar.checkout.views',
     url(r'^$', 'index', name='oscar-checkout-index'),
-    url(r'delivery_address/$', 'delivery_address', name='oscar-checkout-delivery-address'),
-    url(r'delivery_method/$', 'delivery_method', name='oscar-checkout-delivery-method'),
+    url(r'shipping-address/$', 'shipping_address', name='oscar-checkout-shipping-address'),
+    url(r'shipping-method/$', 'shipping_method', name='oscar-checkout-shipping-method'),
     url(r'payment/$', 'payment', name='oscar-checkout-payment'),
     url(r'preview/$', 'preview', name='oscar-checkout-preview'),
-    url(r'submit/$', 'submit', name='oscar-checkout-submit'),
-    url(r'thank_you/$', 'thank_you', name='oscar-checkout-thank-you'),
+    url(r'submit/$', submit_view, name='oscar-checkout-submit'),
+    url(r'thank-you/$', 'thank_you', name='oscar-checkout-thank-you'),
 )
 

oscar/checkout/utils.py

     """
     
     # List of URL names that have to be completed (in this order)
-    urls_for_steps = ['oscar-checkout-delivery-address',
-                      'oscar-checkout-delivery-method',
+    urls_for_steps = ['oscar-checkout-shipping-address',
+                      'oscar-checkout-shipping-method',
                       'oscar-checkout-payment',
                       'oscar-checkout-preview',
                       'oscar-checkout-submit',]

oscar/checkout/views.py

 
 basket_factory = import_module('basket.factory', ['get_or_create_open_basket', 'get_open_basket', 
                                                   'get_or_create_saved_basket', 'get_saved_basket'])
-checkout_forms = import_module('checkout.forms', ['DeliveryAddressForm'])
+checkout_forms = import_module('checkout.forms', ['ShippingAddressForm'])
 checkout_calculators = import_module('checkout.calculators', ['OrderTotalCalculator'])
 checkout_utils = import_module('checkout.utils', ['ProgressChecker'])
-order_models = import_module('order.models', ['DeliveryAddress', 'Order'])
+order_models = import_module('order.models', ['ShippingAddress', 'Order', 'Batch', 'BatchLine', 'BatchLinePrice'])
 address_models = import_module('address.models', ['UserAddress'])
 
 class CheckoutSessionData(object):
     def flush(self):
         self.request.session[self.session_key] = {}
         
-    # Delivery methods    
+    # Shipping methods    
         
-    def deliver_to_user_address(self, address):
-        self._set('delivery', 'user_address_id', address.id)
-        self._unset('delivery', 'new_address_fields')
-        self._unset('delivery', 'is_default')
+    def ship_to_user_address(self, address):
+        self._set('shipping', 'user_address_id', address.id)
+        self._unset('shipping', 'new_address_fields')
+        self._unset('shipping', 'is_default')
         
-    def deliver_to_new_address(self, address_fields, is_default=False):
-        self._set('delivery', 'new_address_fields', address_fields)
-        self._set('delivery', 'is_default', is_default)
-        self._unset('delivery', 'user_address_id')
+    def ship_to_new_address(self, address_fields, is_default=False):
+        self._set('shipping', 'new_address_fields', address_fields)
+        self._set('shipping', 'is_default', is_default)
+        self._unset('shipping', 'user_address_id')
         
     def new_address_fields(self):
-        return self._get('delivery', 'new_address_fields')
+        return self._get('shipping', 'new_address_fields')
         
     def user_address_id(self):
-        return self._get('delivery', 'user_address_id')
-    
-    def should_new_address_be_default(self):
-        return self._get('delivery', 'is_default') == True
+        return self._get('shipping', 'user_address_id')
         
 
 def prev_steps_must_be_complete(view_fn):
     Need to check here if the user is ready to start the checkout
     """
     if request.user.is_authenticated():
-        return HttpResponseRedirect(reverse('oscar-checkout-delivery-address'))
+        return HttpResponseRedirect(reverse('oscar-checkout-shipping-address'))
     return render(request, 'checkout/gateway.html', locals())
 
 @basket_required
-def delivery_address(request):
+def shipping_address(request):
     """
-    Handle the selection of a delivery address.
+    Handle the selection of a shipping address.
     """
     co_data = CheckoutSessionData(request)
     if request.method == 'POST':
         if request.user.is_authenticated and 'address_id' in request.POST:
             address = address_models.UserAddress.objects.get(pk=request.POST['address_id'])
-            if 'action' in request.POST and request.POST['action'] == 'deliver_to':
-                # User has selected a previous address to deliver to
-                co_data.deliver_to_user_address(address)
+            if 'action' in request.POST and request.POST['action'] == 'ship_to':
+                # User has selected a previous address to ship to
+                co_data.ship_to_user_address(address)
                 mark_step_as_complete(request)
-                return HttpResponseRedirect(reverse('oscar-checkout-delivery-method'))
+                return HttpResponseRedirect(reverse('oscar-checkout-shipping-method'))
             elif 'action' in request.POST and request.POST['action'] == 'delete':
                 address.delete()
                 messages.info(request, "Address deleted from your address book")
-                return HttpResponseRedirect(reverse('oscar-checkout-delivery-method'))
+                return HttpResponseRedirect(reverse('oscar-checkout-shipping-method'))
         else:
-            form = checkout_forms.DeliveryAddressForm(request.POST)
+            form = checkout_forms.ShippingAddressForm(request.POST)
             if form.is_valid():
                 # Address data is valid - store in session and redirect to next step.
                 is_default = False
                 if 'save_as_default' in request.POST and request.POST['save_as_default'] == 'on':
                     is_default = True
-                co_data.deliver_to_new_address(form.clean(), is_default)
+                co_data.ship_to_new_address(form.clean(), is_default)
                 mark_step_as_complete(request)
-                return HttpResponseRedirect(reverse('oscar-checkout-delivery-method'))
+                return HttpResponseRedirect(reverse('oscar-checkout-shipping-method'))
     else:
         addr_fields = co_data.new_address_fields()
         if addr_fields:
-            form = checkout_forms.DeliveryAddressForm(addr_fields)
+            form = checkout_forms.ShippingAddressForm(addr_fields)
         else:
-            form = checkout_forms.DeliveryAddressForm()
+            form = checkout_forms.ShippingAddressForm()
     
     # Add in extra template bindings
     basket = basket_factory.get_open_basket(request)
     calc = checkout_calculators.OrderTotalCalculator(request)
     order_total = calc.order_total_incl_tax(basket)
-    delivery_total_excl_tax = 0
-    delivery_total_incl_tax = 0
+    shipping_total_excl_tax = 0
+    shipping_total_incl_tax = 0
     
     # Look up address book data
     if request.user.is_authenticated():
         addresses = address_models.UserAddress.objects.filter(user=request.user)
     
-    return render(request, 'checkout/delivery_address.html', locals())
+    return render(request, 'checkout/shipping_address.html', locals())
     
     
 @prev_steps_must_be_complete    
-def delivery_method(request):
+def shipping_method(request):
     """
-    Delivery methods are domain-specific and so need implementing in a 
+    Shipping methods are domain-specific and so need implementing in a 
     subclass of this class.
     """
     mark_step_as_complete(request)
     # Load address data into a blank address model
     addr_data = co_data.new_address_fields()
     if addr_data:
-        delivery_addr = order_models.DeliveryAddress(**addr_data)
+        shipping_addr = order_models.ShippingAddress(**addr_data)
     addr_id = co_data.user_address_id()
     if addr_id:
-        delivery_addr = address_models.UserAddress.objects.get(pk=addr_id)
+        shipping_addr = address_models.UserAddress.objects.get(pk=addr_id)
     
     # Calculate order total
     calc = checkout_calculators.OrderTotalCalculator(request)
     mark_step_as_complete(request)
     return render(request, 'checkout/preview.html', locals())
 
-@prev_steps_must_be_complete
-def submit(request):
-    """
-    Do several things then redirect to the thank-you page
-    """
-    co_data = CheckoutSessionData(request)
+
+class SubmitView(object):
     
-    # Save the address data
-    addr_data = co_data.new_address_fields()
-    if addr_data:
-        # A new delivery address has been entered
-        delivery_addr = order_models.DeliveryAddress(**addr_data)
-        delivery_addr.save()
+    def __call__(self, request):
+        
+        # Set up the instance variables that are needed to place an order
+        self.request = request
+        self.co_data = CheckoutSessionData(request)
+        self.basket = basket_factory.get_open_basket(request)
+        
+        # All the heavy lifting happens here
+        self._place_order()
+        
+        # Now, reset the states of the basket and checkout 
+        self.basket.set_as_submitted()
+        self.co_data.flush()
+        checkout_utils.ProgressChecker().all_steps_complete(request)
+        
+        # @todo Save order id in session so thank-you page can load it
+        
+        return HttpResponseRedirect(reverse('oscar-checkout-thank-you'))
+        
+    def _place_order(self):
+        order = self._create_order_model()
+        for line in self.basket.lines.all():
+            batch = self._get_or_create_batch_for_line(order, line)
+            self._create_line_model(order, batch, line)
+        
+    def _create_order_model(self):
+        calc = checkout_calculators.OrderTotalCalculator(self.request)
+        order_data = {'basket': self.basket,
+                      'total_incl_tax': calc.order_total_incl_tax(self.basket),
+                      'total_excl_tax': calc.order_total_excl_tax(self.basket),
+                      'shipping_incl_tax': 0,
+                      'shipping_excl_tax': 0,}
+        if self.request.user.is_authenticated():
+            order_data['user_id'] = self.request.user.id
+        order = order_models.Order(**order_data)
+        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 _get_or_create_batch_for_line(self, order, line):
+         partner = self._get_partner_for_product(line.product)
+         shipping_addr = self._get_shipping_address_for_line(line)
+         batch,_ = order_models.Batch.objects.get_or_create(order=order, partner=partner, shipping_address=shipping_addr)
+         return batch
+                
+    def _get_partner_for_product(self, product):
+        if product.has_stockrecord:
+            return product.stockrecord.partner
+        raise AttributeError("No partner found for product '%s'" % product)
+
+    def _get_shipping_address_for_line(self, line):
+        try:
+            addr = self.shipping_addr
+        except AttributeError:
+            # No cached version - create a shipping address
+            addr_data = self.co_data.new_address_fields()
+            addr_id = self.co_data.user_address_id()
+            if addr_data:
+                addr = self._create_shipping_address_from_form_fields(addr_data)
+                self._create_user_address(addr_data)
+            elif addr_id:
+                addr = self._create_shipping_address_from_user_address(addr_id)
+            else:
+                raise AttributeError("No shipping address data found")
+            
+            # Cache it as our default behaviour is to have only one
+            # shipping address per order.
+            self.shipping_addr = addr
+        return addr
+            
         
-        # Save a new user address
-        if request.user.is_authenticated():
-            addr_data['user_id'] = request.user.id
+    def _create_shipping_address_from_form_fields(self, addr_data):
+        shipping_addr = order_models.ShippingAddress(**addr_data)
+        shipping_addr.save() 
+        return shipping_addr
+    
+    def _create_user_address(self, addr_data):
+        """
+        For signed-in users, we create a user address model which will go 
+        into their address book.
+        """
+        if self.request.user.is_authenticated():
+            addr_data['user_id'] = self.request.user.id
             user_addr = address_models.UserAddress(**addr_data)
-            # Check that this address isn't already in the db
+            # Check that this address isn't already in the db as we don't want
+            # to fill up the customer address book with duplicate addresses
             try:
                 duplicate_addr = address_models.UserAddress.objects.get(hash=user_addr.generate_hash())
             except ObjectDoesNotExist:
-                if co_data.should_new_address_be_default():
-                    user_addr.is_primary = True 
                 user_addr.save()
-            
-    addr_id = co_data.user_address_id()
-    if addr_id:
-        # A previously used address has been selected.  We need to convert it
-        # to a delivery address and save it
-        address = address_models.UserAddress.objects.get(pk=addr_id)
-        delivery_addr = order_models.DeliveryAddress()
-        address.populate_alternative_model(delivery_addr)
-        delivery_addr.save()
     
-    # Save the order model
-    calc = checkout_calculators.OrderTotalCalculator(request)
-    basket = basket_factory.get_open_basket(request)
-    order_data = {'basket': basket,
-                  'total_incl_tax': calc.order_total_incl_tax(basket),
-                  'total_excl_tax': calc.order_total_excl_tax(basket),
-                  'shipping_incl_tax': 0,
-                  'shipping_excl_tax': 0,}
-    if request.user.is_authenticated():
-        order_data['user_id'] = request.user.id
-    order = order_models.Order(**order_data).save()
-    
-    # @todo set basket as submitted
-    basket.set_as_submitted()
-    
-    # @todo unset all session data
-    co_data.flush()
-    
-    # @todo Save order id in session so thank-you page can load it
-    checkout_utils.ProgressChecker().all_steps_complete(request)
-    return HttpResponseRedirect(reverse('oscar-checkout-thank-you'))
+    def _create_shipping_address_from_user_address(self, addr_id):
+        address = address_models.UserAddress.objects.get(pk=addr_id)
+        # Increment the number of orders to help determine popularity of orders 
+        address.num_orders += 1
+        address.save()
+        
+        shipping_addr = order_models.ShippingAddress()
+        address.populate_alternative_model(shipping_addr)
+        shipping_addr.save()
+        return shipping_addr
 
 
 def thank_you(request):
-    return render(request, 'checkout/thank_you.html', locals())
+    return render(request, 'checkout/thank_you.html', locals())

oscar/order/abstract_models.py

     def __unicode__(self):
         return "#%d (customer: %s, amount: %.2f)" % (self.number, self.customer.username, self.total_incl_tax)
 
+
 class AbstractBatch(models.Model):
     """
     A batch of items from a single fulfillment partner
     """
     order = models.ForeignKey('order.Order')
     partner = models.ForeignKey('stock.Partner')
-    delivery_method = models.CharField(_("Delivery method"), max_length=128)
-    # Not all batches are actually delivered (such as downloads)
-    delivery_address = models.ForeignKey('order.DeliveryAddress', null=True, blank=True)
-    # Whether the batch should be dispatched in one go, or as they become available
-    dispatch_option = models.CharField(_("Dispatch option"), max_length=128, null=True, blank=True)
+    # Not all batches are actually shipped (such as downloads)
+    shipping_address = models.ForeignKey('order.ShippingAddress', null=True, blank=True)
+    shipping_method = models.CharField(_("Shipping method"), max_length=128, null=True, blank=True)
     
     def get_num_items(self):
         return len(self.lines.all())
     def __unicode__(self):
         return "%s batch for order #%d" % (self.partner.name, self.order.number)
         
+        
 class AbstractBatchLine(models.Model):
     """
     A line within a batch.
     quantity = models.PositiveIntegerField(default=1)
     price_incl_tax = models.DecimalField(decimal_places=2, max_digits=12)
     price_excl_tax = models.DecimalField(decimal_places=2, max_digits=12)
-    delivery_incl_tax = models.DecimalField(decimal_places=2, max_digits=12, default=0)
-    delivery_excl_tax = models.DecimalField(decimal_places=2, max_digits=12, default=0)
+    shipping_incl_tax = models.DecimalField(decimal_places=2, max_digits=12, default=0)
+    shipping_excl_tax = models.DecimalField(decimal_places=2, max_digits=12, default=0)
     
     class Meta:
         abstract = True

oscar/order/admin.py

 from oscar.order.models import *
 
 class BatchAdmin(admin.ModelAdmin):
-    list_display = ('order', 'partner', 'get_num_items', 'delivery_method')
+    list_display = ('order', 'partner', 'get_num_items', 'shipping_method')
 
 class BatchLineAdmin(admin.ModelAdmin):
     list_display = ('batch', 'product', 'quantity')
 admin.site.register(Order)
 admin.site.register(BillingAddress)
 admin.site.register(Batch, BatchAdmin)
-admin.site.register(DeliveryAddress)
+admin.site.register(ShippingAddress)
 admin.site.register(BatchLine, BatchLineAdmin)
 admin.site.register(BatchLinePrice)
 admin.site.register(BatchLineEvent)

oscar/order/models.py

 from django.db import models
 
 from oscar.order.abstract_models import *
-from oscar.address.abstract_models import AbstractAddress, AbstractDeliveryAddress, AbstractBillingAddress
+from oscar.address.abstract_models import AbstractAddress, AbstractShippingAddress, AbstractBillingAddress
 
 class Order(AbstractOrder):
     pass
 class Batch(AbstractBatch):
     pass
 
-class DeliveryAddress(AbstractDeliveryAddress):
+class ShippingAddress(AbstractShippingAddress):
     pass
 
 class BillingAddress(AbstractBillingAddress):

oscar/order/tests.py

 from oscar.basket.models import Basket
 from oscar.order.models import *
 
-class DeliveryAddressTest(unittest.TestCase):
+class ShippingAddressTest(unittest.TestCase):
     
     def setUp(self):
         pass
     
     def test_titleless_salutation_is_stripped(self):
-        a = DeliveryAddress.objects.create(last_name='Barrington', line1="75 Smith Road", postcode="N4 8TY")
+        a = ShippingAddress.objects.create(last_name='Barrington', line1="75 Smith Road", postcode="N4 8TY")
         self.assertEquals("Barrington", a.get_salutation())
     
         

oscar/services.py

                 # Passing classes to __import__ here does not actually filter out the 
                 # classes, we need to iterate through and assign them individually.
                 mod = new_module(real_app)
-                print real_app
                 imported_mod = __import__(real_app, fromlist=classes)
                 for classname in classes:
                     mod.__setattr__(classname, getattr(imported_mod, classname))