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:

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

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

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

    )

            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.

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

    )

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)

        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

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