Corrected bug in session keys for saving objects

oscar/apps/dashboard/offers/app.py

     benefit_view = views.OfferBenefitView
     preview_view = views.OfferPreviewView
     delete_view = views.OfferDeleteView
+    detail_view = views.OfferDetailView
 
     def get_urls(self):
         urlpatterns = patterns('',
             url(r'^(?P<pk>\d+)/preview/$', self.preview_view.as_view(update=True), name='offer-preview'),
             # Delete
             url(r'^(?P<pk>\d+)/delete/$', self.delete_view.as_view(), name='offer-delete'),
+            # Stats
+            url(r'^(?P<pk>\d+)/$', self.detail_view.as_view(), name='offer-detail'),
         )
         return self.post_process_urls(urlpatterns)
 

oscar/apps/dashboard/offers/tests.py

                                              'description': 'offers are nice',
                                              'start_date': '2012-01-01',
                                              'end_date': '2013-01-01'})
-        self.assertIsRedirect(response)
+        self.assertIsRedirect(response, reverse('dashboard:offer-condition'))
 
         # Condition
         response = self.client.post(reverse('dashboard:offer-condition'),
                                             {'range': self.range.id,
                                              'type': 'Count',
                                              'value': '3',})
-        self.assertIsRedirect(response)
+        self.assertIsRedirect(response, reverse('dashboard:offer-benefit'))
 
         # Benefit
         response = self.client.post(reverse('dashboard:offer-benefit'),
                                             {'range': self.range.id,
                                              'type': 'Multibuy',
                                              'value': '1',})
-        self.assertIsRedirect(response)
+        self.assertIsRedirect(response, reverse('dashboard:offer-preview'))
 
         # Preview
         response = self.client.post(reverse('dashboard:offer-preview'), {})
-        self.assertIsRedirect(response)
+        self.assertIsRedirect(response, reverse('dashboard:offer-list'))
 
         offers = ConditionalOffer.objects.all()
         self.assertEqual(1, len(offers))

oscar/apps/dashboard/offers/views.py

-from django.views.generic import ListView, FormView, DeleteView
+from django.views.generic import ListView, FormView, DeleteView, DetailView
 from django.db.models.loading import get_model
 from django.core.urlresolvers import reverse
 from django.contrib import messages
 
 ConditionalOffer = get_model('offer', 'ConditionalOffer')
 Condition= get_model('offer', 'Condition')
+OrderDiscount = get_model('order', 'OrderDiscount')
 Benefit = get_model('offer', 'Benefit')
 MetaDataForm, ConditionForm, BenefitForm, PreviewForm = get_classes('dashboard.offers.forms', [
     'MetaDataForm', 'ConditionForm', 'BenefitForm', 'PreviewForm'])
             return True
         return self.previous_view.is_valid(self, request)
 
+    def _key(self, step_name=None, is_object=False):
+        key = step_name if step_name else self.step_name
+        if self.update:
+            key += str(self.offer.id)
+        if is_object:
+            key += '_obj'
+        return key
+
     def _store_form_kwargs(self, form):
         session_data = self.request.session.setdefault(self.wizard_name, {})
         form_kwargs = {'data': form.cleaned_data.copy()}
-        session_data[self.step_name] = form_kwargs
+        session_data[self._key()] = form_kwargs
         self.request.session.save()
 
     def _fetch_form_kwargs(self, step_name=None):
         if not step_name:
             step_name = self.step_name
         session_data = self.request.session.setdefault(self.wizard_name, {})
-        return session_data.get(step_name, {})
+        return session_data.get(self._key(step_name), {})
 
     def _store_object(self, form):
         session_data = self.request.session.setdefault(self.wizard_name, {})
-        session_data[self.step_name + '_obj'] = form.save(commit=False)
+        session_data[self._key(is_object=True)] = form.save(commit=False)
         self.request.session.save()
 
-    def _fetch_object(self, step_name, request=None):
-        # We pass in the session as part of the checks on previous steps, as in those
-        # cases we're using an
-        if not request:
-            request = self.request
+    def _fetch_object(self, step_name):
         session_data = self.request.session.setdefault(self.wizard_name, {})
-        return session_data.get(step_name + '_obj', None)
+        return session_data.get(self._key(step_name, is_object=True), None)
 
     def _flush_session(self):
         self.request.session[self.wizard_name] = {}
     def get_success_url(self):
         messages.success(self.request, "Offer deleted!")
         return reverse('dashboard:offer-list')
+
+
+class OfferDetailView(DetailView):
+    model = ConditionalOffer
+    template_name = 'dashboard/offers/offer_detail.html'
+    context_object_name = 'offer'
+
+    def get_context_data(self, **kwargs):
+        ctx = super(OfferDetailView, self).get_context_data(**kwargs)
+        ctx['order_discounts'] = OrderDiscount.objects.filter(offer_id=self.object.id).order_by('-id')
+        return ctx

oscar/apps/offer/admin.py

 class ConditionalOfferAdmin(admin.ModelAdmin):
     list_display = ('name', 'offer_type', 'start_date', 'end_date', 'condition', 'benefit', 'total_discount')
     list_filter = ('offer_type',)
-    readonly_fields = ('total_discount',)
+    readonly_fields = ('total_discount', 'num_orders')
     fieldsets = (
         (None, {
             'fields': ('name', 'description', 'offer_type', 'condition', 'benefit', 'start_date', 'end_date', 'priority')
         }),
         ('Usage', {
-            'fields': ('total_discount',)
+            'fields': ('total_discount', 'num_orders')
         }),
     )
 

oscar/apps/offer/models.py

 
     # We track some information on usage
     total_discount = models.DecimalField(decimal_places=2, max_digits=12, default=Decimal('0.00'))
+    num_orders = models.PositiveIntegerField(default=0)
     
     date_created = models.DateTimeField(auto_now_add=True)
 
         return self._proxy_condition().is_satisfied(basket)
         
     def apply_benefit(self, basket):
-        u"""
+        """
         Applies the benefit to the given basket and returns the discount.
         """
         if not self.is_condition_satisfied(basket):
         return self._voucher        
         
     def _proxy_condition(self):
-        u"""
+        """
         Returns the appropriate proxy model for the condition
         """
         field_dict = self.condition.__dict__
         return self.condition
     
     def _proxy_benefit(self):
-        u"""
+        """
         Returns the appropriate proxy model for the condition
         """
         field_dict = self.benefit.__dict__
         elif self.benefit.type == self.benefit.FIXED_PRICE:
             return FixedPriceBenefit(**field_dict)
         return self.benefit
+
+    def record_usage(self, discount):
+        self.num_orders += 1
+        self.total_discount += discount
+        self.save()
         
 
 class Condition(models.Model):

oscar/apps/offer/receivers.py

 from django.dispatch import receiver
 from django.db.models.signals import m2m_changed, post_save
+from django.db.models import get_model
 
-from oscar.core.loading import import_module
 from oscar.apps.basket.abstract_models import AbstractBasket
-import_module('voucher.models', ['Voucher'], locals())
-import_module('order.models', ['OrderDiscount'], locals())
+Voucher = get_model('voucher', 'Voucher')
+OrderDiscount = get_model('order', 'OrderDiscount')
+ConditionalOffer = get_model('offer', 'ConditionalOffer')
+
 
 @receiver(m2m_changed)
 def receive_basket_voucher_change(sender, **kwargs):
         voucher.num_basket_additions += 1
         voucher.save()
 
+
 @receiver(post_save, sender=OrderDiscount)        
 def receive_order_discount_save(sender, instance, **kwargs):
     # Record the amount of discount against the appropriate offers
         discount.voucher.total_discount += discount.amount
         discount.voucher.save()
     if discount.offer:
-        discount.offer.total_discount += discount.amount
-        discount.offer.save()
-    
-    
-        
-    
+        discount.offer.record_usage(discount.amount)

oscar/templates/dashboard/offers/offer_delete.html

 	</table>
 
 	<div class="form-actions">
-		<button class="btn btn-primary" type="submit">Delete</button> or
+		<button class="btn btn-danger" type="submit">Delete</button> or
 		<a href="{% url dashboard:offer-list %}">cancel</a>
 	</div>
 </form>

oscar/test/__init__.py

 from django.test import TestCase
 from django.test.client import Client
 from django.contrib.auth.models import User
+from purl import URL
 
 
 @contextmanager
         self.client = Client()
         if not self.is_anonymous:
             self.user = self.create_user()
-            self.client.login(username=self.username, 
+            self.client.login(username=self.username,
                               password=self.password)
 
     def create_user(self):
         user.save()
         return user
 
-    def assertIsRedirect(self, response):
+    def assertIsRedirect(self, response, expected_url=None):
         self.assertTrue(response.status_code in (httplib.FOUND,
                                                  httplib.MOVED_PERMANENTLY))
+        if expected_url:
+            location = URL.from_string(response['Location'])
+            self.assertEqual(expected_url, location.path())
+
+
 
     def assertIsOk(self, response):
         self.assertEqual(httplib.OK, response.status_code)

testing-reqs.txt

 twill==0.9
 PyHamcrest==1.6
 South==0.7.3
+purl==0.3.2