import contextlib

from django.db.models import Q

from .category import CategoryController

from .discount import DiscountController

from .flag import FlagController

from .product import ProductController

    if we're doing something that could modify the cart.

    It also wraps the execution of this function in a database transaction,

    and marks the boundaries of a cart operations batch.

    '''

        with transaction.atomic():

            with CartController.operations_batch(self.cart.user) as mark:

                mark.mark = True  # Marker that we've modified the cart

    # Marks the carts that are currently in batches

    _FOR_USER = {}

    _BATCH_COUNT = collections.defaultdict(int)

    _MODIFIED_CARTS = set()

    class _ModificationMarker(object):

        pass

    @classmethod

    @contextlib.contextmanager

    def operations_batch(cls, user):

        ''' Marks the boundary for a batch of operations on a user's cart.

        These markers can be nested. Only on exiting the outermost marker will

        a batch be ended.

        When a batch is ended, discounts are recalculated, and the cart's

        revision is increased.

        '''

        if user not in cls._FOR_USER:

            _ctrl = cls.for_user(user)

            cls._FOR_USER[user] = (_ctrl, _ctrl.cart.id)

        ctrl, _id = cls._FOR_USER[user]

        cls._BATCH_COUNT[_id] += 1

        try:

            success = False

            marker = cls._ModificationMarker()

            yield marker

            if hasattr(marker, "mark"):

                cls._MODIFIED_CARTS.add(_id)

            success = True

        finally:

            cls._BATCH_COUNT[_id] -= 1

            # Only end on the outermost batch marker, and only if

            # it excited cleanly, and a modification occurred

            modified = _id in cls._MODIFIED_CARTS

            outermost = cls._BATCH_COUNT[_id] == 0

            if modified and outermost and success:

                ctrl._end_batch()

                cls._MODIFIED_CARTS.remove(_id)

            # Clear out the cache on the outermost operation

            if outermost:

                del cls._FOR_USER[user]

    def _autoextend_reservation(self):

    def _end_batch(self):

        You need to call this after you've finished modifying the user's cart.

        This is normally done by wrapping a block of code using

        ``operations_batch``.

        self.cart.refresh_from_db()

        self._recalculate_discounts()

        self._autoextend_reservation()

        new_items = []

        products = []

            products.append(product)

            if quantity == 0:

                continue

            item = commerce.ProductItem(

            new_items.append(item)

        to_delete = (

            Q(quantity=0) |

            Q(product__in=products)

        )

        items_in_cart.filter(to_delete).delete()

        commerce.ProductItem.objects.bulk_create(new_items)

        # Pre-annotate products

        products = [p for (p, q) in product_quantities]

        r = ProductController.attach_user_remainders(self.cart.user, products)

        with_remainders = dict((p, p) for p in r)

            limit = with_remainders[product].remainder

        # Pre-annotate categories

        r = CategoryController.attach_user_remainders(self.cart.user, by_cat)

        with_remainders = dict((cat, cat) for cat in r)

            limit = with_remainders[category].remainder

        errs = FlagController.test_flags(

        items = items.select_related("product", "product__category")

        # TODO: refactor in terms of available_discounts

        # why aren't we doing that here?!

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

        products = [i.product for i in items]

        discounts_with_quantity = DiscountController.available_discounts(

            user,

            [],

            products,

        )

        discounts = set(i.discount.id for i in discounts_with_quantity)

        discount_items = commerce.DiscountItem.objects.filter(cart=cart)

            if discount.id not in discounts:

    def _recalculate_discounts(self):

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

        discounts = DiscountController.available_discounts(

            self.cart.user,

            [],

            products,

        )

from django.db.models import Case

from django.db.models import F, Q

from django.db.models import When

from django.db.models import Value

    @classmethod

    def attach_user_remainders(cls, user, categories):

        '''

        Return:

            queryset(inventory.Product): A queryset containing items from

            ``categories``, with an extra attribute -- remainder = the amount

            of items from this category that is remaining.

        '''

        ids = [category.id for category in categories]

        categories = inventory.Category.objects.filter(id__in=ids)

        cart_filter = (

            Q(product__productitem__cart__user=user) &

            Q(product__productitem__cart__status=commerce.Cart.STATUS_PAID)

        )

        quantity = When(

            cart_filter,

            then='product__productitem__quantity'

        )

        quantity_or_zero = Case(

            quantity,

            default=Value(0),

        remainder = Case(

            When(limit_per_user=None, then=Value(99999999)),

            default=F('limit_per_user') - Sum(quantity_or_zero),

        categories = categories.annotate(remainder=remainder)

        return categories

    def user_quantity_remaining(self, user):

        ''' Returns the quantity of this product that the user add in the

        current cart. '''

        with_remainders = self.attach_user_remainders(user, [self.category])

        return with_remainders[0].remainder

from django.db.models import Case

from django.db.models import F, Q

from django.db.models import Value

from django.db.models import When

_BIG_QUANTITY = 99999999  # A big quantity

    def __init__(self, condition):

        self.condition = condition

    def _controllers():

        return {

    @staticmethod

    def for_type(cls):

        return ConditionController._controllers()[cls]

    @staticmethod

    def for_condition(condition):

            return ConditionController.for_type(type(condition))(condition)

    def pre_filter(cls, queryset, user):

        ''' Returns only the flag conditions that might be available for this

        user. It should hopefully reduce the number of queries that need to be

        executed to determine if a flag is met.

        If this filtration implements the same query as is_met, then you should

        be able to implement ``is_met()`` in terms of this.

        Arguments:

            queryset (Queryset[c]): The canditate conditions.

            user (User): The user for whom we're testing these conditions.

        Returns:

            Queryset[c]: A subset of the conditions that pass the pre-filter

                test for this user.

        '''

        # Default implementation does NOTHING.

        return queryset

    def passes_filter(self, user):

        ''' Returns true if the condition passes the filter '''

        cls = type(self.condition)

        qs = cls.objects.filter(pk=self.condition.id)

        return self.condition in self.pre_filter(qs, user)

    def user_quantity_remaining(self, user, filtered=False):

        return _BIG_QUANTITY if self.is_met(user, filtered) else 0

    def is_met(self, user, filtered=False):

        Arguments:

            user (User): The user for whom this test must be met.

            filter (bool): If true, this condition was part of a queryset

                returned by pre_filter() for this user.

        return self.user_quantity_remaining(user, filtered) > 0

class IsMetByFilter(object):

    def is_met(self, user, filtered=False):

        ''' Returns True if this flag condition is met, otherwise returns

        False. It determines if the condition is met by calling pre_filter

        with a queryset containing only self.condition. '''

        if filtered:

            return True  # Why query again?

        return self.passes_filter(user)

class RemainderSetByFilter(object):

    def user_quantity_remaining(self, user, filtered=True):

        ''' returns 0 if the date range is violated, otherwise, it will return

        the quantity remaining under the stock limit.

        The filter for this condition must add an annotation called "remainder"

        in order for this to work.

        '''

        if filtered:

            if hasattr(self.condition, "remainder"):

                return self.condition.remainder

        # Mark self.condition with a remainder

        qs = type(self.condition).objects.filter(pk=self.condition.id)

        qs = self.pre_filter(qs, user)

        if len(qs) > 0:

            return qs[0].remainder

        else:

            return 0

class CategoryConditionController(IsMetByFilter, ConditionController):

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the user has a

        product from a category invoking that item's condition in one of their

        carts. '''

        in_user_carts = Q(

            enabling_category__product__productitem__cart__user=user

        )

        released = commerce.Cart.STATUS_RELEASED

        in_released_carts = Q(

            enabling_category__product__productitem__cart__status=released

        queryset = queryset.filter(in_user_carts)

        queryset = queryset.exclude(in_released_carts)

        return queryset

class ProductConditionController(IsMetByFilter, ConditionController):

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the user has a

        product invoking that item's condition in one of their carts. '''

        in_user_carts = Q(enabling_products__productitem__cart__user=user)

        released = commerce.Cart.STATUS_RELEASED

        in_released_carts = Q(

            enabling_products__productitem__cart__status=released

        )

        queryset = queryset.filter(in_user_carts)

        queryset = queryset.exclude(in_released_carts)

        return queryset

class TimeOrStockLimitConditionController(

            RemainderSetByFilter,

            ConditionController,

        ):

    @classmethod

    def pre_filter(self, queryset, user):

        ''' Returns all of the items from queryset where the date falls into

        any specified range, but not yet where the stock limit is not yet

        reached.'''

        # Keep items with no start time, or start time not yet met.

        queryset = queryset.filter(Q(start_time=None) | Q(start_time__lte=now))

        queryset = queryset.filter(Q(end_time=None) | Q(end_time__gte=now))

        # Filter out items that have been reserved beyond the limits

        quantity_or_zero = self._calculate_quantities(user)

        remainder = Case(

            When(limit=None, then=Value(_BIG_QUANTITY)),

            default=F("limit") - Sum(quantity_or_zero),

        )

        queryset = queryset.annotate(remainder=remainder)

        queryset = queryset.filter(remainder__gt=0)