is violated. `product_quantities` is an iterable of (product, quantity)

        pairs. '''

        items_in_cart = rego.ProductItem.objects.filter(cart=self.cart)

        product_quantities = list(product_quantities)

        # n.b need to add have the existing items first so that the new

        # items override the old ones.

            self.cart.vouchers.remove(voucher)

        # Fix products and discounts

        items = rego.ProductItem.objects.filter(cart=self.cart)

        products = set(i.product for i in items)

        available = set(ProductController.available_products(

            self.cart.user,

            products=products,

        # Delete the existing entries.

        rego.DiscountItem.objects.filter(cart=self.cart).delete()

        products = [i.product for i in product_items]

        discounts = discount.available_discounts(self.cart.user, [], products)

        # The highest-value discounts will apply to the highest-value

        # products first.

        product_items = self.cart.productitem_set.all()

        product_items = product_items.order_by('product__price')

        product_items = reversed(product_items)

        for item in product_items:

            self._add_discount(item.product, item.quantity, discounts)

        # STOPGAP -- this needs to be elsewhere tbqh

        from product import ProductController

        if products is AllProducts:

        available = ProductController.available_products(

            user,

            products=products,

import itertools

from collections import defaultdict

from collections import namedtuple

            products = set(products)

            quantities = {}

        # Get the conditions covered by the products themselves

            for product in products

        # All mandatory conditions on a product need to be met

        mandatory = defaultdict(lambda: True)

        # At least one non-mandatory condition on a product must be met

            cond_products = condition.products.all()

            from_category = rego.Product.objects.filter(

                category__in=condition.categories.all(),

            ).all()

            # Remove the products that we aren't asking about

            if quantities:

                consumed = sum(quantities[i] for i in all_products)

            else:

        self.clause = clause

        self.quantity = quantity

    def __repr__(self):

            self.discount, self.clause, self.quantity,

        )

        category__in=(product.category for product in products)

    )

    # (Not relevant: discounts that match products in provided categories)

    # The set of all potential discounts

    potential_discounts = set(itertools.chain(

        product_discounts,

    ))

    discounts = []

    # Markers so that we don't need to evaluate given conditions more than once

    accepted_discounts = set()

    failed_discounts = set()

    for discount in potential_discounts:

        real_discount = rego.DiscountBase.objects.get_subclass(

            pk=discount.discount.pk,

        )

        past_uses = rego.DiscountItem.objects.filter(

            cart__user=user,

            cart__active=False,  # Only past carts count

            cart__released=False,  # You can reuse refunded discounts

        )

        agg = past_uses.aggregate(Sum("quantity"))

        past_use_count = agg["quantity__sum"]

        if past_use_count is None:

            raise ValueError("You must provide products or a category")

        if category is not None:

            all_products = rego.Product.objects.filter(category=category)

        else:

            all_products = []

        if products is not None:

        passed_limits = set(

            product

            for product in all_products

            if cls(product).user_quantity_remaining(user) > 0

        )

        failed_and_messages = ConditionController.test_enabling_conditions(

            field = forms.IntegerField(

                label=product.name,

                help_text=help_text,

            )

            cls.base_fields[cls.field_name(product)] = field

    @classmethod

                    "item from this category."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

    )

    render_type = models.IntegerField(

        choices=CATEGORY_RENDER_TYPES,

        verbose_name=_("Render type"),

                    "it is released for someone else to purchase."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

    )

@python_2_unicode_compatible

    voucher = models.OneToOneField(

        Voucher,

        on_delete=models.CASCADE,

        verbose_name=_("Voucher"),

    )

class IncludedProductDiscount(DiscountBase):

class Cart(models.Model):

    ''' Represents a set of product items that have been purchased, or are

    pending purchase. '''

    def __str__(self):

        return "%d rev #%d" % (self.id, self.revision)

    user = models.ForeignKey(User)

    # ProductItems (foreign key)

    vouchers = models.ManyToManyField(Voucher, blank=True)

    reservation_duration = models.DurationField()

    revision = models.PositiveIntegerField(default=1)

    @classmethod

    def reserved_carts(cls):

        ''' Gets all carts that are 'reserved' '''

            self.product, self.quantity, self.cart)

    cart = models.ForeignKey(Cart)

    product = models.ForeignKey(Product)

@python_2_unicode_compatible

class DiscountItem(models.Model):

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=True,

    return all_items

@register.assignment_tag(takes_context=True)

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=False,

    if category:

        all_items = all_items.filter(product__category=category)

    out = []

    return out

@register.filter

            # Set title appropriately for remaining categories

            current_step = 3

            title = "Additional items"

        for category in cats:

            prefix = "category_" + str(category.id)

            p = handle_products(request, category, products, prefix)

            products_form, discounts, products_handled = p

    # Create initial data for each of products in category

    items = rego.ProductItem.objects.filter(

        product__in=products,

        cart=current_cart.cart,

    quantities = []

    products_form = ProductsForm(

        request.POST or None,

        product_quantities=quantities,

def set_quantities_from_products_form(products_form, current_cart):

    quantities = list(products_form.product_quantities())

    product_quantities = [

    ]

    field_names = dict(

        (i[0][0], i[1][2]) for i in zip(product_quantities, quantities)

    )