self.update_status()

        self.update_validity()  # Make sure this invoice is up-to-date

    @classmethod

    def for_cart(cls, cart):

        ''' Returns an invoice object for a given cart at its current revision.

        If such an invoice does not exist, the cart is validated, and if valid,

        an invoice is generated.'''

        try:

            invoice = rego.Invoice.objects.exclude(

                status=rego.Invoice.STATUS_VOID,

            ).get(

                cart=cart,

                cart_revision=cart.revision,

            )

        except ObjectDoesNotExist:

            cart_controller = CartController(cart)

            cart_controller.validate_cart()  # Raises ValidationError on fail.

            cls.void_all_invoices(cart)

            invoice = cls._generate(cart)

        return cls(invoice)

    @classmethod

    def void_all_invoices(cls, cart):

        invoices = rego.Invoice.objects.filter(cart=cart).all()

        for invoice in invoices:

            cls(invoice).void()

    @classmethod

    def resolve_discount_value(cls, item):

        try:

            condition = rego.DiscountForProduct.objects.get(

                discount=item.discount,

                product=item.product

            )

        except ObjectDoesNotExist:

            condition = rego.DiscountForCategory.objects.get(

                discount=item.discount,

                category=item.product.category

            )

        if condition.percentage is not None:

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

        else:

            value = condition.price

        return value

    @classmethod

    @transaction.atomic

    def _generate(cls, cart):

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

        issued = timezone.now()

        reservation_limit = cart.reservation_duration + cart.time_last_updated

        # Never generate a due time that is before the issue time

        due = max(issued, reservation_limit)

        # Get the invoice recipient

        profile = rego.AttendeeProfileBase.objects.get_subclass(

            id=cart.user.attendee.attendeeprofilebase.id,

        )

        recipient = profile.invoice_recipient()

        invoice = rego.Invoice.objects.create(

            user=cart.user,

            cart=cart,

            cart_revision=cart.revision,

            status=rego.Invoice.STATUS_UNPAID,

            value=Decimal(),

            issue_time=issued,

            due_time=due,

            recipient=recipient,

        )

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

        if len(product_items) == 0:

            raise ValidationError("Your cart is empty.")

        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:

            product = item.product

            line_item = rego.LineItem.objects.create(

                invoice=invoice,

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

                quantity=item.quantity,

                price=product.price,

                product=product,

            )

            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,

                product=item.product,

            )

            invoice_value += line_item.quantity * line_item.price

        invoice.value = invoice_value

        invoice.save()

        return invoice

    def can_view(self, user=None, access_code=None):

        ''' Returns true if the accessing user is allowed to view this invoice,

        or if the given access code matches this invoice's user's access code.

        '''

        if user == self.invoice.user:

            return True

        if user.is_staff:

            return True

        if self.invoice.user.attendee.access_code == access_code:

            return True

        return False

    def _refresh(self):

        ''' Refreshes the underlying invoice and cart objects. '''

        self.invoice.refresh_from_db()

        if self.invoice.cart:

            self.invoice.cart.refresh_from_db()

    def validate_allowed_to_pay(self):

        ''' Passes cleanly if we're allowed to pay, otherwise raise

        a ValidationError. '''

        self._refresh()

        if not self.invoice.is_unpaid:

            raise ValidationError("You can only pay for unpaid invoices.")

        if not self.invoice.cart:

            return

        if not self._invoice_matches_cart():

            raise ValidationError("The registration has been amended since "

                                  "generating this invoice.")

        CartController(self.invoice.cart).validate_cart()

    def total_payments(self):

        ''' Returns the total amount paid towards this invoice. '''

        payments = rego.PaymentBase.objects.filter(invoice=self.invoice)

        total_paid = payments.aggregate(Sum("amount"))["amount__sum"] or 0

        return total_paid

    def update_status(self):

        ''' Updates the status of this invoice based upon the total

        payments.'''

        old_status = self.invoice.status

        total_paid = self.total_payments()

        num_payments = rego.PaymentBase.objects.filter(

            invoice=self.invoice,

        ).count()

        remainder = self.invoice.value - total_paid

        if old_status == rego.Invoice.STATUS_UNPAID:

            # Invoice had an amount owing

            if remainder <= 0:

                # Invoice no longer has amount owing

                self._mark_paid()

            elif total_paid == 0 and num_payments > 0:

                # Invoice has multiple payments totalling zero

                self._mark_void()

        elif old_status == rego.Invoice.STATUS_PAID:

            if remainder > 0:

                # Invoice went from having a remainder of zero or less

                # to having a positive remainder -- must be a refund

                self._mark_refunded()

        elif old_status == rego.Invoice.STATUS_REFUNDED:

            # Should not ever change from here

            pass

        elif old_status == rego.Invoice.STATUS_VOID:

            # Should not ever change from here

            pass

    def _mark_paid(self):

        ''' Marks the invoice as paid, and updates the attached cart if

        necessary. '''

        cart = self.invoice.cart

        if cart:

            cart.active = False

            cart.save()

        self.invoice.status = rego.Invoice.STATUS_PAID

        self.invoice.save()

    def _mark_refunded(self):

        ''' Marks the invoice as refunded, and updates the attached cart if

        necessary. '''

        cart = self.invoice.cart

        if cart:

            cart.active = False

            cart.released = True

            cart.save()

        self.invoice.status = rego.Invoice.STATUS_REFUNDED

        self.invoice.save()

    def _mark_void(self):

        ''' Marks the invoice as refunded, and updates the attached cart if

        necessary. '''

        self.invoice.status = rego.Invoice.STATUS_VOID

        self.invoice.save()

    def _invoice_matches_cart(self):

        ''' Returns true if there is no cart, or if the revision of this

        invoice matches the current revision of the cart. '''

        cart = self.invoice.cart

        if not cart:

            return True

        return cart.revision == self.invoice.cart_revision

    def update_validity(self):

        ''' Voids this invoice if the cart it is attached to has updated. '''

        if not self._invoice_matches_cart():

            self.void()

    def void(self):

        ''' Voids the invoice if it is valid to do so. '''

        if self.invoice.status == rego.Invoice.STATUS_PAID:

            raise ValidationError("Paid invoices cannot be voided, "

                                  "only refunded.")

        self._mark_void()

    @transaction.atomic

    def refund(self, reference, amount):

        ''' Refunds the invoice by the given amount.

        The invoice is marked as refunded, and the underlying cart is marked

        as released.

        TODO: replace with credit notes work instead.

        '''

        if self.invoice.is_void:

            raise ValidationError("Void invoices cannot be refunded")

        # Adds a payment

        # TODO: replace by creating a credit note instead

        rego.ManualPayment.objects.create(

            invoice=self.invoice,

            reference=reference,

from registrasion.controllers.cart import CartController

from registrasion.controllers.invoice import InvoiceController

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

        try:

            product_item = rego.ProductItem.objects.get(

                cart=self.cart,

                product=product)

            old_quantity = product_item.quantity

        except ObjectDoesNotExist:

            old_quantity = 0

        self.set_quantity(product, old_quantity + quantity)

    def next_cart(self):

        self.cart.active = False

        self.cart.save()

class TestingInvoiceController(InvoiceController):

    def pay(self, reference, amount):

        ''' Testing method for simulating an invoice paymenht by the given

        amount. '''

        self.validate_allowed_to_pay()

        ''' Adds a payment '''

            invoice=self.invoice,

            reference=reference,

            amount=amount,

        )

        self.update_status()

import pytz

from decimal import Decimal

from registrasion import models as rego

from registrasion.controllers import discount

from controller_helpers import TestingCartController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class DiscountTestCase(RegistrationCartTestCase):

    @classmethod

    def add_discount_prod_1_includes_prod_2(

            cls,

            amount=Decimal(100),

            quantity=2,

            ):

        discount = rego.IncludedProductDiscount.objects.create(

            description="PROD_1 includes PROD_2 " + str(amount) + "%",

        )

        discount.save()

        discount.enabling_products.add(cls.PROD_1)

        discount.save()

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=cls.PROD_2,

            percentage=amount,

            quantity=quantity,

        ).save()

        return discount

    @classmethod

    def add_discount_prod_1_includes_cat_2(

            cls,

            amount=Decimal(100),

            quantity=2,

            ):

        discount = rego.IncludedProductDiscount.objects.create(

            description="PROD_1 includes CAT_2 " + str(amount) + "%",

        )

        discount.save()

        discount.enabling_products.add(cls.PROD_1)

        discount.save()

        rego.DiscountForCategory.objects.create(

            discount=discount,

            category=cls.CAT_2,

            percentage=amount,

            quantity=quantity,

        ).save()

        return discount

    @classmethod

    def add_discount_prod_1_includes_prod_3_and_prod_4(

            cls,

            amount=Decimal(100),

            quantity=2,

            ):

        discount = rego.IncludedProductDiscount.objects.create(

            description="PROD_1 includes PROD_3 and PROD_4 " +

                        str(amount) + "%",

        )

        discount.save()

        discount.enabling_products.add(cls.PROD_1)

        discount.save()

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=cls.PROD_3,

            percentage=amount,

            quantity=quantity,

        ).save()

        rego.DiscountForProduct.objects.create(

            discount=discount,

            product=cls.PROD_4,

            percentage=amount,

            quantity=quantity,

        ).save()

        return discount

    def test_discount_is_applied(self):

        self.add_discount_prod_1_includes_prod_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        cart.add_to_cart(self.PROD_2, 1)

        # Discounts should be applied at this point...

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

    def test_discount_is_applied_for_category(self):

        self.add_discount_prod_1_includes_cat_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        cart.add_to_cart(self.PROD_3, 1)

        # Discounts should be applied at this point...

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

    def test_discount_does_not_apply_if_not_met(self):

        self.add_discount_prod_1_includes_prod_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 1)

        # No discount should be applied as the condition is not met

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

    def test_discount_applied_out_of_order(self):

        self.add_discount_prod_1_includes_prod_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_2, 1)

        cart.add_to_cart(self.PROD_1, 1)

        # No discount should be applied as the condition is not met

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

    def test_discounts_collapse(self):

        self.add_discount_prod_1_includes_prod_2()

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        cart.add_to_cart(self.PROD_2, 1)

        cart.add_to_cart(self.PROD_2, 1)

        # Discounts should be applied and collapsed at this point...

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

    def test_discounts_respect_quantity(self):

        self.add_discount_prod_1_includes_prod_2()

        # Cart should not be active

        self.assertFalse(invoice.invoice.cart.active)

        # Asking for a cart should generate a new one

        new_cart = TestingCartController.for_user(self.USER_1)

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

    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)

        invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)

        # That invoice should have two line items

        line_items = rego.LineItem.objects.filter(invoice=invoice_1.invoice)

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

            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)

        invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)

        self.assertTrue(invoice_1.invoice.is_paid)

    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 = TestingInvoiceController.for_cart(current_cart.cart)

        self.assertFalse(invoice_1.invoice.is_void)

        # Adding item to cart should produce a new invoice

        current_cart.add_to_cart(self.PROD_2, 1)

        invoice_2 = TestingInvoiceController.for_cart(current_cart.cart)

        self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)

        # Viewing invoice_1's invoice should show it as void

        invoice_1_new = TestingInvoiceController(invoice_1.invoice)

        self.assertTrue(invoice_1_new.invoice.is_void)

        # Viewing invoice_2's invoice should *not* show it as void

        invoice_2_new = TestingInvoiceController(invoice_2.invoice)

        self.assertFalse(invoice_2_new.invoice.is_void)

    def test_voiding_invoice_creates_new_invoice(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 = TestingInvoiceController.for_cart(current_cart.cart)

        self.assertFalse(invoice_1.invoice.is_void)

        invoice_1.void()

        invoice_2 = TestingInvoiceController.for_cart(current_cart.cart)

        self.assertNotEqual(invoice_1.invoice, invoice_2.invoice)

    def test_cannot_pay_void_invoice(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 = TestingInvoiceController.for_cart(current_cart.cart)

        invoice_1.void()

        with self.assertRaises(ValidationError):

            invoice_1.validate_allowed_to_pay()

    def test_cannot_void_paid_invoice(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 = TestingInvoiceController.for_cart(current_cart.cart)

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

        with self.assertRaises(ValidationError):

            invoice_1.void()

    def test_cannot_generate_blank_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

    def test_cannot_pay_implicitly_void_invoice(self):

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice = TestingInvoiceController.for_cart(self.reget(cart.cart))

        # Implicitly void the invoice

        cart.add_to_cart(self.PROD_1, 1)

        with self.assertRaises(ValidationError):

            invoice.validate_allowed_to_pay()

    # TODO: test partially paid invoice cannot be void until payments

    # are refunded

    # TODO: test overpaid invoice results in credit note

    # TODO: test credit note generation more generally

import string

from django.utils.crypto import get_random_string

def generate_access_code():

    ''' Generates an access code for users' payments as well as their

    fulfilment code for check-in.

    The access code will 4 characters long, which allows for 1,500,625

    unique codes, which really should be enough for anyone. '''

    length = 4

    # all upper-case letters + digits 1-9 (no 0 vs O confusion)

    chars = string.uppercase + string.digits[1:]

    # 4 chars => 35 ** 4 = 1500625 (should be enough for anyone)

    return get_random_string(length=length, allowed_chars=chars)