# Get the invoice recipient

        profile = people.AttendeeProfileBase.objects.get_subclass(

            id=user.attendee.attendeeprofilebase.id,

        )

        recipient = profile.invoice_recipient()

        invoice_value = sum(item.quantity * item.price for item in line_items)

        invoice = commerce.Invoice.objects.create(

            user=user,

            cart=cart,

            cart_revision=cart.revision if cart else None,

            status=commerce.Invoice.STATUS_UNPAID,

            value=invoice_value,

            issue_time=issued,

            due_time=due,

            recipient=recipient,

        )

        # Associate the line items with the invoice

        for line_item in line_items:

            line_item.invoice = invoice

        commerce.LineItem.objects.bulk_create(line_items)

        cls._apply_credit_notes(invoice)

        cls.email_on_invoice_creation(invoice)

        return invoice

    @classmethod

    def _apply_credit_notes(cls, invoice):

        ''' Applies the user's credit notes to the given invoice on creation.

        '''

        # We only automatically apply credit notes if this is the *only*

        # unpaid invoice for this user.

        invoices = commerce.Invoice.objects.filter(

            user=invoice.user,

            status=commerce.Invoice.STATUS_UNPAID,

        )

        if invoices.count() > 1:

            return

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

            invoice__user=invoice.user

        )

        for note in notes:

            try:

                CreditNoteController(note).apply_to_invoice(invoice)

            except ValidationError:

                # ValidationError will get raised once we're overpaying.

                break

        invoice.refresh_from_db()

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

            pass

        # Generate credit notes from residual payments

        residual = 0

        if self.invoice.is_paid:

            if remainder < 0:

                residual = 0 - remainder

        elif self.invoice.is_void or self.invoice.is_refunded:

            residual = total_paid

        if residual != 0:

            CreditNoteController.generate_from_invoice(self.invoice, residual)

        self.email_on_invoice_change(

            self.invoice,

            old_status,

            self.invoice.status,

        )

    def _mark_paid(self):

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

        necessary. '''

        cart = self.invoice.cart

        if cart:

            cart.status = commerce.Cart.STATUS_PAID

            cart.save()

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

            cart.save()

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

        cls.email(invoice, "invoice_created")

    @classmethod

    def email_on_invoice_change(cls, invoice, old_status, new_status):

        ''' Sends out all of the necessary notifications that the status of the

        invoice has changed to:

        - Invoice is now paid

        - Invoice is now refunded

        '''

        # The statuses that we don't care about.

        silent_status = [

            commerce.Invoice.STATUS_VOID,

            commerce.Invoice.STATUS_UNPAID,

        ]

        if old_status == new_status:

            return

        if False and new_status in silent_status:

            pass

        cls.email(invoice, "invoice_updated")

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

    STATUS_PAID = 2

    STATUS_RELEASED = 3

    STATUS_TYPES = [

        (STATUS_ACTIVE, _("Active")),

        (STATUS_PAID, _("Paid")),

        (STATUS_RELEASED, _("Released")),

    ]

    user = models.ForeignKey(User)

    # ProductItems (foreign key)

    vouchers = models.ManyToManyField(inventory.Voucher, blank=True)

    time_last_updated = models.DateTimeField(

        db_index=True,

    )

    reservation_duration = models.DurationField()

    revision = models.PositiveIntegerField(default=1)

    status = models.IntegerField(

        choices=STATUS_TYPES,

        db_index=True,

        default=STATUS_ACTIVE,

    )

    @classmethod

    def reserved_carts(cls):

        ''' Gets all carts that are 'reserved' '''

        return Cart.objects.filter(

            (Q(status=Cart.STATUS_ACTIVE) &

                Q(time_last_updated__gt=(

                    timezone.now()-F('reservation_duration')

                                        ))) |

            Q(status=Cart.STATUS_PAID)

        )

@python_2_unicode_compatible

class ProductItem(models.Model):

    ''' Represents a product-quantity pair in a Cart. '''

    class Meta:

        app_label = "registrasion"

        ordering = ("product", )

    def __str__(self):

        return "product: %s * %d in Cart: %s" % (

            self.product, self.quantity, self.cart)

    cart = models.ForeignKey(Cart)

    product = models.ForeignKey(inventory.Product)

    quantity = models.PositiveIntegerField(db_index=True)

@python_2_unicode_compatible

class DiscountItem(models.Model):

    ''' Represents a discount-product-quantity relation in a Cart. '''

    class Meta:

        app_label = "registrasion"

        ordering = ("product", )

    def __str__(self):

        return "%s: %s * %d in Cart: %s" % (

            self.discount, self.product, self.quantity, self.cart)

    cart = models.ForeignKey(Cart)

    product = models.ForeignKey(inventory.Product)

    discount = models.ForeignKey(conditions.DiscountBase)

    quantity = models.PositiveIntegerField()

@python_2_unicode_compatible

class Invoice(models.Model):

    ''' An invoice. Invoices can be automatically generated when checking out

    a Cart, in which case, it is attached to a given revision of a Cart.

    Attributes:

        user (User): The owner of this invoice.

        cart (commerce.Cart): The cart that was used to generate this invoice.

        cart_revision (int): The value of ``cart.revision`` at the time of this

            invoice's creation. If a change is made to the underlying cart,

            this invoice is automatically void -- this change is detected

            when ``cart.revision != cart_revision``.

        status (int): One of ``STATUS_UNPAID``, ``STATUS_PAID``,

            ``STATUS_REFUNDED``, OR ``STATUS_VOID``. Call

            ``get_status_display`` for a human-readable representation.

        recipient (str): A rendered representation of the invoice's recipient.

        issue_time (datetime): When the invoice was issued.

        due_time (datetime): When the invoice is due.

        value (Decimal): The total value of the line items attached to the

            invoice.

        lineitem_set (Queryset[LineItem]): The set of line items that comprise

            this invoice.

        paymentbase_set(Queryset[PaymentBase]): The set of PaymentBase objects

            that have been applied to this invoice.

    '''

    class Meta:

        app_label = "registrasion"

    STATUS_UNPAID = 1

    STATUS_PAID = 2

    STATUS_REFUNDED = 3

    STATUS_VOID = 4

    STATUS_TYPES = [

        (STATUS_UNPAID, _("Unpaid")),

        (STATUS_PAID, _("Paid")),

        (STATUS_REFUNDED, _("Refunded")),

        (STATUS_VOID, _("VOID")),

    ]

    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.

    Attributes:

        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.

    '''

    class Meta:

        ordering = ("time", )

    objects = InheritanceManager()

    def __str__(self):

        return "Payment: ref=%s amount=%s" % (self.reference, self.amount)

    invoice = models.ForeignKey(Invoice)

    time = models.DateTimeField(default=timezone.now)

    reference = models.CharField(max_length=255)

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

class ManualPayment(PaymentBase):

    ''' Payments that are manually entered by staff. '''

    class Meta:

        app_label = "registrasion"

    entered_by = models.ForeignKey(User)

class CreditNote(PaymentBase):

    ''' Credit notes represent money accounted for in the system that do not

    belong to specific invoices. They may be paid into other invoices, or

    cashed out as refunds.

    Each CreditNote may either be used to pay towards another Invoice in the

    system (by attaching a CreditNoteApplication), or may be marked as

    refunded (by attaching a CreditNoteRefund).'''

    class Meta:

        app_label = "registrasion"

    @classmethod

    def unclaimed(cls):

        return cls.objects.filter(

            creditnoteapplication=None,

            creditnoterefund=None,

        )

    @property

    def status(self):

        if self.is_unclaimed:

            return "Unclaimed"

        if hasattr(self, 'creditnoteapplication'):

            destination = self.creditnoteapplication.invoice.id

            return "Applied to invoice %d" % destination

        elif hasattr(self, 'creditnoterefund'):

            reference = self.creditnoterefund.reference

            print reference

            return "Refunded with reference: %s" % reference

        raise ValueError("This should never happen.")

    @property

    def is_unclaimed(self):

        return not (

            hasattr(self, 'creditnoterefund') or

            hasattr(self, 'creditnoteapplication')

        )

    @property

    def value(self):

        ''' Returns the value of the credit note. Because CreditNotes are

        implemented as PaymentBase objects internally, the amount is a

        negative payment against an invoice. '''

        return -self.amount

from registrasion.models import commerce

from registrasion.controllers.category import CategoryController

from registrasion.controllers.item import ItemController

from django import template

from django.db.models import Sum

register = template.Library()

@register.assignment_tag(takes_context=True)

def available_categories(context):

    ''' Gets all of the currently available products.

    Returns:

        [models.inventory.Category, ...]: A list of all of the categories that

            have Products that the current user can reserve.

    '''

    return CategoryController.available_categories(context.request.user)

@register.assignment_tag(takes_context=True)

def missing_categories(context):

    ''' Adds the categories that the user does not currently have. '''

    user = context.request.user

    categories_available = set(CategoryController.available_categories(user))

    items = ItemController(user).items_pending_or_purchased()

    categories_held = set()

    for product, quantity in items:

        categories_held.add(product.category)

    return categories_available - categories_held

@register.assignment_tag(takes_context=True)

def available_credit(context):

    ''' Calculates the sum of unclaimed credit from this user's credit notes.

    Returns:

        Decimal: the sum of the values of unclaimed credit notes for the

            current user.

    '''

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

        invoice__user=context.request.user,

    )

    ret = notes.values("amount").aggregate(Sum("amount"))["amount__sum"] or 0

    return 0 - ret

@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

    )

import datetime

import pytz

from decimal import Decimal

from django.core.exceptions import ValidationError

from registrasion.models import commerce

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

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

        cn = self._credit_note_for_invoice(invoice.invoice)

        # That credit note should be in the unclaimed pile

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        # Create a new (identical) cart with invoice

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

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

        cn.apply_to_invoice(invoice2.invoice)

        self.assertTrue(invoice2.invoice.is_paid)

        # That invoice should not show up as unclaimed any more

        self.assertEquals(0, commerce.CreditNote.unclaimed().count())

    def test_apply_credit_note_generates_new_credit_note_if_overpaying(self):

        # Create and refund an invoice, generating a credit note.

        invoice = self._invoice_containing_prod_1(2)

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

        self.assertTrue(invoice.invoice.is_paid)

        invoice.refund()

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

        cn = self._credit_note_for_invoice(invoice.invoice)

        self.assertEquals(1, commerce.CreditNote.unclaimed().count())

        # Create a new invoice for a cart of half value of inv 1

        invoice2 = self._invoice_containing_prod_1(1)