class TimeOrStockLimitDiscountAdmin(admin.ModelAdmin, EffectsDisplayMixin):

    list_display = (

        "description",

        "start_time",

        "end_time",

        "limit",

        "effects",

    )

    ordering = ("start_time", "end_time", "limit")

    inlines = [

        DiscountForProductInline,

        DiscountForCategoryInline,

    ]

@admin.register(rego.IncludedProductDiscount)

class IncludedProductDiscountAdmin(admin.ModelAdmin):

    def enablers(self, obj):

        return list(obj.enabling_products.all())

    def effects(self, obj):

        return list(obj.effects())

    list_display = ("description", "enablers", "effects")

    inlines = [

        DiscountForProductInline,

        DiscountForCategoryInline,

    ]

# Vouchers

class VoucherDiscountInline(nested_admin.NestedStackedInline):

    model = rego.VoucherDiscount

    verbose_name = _("Discount")

    # TODO work out why we're allowed to add more than one?

    max_num = 1

    extra = 1

    inlines = [

        DiscountForProductInline,

        DiscountForCategoryInline,

    ]

    verbose_name = _("Product and category enabled by voucher")

    verbose_name_plural = _("Products and categories enabled by voucher")

    # TODO work out why we're allowed to add more than one?

    max_num = 1

    extra = 1

@admin.register(rego.Voucher)

class VoucherAdmin(nested_admin.NestedAdmin):

    def effects(self, obj):

        ''' List the effects of the voucher in the admin. '''

        out = []

        try:

            discount_effects = obj.voucherdiscount.effects()

        except ObjectDoesNotExist:

            discount_effects = None

        try:

        except ObjectDoesNotExist:

            enabling_effects = None

        if discount_effects:

            out.append("Discounts: " + str(list(discount_effects)))

        if enabling_effects:

            out.append("Enables: " + str(list(enabling_effects)))

        return "\n".join(out)

    model = rego.Voucher

    list_display = ("recipient", "code", "effects")

    inlines = [

        VoucherDiscountInline,

    ]

# Enabling conditions

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    def enablers(self, obj):

        return list(obj.enabling_products.all())

    fields = ("description", "enabling_products", "mandatory", "products",

              "categories"),

    list_display = ("description", "enablers", "effects")

# Enabling conditions

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    fields = ("description", "enabling_category", "mandatory", "products",

              "categories"),

    list_display = ("description", "enabling_category", "effects")

    ordering = ("enabling_category",)

# Enabling conditions

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    list_display = (

        "description",

        "start_time",

        "end_time",

        "limit",

        "effects",

    )

    ordering = ("start_time", "end_time", "limit")

        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)

        items_in_cart = items_in_cart.select_related(

            "product",

            "product__category",

        )

        product_quantities = list(product_quantities)

        # n.b need to add have the existing items first so that the new

        # items override the old ones.

        all_product_quantities = dict(itertools.chain(

            ((i.product, i.quantity) for i in items_in_cart.all()),

            product_quantities,

        )).items()

        # Validate that the limits we're adding are OK

        self._test_limits(all_product_quantities)

        for product, quantity in product_quantities:

            try:

                product_item = rego.ProductItem.objects.get(

                    cart=self.cart,

                    product=product,

                )

                product_item.quantity = quantity

                product_item.save()

            except ObjectDoesNotExist:

                rego.ProductItem.objects.create(

                    cart=self.cart,

                    product=product,

                    quantity=quantity,

                )

        items_in_cart.filter(quantity=0).delete()

        self.end_batch()

    def _test_limits(self, product_quantities):

        ''' Tests that the quantity changes we intend to make do not violate

        errors = []

        # Test each product limit here

        for product, quantity in product_quantities:

            if quantity < 0:

                errors.append((product, "Value must be zero or greater."))

            prod = ProductController(product)

            limit = prod.user_quantity_remaining(self.cart.user)

            if quantity > limit:

                errors.append((

                    product,

                    "You may only have %d of product: %s" % (

                        limit, product,

                    )

                ))

        # Collect by category

        by_cat = collections.defaultdict(list)

        for product, quantity in product_quantities:

            by_cat[product.category].append((product, quantity))

        # Test each category limit here

        for category in by_cat:

            ctrl = CategoryController(category)

            limit = ctrl.user_quantity_remaining(self.cart.user)

            # Get the amount so far in the cart

            to_add = sum(i[1] for i in by_cat[category])

            if to_add > limit:

                errors.append((

                    category,

                    "You may only have %d items in category: %s" % (

                        limit, category.name,

                    )

                ))

            self.cart.user,

            product_quantities=product_quantities,

        )

        if errs:

            for error in errs:

                errors.append(error)

        if errors:

            raise CartValidationError(errors)

    def apply_voucher(self, voucher_code):

        ''' Applies the voucher with the given code to this cart. '''

        # Try and find the voucher

        voucher = rego.Voucher.objects.get(code=voucher_code.upper())

        # Re-applying vouchers should be idempotent

        if voucher in self.cart.vouchers.all():

            return

        self._test_voucher(voucher)

        # If successful...

        self.cart.vouchers.add(voucher)

        self.end_batch()

    def _test_voucher(self, voucher):

        ''' Tests whether this voucher is allowed to be applied to this cart.

        Raises ValidationError if not. '''

        # Is voucher exhausted?

        active_carts = rego.Cart.reserved_carts()

        # It's invalid for a user to enter a voucher that's exhausted

        carts_with_voucher = active_carts.filter(vouchers=voucher)

        carts_with_voucher = carts_with_voucher.exclude(pk=self.cart.id)

        if carts_with_voucher.count() >= voucher.limit:

            raise ValidationError(

                "Voucher %s is no longer available" % voucher.code)

        # It's not valid for users to re-enter a voucher they already have

        user_carts_with_voucher = carts_with_voucher.filter(

            user=self.cart.user,

        )

        if user_carts_with_voucher.count() > 0:

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

import itertools

import operator

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",

    ),

)

class ConditionController(object):

    or Discount objects. '''

    def __init__(self):

        pass

    @staticmethod

    def for_condition(condition):

        CONTROLLERS = {

            rego.IncludedProductDiscount: ProductConditionController,

            rego.TimeOrStockLimitDiscount:

                TimeOrStockLimitDiscountController,

            rego.VoucherDiscount: VoucherConditionController,

        }

        try:

            return CONTROLLERS[type(condition)](condition)

        except KeyError:

            return ConditionController()

    SINGLE = True

    PLURAL = False

    NONE = True

    SOME = False

    MESSAGE = {

        NONE: {

            SINGLE:

                "%(items)s is no longer available to you",

            PLURAL:

                "%(items)s are no longer available to you",

        },

        SOME: {

            SINGLE:

                "Only %(remainder)d of the following item remains: %(items)s",

            PLURAL:

                "Only %(remainder)d of the following items remain: %(items)s"

        },

    }

    @classmethod

            cls, user, products=None, product_quantities=None):

        If `product_quantities` is supplied, the condition is only met if it

        will permit the sum of the product quantities for all of the products

        it covers. Otherwise, it will be met if at least one item can be

        accepted.

        a list is returned containing all of the products that are *not

        enabled*. '''

        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)

            quantities = dict((product, quantity)

                              for product, quantity in product_quantities)

        elif product_quantities is None:

            products = set(products)

            quantities = {}

        # Get the conditions covered by the products themselves

        prods = (

            for product in products

        )

        # Get the conditions covered by their categories

        cats = (

            for category in set(product.category for product in products)

        )

        if products:

            # Simplify the query.

            all_conditions = reduce(operator.or_, itertools.chain(prods, cats))

        else:

            all_conditions = []

        messages = {}

        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 = cond_products | from_category

            all_products = all_products.select_related("category")

            # Remove the products that we aren't asking about

            all_products = [

                product

                for product in all_products

                if product in products

            ]

            if quantities:

                consumed = sum(quantities[i] for i in all_products)

            else:

                consumed = 1

            met = consumed <= remainder

            if not met:

                items = ", ".join(str(product) for product in all_products)

                base = cls.MESSAGE[remainder == 0][len(all_products) == 1]

                message = base % {"items": items, "remainder": remainder}

            for product in all_products:

                else:

                if not met and product not in messages:

                    messages[product] = message

        error_fields = [

            (product, messages[product])

            for product in valid if not valid[product]

        ]

        return error_fields

    def user_quantity_remaining(self, user):

        user can add to the current cart. This default implementation returns

        a big number if is_met() is true, otherwise 0.

        Either this method, or is_met() must be overridden in subclasses.

        '''

        return 99999999 if self.is_met(user) else 0

    def is_met(self, user):

        False.

        Either this method, or user_quantity_remaining() must be overridden

        in subclasses.

        '''

        return self.user_quantity_remaining(user) > 0

class CategoryConditionController(ConditionController):

    def __init__(self, condition):

        self.condition = condition

    def is_met(self, user):

        ''' returns True if the user has a product from a category that invokes

        this condition in one of their carts '''

        carts = rego.Cart.objects.filter(user=user, released=False)

        enabling_products = rego.Product.objects.filter(

            category=self.condition.enabling_category,

        )

        products_count = rego.ProductItem.objects.filter(

            cart__in=carts,

            product__in=enabling_products,

        ).count()

        return products_count > 0

class ProductConditionController(ConditionController):

    IncludedProductDiscount. '''

    def __init__(self, condition):

        self.condition = condition

    def is_met(self, user):

        ''' returns True if the user has a product that invokes this

        condition in one of their carts '''

        carts = rego.Cart.objects.filter(user=user, released=False)

        products_count = rego.ProductItem.objects.filter(

            cart__in=carts,

            product__in=self.condition.enabling_products.all(),

        ).count()

        return products_count > 0

class TimeOrStockLimitConditionController(ConditionController):

    Discount.'''

    def __init__(self, ceiling):

        self.ceiling = ceiling

    def user_quantity_remaining(self, user):

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

        the quantity remaining under the stock limit. '''

        # Test date range

        if not self._test_date_range():

            return 0

        return self._get_remaining_stock(user)

    def _test_date_range(self):

        now = timezone.now()

        if self.ceiling.start_time is not None:

            if now < self.ceiling.start_time:

                return False

        if self.ceiling.end_time is not None:

            if now > self.ceiling.end_time:

                return False

        return True

    def _get_remaining_stock(self, user):

        ''' Returns the stock that remains under this ceiling, excluding the

        user's current cart. '''

        if self.ceiling.limit is None:

            return 99999999

        # We care about all reserved carts, but not the user's current cart

        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

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

        )

        return product_items

class TimeOrStockLimitDiscountController(TimeOrStockLimitConditionController):

    def _items(self):

        discount_items = rego.DiscountItem.objects.filter(

            discount=self.ceiling,

        )

        return discount_items

class VoucherConditionController(ConditionController):

    def __init__(self, condition):

        self.condition = condition

    def is_met(self, user):

        ''' returns True if the user has the given voucher attached. '''

        carts_count = rego.Cart.objects.filter(

            user=user,

            vouchers=self.condition.voucher,

        ).count()

        return carts_count > 0

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

    @classmethod

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

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

        TODO: refactor so that all conditions are tested here and

        if category is None and products is None:

            raise ValueError("You must provide products or a category")

        if category is not None:

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

            all_products = all_products.select_related("category")

        else:

            all_products = []

        if products is not None:

            all_products = set(itertools.chain(all_products, products))

        cat_quants = dict(

            (

                category,

                CategoryController(category).user_quantity_remaining(user),

            )

            for category in set(product.category for product in all_products)

        )

        passed_limits = set(

            product

            for product in all_products

            if cat_quants[product.category] > 0

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

        )

            user, products=passed_limits

        )

        failed_conditions = set(i[0] for i in failed_and_messages)

        out = list(passed_limits - failed_conditions)

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

        return out

    def user_quantity_remaining(self, user):

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

        current cart. '''

        prod_limit = self.product.limit_per_user

        if prod_limit is None:

            # Don't need to run the remaining queries

            return 999999  # We can do better

        carts = rego.Cart.objects.filter(

            user=user,

            active=False,

            released=False,

        )

        items = rego.ProductItem.objects.filter(

            cart__in=carts,

            product=self.product,

        )

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

        return prod_limit - prod_count

    limit = models.PositiveIntegerField(

        null=True,

        blank=True,

        verbose_name=_("Limit"),

        help_text=_("This discount may only be applied this many times."),

    )

class VoucherDiscount(DiscountBase):

    ''' Discounts that are enabled when a voucher code is in the current

    cart. '''

    class Meta:

        verbose_name = _("discount (enabled by voucher)")

        verbose_name_plural = _("discounts (enabled by voucher)")

    voucher = models.OneToOneField(

        Voucher,

        on_delete=models.CASCADE,

        verbose_name=_("Voucher"),

        db_index=True,

    )

class IncludedProductDiscount(DiscountBase):

    ''' Discounts that are enabled because another product has been purchased.

    e.g. A conference ticket includes a free t-shirt. '''

    class Meta:

        verbose_name = _("discount (product inclusions)")

        verbose_name_plural = _("discounts (product inclusions)")

    enabling_products = models.ManyToManyField(

        Product,

        verbose_name=_("Including product"),

        help_text=_("If one of these products are purchased, the discounts "

                    "below will be enabled."),

    )

class RoleDiscount(object):

    ''' Discounts that are enabled because the active user has a specific

    role. This is for e.g. volunteers who can get a discount ticket. '''