import nested_admin

class EffectsDisplayMixin(object):

class ProductInline(admin.TabularInline):

class CategoryAdmin(admin.ModelAdmin):

    fields = ("name", "description", "required", "render_type",

              "limit_per_user", "order",)

    list_display = ("name", "description")

    ]

class ProductAdmin(admin.ModelAdmin):

    list_display = ("name", "category", "description")

    list_filter = ("category", )

# Discounts

class DiscountForProductInline(admin.TabularInline):

    verbose_name = _("Product included in discount")

    verbose_name_plural = _("Products included in discount")

class DiscountForCategoryInline(admin.TabularInline):

    verbose_name = _("Category included in discount")

    verbose_name_plural = _("Categories included in discount")

class TimeOrStockLimitDiscountAdmin(admin.ModelAdmin, EffectsDisplayMixin):

    list_display = (

        "description",

    ]

class IncludedProductDiscountAdmin(admin.ModelAdmin):

    def enablers(self, obj):

# Vouchers

class VoucherDiscountInline(nested_admin.NestedStackedInline):

    verbose_name = _("Discount")

    # TODO work out why we're allowed to add more than one?

class VoucherFlagInline(nested_admin.NestedStackedInline):

    verbose_name = _("Product and category enabled by voucher")

    verbose_name_plural = _("Products and categories enabled by voucher")

    extra = 1

class VoucherAdmin(nested_admin.NestedAdmin):

    def effects(self, obj):

        return "\n".join(out)

    list_display = ("recipient", "code", "effects")

    inlines = [

        VoucherDiscountInline,

# Enabling conditions

class ProductFlagAdmin(

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    def enablers(self, obj):

        return list(obj.enabling_products.all())

    fields = ("description", "enabling_products", "condition", "products",

              "categories"),

# Enabling conditions

class CategoryFlagAdmin(

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    fields = ("description", "enabling_category", "condition", "products",

              "categories"),

# Enabling conditions

class TimeOrStockLimitFlagAdmin(

        nested_admin.NestedAdmin,

        EffectsDisplayMixin):

    list_display = (

        "description",

from django.db.models import Max

from django.utils import timezone

from registrasion.exceptions import CartValidationError

from category import CategoryController

from conditions import ConditionController

        if there isn't one ready yet. '''

        try:

        except ObjectDoesNotExist:

                user=user,

                time_last_updated=timezone.now(),

                reservation_duration=datetime.timedelta(),

        # If we have vouchers, we're entitled to an hour at minimum.

        if len(self.cart.vouchers.all()) >= 1:

        # Else, it's the maximum of the included products

        agg = items.aggregate(Max("product__reservation_duration"))

        product_max = agg["product__reservation_duration__max"]

        is violated. `product_quantities` is an iterable of (product, quantity)

        pairs. '''

        items_in_cart = items_in_cart.select_related(

            "product",

            "product__category",

        for product, quantity in product_quantities:

            try:

                    cart=self.cart,

                    product=product,

                )

                product_item.quantity = quantity

                product_item.save()

            except ObjectDoesNotExist:

                    cart=self.cart,

                    product=product,

                    quantity=quantity,

        ''' Applies the voucher with the given code to this cart. '''

        # Try and find the voucher

        # Re-applying vouchers should be idempotent

        if voucher in self.cart.vouchers.all():

        Raises ValidationError if not. '''

        # Is voucher exhausted?

        # It's invalid for a user to enter a voucher that's exhausted

        carts_with_voucher = active_carts.filter(vouchers=voucher)

        except ValidationError as ve:

            errors.append(ve)

        product_quantities = list((i.product, i.quantity) for i in items)

        try:

                errors.append(error.message[1])

        # Validate the discounts

        seen_discounts = set()

        for discount_item in discount_items:

            if discount in seen_discounts:

                continue

            seen_discounts.add(discount)

                pk=discount.pk)

            cond = ConditionController.for_condition(real_discount)

            self.cart.vouchers.remove(voucher)

        # Fix products and discounts

        items = items.select_related("product")

        products = set(i.product for i in items)

        available = set(ProductController.available_products(

        '''

        # Delete the existing entries.

        product_items = self.cart.productitem_set.all().select_related(

            "product", "product__category",

        def matches(discount):

            ''' Returns True if and only if the given discount apples to

            our product. '''

                return discount.clause.category == product.category

            else:

                return discount.clause.product == product

            # Get a provisional instance for this DiscountItem

            # with the quantity set to as much as we have in the cart

                product=product,

                cart=self.cart,

                discount=candidate.discount,

from django.db.models import Sum

        from product import ProductController

        if products is AllProducts:

        available = ProductController.available_products(

            user,

            # We don't need to waste the following queries

            return 99999999

            user=user,

            active=False,

            released=False,

        )

            cart__in=carts,

            product__category=self.category,

        )

from django.db.models import Sum

from django.utils import timezone

ConditionAndRemainder = namedtuple(

    @staticmethod

    def for_condition(condition):

        CONTROLLERS = {

                TimeOrStockLimitDiscountController,

                TimeOrStockLimitFlagController,

        }

        try:

            # Get all products covered by this condition, and the products

            # from the categories covered by this condition

            cond_products = condition.products.all()

                category__in=condition.categories.all(),

            ).all()

            all_products = cond_products | from_category

        ''' returns True if the user has a product from a category that invokes

        this condition in one of their carts '''

            category=self.condition.enabling_category,

        )

            cart__in=carts,

            product__in=enabling_products,

        ).count()

        ''' returns True if the user has a product that invokes this

        condition in one of their carts '''

            cart__in=carts,

            product__in=self.condition.enabling_products.all(),

        ).count()

            return 99999999

        # We care about all reserved carts, but not the user's current cart

        reserved_carts = reserved_carts.exclude(

            user=user,

            active=True,

        TimeOrStockLimitConditionController):

    def _items(self):

            category__in=self.ceiling.categories.all(),

        )

        products = self.ceiling.products.all() | category_products

            product__in=products.all(),

        )

        return product_items

class TimeOrStockLimitDiscountController(TimeOrStockLimitConditionController):

    def _items(self):

            discount=self.ceiling,

        )

        return discount_items

    def is_met(self, user):

        ''' returns True if the user has the given voucher attached. '''

            user=user,

            vouchers=self.condition.voucher,

        ).count()

from django.db import transaction

class CreditNoteController(object):

        the given invoice. You need to call InvoiceController.update_status()

        to set the status correctly, if appropriate. '''

            invoice=invoice,

            amount=0-value,  # Credit notes start off as a payment against inv.

            reference="ONE MOMENT",

        inv.validate_allowed_to_pay()

        # Apply payment to invoice

            parent=self.credit_note,

            invoice=invoice,

            amount=self.credit_note.value,

import itertools

from conditions import ConditionController

from django.db.models import Sum

    not including products that are pending purchase. '''

    # discounts that match provided categories

        category__in=categories

    )

    # discounts that match provided products

        product__in=products

    )

    # discounts that match categories for provided products

        category__in=(product.category for product in products)

    )

    # (Not relevant: discounts that match products in provided categories)

    failed_discounts = set()

    for discount in potential_discounts:

            pk=discount.discount.pk,

        )

        cond = ConditionController.for_condition(real_discount)

        # Count the past uses of the given discount item.

        # If this user has exceeded the limit for the clause, this clause

        # is not available any more.

            cart__user=user,

            cart__active=False,  # Only past carts count

            cart__released=False,  # You can reuse refunded discounts

from django.db.models import Sum

from django.utils import timezone

from cart import CartController

from credit_note import CreditNoteController

        an invoice is generated.'''

        try:

            ).get(

                cart=cart,

                cart_revision=cart.revision,

    @classmethod

    def void_all_invoices(cls, cart):

        for invoice in invoices:

            cls(invoice).void()

    @classmethod

    def resolve_discount_value(cls, item):

        try:

                discount=item.discount,

                product=item.product

            )

        except ObjectDoesNotExist:

                discount=item.discount,

                category=item.product.category

            )

        due = max(issued, reservation_limit)

        # Get the invoice recipient

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

        )

        recipient = profile.invoice_recipient()

            user=cart.user,

            cart=cart,

            cart_revision=cart.revision,

            value=Decimal(),

            issue_time=issued,

            due_time=due,

            recipient=recipient,

        )

        if len(product_items) == 0:

            raise ValidationError("Your cart is empty.")

        product_items = product_items.order_by(

            "product__category__order", "product__order"

        )

        invoice_value = Decimal()

        for item in product_items:

            product = item.product

                invoice=invoice,

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

                quantity=item.quantity,

            invoice_value += line_item.quantity * line_item.price

        for item in discount_items:

                invoice=invoice,

                description=item.discount.description,

                quantity=item.quantity,

    def total_payments(self):

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

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

        return total_paid

        old_status = self.invoice.status

        total_paid = self.total_payments()

            invoice=self.invoice,

        ).count()

        remainder = self.invoice.value - total_paid

            # Invoice had an amount owing

            if remainder <= 0:

                # Invoice no longer has amount owing

            elif total_paid == 0 and num_payments > 0:

                # Invoice has multiple payments totalling zero

                self._mark_void()

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

            # Should not ever change from here

            pass

            # Should not ever change from here

            pass

        if cart:

            cart.active = False

            cart.save()

        self.invoice.save()

    def _mark_refunded(self):

            cart.active = False

            cart.released = True

            cart.save()

        self.invoice.save()

    def _mark_void(self):

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

        necessary. '''

        self.invoice.save()

    def _invoice_matches_cart(self):

import itertools

from django.db.models import Sum

from category import CategoryController

from conditions import ConditionController

            raise ValueError("You must provide products or a category")

        if category is not None:

            all_products = all_products.select_related("category")

        else:

            all_products = []

            # Don't need to run the remaining queries

            return 999999  # We can do better

            user=user,

            active=False,

            released=False,

        )

            cart__in=carts,

            product=self.product,

        )

from django import forms

        self.fields["invoice"].choices = self._unpaid_invoices_for_user

    def _unpaid_invoices_for_user(self):

            user=self.user,

        )

        ]

    invoice = forms.ChoiceField(

        required=True,

    )

class ManualCreditNoteRefundForm(forms.ModelForm):

    class Meta:

        fields = ["reference"]

class ManualPaymentForm(forms.ModelForm):

    class Meta:

        fields = ["reference", "amount"]

    # Each Category.RENDER_TYPE value has a subclass here.

    RENDER_TYPES = {

    }

    # Produce a subclass of _ProductsForm which we can alter the base_fields on