Merge branch 'master' into offer-proxy-models

Conflicts:
	docs/source/index.rst
	oscar/order/utils.py

docs/source/contributing.rst

 * Pull requests will be rejected if sufficient tests aren't provided
 * Please updated the documentation when altering behaviour or introducing new features 
 
-Coding conventions
-------------------
-
-* Follow the Django conventions (http://docs.djangoproject.com/en/dev/internals/contributing/#coding-style)
-* PEP8 (http://www.python.org/dev/peps/pep-0008/)
-* PEP257 (http://www.python.org/dev/peps/pep-0257/)
 
 Contents:
 
 
    contributing/installation
    contributing/testing
+   contributing/conventions

docs/source/contributing/conventions.rst

+===========
+Conventions
+===========
+
+Coding conventions
+------------------
+
+* Follow the Django conventions (http://docs.djangoproject.com/en/dev/internals/contributing/#coding-style)
+* PEP8 (http://www.python.org/dev/peps/pep-0008/)
+* PEP257 (http://www.python.org/dev/peps/pep-0257/)
+
+General guidelines
+------------------
+
+The following are a set of design conventions that should be followed when
+writing apps for oscar:
+
+* When referencing managers of model classes, use ``_default_manager`` rather than
+  ``objects``.  This allows projects to override the default manager to provide
+  domain-specific behaviour.
+
+

docs/source/getting_started/installation.rst

     ./manage.py syncdb
 
 However, in reality you will need to start extending the models to match your domain.  It's best to do
-this before creating your initial schema.
+this before creating your initial schema.
+
+Configure urls
+--------------
+
+Oscar comes with a number of urls and views out of the box.  These are
+recommendations rather than a requirement but you easily use them in your
+e-commerce site by adding the oscar urls to your projects local ``urls.py``
+
+    (r'^', include('oscar.urls')),
+
+This will bring in all of oscar's defined urls. Of course you can pull in the
+urls for the individual apps if you prefer or simply define your own

docs/source/index.rst

    web_services
    recipes
    contributing
-   settings
+   reference
 
 Indices and tables
 ==================

docs/source/reference.rst

+=========
+Reference
+=========
+
+Contents:
+
+.. toctree::
+   :maxdepth: 2
+
+   reference/settings

docs/source/reference/settings.rst

+=======================
+Oscar specific settings
+=======================
+
+Oscar provides a number of configurable settings used to confugre the system.
+
+.. contents::
+    :local:
+    :depth: 1
+
+Available settings
+==================
+
+OSCAR_DEFAULT_CURRENCY
+----------------------
+
+Default: None (This is a required field)
+
+This should be the symbol of the currency you wish Oscar to use by default.
+
+OSCAR_BASKET_COOKIE_LIFETIME
+----------------------------
+
+Default: 604800 (1 week in seconds)
+
+The time to live for the basket cookie in seconds
+
+Deprecated settings
+===================
+
+There are currently no deprecated settings in oscar

docs/source/settings.rst

-Settings
-========
-
-The following settings can be configured in your `settings.py`:
-
-* `OSCAR_DEFAULT_CURRENCY` - The default currency for all price fields within models
-* `OSCAR_BASKET_COOKIE_LIFETIME` - The lifespan of a basket cookie in seconds - defaults to a week.

oscar/checkout/core_views.py

+from django.http import HttpResponse, Http404, HttpResponseRedirect, HttpResponseBadRequest
+from django.contrib import messages
+from django.core.urlresolvers import reverse
+
+from oscar.services import import_module
+basket_factory = import_module('basket.factory', ['BasketFactory'])
+checkout_calculators = import_module('checkout.calculators', ['OrderTotalCalculator'])
+order_models = import_module('order.models', ['Order', 'ShippingAddress'])
+checkout_utils = import_module('checkout.utils', ['ProgressChecker', 'CheckoutSessionData'])
+address_models = import_module('address.models', ['UserAddress'])
+
+def prev_steps_must_be_complete(view_fn):
+    u"""
+    Decorator fn for checking that previous steps of the checkout
+    are complete.
+    
+    The completed steps (identified by URL-names) are stored in the session.
+    If this fails, then we redirect to the next uncompleted step.
+    """
+    def _view_wrapper(self, request, *args, **kwargs):
+        checker = checkout_utils.ProgressChecker()
+        if not checker.are_previous_steps_complete(request):
+            messages.error(request, "You must complete this step of the checkout first")
+            url_name = checker.get_next_step(request)
+            return HttpResponseRedirect(reverse(url_name))
+        return view_fn(self, request, *args, **kwargs)
+    return _view_wrapper
+
+def basket_required(view_fn):
+    def _view_wrapper(self, request, *args, **kwargs):
+        basket = basket_factory.BasketFactory().get_open_basket(request)
+        if not basket:
+            messages.error(request, "You must add some products to your basket before checking out")
+            return HttpResponseRedirect(reverse('oscar-basket'))
+        return view_fn(self, request, *args, **kwargs)
+    return _view_wrapper
+
+def mark_step_as_complete(request):
+    u""" 
+    Convenience function for marking a checkout page
+    as complete.
+    """
+    checkout_utils.ProgressChecker().step_complete(request)
+    
+def mark_step_as_complete(request):
+    u""" 
+    Convenience function for marking a checkout page
+    as complete.
+    """
+    checkout_utils.ProgressChecker().step_complete(request)
+    
+def get_next_step(request):
+    return checkout_utils.ProgressChecker().get_next_step(request)    
+    
+
+class CheckoutView(object):
+    u"""
+    Top-level superclass for all checkout view classes
+    """
+    
+    def __init__(self, template_file=None):
+        if template_file:
+            self.template_file = template_file
+        
+    @basket_required
+    @prev_steps_must_be_complete
+    def __call__(self, request):
+        u"""
+        We forward request handling to the appropriate method
+        based on the HTTP method.
+        """
+        
+        # Set up the instance variables that are needed to place an order
+        self.request = request
+        self.co_data = checkout_utils.CheckoutSessionData(request)
+        self.basket = basket_factory.BasketFactory().get_open_basket(self.request)
+        
+        # Set up template context that is available to every view
+        method = self.co_data.shipping_method()
+        if method:
+            method.set_basket(self.basket)
+        
+        self.context = {'basket': self.basket,
+                        'order_total': self.get_order_total(method),
+                        'shipping_addr': self.get_shipping_address()}
+        self.set_shipping_context(method)
+        self.set_payment_context()
+        
+        if request.method == 'POST':
+            response = self.handle_POST()
+        elif request.method == 'GET':
+            response = self.handle_GET()
+        else:
+            response = HttpResponseBadRequest()
+        return response
+    
+    def set_shipping_context(self, method):
+        if method:
+            self.context['method'] = method
+            self.context['shipping_total_excl_tax'] = method.basket_charge_excl_tax()
+            self.context['shipping_total_incl_tax'] = method.basket_charge_incl_tax()
+            
+    def set_payment_context(self):
+        method = self.co_data.payment_method()
+        if method:
+            self.context['payment_method'] = method
+    
+    def handle_GET(self):
+        u"""
+        Default behaviour is to set step as complete and redirect
+        to the next step.
+        """ 
+        return self.get_success_response()
+    
+    def get_order_total(self, shipping_method):
+        calc = checkout_calculators.OrderTotalCalculator(self.request)
+        return calc.order_total_incl_tax(self.basket, shipping_method)
+    
+    def get_shipping_address(self):
+        # Load address data into a blank address model
+        addr_data = self.co_data.new_address_fields()
+        if addr_data:
+            return order_models.ShippingAddress(**addr_data)
+        addr_id = self.co_data.user_address_id()
+        if addr_id:
+            return address_models.UserAddress._default_manager.get(pk=addr_id)
+        return None
+    
+    def get_success_response(self):
+        u"""
+        Returns the appropriate redirect response if a checkout
+        step has been successfully passed.
+        """
+        mark_step_as_complete(self.request)
+        return HttpResponseRedirect(reverse(get_next_step(self.request)))
+    
+    def handle_POST(self):
+        pass

oscar/checkout/forms.py

         self.set_country_queryset() 
         
     def set_country_queryset(self):    
-        self.fields['country'].queryset = address_models.Country.objects.filter(is_shipping_country=True)
+        self.fields['country'].queryset = address_models.Country._default_manager.filter(is_shipping_country=True)
     
     class Meta:
         model = order_models.ShippingAddress

oscar/checkout/views.py

 checkout_calculators = import_module('checkout.calculators', ['OrderTotalCalculator'])
 checkout_utils = import_module('checkout.utils', ['ProgressChecker', 'CheckoutSessionData'])
 checkout_signals = import_module('checkout.signals', ['order_placed', 'pre_payment', 'post_payment'])
+checkout_views = import_module('checkout.core_views', ['CheckoutView', 'mark_step_as_complete'])
 order_models = import_module('order.models', ['Order', 'ShippingAddress'])
 order_utils = import_module('order.utils', ['OrderNumberGenerator', 'OrderCreator'])
 address_models = import_module('address.models', ['UserAddress'])
 shipping_repository = import_module('shipping.repository', ['Repository'])
 
-def prev_steps_must_be_complete(view_fn):
-    u"""
-    Decorator fn for checking that previous steps of the checkout
-    are complete.
-    
-    The completed steps (identified by URL-names) are stored in the session.
-    If this fails, then we redirect to the next uncompleted step.
-    """
-    def _view_wrapper(self, request, *args, **kwargs):
-        checker = checkout_utils.ProgressChecker()
-        if not checker.are_previous_steps_complete(request):
-            messages.error(request, "You must complete this step of the checkout first")
-            url_name = checker.get_next_step(request)
-            assert False
-            return HttpResponseRedirect(reverse(url_name))
-        return view_fn(self, request, *args, **kwargs)
-    return _view_wrapper
-
-def basket_required(view_fn):
-    def _view_wrapper(self, request, *args, **kwargs):
-        basket = basket_factory.BasketFactory().get_open_basket(request)
-        if not basket:
-            messages.error(request, "You must add some products to your basket before checking out")
-            return HttpResponseRedirect(reverse('oscar-basket'))
-        return view_fn(self, request, *args, **kwargs)
-    return _view_wrapper
-
-def mark_step_as_complete(request):
-    u""" 
-    Convenience function for marking a checkout page
-    as complete.
-    """
-    checkout_utils.ProgressChecker().step_complete(request)
-    
-def get_next_step(request):
-    return checkout_utils.ProgressChecker().get_next_step(request)
-
-
-class CheckoutView(object):
-    u"""
-    Top-level superclass for all checkout view classes
-    """
-    
-    def __init__(self, template_file=None):
-        if template_file:
-            self.template_file = template_file
-        
-    @basket_required
-    @prev_steps_must_be_complete
-    def __call__(self, request):
-        u"""
-        We forward request handling to the appropriate method
-        based on the HTTP method.
-        """
-        
-        # Set up the instance variables that are needed to place an order
-        self.request = request
-        self.co_data = checkout_utils.CheckoutSessionData(request)
-        self.basket = basket_factory.BasketFactory().get_open_basket(self.request)
-        
-        # Set up template context that is available to every view
-        self.context = {'basket': self.basket,
-                        'order_total': self.get_order_total(),
-                        'shipping_addr': self.get_shipping_address()}
-        self.set_shipping_context()
-        self.set_payment_context()
-        
-        if request.method == 'POST':
-            response = self.handle_POST()
-        elif request.method == 'GET':
-            response = self.handle_GET()
-        else:
-            response = HttpResponseBadRequest()
-        return response
-    
-    def set_shipping_context(self):
-        method = self.co_data.shipping_method()
-        if method:
-            method.set_basket(self.basket)
-            self.context['method'] = method
-            self.context['shipping_total_excl_tax'] = method.basket_charge_excl_tax()
-            self.context['shipping_total_incl_tax'] = method.basket_charge_incl_tax()
-            
-    def set_payment_context(self):
-        method = self.co_data.payment_method()
-        if method:
-            self.context['payment_method'] = method
-    
-    def handle_GET(self):
-        u"""
-        Default behaviour is to set step as complete and redirect
-        to the next step.
-        """ 
-        return self.get_success_response()
-    
-    def get_order_total(self):
-        calc = checkout_calculators.OrderTotalCalculator(self.request)
-        return calc.order_total_incl_tax(self.basket)
-    
-    def get_shipping_address(self):
-        # Load address data into a blank address model
-        addr_data = self.co_data.new_address_fields()
-        if addr_data:
-            return order_models.ShippingAddress(**addr_data)
-        addr_id = self.co_data.user_address_id()
-        if addr_id:
-            return address_models.UserAddress.objects.get(pk=addr_id)
-        return None
-    
-    def get_success_response(self):
-        u"""
-        Returns the appropriate redirect response if a checkout
-        step has been successfully passed.
-        """
-        mark_step_as_complete(self.request)
-        return HttpResponseRedirect(reverse(get_next_step(self.request)))
-    
-    def handle_POST(self):
-        pass
-
 
 class IndexView(object):
     template_file = 'checkout/gateway.html'
         return render(request, self.template_file, locals())    
 
 
-class ShippingAddressView(CheckoutView):
+class ShippingAddressView(checkout_views.CheckoutView):
     template_file = 'checkout/shipping_address.html'
     
     def handle_POST(self):
         if self.request.user.is_authenticated and 'address_id' in self.request.POST:
-            address = address_models.UserAddress.objects.get(pk=self.request.POST['address_id'])
+            address = address_models.UserAddress._default_manager.get(pk=self.request.POST['address_id'])
             if 'action' in self.request.POST and self.request.POST['action'] == 'ship_to':
                 # User has selected a previous address to ship to
                 self.co_data.ship_to_user_address(address)
     
         # Look up address book data
         if self.request.user.is_authenticated():
-            self.context['addresses'] = address_models.UserAddress.objects.filter(user=self.request.user)
+            self.context['addresses'] = address_models.UserAddress._default_manager.filter(user=self.request.user)
         
         return render(self.request, self.template_file, self.context)
     
     
-class ShippingMethodView(CheckoutView):
+class ShippingMethodView(checkout_views.CheckoutView):
     u"""
     Shipping methods are domain-specific and so need implementing in a 
     subclass of this class.
         return self.get_success_response()
         
 
-class PaymentMethodView(CheckoutView):
+class PaymentMethodView(checkout_views.CheckoutView):
     u"""
     View for a user to choose which payment method(s) they want to use.
     
     pass
 
 
-class OrderPreviewView(CheckoutView):
+class OrderPreviewView(checkout_views.CheckoutView):
     u"""View a preview of the order before submitting."""
     
     template_file = 'checkout/preview.html'
     
     def handle_GET(self):
-        mark_step_as_complete(self.request)
+        checkout_views.mark_step_as_complete(self.request)
         return render(self.request, self.template_file, self.context)
 
 
-class PaymentDetailsView(CheckoutView):
+class PaymentDetailsView(checkout_views.CheckoutView):
     u"""
     For taking the details of payment and creating the order
     
             # 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())
+                duplicate_addr = address_models.UserAddress._default_manager.get(hash=user_addr.generate_hash())
             except ObjectDoesNotExist:
                 user_addr.save()
     
     def _create_shipping_address_from_user_address(self, addr_id):
         u"""Creates a shipping address from a user address"""
-        address = address_models.UserAddress.objects.get(pk=addr_id)
+        address = address_models.UserAddress._default_manager.get(pk=addr_id)
         # Increment the number of orders to help determine popularity of orders 
         address.num_orders += 1
         address.save()
     
     def __call__(self, request):
         try:
-            order = order_models.Order.objects.get(pk=request.session['checkout_order_id'])
+            order = order_models.Order._default_manager.get(pk=request.session['checkout_order_id'])
             
             # Remove order number from session to ensure that the thank-you page is only 
             # viewable once.

oscar/customer/views.py

 def profile(request):
     u"""Return a customers's profile"""
     # Load last 5 orders as preview
-    orders = order_models.Order.objects.filter(user=request.user)[0:5]
+    orders = order_models.Order._default_manager.filter(user=request.user)[0:5]
     return render(request, 'customer/profile.html', locals())
     
         
 
     def get_queryset(self):
         u"""Return a customer's orders"""
-        return order_models.Order.objects.filter(user=self.request.user)
+        return order_models.Order._default_manager.filter(user=self.request.user)
 
 
 class OrderDetailView(ModelView):
         
     def get_queryset(self):
         u"""Return a customer's addresses"""
-        return address_models.UserAddress.objects.filter(user=self.request.user)
+        return address_models.UserAddress._default_manager.filter(user=self.request.user)
     
     
 class AddressView(ModelView):

oscar/order/abstract_models.py

     information when it splits across a line.
     """
     order = models.ForeignKey('order.Order', related_name='lines')
+    
+    # We store the partner and their SKU for cases where the product has been
+    # deleted from the catalogue.
     partner = models.ForeignKey('stock.Partner', related_name='order_lines')
-    product = models.ForeignKey('product.Item')
+    partner_reference = models.CharField(_("Partner reference"), max_length=128, blank=True, null=True)
+    
+    # We don't want any hard links between orders and the products table
+    product = models.ForeignKey('product.Item', on_delete=models.SET_NULL, null=True)
     quantity = models.PositiveIntegerField(default=1)
+    
     # Price information (these fields are actually redundant as the information
     # can be calculated from the LinePrice models
     line_price_incl_tax = models.DecimalField(decimal_places=2, max_digits=12)
     line_price_excl_tax = models.DecimalField(decimal_places=2, max_digits=12)
     
+    # Cost price (the price charged by the fulfilment partner for this product).  This
+    # is useful for audit and financial reporting.
+    cost_price = models.DecimalField(decimal_places=2, max_digits=12, blank=True, null=True)
+    
     # Partner information
-    partner_reference = models.CharField(_("Partner reference"), max_length=128, blank=True, null=True,
+    partner_line_reference = models.CharField(_("Partner reference"), max_length=128, blank=True, null=True,
         help_text=_("This is the item number that the partner uses within their system"))
-    partner_notes = models.TextField(blank=True, null=True)
+    partner_line_notes = models.TextField(blank=True, null=True)
     
     @property
     def description(self):
 
     def _check_previous_events_are_complete(self):
         u"""Checks whether previous shipping events have passed"""
-        previous_events = ShippingEventQuantity.objects.filter(line=self.line, 
-                                                               event__event_type__sequence_number__lt=self.event.event_type.sequence_number)
+        previous_events = ShippingEventQuantity._default_manager.filter(line=self.line, 
+                                                                        event__event_type__sequence_number__lt=self.event.event_type.sequence_number)
         self.quantity = int(self.quantity)
         for event_quantities in previous_events:
             if event_quantities.quantity < self.quantity:
                 raise ValueError("Invalid quantity (%d) for event type (a previous event has not been fully passed)" % self.quantity)
 
     def _check_new_quantity(self):
-        quantity_row = ShippingEventQuantity.objects.filter(line=self.line, 
-                                                            event__event_type=self.event.event_type).aggregate(Sum('quantity'))
+        quantity_row = ShippingEventQuantity._default_manager.filter(line=self.line, 
+                                                                     event__event_type=self.event.event_type).aggregate(Sum('quantity'))
         previous_quantity = quantity_row['quantity__sum']
         if previous_quantity == None:
             previous_quantity = 0

oscar/order/fixtures/sample-order.json

         "model": "order.line", 
         "fields": {
 			"partner": 1,
-            "partner_notes": null, 
+            "partner_line_notes": null, 
             "product": 8, 
             "line_price_excl_tax": "69.90", 
             "partner_reference": null, 
         "model": "order.line", 
         "fields": {
 			"partner": 1,
-            "partner_notes": null, 
+            "partner_line_notes": null, 
             "product": 9, 
             "line_price_excl_tax": "68.80", 
             "partner_reference": null, 

oscar/order/utils.py

         calc = self.order_total_calculator
         order_data = {'basket': basket,
                       'number': order_number,
-                      'site': Site.objects.get_current(),
+                      'site': Site._default_manager.get_current(),
                       'total_incl_tax': calc.order_total_incl_tax(basket, shipping_method),
                       'total_excl_tax': calc.order_total_excl_tax(basket, shipping_method),
                       'shipping_address': shipping_address,
     
     def _create_line_models(self, order, basket_line):
         u"""Creates the batch line model."""
-        order_line = order_models.Line.objects.create(order=order,
-                                                      partner=self._get_partner_for_product(basket_line.product),
-                                                      product=basket_line.product, 
-                                                      quantity=basket_line.quantity, 
-                                                      line_price_excl_tax=basket_line.line_price_excl_tax_and_discounts, 
-                                                      line_price_incl_tax=basket_line.line_price_incl_tax_and_discounts)
+        order_line = order_models.Line(order=order,
+                                      partner=self._get_partner_for_product(basket_line.product),
+                                      product=basket_line.product, 
+                                      quantity=basket_line.quantity, 
+                                      line_price_excl_tax=basket_line.line_price_excl_tax_and_discounts, 
+                                      line_price_incl_tax=basket_line.line_price_incl_tax_and_discounts)
+        if basket_line.product.has_stockrecord:
+            order_line.partner_reference = basket_line.product.stockrecord.partner_reference
+        order_line.save()
         self._create_line_price_models(order, order_line, basket_line)
         self._create_line_attributes(order, order_line, basket_line)
         
         u"""Creates the batch line price models"""
         breakdown = basket_line.get_price_breakdown()
         for price_incl_tax, price_excl_tax, quantity in breakdown:
-            order_models.LinePrice.objects.create(order=order,
+            order_models.LinePrice._default_manager.create(order=order,
                                                   line=order_line, 
                                                   quantity=quantity, 
                                                   price_incl_tax=price_incl_tax,
     def _create_line_attributes(self, order, order_line, basket_line):
         u"""Creates the batch line attributes."""
         for attr in basket_line.attributes.all():
-            order_models.LineAttribute.objects.create(line=order_line, type=attr.option.code,
+            order_models.LineAttribute._default_manager.create(line=order_line, type=attr.option.code,
                                                       value=attr.value)

oscar/order_management/views.py

     paginate_by = 20
 
     def get_queryset(self):
-        return order_models.Order.objects.all()
+        return order_models.Order._default_manager.all()
     
   
 class OrderView(ModelView):
         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()
+        shipping_options = order_models.ShippingEventType._default_manager.all()
+        payment_options = order_models.PaymentEventType._default_manager.all()
         
         self.response = render(self.request, self.template_file, locals())
         
     def create_shipping_event(self, order, lines):
         u"""Create a shipping event for an order"""
         with transaction.commit_on_success():
-            event_type = order_models.ShippingEventType.objects.get(code=self.request.POST['shipping_event'])
-            event = order_models.ShippingEvent.objects.create(order=order, event_type=event_type)
+            event_type = order_models.ShippingEventType._default_manager.get(code=self.request.POST['shipping_event'])
+            event = order_models.ShippingEvent._default_manager.create(order=order, event_type=event_type)
             for line in lines:
                 try:
                     event_quantity = int(self.request.POST['order_line_quantity_%d' % line.id])
                 except KeyError:
                     event_quantity = line.quantity
-                order_models.ShippingEventQuantity.objects.create(event=event, line=line, 
+                order_models.ShippingEventQuantity._default_manager.create(event=event, line=line, 
                                                                   quantity=event_quantity)
             
     def create_payment_event(self, order, lines, type_code):
         u"""Create a payment event for an order"""
-        event_type = order_models.PaymentEventType.objects.get(code=type_code)
+        event_type = order_models.PaymentEventType._default_manager.get(code=type_code)
         for line in lines.values():
-            order_models.PaymentEvent.objects.create(order=order, line=line, 
+            order_models.PaymentEvent._default_manager.create(order=order, line=line, 
                                                      quantity=line.quantity, event_type=event_type)
             
     def do_add_note(self, order):
             message = self.request.POST['message'].strip()
             if message:
                 messages.info(self.request, "Message added")
-                order_models.OrderNote.objects.create(order=order, message=self.request.POST['message'],
+                order_models.OrderNote._default_manager.create(order=order, message=self.request.POST['message'],
                                                          user=self.request.user)
             else:
                 messages.info(self.request, "Please enter a message")

oscar/payment/abstract_models.py

     
     
 class AbstractSourceType(models.Model):
-    u"""A type of payment source (eg Bankcard, Business account, Gift card)"""
+    u"""
+    A type of payment source.
+    
+    This could be an external partner like PayPal or DataCash,
+    or an internal source such as a managed account.i
+    """
     name = models.CharField(max_length=128)
     code = models.SlugField(max_length=128, help_text="""This is used within
         forms to identify this source type""")

oscar/payment/forms.py

         self.set_country_queryset() 
         
     def set_country_queryset(self):    
-        self.fields['country'].queryset = address_models.Country.objects.all()
+        self.fields['country'].queryset = address_models.Country._default_manager.all()
     
     class Meta:
         model = order_models.BillingAddress

oscar/product/abstract_models.py

 
 class AbstractAttributeType(models.Model):
     u"""Defines an attribute. (Eg. size)"""
-    code = models.CharField(_('code'), max_length=128)
     name = models.CharField(_('name'), max_length=128)
+    code = models.SlugField(_('code'), max_length=128)
     has_choices = models.BooleanField(default=False)
 
     class Meta:
 
 class AbstractItemAttributeValue(models.Model):
     u"""
-    A specific attribute value for an item.
+    The "through" model for the m2m relationship between product.Item
+    and product.AttributeType.  This specifies the value of the attribute
+    for a particular product.
     
     Eg: size = L
     """

oscar/product/admin.py

     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]
+    
+class AttributeTypeAdmin(admin.ModelAdmin):
+    prepopulated_fields = {"code": ("name",)}
 
 admin.site.register(product_models.ItemClass, ItemClassAdmin)
 admin.site.register(product_models.Item, ItemAdmin)
-admin.site.register(product_models.AttributeType)
+admin.site.register(product_models.AttributeType, AttributeTypeAdmin)
 admin.site.register(product_models.ItemAttributeValue)
 admin.site.register(product_models.Option)

oscar/shipping/repository.py

         this behaviour can easily be overridden by subclassing this class
         and overriding this method.
         """ 
-        methods = shipping_models.OrderAndItemLevelChargeMethod.objects.all()
+        methods = shipping_models.OrderAndItemLevelChargeMethod._default_manager.all()
         if not methods.count():
             return [FreeShipping()]
         
         """
         if code == FreeShipping.code:
             return FreeShipping()
-        return shipping_models.OrderAndItemLevelChargeMethod.objects.get(code=code)          
+        return shipping_models.OrderAndItemLevelChargeMethod._default_manager.get(code=code)          

oscar/stock/abstract_models.py

     # This is the base price for calculations
     price_excl_tax = models.DecimalField(decimal_places=2, max_digits=12)
     
+    # Cost price is optional as not all partner supply it
+    cost_price = models.DecimalField(decimal_places=2, max_digits=12, blank=True, null=True)
+    
     # Stock level information
     num_in_stock = models.IntegerField(default=0)
     num_allocated = models.IntegerField(default=0)

oscar/utils.py

     Helper method for creating products that are used in 
     tests.
     """
-    ic,_ = ItemClass.objects.get_or_create(name="Dummy item class")
-    item = Item.objects.create(title="Dummy product", item_class=ic)
+    ic,_ = ItemClass._default_manager.get_or_create(name="Dummy item class")
+    item = Item._default_manager.create(title="Dummy product", item_class=ic)
     if price:
-        partner,_ = Partner.objects.get_or_create(name="Dummy partner")
-        sr = StockRecord.objects.create(product=item, partner=partner, price_excl_tax=price)
+        partner,_ = Partner._default_manager.get_or_create(name="Dummy partner")
+        sr = StockRecord._default_manager.create(product=item, partner=partner, price_excl_tax=price)
     return item