import collections

import datetime

import functools

import itertools

        )

        products = [i.product for i in product_items]

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

        # products first.

import itertools

from django.db.models import Case

from django.db.models import F, Q

from django.db.models import Sum

from django.db.models import Value

        reserved_carts = cls._relevant_carts(user)

        # Calculate category lines

        reserved_category_products = (

            Q(categories__product__productitem__cart__in=reserved_carts)

        )

    @classmethod

    def available_discounts(cls, user, categories, products):

        filtered_clauses = cls._filtered_discounts(user, categories, products)

        discounts = []

        accepted_discounts = set()

        failed_discounts = set()

                pass

            elif discount not in failed_discounts:

                # This clause is still available

                    # This clause is valid for this user

                    discounts.append(DiscountAndQuantity(

                        discount=discount,

        '''

        Returns:

        '''

        types = list(ConditionController._controllers())

        # discounts that match provided categories

        category_discounts = conditions.DiscountForCategory.objects.filter(

            product__in=products

        )

        # discounts that match categories for provided products

            category__in=(product.category for product in products)

        )

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

            "product__category",

        )

        all_category_discounts = all_category_discounts.select_related(

            "category",

        )

        filtered_discounts = list(itertools.chain(*all_subsets))

        from_filter = dict((i.id, i) for i in filtered_discounts)

        # The set of all potential discounts

            default=Value(0),

        )

        return queryset

        # Get the count of how many conditions should exist per product

        flagbases = conditions.FlagBase.objects

        keys = ("eit", "dif")

        flags = [

            for condition_type in types

        ]

from registrasion.models import inventory

from .category import CategoryController

from .flag import FlagController

        super(RegistrationCartTestCase, self).setUp()

    def tearDown(self):

            # If you're seeing segfaults in tests, enable this.

            call_command(

                'flush',

            cart.add_to_cart(self.PROD_1, 1)

            cart.next_cart()

        self.assertEqual(0, len(discounts))

    # Tests for the DiscountController.available_discounts enumerator

    def test_enumerate_no_discounts_for_no_input(self):

        self.assertEqual(0, len(discounts))

    def test_enumerate_no_discounts_if_condition_not_met(self):

        )

        self.assertEqual(0, len(discounts))

        self.assertEqual(0, len(discounts))

    def test_category_discount_appears_once_if_met_twice(self):

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        self.assertEqual(1, len(discounts))

    def test_category_discount_appears_with_product(self):

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        self.assertEqual(0, len(discounts))

    def test_discount_quantity_is_correct_before_first_purchase(self):

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        self.assertEqual(2, discounts[0].quantity)

        cart.next_cart()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        self.assertEqual(1, discounts[0].quantity)

        cart.next_cart()

    def test_discount_is_gone_after_quantity_exhausted(self):

        self.test_discount_quantity_is_correct_after_first_purchase()

        self.assertEqual(0, len(discounts))

    def test_product_discount_enabled_twice_appears_twice(self):

                )

    handled = False if products_form.errors else True

    return products_form, discounts, handled