value = item.product.price * (condition.percentage / 100)

        else:

            value = condition.price

        return value

    @classmethod

    def _generate(cls, cart):

        ''' Generates an invoice for the given cart. '''

        invoice = rego.Invoice.objects.create(

            user=cart.user,

            cart=cart,

            cart_revision=cart.revision,

            value=Decimal()

        )

        product_items = rego.ProductItem.objects.filter(cart=cart)

        product_items = product_items.order_by(

            "product__category__order", "product__order"

        )

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

        invoice_value = Decimal()

        for item in product_items:

            line_item = rego.LineItem.objects.create(

                invoice=invoice,

                description="%s - %s" % (product.category.name, product.name),

                quantity=item.quantity,

                price=product.price,

            )

            invoice_value += line_item.quantity * line_item.price

        for item in discount_items:

            line_item = rego.LineItem.objects.create(

                invoice=invoice,

                description=item.discount.description,

                quantity=item.quantity,

                price=cls.resolve_discount_value(item) * -1,

            )

            invoice_value += line_item.quantity * line_item.price

        invoice.value = invoice_value

        invoice.save()

        return invoice

    def update_validity(self):

        ''' Updates the validity of this invoice if the cart it is attached to

    ''' Products entry form that allows users to enter quantities

    of desired products. '''

    @classmethod

    def set_fields(cls, category, products):

        for product in products:

            field = forms.IntegerField(

                label=product.name,

                help_text=help_text,

            )

            cls.base_fields[cls.field_name(product)] = field

        cart__active=True,

    )

    return all_items

@register.assignment_tag(takes_context=True)

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=False,

    )

    products = set(item.product for item in all_items)

    out = []

    for product in products:

        pp = all_items.filter(product=product)

        quantity = pp.aggregate(Sum("quantity"))["quantity__sum"]

        out.append(ProductAndQuantity(product, quantity))

                cart=self.cart,

                product=product)

            old_quantity = product_item.quantity

        except ObjectDoesNotExist:

            old_quantity = 0

        self.set_quantity(product, old_quantity + quantity)

        cls.PROD_4.price = Decimal("5.00")

        cls.PROD_4.save()

        # Burn through some carts -- this made some past EC tests fail

        current_cart = TestingCartController.for_user(cls.USER_1)

        current_cart = TestingCartController.for_user(cls.USER_2)

    @classmethod

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

        limit_ceiling = rego.TimeOrStockLimitEnablingCondition.objects.create(

            description=name,

            mandatory=True,

class BasicCartTests(RegistrationCartTestCase):

    def test_get_cart(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        old_cart = current_cart

        current_cart = TestingCartController.for_user(self.USER_1)

        self.assertNotEqual(old_cart.cart, current_cart.cart)

        # User should not be able to add 10 of PROD_1 to the current cart now,

        # because they have a limit of 10.

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_1, 10)

        current_cart = TestingCartController.for_user(self.USER_1)

        # User should not be able to add 10 of PROD_1 to the current cart now,

        # even though it's a new cart.

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_1, 10)

        current_cart.set_quantity(self.PROD_3, 5)

        current_cart.set_quantity(self.PROD_4, 5)

        # Cannot add to cart if category limit is filled by two products

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_3, 1)

        current_cart = TestingCartController.for_user(self.USER_1)

        # The category limit should extend across carts

        with self.assertRaises(ValidationError):

            current_cart.add_to_cart(self.PROD_3, 10)

        current_cart.set_quantity(self.PROD_3, 0)

        with self.assertRaises(ValidationError):

            # There's only 6 allowed of PROD_4

            current_cart.add_to_cart(self.PROD_4, 1)

        # The limits should extend across carts...

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.set_quantity(self.PROD_3, 4)

        with self.assertRaises(ValidationError):

            current_cart.set_quantity(self.PROD_3, 5)

        current_cart = TestingCartController.for_user(self.USER_1)

        prods = get_prods()

        self.assertTrue(item in prods)

        current_cart.add_to_cart(item, quantity)

        self.assertTrue(item in prods)

        current_cart = TestingCartController.for_user(self.USER_1)

        prods = get_prods()

        self.assertTrue(item not in prods)

        # User 2 should be able to add item to their cart once the

        # reservation duration is elapsed

        self.add_timedelta(self.RESERVATION + datetime.timedelta(seconds=1))

        second_cart.add_to_cart(self.PROD_1, 1)

        # User 2 pays for their cart

        # User 1 should not be able to add item to their cart

        # because user 2 has paid for their reserved item, exhausting

        # the ceiling, regardless of the reservation time.

        self.add_timedelta(self.RESERVATION * 20)

        with self.assertRaises(ValidationError):

        # Unpaid cart within reservation window

        second_cart.add_to_cart(self.PROD_1, 1)

        with self.assertRaises(ValidationError):

            first_cart.validate_cart()

        # Paid cart outside the reservation window

        self.add_timedelta(self.RESERVATION + datetime.timedelta(seconds=1))

        with self.assertRaises(ValidationError):

            first_cart.validate_cart()

    def test_items_released_from_ceiling_by_refund(self):

        self.make_ceiling("Limit ceiling", limit=1)

        first_cart = TestingCartController.for_user(self.USER_1)

        first_cart.add_to_cart(self.PROD_1, 1)

        second_cart = TestingCartController.for_user(self.USER_2)

        with self.assertRaises(ValidationError):

            second_cart.add_to_cart(self.PROD_1, 1)

        first_cart.cart.released = True

        second_cart.add_to_cart(self.PROD_1, 1)

    def test_discount_ceiling_only_counts_items_covered_by_ceiling(self):

        self.make_discount_ceiling("Limit ceiling", limit=1, percentage=50)

        voucher = self.new_voucher(code="VOUCHER")

        # the 100% discount from the voucher should apply to the first item

        # and not the ceiling discount.

        cart.apply_voucher("VOUCHER")

        cart.add_to_cart(self.PROD_1, 1)

        self.assertEqual(1, len(cart.cart.discountitem_set.all()))

        # The second cart has no voucher attached, so should apply the

        # ceiling discount

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        self.assertEqual(1, len(cart.cart.discountitem_set.all()))

    def test_discount_applies_across_carts(self):

        self.add_discount_prod_1_includes_prod_2()

        # Enable the discount during the first cart.

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        # Use the discount in the second cart

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 1)

        # The discount should be applied.

        self.assertEqual(1, len(cart.cart.discountitem_set.all()))

        # The discount should respect the total quantity across all

        # of the user's carts.

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 2)

    def test_discount_applies_only_once_enabled(self):

        # Enable the discount during the first cart.

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        # This would exhaust discount if present

        cart.add_to_cart(self.PROD_2, 2)

        self.add_discount_prod_1_includes_prod_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 2)

        discount_items = list(cart.cart.discountitem_set.all())

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(2, discounts[0].quantity)

    def test_discount_quantity_is_correct_after_first_purchase(self):

        self.test_discount_quantity_is_correct_before_first_purchase()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(1, discounts[0].quantity)

    def test_discount_is_gone_after_quantity_exhausted(self):

        self.test_discount_quantity_is_correct_after_first_purchase()

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(0, len(discounts))

            [],

            [self.PROD_2],

        )

        self.assertEqual(1, len(discounts))

        cart.cart.active = False  # Keep discount enabled

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 2)  # The discount will be exhausted

        discounts = discount.available_discounts(

            self.USER_1,

            [],

            [self.PROD_2],

        )

        self.assertEqual(0, len(discounts))

        cart.cart.released = True

        discounts = discount.available_discounts(

            self.USER_1,

            [],

            [self.PROD_2],

        )

    def test_product_enabled_by_product_in_previous_cart(self):

        self.add_product_enabling_condition()

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_2, 1)

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

    def test_product_enabling_condition_enables_category(self):

    def test_product_enabled_by_category_in_previous_cart(self):

        self.add_category_enabling_condition()

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.add_to_cart(self.PROD_3, 1)

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

    def test_multiple_non_mandatory_conditions(self):

    def test_category_enabling_condition_fails_if_cart_refunded(self):

        self.add_category_enabling_condition(mandatory=False)

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_3, 1)

        cart_2 = TestingCartController.for_user(self.USER_1)

        cart_2.add_to_cart(self.PROD_1, 1)

        cart_2.set_quantity(self.PROD_1, 0)

        cart.cart.released = True

        with self.assertRaises(ValidationError):

            cart_2.set_quantity(self.PROD_1, 1)

    def test_product_enabling_condition_fails_if_cart_refunded(self):

        self.add_product_enabling_condition(mandatory=False)

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 1)

        cart_2 = TestingCartController.for_user(self.USER_1)

        cart_2.add_to_cart(self.PROD_1, 1)

        cart_2.set_quantity(self.PROD_1, 0)

        cart.cart.released = True

        with self.assertRaises(ValidationError):

            cart_2.set_quantity(self.PROD_1, 1)

    def test_available_categories(self):

        self.add_product_enabling_condition_on_category(mandatory=False)

    def test_invoice_includes_discounts(self):

        voucher = rego.Voucher.objects.create(

            recipient="Voucher recipient",

            code="VOUCHER",

            limit=1

        )

        discount = rego.VoucherDiscount.objects.create(

            description="VOUCHER RECIPIENT",

            voucher=voucher,

        )

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=self.PROD_1,

            percentage=Decimal(50),

            quantity=1

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        self.assertEqual(2, len(line_items))

        # That invoice should have a value equal to 50% of the cost of PROD_1

        self.assertEqual(

            self.PROD_1.price * Decimal("0.5"),

            invoice_1.invoice.value)

    def test_invoice_voids_self_if_cart_is_invalid(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice_1 = InvoiceController.for_cart(current_cart.cart)

        invoice_1 = InvoiceController.for_cart(current_cart.cart)

        invoice_1.pay("Reference", invoice_1.invoice.value)

        with self.assertRaises(ValidationError):

            invoice_1.void()

            cart_2.apply_voucher(voucher.code)

        # After the reservation duration

        # user 2 should be able to apply voucher

        self.add_timedelta(rego.Voucher.RESERVATION_DURATION * 2)

        cart_2.apply_voucher(voucher.code)

        # After the reservation duration, even though the voucher has applied,

        # it exceeds the number of vouchers available.

        self.add_timedelta(rego.Voucher.RESERVATION_DURATION * 2)

        with self.assertRaises(ValidationError):

            cart_1.validate_cart()

    def test_voucher_can_only_be_applied_once_across_multiple_carts(self):

        voucher = self.new_voucher(limit=2)

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.apply_voucher(voucher.code)

        return current_cart

    def test_refund_releases_used_vouchers(self):

        voucher = self.new_voucher(limit=2)

        current_cart = TestingCartController.for_user(self.USER_1)

        current_cart.apply_voucher(voucher.code)

        inv = InvoiceController.for_cart(current_cart.cart)

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

            current_cart.apply_voucher(voucher.code)

        inv.refund("Hello!", inv.invoice.value)