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

        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:

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

        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:

                    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:

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

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

                              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)

            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

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

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

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

        )

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

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

            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)

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

    # TODO: implement RoleDiscount

    pass

@python_2_unicode_compatible

    ''' This defines a condition which allows products or categories to

    def __str__(self):

        return self.description

    def effects(self):

        return itertools.chain(self.products.all(), self.categories.all())

    description = models.CharField(max_length=255)

    )

    products = models.ManyToManyField(

        Product,

        blank=True,

    )

    categories = models.ManyToManyField(

        Category,

        blank=True,

    )

    ''' Registration product ceilings '''

    class Meta:

    start_time = models.DateTimeField(

        null=True,

        blank=True,

        help_text=_("Products included in this condition will only be "

                    "available after this time."),

        help_text=_("The number of items under this grouping that can be "

                    "purchased."),

    )

@python_2_unicode_compatible

    ''' The condition is met because a specific product is purchased. '''

    def __str__(self):

        return "Enabled by products: " + str(self.enabling_products.all())

    enabling_products = models.ManyToManyField(

        Product,

        help_text=_("If one of these products are purchased, this condition "

                    "is met."),

    )

@python_2_unicode_compatible

    ''' The condition is met because a product in a particular product is

    purchased. '''

    def __str__(self):

        return "Enabled by product in category: " + str(self.enabling_category)

    enabling_category = models.ForeignKey(

        Category,

        help_text=_("If a product from this category is purchased, this "

                    "condition is met."),

    )

@python_2_unicode_compatible

    ''' The condition is met because a Voucher is present. This is for e.g.

    enabling sponsor tickets. '''

    def __str__(self):

        return "Enabled by voucher: %s" % self.voucher

    voucher = models.OneToOneField(Voucher)

# @python_2_unicode_compatible

    ''' The condition is met because the active user has a particular Role.

    This is for e.g. enabling Team tickets. '''

    pass

# Commerce Models

@python_2_unicode_compatible

        current_cart = TestingCartController.for_user(cls.USER_2)

        current_cart.next_cart()

    @classmethod

    def make_ceiling(cls, name, limit=None, start_time=None, end_time=None):

            description=name,

            limit=limit,

            start_time=start_time,

            end_time=end_time

        )

        limit_ceiling.save()

        limit_ceiling.products.add(cls.PROD_1, cls.PROD_2)

        limit_ceiling.save()

    @classmethod

    def make_category_ceiling(

            cls, name, limit=None, start_time=None, end_time=None):

            description=name,

            limit=limit,

            start_time=start_time,

            end_time=end_time

        )

        limit_ceiling.save()

        limit_ceiling.categories.add(cls.CAT_1)

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

    @classmethod

        predicated on adding PROD_2 beforehand. '''

            description="Product condition",

        )

    @classmethod

        adding an item from CAT_1 is predicated on adding PROD_3 beforehand '''

            description="Product condition",

        )

        predicated on adding an item from CAT_2 beforehand.'''

            description="Category condition",

            enabling_category=cls.CAT_2,

        )

        # Cannot buy PROD_1 without buying PROD_2

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_1, 1)

        current_cart.add_to_cart(self.PROD_2, 1)

        current_cart.add_to_cart(self.PROD_1, 1)

    def test_product_enabled_by_product_in_previous_cart(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_2, 1)

        current_cart.next_cart()

        # Create new cart and try to add PROD_1

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_1, 1)

        # Cannot buy PROD_1 without buying item from CAT_2

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_1, 1)

        current_cart.add_to_cart(self.PROD_3, 1)

        current_cart.add_to_cart(self.PROD_1, 1)

        # Cannot buy PROD_1 without buying PROD_2

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_1, 1)

        # PROD_3 is in CAT_2

        current_cart.add_to_cart(self.PROD_3, 1)

        current_cart.add_to_cart(self.PROD_1, 1)

    def test_product_enabled_by_category_in_previous_cart(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_3, 1)

        current_cart.next_cart()

        # Create new cart and try to add PROD_1

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_1, 1)

        cart_1 = TestingCartController.for_user(self.USER_1)

        # Cannot add PROD_1 until a condition is met

        with self.assertRaises(ValidationError):

            cart_1.add_to_cart(self.PROD_1, 1)

        cart_1.add_to_cart(self.PROD_2, 1)

        cart_1.add_to_cart(self.PROD_1, 1)