Merge branch 'master' of git://github.com/tangentlabs/django-oscar

oscar/apps/address/abstract_models.py

         (MS, _("Ms")),
         (DR, _("Dr")),
     )
-    title = models.CharField(_("Title"), max_length=64, choices=TITLE_CHOICES, blank=True)
-    first_name = models.CharField(_("First name"), max_length=255, blank=True)
-    last_name = models.CharField(_("Last name"), max_length=255)
+    title = models.CharField(_("Title"), max_length=64, choices=TITLE_CHOICES, blank=True, null=True)
+    first_name = models.CharField(_("First name"), max_length=255, blank=True, null=True)
+    last_name = models.CharField(_("Last name"), max_length=255, blank=True)
     
     # We use quite a few lines of an address as they are often quite long and 
     # it's easier to just hide the unnecessary ones than add extra ones.
     line1 = models.CharField(_("First line of address"), max_length=255)
-    line2 = models.CharField(_("Second line of address"), max_length=255, blank=True)
-    line3 = models.CharField(_("Third line of address"), max_length=255, blank=True)
-    line4 = models.CharField(_("City"), max_length=255, blank=True)
-    state = models.CharField(_("State/County"), max_length=255, blank=True)
+    line2 = models.CharField(_("Second line of address"), max_length=255, blank=True, null=True)
+    line3 = models.CharField(_("Third line of address"), max_length=255, blank=True, null=True)
+    line4 = models.CharField(_("City"), max_length=255, blank=True, null=True)
+    state = models.CharField(_("State/County"), max_length=255, blank=True, null=True)
     postcode = models.CharField(_("Post/Zip-code"), max_length=64)
     country = models.ForeignKey('address.Country')
     
         """
         Clean up fields
         """
-        self.first_name = self.first_name.strip()
         for field in ['first_name', 'last_name', 'line1', 'line2', 'line3', 'line4', 'postcode']:
-            self.__dict__[field] = self.__dict__[field].strip()
+            if self.__dict__[field]:
+               self.__dict__[field] = self.__dict__[field].strip()
         
         # Ensure postcodes are always uppercase
         if self.postcode:

oscar/apps/catalogue/abstract_models.py

     def get_absolute_url(self):
         u"""Return a product's absolute url"""
         return ('catalogue:detail', (), {
-            'item_slug': self.slug,
+            'product_slug': self.slug,
             'pk': self.id})
     
     def save(self, *args, **kwargs):

oscar/apps/catalogue/admin.py

     
 class OptionAdmin(admin.ModelAdmin):
     exclude = ['code']
+    
+class ProductAttributeValueAdmin(admin.ModelAdmin):
+    list_display = ('product', 'type', 'value')
+    
 
 admin.site.register(product_models.ProductClass, ProductClassAdmin)
 admin.site.register(product_models.Product, ProductAdmin)
 admin.site.register(product_models.AttributeType, AttributeTypeAdmin)
-admin.site.register(product_models.ProductAttributeValue)
+admin.site.register(product_models.ProductAttributeValue, ProductAttributeValueAdmin)
 admin.site.register(product_models.Option, OptionAdmin)
 admin.site.register(product_models.ProductImage)
 admin.site.register(product_models.Category)

oscar/apps/catalogue/app.py

         urlpatterns = super(BaseCatalogueApplication, self).get_urls()        
         urlpatterns += patterns('',
             url(r'^$', self.index_view.as_view(), name='index'),       
-            url(r'^(?P<item_slug>[\w-]*)-(?P<pk>\d+)/$', self.detail_view.as_view(), name='detail'),
+            url(r'^(?P<product_slug>[\w-]*)-(?P<pk>\d+)/$', self.detail_view.as_view(), name='detail'),
             url(r'^(?P<category_slug>[\w-]+(/[\w-]+)*)/$', self.category_view.as_view(), name='category')
         )
         return urlpatterns
     def get_urls(self):
         urlpatterns = super(ReviewsApplication, self).get_urls()
         urlpatterns += patterns('',
-            url(r'^(?P<item_slug>[\w-]*)-(?P<item_pk>\d+)/reviews/', include(self.reviews_app.urls)),
+            url(r'^(?P<product_slug>[\w-]*)-(?P<product_pk>\d+)/reviews/', include(self.reviews_app.urls)),
         )
         return urlpatterns
 

oscar/apps/catalogue/reviews/abstract_models.py

     @models.permalink
     def get_absolute_url(self):
         return ('products:reviews-detail', (), {
-            'item_slug': self.product.slug,
-            'item_pk': self.product.id,
+            'product_slug': self.product.slug,
+            'product_pk': self.product.id,
             'pk': self.id})
 
     def __unicode__(self):

oscar/apps/catalogue/reviews/tests.py

         username = str(randint(0, maxint))
         self.user = User.objects.create_user(username, '%s@users.com'%username, '%spass123'%username)
         self.anon_user = AnonymousUser()
-        self.item = create_product()
-        self.review = ProductReview.objects.create(product=self.item,
+        self.product = create_product()
+        self.review = ProductReview.objects.create(product=self.product,
                                                    title="Dummy review",
                                                    score=3,
                                                    user=self.user)
 
     def test_top_level_reviews_must_have_titles_and_scores(self):
-        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.item,
+        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.product,
                           user=self.user)
 
     def test_top_level_anonymous_reviews_must_have_names_and_emails(self):
-        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.item,
+        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.product,
                           user=None, title="Anonymous review", score=3)
 
 
         self.client = Client()
         super(SingleProductReviewViewTest, self).setUp()
         self.kwargs = {
-                'item_slug': self.item.slug,
-                'pk': str(self.item.id)}
+                'product_slug': self.product.slug,
+                'pk': str(self.product.id)}
         
     def test_each_product_has_review(self):
         url = reverse('catalogue:detail', kwargs=self.kwargs)
     
     def test_user_can_add_product_review(self):
         kwargs = {
-                'item_slug': self.item.slug,
-                'item_pk': str(self.item.id)}
+                'product_slug': self.product.slug,
+                'product_pk': str(self.product.id)}
         url = reverse('catalogue:reviews-add', kwargs=kwargs)
         self.client.login(username='testuser', password='secret')
         response = self.client.get(url)

oscar/apps/catalogue/reviews/views.py

     
     def get_context_data(self, **kwargs):
         context = super(CreateProductReview, self).get_context_data(**kwargs)
-        context['item'] = self.get_product()
+        context['product'] = self.get_product()
         return context
     
     def get_product(self):
-        return get_object_or_404(self.product_model, pk=self.kwargs['item_pk'])
+        return get_object_or_404(self.product_model, pk=self.kwargs['product_pk'])
     
     def get_form_class(self):
         if not self.request.user.is_authenticated():
     template_name = "reviews/add_review_complete.html"
     context_object_name = 'review'
     model = get_model('reviews', 'productreview')
-    product_model = get_model('product', 'item')
+    product_model = get_model('catalogue', 'product')
     
     def get_context_data(self, **kwargs):
         context = super(CreateProductReviewComplete, self).get_context_data(**kwargs)
-        context['item'] = get_object_or_404(self.product_model, pk=self.kwargs['item_pk'])
+        context['product'] = get_object_or_404(self.product_model, pk=self.kwargs['product_pk'])
         return context    
 
 
     template_name = "reviews/review.html"
     context_object_name = 'review'
     model = get_model('reviews', 'productreview')
-    product_model = get_model('product', 'item')
+    product_model = get_model('catalogue', 'product')
     vote_model = vote_model
     
     def get_context_data(self, **kwargs):
         context = super(ProductReviewDetail, self).get_context_data(**kwargs)
-        context['item'] = get_object_or_404(self.product_model, pk=self.kwargs['item_pk'])
+        context['product'] = get_object_or_404(self.product_model, pk=self.kwargs['product_pk'])
         return context
     
     def post(self, request, *args, **kwargs ):
     template_name = 'reviews/reviews.html'
     context_object_name = "reviews"
     model = get_model('reviews', 'productreview')
-    product_model = get_model('product', 'item')    
+    product_model = get_model('catalogue', 'product')    
     paginate_by = 20
      
     def get_queryset(self):
-        qs = self.model.approved.filter(product=self.kwargs['item_pk'])
+        qs = self.model.approved.filter(product=self.kwargs['product_pk'])
         if 'sort_by' in self.request.GET and self.request.GET['sort_by'] == 'score':
             return qs.order_by('-score')
         return qs.order_by('-date_created')
      
     def get_context_data(self, **kwargs):
         context = super(ProductReviewList, self).get_context_data(**kwargs)
-        context['item'] = get_object_or_404(self.product_model, pk=self.kwargs['item_pk'])  
+        context['product'] = get_object_or_404(self.product_model, pk=self.kwargs['product_pk'])  
         context['avg_score'] = self.object_list.aggregate(Avg('score'))           
         return context

oscar/apps/catalogue/tests.py

         
     def test_canonical_urls_are_enforced(self):
         p = Product.objects.get(id=1)
-        args = {'item_slug': 'wrong-slug',
+        args = {'product_slug': 'wrong-slug',
                 'pk': p.id}
         wrong_url = reverse('catalogue:detail', kwargs=args)
         response = self.client.get(wrong_url)
-        self.assertEquals(301, response.status_code)
+        self.assertEquals(301, response.status_code)

oscar/apps/checkout/views.py

                 basket = self.request.basket
             method.set_basket(basket)
         else:
+            # We default to using free shipping
             method = FreeShipping()
         return method
     
     def get_object(self):
         # We allow superusers to force an order thankyou page for testing
         order = None
-        if self.request.user.is_superuser():
+        if self.request.user.is_superuser:
             if 'order_number' in self.request.GET:
                 order = Order._default_manager.get(number=self.request.GET['order_number'])
             elif 'order_id' in self.request.GET:

oscar/apps/order/abstract_models.py

 
 
 class AbstractOrderNote(models.Model):
-    u"""A note against an order."""
+    """
+    A note against an order.
+    
+    This are often used for audit purposes too.  IE, whenever an admin
+    makes a change to an order, we create a note to record what happened.
+    """
     order = models.ForeignKey('order.Order', related_name="notes")
-    user = models.ForeignKey('auth.User')
+    
+    # These are sometimes programatically generated so don't need a 
+    # user everytime
+    user = models.ForeignKey('auth.User', null=True)
+    
+    # We allow notes to be classified although this isn't always needed
+    note_type = models.CharField(max_length=128, null=True)
+    
     message = models.TextField()
     date = models.DateTimeField(auto_now_add=True)
     

oscar/apps/partner/abstract_models.py

         """
         return get_partner_wrapper(self.partner.name).is_available_to_buy(self)
     
+    @property
+    def net_stock_level(self):
+        """
+        Return the effective number in stock
+        """ 
+        return self.num_in_stock - self.num_allocated
+    
     @property
     def availability(self):
         u"""Return an item's availability as a string"""

oscar/apps/payment/abstract_models.py

     source will have its own entry.
     """
     order = models.ForeignKey('order.Order', related_name='sources')
-    type = models.ForeignKey('payment.SourceType')
+    source_type = models.ForeignKey('payment.SourceType')
     currency = models.CharField(max_length=12, default=settings.OSCAR_DEFAULT_CURRENCY)
     amount_allocated = models.DecimalField(decimal_places=2, max_digits=12)
     amount_debited = models.DecimalField(decimal_places=2, max_digits=12, default=Decimal('0.00'))

oscar/apps/payment/admin.py

 models = import_module('payment.models', ['Source', 'Transaction', 'SourceType'])
 
 class SourceAdmin(admin.ModelAdmin):
-    list_display = ('order', 'type', 'amount_allocated', 'amount_debited', 'balance', 'reference')
+    list_display = ('order', 'source_type', 'amount_allocated', 'amount_debited', 'balance', 'reference')
+
 
 admin.site.register(models.Source, SourceAdmin)
 admin.site.register(models.SourceType)

oscar/apps/payment/models.py

 from oscar.apps.payment.abstract_models import *
 
+
 class Source(AbstractSource):
     pass
 
+
 class SourceType(AbstractSourceType):
     pass
 
+
 class Transaction(AbstractTransaction):
     pass
 
+
 class Bankcard(AbstractBankcard):
     pass
 

oscar/apps/promotions/context_processors.py

     by position, and write these lists to the context dict.
     """
     for linked_promotion in linked_promotions:
+        if not linked_promotion.content_object:
+            continue
         key = 'promotions_%s' % linked_promotion.position.lower()
         if key not in context:
             context[key] = []

oscar/apps/promotions/models.py

     _type = 'Multi-image'
     name = models.CharField(_("Name"), max_length=128)
     images = models.ManyToManyField('promotions.Image', null=True, blank=True)
+    date_created = models.DateTimeField(auto_now_add=True)
     
     def __unicode__(self):
         return self.name

oscar/forms/fields.py

 from django.db import models
 from django.http import Http404
 
+
 class ExtendedURLField(models.CharField):
     u"""
     Custom field similar to URLField type field, however also accepting