def update(self, request):
        """
        This should be called whenever anything is changed in the cart (added
        or removed).
        
        It will loop on all line items in the cart, and call all the price
        modifiers on each row.
        After doing this, it will compute and update the order's total and
        subtotal fields, along with any payment field added along the way by
        modifiers.

        Note that theses added fields are not stored - we actually want to
        reflect rebate and tax changes on the *cart* items, but we don't want
        that for the order items (since they are legally binding after the
        "purchase" button was pressed)
        """
        from shop.models import CartItem, Product

        # This is a ghetto "select_related" for polymorphic models.
        items = CartItem.objects.filter(cart=self).order_by('pk')
        product_ids = [item.product_id for item in items]
        products = Product.objects.filter(pk__in=product_ids)
        products_dict = dict([(p.pk, p) for p in products])

        self.extra_price_fields = []  # Reset the price fields
        self.subtotal_price = Decimal('0.0')  # Reset the subtotal

        # The request object holds extra information in a dict named 'cart_modifier_state'.
        # Cart modifiers can use this dict to pass arbitrary data from and to each other.
        if not hasattr(request, 'cart_modifier_state'):
            setattr(request, 'cart_modifier_state', {})

        # This calls all the pre_process_cart methods (if any), before the cart
        # is processed. This allows for data collection on the cart for
        # example)
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.pre_process_cart(self, request)

        for item in items:  # For each CartItem (order line)...
            # This is still the ghetto select_related
            item.product = products_dict[item.product_id]
            self.subtotal_price = self.subtotal_price + item.update(request)

        self.current_total = self.subtotal_price
        # Now we have to iterate over the registered modifiers again
        # (unfortunately) to pass them the whole Order this time
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.process_cart(self, request)

        self.total_price = self.current_total

        # This calls the post_process_cart method from cart modifiers, if any.
        # It allows for a last bit of processing on the "finished" cart, before
        # it is displayed
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.post_process_cart(self, request)

        # Cache updated cart items
        self._updated_cart_items = items

    def update(self, state=None):
        """
        This should be called whenever anything is changed in the cart (added
        or removed).
        It will loop on all line items in the cart, and call all the price
        modifiers on each row.
        After doing this, it will compute and update the order's total and
        subtotal fields, along with any payment field added along the way by
        modifiers.

        Note that theses added fields are not stored - we actually want to
        reflect rebate and tax changes on the *cart* items, but we don't want
        that for the order items (since they are legally binding after the
        "purchase" button was pressed)
        """
        from shop.models import CartItem, Product

        # This is a ghetto "select_related" for polymorphic models.
        items = CartItem.objects.filter(cart=self)
        product_ids = [item.product_id for item in items]
        products = Product.objects.filter(id__in=product_ids)
        products_dict = dict([(p.id, p) for p in products])

        self.extra_price_fields = []  # Reset the price fields
        self.subtotal_price = Decimal("0.0")  # Reset the subtotal

        # This will hold extra information that cart modifiers might want to pass
        # to each other
        if state == None:
            state = {}

        # This calls all the pre_process_cart methods (if any), before the cart
        # is processed. This allows for data collection on the cart for example)
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.pre_process_cart(self, state)

        for item in items:  # For each OrderItem (order line)...
            item.product = products_dict[item.product_id]  # This is still the ghetto select_related
            self.subtotal_price = self.subtotal_price + item.update(state)

        self.current_total = self.subtotal_price
        # Now we have to iterate over the registered modifiers again (unfortunately)
        # to pass them the whole Order this time
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.process_cart(self, state)

        self.total_price = self.current_total

        # This calls the post_process_cart method from cart modifiers, if any.
        # It allows for a last bit of processing on the "finished" cart, before
        # it is displayed
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.post_process_cart(self, state)

 def update(self):
     """
     This should be called whenever anything is changed in the cart (added or removed)
     It will loop on all line items in the cart, and call all the price modifiers
     on each row.
     After doing this, it will compute and update the order's total and
     subtotal fields, along with any payment field added along the way by
     modifiers.
     
     Note that theses added fields are not stored - we actually want to reflect
     rebate and tax changes on the *cart* items, but we don't want that for
     the order items (since they are legally binding after the "purchase" button
     was pressed)
     """
     items = CartItem.objects.filter(cart=self)
     self.subtotal_price = Decimal('0.0') # Reset the subtotal
     
     for item in items: # For each OrderItem (order line)...
         self.subtotal_price = self.subtotal_price + item.update()
         item.save()
     
     # Now we have to iterate over the registered modifiers again (unfortunately)
     # to pass them the whole Order this time
     for modifier in cart_modifiers_pool.get_modifiers_list():
         modifier.process_cart(self)
         
     self.total_price = self.subtotal_price
     # Like for line items, most of the modifiers will simply add a field
     # to extra_price_fields, let's update the total with them
     for label, value in self.extra_price_fields:
         self.total_price = self.total_price + value

 def update(self):
     '''
     This should be called whenever anything is changed in the cart (added or removed)
     It will loop on all line items in the cart, and call all the price modifiers
     on each row.
     After doing this, it will compute and update the order's total and
     subtotal fields, along with any payment field added along the way by
     modifiers.
     
     Note that theses added fields are not stored - we actually want to reflect
     rebate and tax changes on the *cart* items, but we don't want that for
     the order items (since they are legally binding after the "purchase" button
     was pressed)
     '''
     items = list(CartItem.objects.filter(cart=self)) # force query to "cache" it
     
     self.subtotal_price = Decimal('0.0') # Reset the subtotal
     for item in items: # For each OrderItem (order line)...
         
         item.line_subtotal = item.product.unit_price * item.quantity
         item.line_total = item.line_subtotal
         
         for modifier in cart_modifiers_pool.get_modifiers_list():
             # We now loop over every registered price modifier,
             # most of them will simply add a field to extra_payment_fields
             item = modifier.process_cart_item(item)
             for value in item.extra_price_fields.itervalues():
                 item.line_total = item.line_total + value
             
         # Let's update the Order's subtotal with this line's total while 
         # we're at it
         self.subtotal_price = self.subtotal_price + item.line_total
         item.save()
     
     # Now we have to iterate over the registered modifiers again (unfortunately)
     # to pass them the whole Order this time
     for modifier in cart_modifiers_pool.get_modifiers_list():
         modifier.process_cart(self)
         
     self.total_price = self.subtotal_price
     # Like for line items, most of the modifiers will simply add a field
     # to extra_price_fields, let's update the total with them
     for value in self.extra_price_fields.itervalues():
         self.total_price = self.total_price + value
         
     self.save()

    def update(self, state):
        self.extra_price_fields = []  # Reset the price fields
        self.line_subtotal = self.product.get_price() * self.quantity
        self.current_total = self.line_subtotal

        for modifier in cart_modifiers_pool.get_modifiers_list():
            # We now loop over every registered price modifier,
            # most of them will simply add a field to extra_payment_fields
            modifier.process_cart_item(self, state)

        self.line_total = self.current_total
        return self.line_total

 def update(self):
     self.line_subtotal = self.product.get_price() * self.quantity
     self.line_total = self.line_subtotal
     
     for modifier in cart_modifiers_pool.get_modifiers_list():
         # We now loop over every registered price modifier,
         # most of them will simply add a field to extra_payment_fields
         modifier.process_cart_item(self)
         for value in self.extra_price_fields.itervalues():
             self.line_total = self.line_total + value
             
     return self.line_total

    def update(self):
        """
        This should be called whenever anything is changed in the cart (added
        or removed).
        It will loop on all line items in the cart, and call all the price
        modifiers on each row.
        After doing this, it will compute and update the order's total and
        subtotal fields, along with any payment field added along the way by
        modifiers.

        Note that theses added fields are not stored - we actually want to
        reflect rebate and tax changes on the *cart* items, but we don't want
        that for the order items (since they are legally binding after the
        "purchase" button was pressed)
        """
        from shop.models import CartItem, Product
        
        # This is a ghetto "select_related" for polymorphic models. 2 queries!
        items = CartItem.objects.filter(cart=self)
        product_ids = [item.product_id for item in items]
        products = Product.objects.filter(id__in=product_ids)
        products_dict = dict([(p.id, p) for p in products])
        
        self.extra_price_fields = [] # Reset the price fields
        self.subtotal_price = Decimal('0.0') # Reset the subtotal

        for item in items: # For each OrderItem (order line)...
            item.product = products_dict[item.product_id] #This is still the ghetto select_related
            self.subtotal_price = self.subtotal_price + item.update()
            item.save()
        
        self.current_total = self.subtotal_price
        # Now we have to iterate over the registered modifiers again (unfortunately)
        # to pass them the whole Order this time
        for modifier in cart_modifiers_pool.get_modifiers_list():
            modifier.process_cart(self)
        
        self.total_price = self.current_total