''' Sets the quantities on each of the products on each of the

        products specified. Raises an exception (ValidationError) if a limit

        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.

        all_product_quantities = dict(itertools.chain(

            ((i.product, i.quantity) for i in items_in_cart.all()),

        for voucher in to_remove:

            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,

        ))

        ''' Calculates all of the discounts available for this product.

        '''

        # 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)

    def _add_discount(self, product, quantity, discounts):

        products, otherwise it'll do all. '''

        # 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

from django.db.models import Sum

from django.utils import timezone

                              for product, quantity in product_quantities)

        elif product_quantities is None:

            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

        # if there are no mandatory conditions

        non_mandatory = defaultdict(lambda: False)

            # Get all products covered by this condition, and the products

            # from the categories covered by this condition

            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:

                consumed = 1

            met = consumed <= remainder

    def __init__(self, discount, clause, quantity):

        self.discount = discount

        self.clause = clause

        self.quantity = quantity

    def __repr__(self):

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

        )

def available_discounts(user, categories, products):

    ''' Returns all discounts available to this user for the given categories

    # discounts that match categories for provided products

    product_category_discounts = rego.DiscountForCategory.objects.filter(

        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,

        )

        cond = ConditionController.for_condition(real_discount)

        # If this user has exceeded the limit for the clause, this clause

        # is not available any more.

        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:

            past_use_count = 0

        can_add_with_enabling_conditions calls this method. '''

        if category is None and products 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(

            user, products=passed_limits

        )

    ''' Returns all of the items that this user has in their current cart,

    and is awaiting payment. '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=True,

    return all_items

@register.assignment_tag(takes_context=True)

def items_purchased(context, category=None):

    ''' Returns all of the items that this user has purchased, optionally

    from the given category. '''

    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

def multiply(value, arg):

    ''' Multiplies value by arg '''

            cats = [cats[0]]

        else:

            # 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

            section = GuidedRegistrationSection(

    ProductsForm = forms.ProductsForm(category, products)

    # 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,

        prefix=prefix,

    )

    return products_form, discounts, handled

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)

    )

    try: