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 update_status(self):

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

        payments.'''

        old_status = self.invoice.status

        num_payments = commerce.PaymentBase.objects.filter(

            invoice=self.invoice,

        ).count()

        remainder = self.invoice.value - total_paid

        if old_status == commerce.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 == commerce.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 == commerce.Invoice.STATUS_REFUNDED:

            # Should not ever change from here

            pass

        elif old_status == commerce.Invoice.STATUS_VOID:

            # Should not ever change from here

        self.invoice.status = commerce.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 = commerce.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. '''

        self._refresh()

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

                # Free up the payments made to this invoice

                self.refund()

            else:

                self.void()

    def void(self):

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

            raise ValidationError("Invoices with payments must be refunded.")

        elif self.invoice.is_refunded:

            raise ValidationError("Refunded invoices may not be voided.")

        self._mark_void()

    @transaction.atomic

    def refund(self):

        ''' Refunds the invoice by generating a CreditNote for the value of

        all of the payments against the cart.

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

        as released.

        '''

        if self.invoice.is_void:

            raise ValidationError("Void invoices cannot be refunded")

        # Raises a credit note fot the value of the invoice.

        if amount == 0:

            self.void()

            return

        CreditNoteController.generate_from_invoice(self.invoice, amount)

        self.update_status()

    @classmethod

    def email(cls, invoice, kind):

        ''' Sends out an e-mail notifying the user about something to do

        with that invoice. '''

        context = {

            "invoice": invoice,

        }

        send_email([invoice.user.email], kind, context=context)

    @classmethod

    def email_on_invoice_creation(cls, invoice):

        ''' Sends out an e-mail notifying the user that an invoice has been

        created. '''

from . import conditions

from . import inventory

from django.contrib.auth.models import User

from django.core.exceptions import ValidationError

from django.db import models

from django.utils import timezone

from django.utils.encoding import python_2_unicode_compatible

from django.utils.translation import ugettext_lazy as _

from model_utils.managers import InheritanceManager

# Commerce Models

@python_2_unicode_compatible

class Cart(models.Model):

    ''' Represents a set of product items that have been purchased, or are

    pending purchase. '''

    class Meta:

        app_label = "registrasion"

        index_together = [

            ("status", "time_last_updated"),

            ("status", "user"),

        ]

    def __str__(self):

        return "%d rev #%d" % (self.id, self.revision)

    STATUS_ACTIVE = 1

    def __str__(self):

        return "Invoice #%d" % self.id

    def clean(self):

        if self.cart is not None and self.cart_revision is None:

            raise ValidationError(

                "If this is a cart invoice, it must have a revision")

    @property

    def is_unpaid(self):

        return self.status == self.STATUS_UNPAID

    @property

    def is_void(self):

        return self.status == self.STATUS_VOID

    @property

    def is_paid(self):

        return self.status == self.STATUS_PAID

    @property

    def is_refunded(self):

        return self.status == self.STATUS_REFUNDED

    # Invoice Number

    user = models.ForeignKey(User)

    cart = models.ForeignKey(Cart, null=True)

    cart_revision = models.IntegerField(

        null=True,

        db_index=True,

    )

    # Line Items (foreign key)

    status = models.IntegerField(

        choices=STATUS_TYPES,

        db_index=True,

    )

    recipient = models.CharField(max_length=1024)

    issue_time = models.DateTimeField()

    due_time = models.DateTimeField()

    value = models.DecimalField(max_digits=8, decimal_places=2)

@python_2_unicode_compatible

class LineItem(models.Model):

    ''' Line items for an invoice. These are denormalised from the ProductItems

    and DiscountItems that belong to a cart (for consistency), but also allow

    for arbitrary line items when required.

        invoice (commerce.Invoice): The invoice to which this LineItem is

            attached.

        description (str): A human-readable description of the line item.

        quantity (int): The quantity of items represented by this line.

        price (Decimal): The per-unit price for this line item.

        product (Optional[inventory.Product]): The product that this LineItem

            applies to. This allows you to do reports on sales and applied

            discounts to individual products.

    '''

    class Meta:

        app_label = "registrasion"

        ordering = ("id", )

    def __str__(self):

        return "Line: %s * %d @ %s" % (

            self.description, self.quantity, self.price)

    invoice = models.ForeignKey(Invoice)

    description = models.CharField(max_length=255)

    quantity = models.PositiveIntegerField()

    price = models.DecimalField(max_digits=8, decimal_places=2)

    product = models.ForeignKey(inventory.Product, null=True, blank=True)

@python_2_unicode_compatible

class PaymentBase(models.Model):

    ''' The base payment type for invoices. Payment apps should subclass this

    class to handle implementation-specific issues.

    Attributes:

        invoice (inventory.Invoice): The invoice that this payment applies to.

        time (datetime): The time that this payment was generated. Note that

            this will default to the current time when the model is created.

        reference (str): A human-readable reference for the payment, this will

            be displayed alongside the invoice.

        amount (Decimal): The amount the payment is for.

    '''

@register.assignment_tag(takes_context=True)

def invoices(context):

    '''

    Returns:

        [models.commerce.Invoice, ...]: All of the current user's invoices. '''

    return commerce.Invoice.objects.filter(user=context.request.user)

@register.assignment_tag(takes_context=True)

def items_pending(context):

    ''' Gets all of the items that the user from this context has reserved.'''

    return ItemController(context.request.user).items_pending()

@register.assignment_tag(takes_context=True)

def items_purchased(context, category=None):

    ''' Returns the items purchased for this user. '''

    return ItemController(context.request.user).items_purchased(

        category=category

    )

from registrasion.models import conditions

from registrasion.models import inventory

from controller_helpers import TestingCartController

from controller_helpers import TestingCreditNoteController

from controller_helpers import TestingInvoiceController

from test_helpers import TestHelperMixin

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

HOURS = datetime.timedelta(hours=1)

class CreditNoteTestCase(TestHelperMixin, RegistrationCartTestCase):

    def test_overpaid_invoice_results_in_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        # Invoice is overpaid by 1 unit

        to_pay = invoice.invoice.value + 1

        invoice.pay("Reference", to_pay)

        # The total paid should be equal to the value of the invoice only

        self.assertTrue(invoice.invoice.is_paid)

        # There should be a credit note generated out of the invoice.

        credit_notes = commerce.CreditNote.objects.filter(

            invoice=invoice.invoice,

        )

        self.assertEqual(1, credit_notes.count())

        self.assertEqual(to_pay - invoice.invoice.value, credit_notes[0].value)

    def test_full_paid_invoice_does_not_generate_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        # Invoice is paid evenly

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

        # The total paid should be equal to the value of the invoice only

        self.assertTrue(invoice.invoice.is_paid)

        # There should be no credit notes

        credit_notes = commerce.CreditNote.objects.filter(

            invoice=invoice.invoice,

        )

        self.assertEqual(0, credit_notes.count())

    def test_refund_partially_paid_invoice_generates_correct_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        # Invoice is underpaid by 1 unit

        to_pay = invoice.invoice.value - 1

        invoice.pay("Reference", to_pay)

        invoice.refund()

        # The total paid should be zero

        self.assertTrue(invoice.invoice.is_void)

        # There should be a credit note generated out of the invoice.

        credit_notes = commerce.CreditNote.objects.filter(

            invoice=invoice.invoice,

        )

        self.assertEqual(1, credit_notes.count())

        self.assertEqual(to_pay, credit_notes[0].value)

    def test_refund_fully_paid_invoice_generates_correct_credit_note(self):

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        # The total paid should be zero

        self.assertTrue(invoice.invoice.is_refunded)

        # There should be a credit note generated out of the invoice.

        credit_notes = commerce.CreditNote.objects.filter(

            invoice=invoice.invoice,

        )

        self.assertEqual(1, credit_notes.count())

        self.assertEqual(to_pay, credit_notes[0].value)

    def test_apply_credit_note_pays_invoice(self):

        # Create a manual invoice (stops credit notes from being auto-applied)

        self._manual_invoice(1)

        # Begin the test

        invoice = self._invoice_containing_prod_1(1)

        to_pay = invoice.invoice.value

        invoice.pay("Reference", to_pay)

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

        # Generate a new invoice to the same value as first invoice

        # Should be paid, because we're applying credit notes automatically

        invoice2 = self._invoice_containing_prod_1(1)

        self.assertTrue(invoice2.invoice.is_paid)

    def _generate_multiple_credit_notes(self):

        invoice1 = self._manual_invoice(11)

        invoice2 = self._manual_invoice(11)

        invoice1.pay("Pay", invoice1.invoice.value)

        invoice1.refund()

        invoice2.pay("Pay", invoice2.invoice.value)

        invoice2.refund()

        return invoice1.invoice.value + invoice2.invoice.value

    def test_mutiple_credit_notes_are_applied_when_generating_invoice_1(self):

        ''' Tests (1) that multiple credit notes are applied to new invoice.

        Sum of credit note values will be *LESS* than the new invoice.

        '''

        notes_value = self._generate_multiple_credit_notes()

        invoice = self._manual_invoice(notes_value + 1)

        self.assertTrue(invoice.invoice.is_unpaid)

        user_unclaimed = commerce.CreditNote.unclaimed()

        user_unclaimed = user_unclaimed.filter(invoice__user=self.USER_1)

        self.assertEqual(0, user_unclaimed.count())

    def test_mutiple_credit_notes_are_applied_when_generating_invoice_2(self):

        ''' Tests (2) that multiple credit notes are applied to new invoice.

        Sum of credit note values will be *GREATER* than the new invoice.

        '''

        notes_value = self._generate_multiple_credit_notes()

        invoice = self._manual_invoice(notes_value - 1)

        self.assertTrue(invoice.invoice.is_paid)

        user_unclaimed = commerce.CreditNote.unclaimed().filter(

            invoice__user=self.USER_1

        )

        self.assertEqual(1, user_unclaimed.count())

        excess = self._credit_note_for_invoice(invoice.invoice)

        self.assertEqual(excess.credit_note.value, 1)

    def test_credit_notes_are_left_over_if_not_all_are_needed(self):

        ''' Tests that excess credit notes are untouched if they're not needed

        '''

        notes_value = self._generate_multiple_credit_notes()

        notes_old = commerce.CreditNote.unclaimed().filter(

            invoice__user=self.USER_1

        )

        # Create a manual invoice whose value is smaller than any of the

        # credit notes we created

        invoice = self._manual_invoice(1)

        notes_new = commerce.CreditNote.unclaimed().filter(

            invoice__user=self.USER_1

        )

        # Item is True if the note was't consumed when generating invoice.

        note_was_unused = [(i in notes_old) for i in notes_new]

        self.assertIn(True, note_was_unused)

    def test_credit_notes_are_not_applied_if_user_has_multiple_invoices(self):

        # Have an invoice pending with no credit notes; no payment will be made

        invoice1 = self._invoice_containing_prod_1(1)

        # Create some credit notes.

        self._generate_multiple_credit_notes()

        invoice = self._manual_invoice(2)

        # Because there's already an invoice open for this user

        # The credit notes are not automatically applied.

        self.assertTrue(invoice.invoice.is_unpaid)

    def test_credit_notes_are_applied_even_if_some_notes_are_claimed(self):

        for i in xrange(10):

            # Generate credit note

            invoice1 = self._manual_invoice(1)

            invoice1.pay("Pay", invoice1.invoice.value)

            invoice1.refund()

            # Generate invoice that should be automatically paid

            invoice2 = self._manual_invoice(1)

            self.assertTrue(invoice2.invoice.is_paid)

    def test_cancellation_fee_is_applied(self):

        invoice1 = self._manual_invoice(1)

        invoice1.pay("Pay", invoice1.invoice.value)

        invoice1.refund()

        percentage = 15

        cn = self._credit_note_for_invoice(invoice1.invoice)

        canc = cn.cancellation_fee(15)

        cart_2.add_to_cart(self.PROD_1, 1)

        # Now try to invoice the first user

        with self.assertRaises(ValidationError):

            TestingInvoiceController.for_cart(current_cart.cart)

    def test_paying_invoice_makes_new_cart(self):

        invoice = self._invoice_containing_prod_1(1)

        invoice.pay("A payment!", invoice.invoice.value)

        # This payment is for the correct amount invoice should be paid.

        self.assertTrue(invoice.invoice.is_paid)

        # Cart should not be active

        self.assertNotEqual(

            commerce.Cart.STATUS_ACTIVE,

            invoice.invoice.cart.status,

        )

        # Asking for a cart should generate a new one

        new_cart = TestingCartController.for_user(self.USER_1)

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

    def test_invoice_includes_discounts(self):

        voucher = inventory.Voucher.objects.create(

            recipient="Voucher recipient",

            code="VOUCHER",

            limit=1

        )

        discount = conditions.VoucherDiscount.objects.create(

            description="VOUCHER RECIPIENT",

            voucher=voucher,

        )

        conditions.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)