def handle_billingshipping_forms(self, js_enabled, update_only, shipping_adress_form, billing_address_form):
     all_valid = False
     
     billingshipping_form = \
         self.get_billing_and_shipping_selection_form()
     if billingshipping_form.is_valid():
         self.request.session['payment_backend'] = \
             billingshipping_form.cleaned_data['payment_method']
         self.request.session['shipping_backend'] = \
             billingshipping_form.cleaned_data['shipping_method']
             
     shipping_choices_form = False
     payment_choices_form = False
                         
     if billingshipping_form.is_valid():            
         shipping_method = billingshipping_form.cleaned_data['shipping_method']
         payment_method = billingshipping_form.cleaned_data['payment_method']
         
         if self.request.method == 'POST' and js_enabled:
             items = get_or_create_cart(self.request).items.all()
             shipping_choices_form = self.get_backend_choices_form('shipping', shipping_method, items,
                 shipping_adress_form, billing_address_form)         
             payment_choices_form = self.get_backend_choices_form('payment', payment_method, items,
                 shipping_adress_form, billing_address_form)         
             if not update_only:
                 if shipping_choices_form:
                     if shipping_choices_form.is_valid():
                         self.request.session['shipping_choices'] = shipping_choices_form.cleaned_data
                 if payment_choices_form:
                     if payment_choices_form.is_valid():
                         self.request.session['payment_choices'] = payment_choices_form.cleaned_data
                     
     return (billingshipping_form, shipping_choices_form, payment_choices_form)

    def get_context_data(self, **kwargs):
        ctx = super(ShopTemplateView, self).get_context_data(**kwargs)

        # Set the order status:
        order = get_order_from_request(self.request)

        
        if order:
            order.status = Order.COMPLETED
            order.save()
            
        else:
            order = Order.objects.get_latest_for_user(self.request.user)
            #TODO: Is this ever the case?
        ctx.update({'order': order, })
        
        # TODO: move away from shop!!
        # ctx.update({'downloads': [1], })

        
        completed.send(sender=self, order=order)

        # Empty the customers basket, to reflect that the purchase was
        # completed
        cart_object = get_or_create_cart(self.request)
        cart_object.empty()

        return ctx

 def test_03_passing_user_returns_proper_cart(self):
     self.cart.user = self.user
     self.cart.save()
     setattr(self.request, 'user', self.user)
     ret = get_or_create_cart(self.request)
     self.assertNotEqual(ret, None)
     self.assertEqual(ret, self.cart)

 def add_product_to_cart(self):
     product = DiaryProduct(isbn='1234567890', number_of_pages=100, name='test',
         slug='test', active=True, unit_price=Decimal('1.23'))
     product.save()
     self.cart = get_or_create_cart(self.request, True)
     self.cart.add_product(product, 1)
     self.cart.save()

 def get_context(self, context):
     cart = get_or_create_cart(context['request'])
     cart.update()
     return {
         'cart': cart,
         'cart_items': cart.get_updated_cart_items()
     }

 def get_context_data(self, **kwargs):
     context = {'object_list': []}
     cart = get_or_create_cart(self.request, True)
     context['object_list'] = CartModifierCode.objects.filter(cart=cart)
     context.update(kwargs)
     return super(CartModifierCodeCreateView, self).\
         get_context_data(**context)

 def get_context(self, context):
     request = context['request']
     cart = get_or_create_cart(request)
     cart.update(request)
     return {
         'cart': cart
     }

 def delete(self, *args, **kwargs):
     """
     Empty shopping cart.
     """
     cart_object = get_or_create_cart(self.request)
     cart_object.empty()
     return self.delete_success()

def cart(context):
    """Inclusion tag for displaying cart summary."""
    request = context['request']
    cart = get_or_create_cart(request)
    cart.update(request)
    return {
        'cart': cart
    }

 def test_having_two_empty_carts_returns_database_cart(self):
     setattr(self.request, 'user', self.user)
     setattr(self.request, 'session', {'cart_id': self.cart.pk})
     database_cart = Cart.objects.create(user=self.user)
     ret = get_or_create_cart(self.request)
     self.assertNotEqual(ret, None)
     self.assertEqual(ret, database_cart)
     self.assertNotEqual(ret, self.cart)

 def get_context_data(self, **kwargs):
     # There is no get_context_data on super(), we inherit from the mixin!
     ctx = {}
     cart = get_or_create_cart(self.request)
     cart.update(self.request)
     ctx.update({'cart': cart})
     ctx.update({'cart_items': cart.get_updated_cart_items()})
     return ctx

    def render_tag(self, context):
        cart = get_or_create_cart(context['request'])
        cart.update()
        context['cart'] = cart
        context['cart_items': cart.get_updated_cart_items()]
        formset = get_cart_item_formset(cart_items=context['cart_items'])
        context['formset': formset]

        return ''

 def success(self):
     """
     Generic hook by default redirects to cart
     """
     if self.request.is_ajax():
         cart_object = get_or_create_cart(self.request)
         return HttpResponse(json.dumps({"success": True, "cart": cart_object.total_quantity}))
     else:
         return HttpResponseRedirect(reverse("cart"))

 def add_to_cart(self):
     variation = self.get_variation()
     product_quantity = self.request.POST.get('add_item_quantity')
     if not product_quantity:
         product_quantity = 1
     product = self.get_object()
     cart = get_or_create_cart(self.request)
     cart.add_product(product, product_quantity, variation)
     cart.save()

    def render(self, context, instance, placeholder):
        request = context['request']
        cart = get_or_create_cart(request)
        cart_items = cart.items
        
        context.update({'cart':cart})
        context.update({'cart_items':cart_items})

        return context

 def create_order_object_from_cart(self):
     """
     This will create an Order object form the current cart, and will pass
     a reference to the Order on either the User object or the session.
     """
     cart = get_or_create_cart(self.request)
     order = Order.objects.create_from_cart(cart)
     request = self.request
     add_order_to_request(request, order)

    def post(self, *args, **kwargs):
        #it starts similar to the original post method
        product_id = self.request.POST['add_item_id']
        product_quantity = self.request.POST.get('add_item_quantity')
        if not product_quantity:
            product_quantity = 1
        product = Product.objects.get(pk=product_id)
        cart_object = get_or_create_cart(self.request)

        #now we need to find out which options have been chosen by the user
        option_ids = []
        text_option_ids = {} # A dict of {TextOption.id:CartItemTextOption.text}
        for key in self.request.POST.keys():
            if key.startswith('add_item_option_group_'):
                option_ids.append(self.request.POST[key])
            elif key.startswith('add_item_text_option_'):
                id = key.split('add_item_text_option_')[1]
                text_option_ids.update({id:self.request.POST[key]})

        #now we need to find out if there are any cart items that have the exact
        #same set of options
        qs = CartItem.objects.filter(cart=cart_object).filter(product=product)
        found_cartitem_id = None
        merge = False
        for cartitem in qs:
            # for each CartItem in the Cart, get it's options and text options
            cartitemoptions = CartItemOption.objects.filter(
                cartitem=cartitem, option__in=option_ids
                )

            cartitemtxtoptions = CartItemTextOption.objects.filter(
                text_option__in=text_option_ids.keys(),
                text__in=text_option_ids.values()
                )

            if (len(cartitemoptions) + len(cartitemtxtoptions)
                == (len(option_ids) + len(text_option_ids))):
                found_cartitem_id = cartitem.id
                merge = True
                break

        #if we found a CartItem object that has the same options, we need
        #to select this one instead of just any CartItem that belongs to this
        #cart and this product.
        if found_cartitem_id:
            qs = CartItem.objects.filter(pk=found_cartitem_id)

        cart_item = cart_object.add_product(
            product, product_quantity, merge=merge, queryset=qs)
        if isinstance(product, Cigarette):
            try:
                cart_object.add_product(product.cartridge, 0)
                for accessory in product.accessories.all():
                    cart_object.add_product(accessory, 0)
            except Cartridge.DoesNotExist, AttributeError:
                pass

    def post(self, request, id, *args, **kwargs):
        split_template = get_object_or_404(SplitTemplate, id=id)        
        split_form = UserSplitForm(split_template, request.POST)

        # Make sure we empty the cart
        cart = get_or_create_cart(request, save=True)
        cart.delete()
        cart = get_or_create_cart(request, save=True)        
        
        if split_form.is_valid():
            for key, product_qtty in split_form.cleaned_data.iteritems():
                if key.startswith('product_'):
                    product_id = key.lstrip('product_')
                    product = get_object_or_404(Product, id=product_id)
                    cart.add_product(product, product_qtty)

        cart.save()

        return redirect(reverse('cart'))

 def test_having_empty_session_cart_and_filled_database_cart_returns_database_cart(self):
     setattr(self.request, 'user', self.user)
     setattr(self.request, 'session', {'cart_id': self.cart.pk})
     database_cart = Cart.objects.create(user=self.user)
     product = Product.objects.create(name='pizza', slug='pizza', unit_price=0)
     CartItem.objects.create(cart=database_cart, quantity=1, product=product)
     ret = get_or_create_cart(self.request)
     self.assertNotEqual(ret, None)
     self.assertEqual(ret, database_cart)
     self.assertNotEqual(ret, self.cart)

    def post(self, *args, **kwargs):
        #it starts similar to the original post method
        product_id = self.request.POST['add_item_id']
        product_quantity = self.request.POST.get('add_item_quantity')
        if not product_quantity:
            product_quantity = 1
        product = Product.objects.get(pk=product_id)
        cart_object = get_or_create_cart(self.request, save=True)

        #now we need to find out which options have been chosen by the user
        option_ids = []
        text_option_ids = {} # A dict of {TextOption.id:CartItemTextOption.text}
        for key in self.request.POST.keys():
            if key.startswith('add_item_option_group_'):
                option_ids.append(self.request.POST[key])
            elif key.startswith('add_item_text_option_'):
                id = key.split('add_item_text_option_')[1]
                txt = self.request.POST[key]
                if txt != '':
                    text_option_ids.update({id:txt})
                    
        #now we need to find out if there are any cart items that have the exact
        #same set of options
        qs = CartItem.objects.filter(cart=cart_object).filter(product=product)
        found_cartitem_id = None
        merge = False
        
        # TODO: Something funky happening with the merged qs preventing new 
        # carts from being created. We can live with separate line items for now...
        # for cartitem in qs:
        #             # for each CartItem in the Cart, get it's options and text options
        #             cartitemoptions = CartItemOption.objects.filter(
        #                 cartitem=cartitem, option__in=option_ids
        #                 )
        #                 
        #             cartitemtxtoptions = CartItemTextOption.objects.filter(
        #                 text_option__in=text_option_ids.keys(),
        #                 text__in=text_option_ids.values()
        #                 )
        #             
        #             if len(cartitemoptions) + len(cartitemtxtoptions) == (len(option_ids) + len(text_option_ids)):
        #                 found_cartitem_id = cartitem.id
        #                 merge = True
        #                 break

        #if we found a CartItem object that has the same options, we need
        #to select this one instead of just any CartItem that belongs to this
        #cart and this product.
        if found_cartitem_id:
            qs = CartItem.objects.filter(pk=found_cartitem_id)
        
        cart_item = cart_object.add_product(
            product, product_quantity, merge=merge, queryset=qs)
        cart_object.save()
        return self.post_success(product, cart_item)