import collections

import datetime

import functools

import itertools

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.db import transaction

from django.db.models import Max

from django.utils import timezone

from registrasion.exceptions import CartValidationError

from registrasion.models import commerce

from registrasion.models import conditions

    def recalculate_discounts(self):

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

        '''

        # Delete the existing entries.

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

        product_items = self.cart.productitem_set.all().select_related(

            "product", "product__category", "product__price"

        )

        products = [i.product for i in product_items]

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

        # products first.

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

        ''' Applies the best discounts on the given product, from the given

        discounts.'''

        def matches(discount):

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

from django.db.models import When

from django.utils import timezone

from registrasion.models import commerce

from registrasion.models import conditions

from registrasion.models import inventory

        )

        return reserved_carts

class TimeOrStockLimitFlagController(

        TimeOrStockLimitConditionController):

    @classmethod

    def _calculate_quantities(cls, user):

        reserved_carts = cls._relevant_carts(user)

        # Calculate category lines

        reserved_category_products = (

            Q(categories__product__productitem__cart__in=reserved_carts)

        )

        # Calculate product lines

        reserved_products = (

            Q(products=F('products__productitem__product')) &

            Q(products__productitem__cart__in=reserved_carts)

        )

        category_quantity_in_reserved_carts = When(

            reserved_category_products,

            then="categories__product__productitem__quantity",

        self.quantity = quantity

    def __repr__(self):

        return "(discount=%s, clause=%s, quantity=%d)" % (

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

        )

class DiscountController(object):

    @classmethod

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

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

        discounts = []

        accepted_discounts = set()

        failed_discounts = set()

        for clause in filtered_clauses:

            discount = clause.discount

            cond = ConditionController.for_condition(discount)

            past_use_count = discount.past_use_count

            if past_use_count >= clause.quantity:

                # This clause has exceeded its use count

                pass

            elif discount not in failed_discounts:

                # This clause is still available

                    # This clause is valid for this user

                    discounts.append(DiscountAndQuantity(

                        discount=discount,

                        clause=clause,

                        quantity=clause.quantity - past_use_count,

                    ))

                    accepted_discounts.add(discount)

                else:

                    # This clause is not valid for this user

                    failed_discounts.add(discount)

        return discounts

    @classmethod

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

        '''

        Returns:

        '''

        types = list(ConditionController._controllers())

        # discounts that match provided categories

        category_discounts = conditions.DiscountForCategory.objects.filter(

            category__in=categories

        )

        # discounts that match provided products

        product_discounts = conditions.DiscountForProduct.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_discounts = product_discounts.select_related(

            "product",

            "product__category",

        )

        all_category_discounts = all_category_discounts.select_related(

            "category",

        )

        valid_discounts = conditions.DiscountBase.objects.filter(

            Q(discountforproduct__in=product_discounts) |

            Q(discountforcategory__in=all_category_discounts)

        )

        all_subsets = []

        for discounttype in discounttypes:

            discounts = discounttype.objects.filter(id__in=valid_discounts)

            ctrl = ConditionController.for_type(discounttype)

            discounts = ctrl.pre_filter(discounts, user)

            discounts = cls._annotate_with_past_uses(discounts, user)

            all_subsets.append(discounts)

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

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

        # The set of all potential discounts

        discount_clauses = set(itertools.chain(

            product_discounts.filter(discount__in=filtered_discounts),

            all_category_discounts.filter(discount__in=filtered_discounts),

        ))

        # Replace discounts with the filtered ones

        # These are the correct subclasses (saves query later on), and have

        # correct annotations from filters if necessary.

        for clause in discount_clauses:

            (

                Q(discountitem__cart__user=user) &

                Q(discountitem__cart__status=commerce.Cart.STATUS_PAID)

            ),

            then="discountitem__quantity",

        )

        past_use_quantity_or_zero = Case(

            past_use_quantity,

            default=Value(0),

        )

        return queryset

        "eit",

    ),

)

class FlagCounter(_FlagCounter):

    @classmethod

    def count(cls):

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

        flagbases = conditions.FlagBase.objects

        keys = ("eit", "dif")

        flags = [

            for condition_type in types

        ]

        cats = defaultdict(lambda: defaultdict(int))

        prod = defaultdict(lambda: defaultdict(int))

        for key, flagcounts in zip(keys, flags):

            for row in flagcounts:

                if row["products"] is not None:

                    prod[row["products"]][key] = row["count"]

                if row["categories"] is not None:

                    cats[row["categories"]][key] = row["count"]

import itertools

from django.db.models import Sum

from registrasion.models import commerce

from registrasion.models import inventory

from .category import CategoryController

from .flag import FlagController

class ProductController(object):

    def __init__(self, product):

        self.product = product

    @classmethod

    def available_products(cls, user, category=None, products=None):

        ''' Returns a list of all of the products that are available per

        flag conditions from the given categories.

from controller_helpers import TestingCartController

from patch_datetime import SetTimeMixin

UTC = pytz.timezone('UTC')

class RegistrationCartTestCase(SetTimeMixin, TestCase):

    def setUp(self):

        super(RegistrationCartTestCase, self).setUp()

    def tearDown(self):

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

            call_command(

                'flush',

                verbosity=0,

                interactive=False,

                reset_sequences=False,

                allow_cascade=False,

                inhibit_post_migrate=False

            )

        super(RegistrationCartTestCase, self).tearDown()

    def test_discount_ceiling_aggregates_products(self):

        # Create two carts, add 1xprod_1 to each. Ceiling should disappear

        # after second.

        self.make_discount_ceiling(

            "Multi-product limit discount ceiling",

            limit=2,

        )

        for i in xrange(2):

            cart = TestingCartController.for_user(self.USER_1)

            cart.add_to_cart(self.PROD_1, 1)

            cart.next_cart()

        self.assertEqual(0, len(discounts))

    def test_flag_ceiling_aggregates_products(self):

        # Create two carts, add 1xprod_1 to each. Ceiling should disappear

        # after second.

        self.make_ceiling("Multi-product limit ceiling", limit=2)

        for i in xrange(2):

            cart = TestingCartController.for_user(self.USER_1)

            cart.add_to_cart(self.PROD_1, 1)

            cart.next_cart()

        # in the same way

        for user in (self.USER_1, self.USER_2):

            cart = TestingCartController.for_user(user)

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

            cart.add_to_cart(self.PROD_3, 1)

            discount_items = list(cart.cart.discountitem_set.all())

            # The discount is applied.

            self.assertEqual(1, len(discount_items))

    # 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.add_discount_prod_1_includes_cat_2(quantity=1)

        discounts = DiscountController.available_discounts(

            self.USER_1,

            [],

            [self.PROD_3],

        )

        self.assertEqual(0, len(discounts))

        self.assertEqual(0, len(discounts))

    def test_category_discount_appears_once_if_met_twice(self):

        self.add_discount_prod_1_includes_cat_2(quantity=1)

        cart = TestingCartController.for_user(self.USER_1)

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

        discounts = DiscountController.available_discounts(

            self.USER_1,

            [self.CAT_2],

            [self.PROD_3],

        )

        self.assertEqual(1, len(discounts))

    def test_category_discount_appears_with_category(self):

        self.add_discount_prod_1_includes_cat_2(quantity=1)

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

        self.add_discount_prod_1_includes_cat_2(quantity=1)

        cart = TestingCartController.for_user(self.USER_1)

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

        discounts = DiscountController.available_discounts(

            self.USER_1,

            [],

            [self.PROD_3],

            self.USER_1,

            [],

            [self.PROD_2],

        )

        self.assertEqual(1, len(discounts))

    def test_product_discount_does_not_appear_with_category(self):

        self.add_discount_prod_1_includes_prod_2(quantity=1)

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

        self.add_discount_prod_1_includes_cat_2(quantity=2)

        cart = TestingCartController.for_user(self.USER_1)

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

    def test_discount_quantity_is_correct_after_first_purchase(self):

        self.test_discount_quantity_is_correct_before_first_purchase()

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

        self.add_discount_prod_1_includes_prod_3_and_prod_4(quantity=2)

        cart = TestingCartController.for_user(self.USER_1)

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

        discounts = DiscountController.available_discounts(

            self.USER_1,

            [],

            [self.PROD_3, self.PROD_4],

        )

        self.assertEqual(2, len(discounts))

            carts = commerce.Cart.objects.filter(user=request.user)

            items = commerce.ProductItem.objects.filter(

                product__category=category,

                cart=carts,

            )

            if len(items) == 0:

                products_form.add_error(

                    None,

                    "You must have at least one item from this category",

                )

    handled = False if products_form.errors else True

    return products_form, discounts, handled

def _set_quantities_from_products_form(products_form, current_cart):

    quantities = list(products_form.product_quantities())

    pks = [i[0] for i in quantities]

    products = inventory.Product.objects.filter(

        id__in=pks,

    ).select_related("category")