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:

        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

        '''

        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)

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

        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,

        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)

def items_purchased(context, category=None):

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

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

        category=category

    )

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

        )

        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,

        )

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

        )

        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,

        )

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

        '''

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

        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

        )

        # 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

        )