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

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

        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)

        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

        if products is not None and product_quantities is not None:

            raise ValueError("Please specify only products or "

                             "product_quantities")

        elif products is None:

            products = set(i[0] for i in product_quantities)

        elif product_quantities is None:

            products = set(products)

            quantities = {}

        # Get the conditions covered by the products themselves

        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

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

import itertools

from django.db.models import Sum

from registrasion import models as rego

from category import CategoryController

from conditions import ConditionController

        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

        ))

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

            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,

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(