import collections

import datetime

import discount

import itertools

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.db import transaction

from django.utils import timezone

from registrasion import models as rego

from category import CategoryController

from conditions import ConditionController

from product import ProductController

class CartController(object):

    def __init__(self, cart):

    def end_batch(self):

        ''' Performs operations that occur occur at the end of a batch of

        product changes/voucher applications etc.

        THIS SHOULD BE PRIVATE

        '''

        self.recalculate_discounts()

        self.extend_reservation()

        self.cart.revision += 1

        self.cart.save()

    @transaction.atomic

    def set_quantities(self, product_quantities):

        ''' 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.

        )

        if len(user_carts_with_voucher) > 0:

            raise ValidationError("You have already entered this voucher.")

        # If successful...

        self.cart.vouchers.add(voucher)

        self.end_batch()

    def validate_cart(self):

        ''' Determines whether the status of the current cart is valid;

        this is normally called before generating or paying an invoice '''

        # TODO: validate vouchers

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

        product_quantities = list((i.product, i.quantity) for i in items)

        self._test_limits(product_quantities)

        # Validate the discounts

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

        seen_discounts = set()

        for discount_item in discount_items:

        carts = rego.Cart.objects.filter(

            user=user,

            active=False,

            released=False,

        )

        items = rego.ProductItem.objects.filter(

            cart__in=carts,

            product__category=self.category,

        )

        cat_count = items.aggregate(Sum("quantity"))["quantity__sum"] or 0

import itertools

from collections import defaultdict

from collections import namedtuple

from django.db.models import Sum

from django.utils import timezone

from registrasion import models as rego

ConditionAndRemainder = namedtuple(

    "ConditionAndRemainder",

    (

        "condition",

        "remainder",

    ),

            product.enablingconditionbase_set.select_subclasses() |

            product.category.enablingconditionbase_set.select_subclasses()

            for product in products

        ]

        all_conditions = set(itertools.chain(*all_conditions))

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

        for condition in all_conditions:

            cond = cls.for_condition(condition)

            remainder = cond.user_quantity_remaining(user)

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

            all_products = set(itertools.chain(cond_products, from_category))

        reserved_carts = rego.Cart.reserved_carts()

        reserved_carts = reserved_carts.exclude(

            user=user,

            active=True,

        )

        items = self._items()

        items = items.filter(cart__in=reserved_carts)

        count = items.aggregate(Sum("quantity"))["quantity__sum"] or 0

        return self.ceiling.limit - count

class TimeOrStockLimitEnablingConditionController(

        TimeOrStockLimitConditionController):

    def _items(self):

        category_products = rego.Product.objects.filter(

            category__in=self.ceiling.categories.all(),

        )

        products = self.ceiling.products.all() | category_products

        product_items = rego.ProductItem.objects.filter(

            product__in=products.all(),

        )

import itertools

from django.db.models import Sum

from registrasion import models as rego

from category import CategoryController

from conditions import ConditionController

class ProductController(object):

    def __init__(self, product):

        self.product = product

        if category is not None:

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

        else:

            all_products = []

        if products is not None:

            all_products = itertools.chain(all_products, products)

        passed_limits = set(

            product

            for product in all_products

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

        )

        failed_conditions = set(ConditionController.test_enabling_conditions(

            user, products=passed_limits

        ))

        out = list(passed_limits - failed_conditions)

        out.sort(key=lambda product: product.order)

        return out

from registrasion.controllers.cart import CartController

from registrasion import models as rego

from django.core.exceptions import ObjectDoesNotExist

class TestingCartController(CartController):

    def set_quantity(self, product, quantity, batched=False):

        ''' Sets the _quantity_ of the given _product_ in the cart to the given

        _quantity_. '''

        self.set_quantities(((product, quantity),))

    def add_to_cart(self, product, quantity):

        ''' Adds _quantity_ of the given _product_ to the cart. Raises

        ValidationError if constraints are violated.'''

            start_time=start_time,

            end_time=end_time,

            limit=limit,

        )

        limit_ceiling.save()

        rego.DiscountForProduct.objects.create(

            discount=limit_ceiling,

            product=cls.PROD_1,

            percentage=percentage,

            quantity=10,

        ).save()

    @classmethod

    def new_voucher(self, code="VOUCHER", limit=1):

        voucher = rego.Voucher.objects.create(

            recipient="Voucher recipient",

            code=code,

            limit=limit,

        )

        voucher.save()

        return voucher

class BasicCartTests(RegistrationCartTestCase):

from registrasion.controllers import discount

from registrasion.controllers.cart import CartController

from registrasion.controllers.invoice import InvoiceController

from registrasion.controllers.product import ProductController

from collections import namedtuple

from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.contrib import messages

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.http import Http404

from django.shortcuts import redirect

from django.shortcuts import render

GuidedRegistrationSection = namedtuple(

    "GuidedRegistrationSection",

    (

        "title",

        "discounts",

        "description",

        "form",