time_last_updated=timezone.now(),

                reservation_duration=datetime.timedelta(),

                 )

            existing.save()

        return cls(existing)

    def extend_reservation(self):

        ''' Updates the cart's time last updated value, which is used to

        determine whether the cart has reserved the items and discounts it

        holds. '''

        reservations = [datetime.timedelta()]

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

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

            reservations.append(rego.Voucher.RESERVATION_DURATION)

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

        items = rego.ProductItem.objects.filter(cart=self.cart)

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

        product_max = agg["product__reservation_duration__max"]

        if product_max is not None:

            reservations.append(product_max)

        self.cart.time_last_updated = timezone.now()

        self.cart.reservation_duration = max(reservations)

    def end_batch(self):

        ''' Performs operations that occur occur at the end of a batch of

        product changes/voucher applications etc.

        THIS SHOULD BE PRIVATE

        '''

        self.recalculate_discounts()

        self.extend_reservation()

        self.cart.revision += 1

        self.cart.save()

    @transaction.atomic

    def set_quantities(self, product_quantities):

        ''' Sets the quantities on each of the products on each of the

        products specified. Raises an exception (ValidationError) if a limit

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

        pairs. '''

        items_in_cart = rego.ProductItem.objects.filter(cart=self.cart)

        product_quantities = list(product_quantities)

        # n.b need to add have the existing items first so that the new

        # items override the old ones.

        all_product_quantities = dict(itertools.chain(

            ((i.product, i.quantity) for i in items_in_cart.all()),

            product_quantities,

        )).items()

        # Validate that the limits we're adding are OK

        self._test_limits(all_product_quantities)

        for product, quantity in product_quantities:

            try:

                product_item = rego.ProductItem.objects.get(

                    cart=self.cart,

                    product=product,

                )

                product_item.quantity = quantity

                product_item.save()

            except ObjectDoesNotExist:

                rego.ProductItem.objects.create(

                    cart=self.cart,

                    product=product,

                    quantity=quantity,

                )

        items_in_cart.filter(quantity=0).delete()

        self.end_batch()

    def _test_limits(self, product_quantities):

        ''' Tests that the quantity changes we intend to make do not violate

        the limits and enabling conditions imposed on the products. '''

        errors = []

        # Test each product limit here

        for product, quantity in product_quantities:

            if quantity < 0:

                errors.append((product, "Value must be zero or greater."))

            prod = ProductController(product)

            limit = prod.user_quantity_remaining(self.cart.user)

            if quantity > limit:

                errors.append((

                    product,

        try:

            self._test_limits(product_quantities)

        except ValidationError as ve:

            for error in ve.error_list:

                errors.append(error.message[1])

        # Validate the discounts

        discount_items = rego.DiscountItem.objects.filter(cart=cart)

        seen_discounts = set()

        for discount_item in discount_items:

            discount = discount_item.discount

            if discount in seen_discounts:

                continue

            seen_discounts.add(discount)

            real_discount = rego.DiscountBase.objects.get_subclass(

                pk=discount.pk)

            cond = ConditionController.for_condition(real_discount)

            if not cond.is_met(user):

                errors.append(

                    ValidationError("Discounts are no longer available")

                )

        if errors:

            raise ValidationError(errors)

    @transaction.atomic

    def fix_simple_errors(self):

        ''' This attempts to fix the easy errors raised by ValidationError.

        This includes removing items from the cart that are no longer

        available, recalculating all of the discounts, and removing voucher

        codes that are no longer available. '''

        # Fix vouchers first (this affects available discounts)

        active_carts = rego.Cart.reserved_carts()

        to_remove = []

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

            try:

                self._test_voucher(voucher)

            except ValidationError as ve:

                to_remove.append(voucher)

        for voucher in to_remove:

            self.cart.vouchers.remove(voucher)

        # Fix products and discounts

        items = rego.ProductItem.objects.filter(cart=self.cart)

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

        available = set(ProductController.available_products(

            self.cart.user,

            products=products,

        ))

        not_available = products - available

        zeros = [(product, 0) for product in not_available]

        self.set_quantities(zeros)

    @transaction.atomic

    def recalculate_discounts(self):

        ''' Calculates all of the discounts available for this product.

        '''

        # Delete the existing entries.

        rego.DiscountItem.objects.filter(cart=self.cart).delete()

        products = [i.product for i in product_items]

        discounts = discount.available_discounts(self.cart.user, [], products)

        # The highest-value discounts will apply to the highest-value

        # products first.

        product_items = self.cart.productitem_set.all()

        product_items = product_items.order_by('product__price')

        product_items = reversed(product_items)

        for item in product_items:

            self._add_discount(item.product, item.quantity, discounts)

    def _add_discount(self, product, quantity, discounts):

        ''' Applies the best discounts on the given product, from the given

        discounts.'''

        def matches(discount):

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

            our product. '''

            if isinstance(discount.clause, rego.DiscountForCategory):

                return discount.clause.category == product.category

            else:

                return discount.clause.product == product

        def value(discount):

            ''' Returns the value of this discount clause

            as applied to this product '''

            if discount.clause.percentage is not None:

                return discount.clause.percentage * product.price

            else:

                return discount.clause.price

        discounts = [i for i in discounts if matches(i)]

        discounts.sort(key=value)

        for candidate in reversed(discounts):

            if quantity == 0:

                break

            elif candidate.quantity == 0:

                # This discount clause has been exhausted by this cart

                continue

            # Get a provisional instance for this DiscountItem

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

            discount_item = rego.DiscountItem.objects.create(

                product=product,

                cart=self.cart,

                discount=candidate.discount,

                quantity=quantity,

            )

            # Truncate the quantity for this DiscountItem if we exceed quantity

            ours = discount_item.quantity

            allowed = candidate.quantity

            if ours > allowed:

from registrasion import models as rego

from django.db.models import Sum

class AllProducts(object):

    pass

class CategoryController(object):

    def __init__(self, category):

        self.category = category

    @classmethod

    def available_categories(cls, user, products=AllProducts):

        ''' Returns the categories available to the user. Specify `products` if

        you want to restrict to just the categories that hold the specified

        products, otherwise it'll do all. '''

        # STOPGAP -- this needs to be elsewhere tbqh

        from product import ProductController

        if products is AllProducts:

        available = ProductController.available_products(

            user,

            products=products,

        )

        return set(i.category for i in available)

    def user_quantity_remaining(self, user):

        ''' Returns the number of items from this category that the user may

        add in the current cart. '''

        cat_limit = self.category.limit_per_user

        if cat_limit is None:

            # We don't need to waste the following queries

            return 99999999

        carts = rego.Cart.objects.filter(

            user=user,

            active=False,

            released=False,

        )

        items = rego.ProductItem.objects.filter(

            cart__in=carts,

            product__category=self.category,

        )

        cat_count = items.aggregate(Sum("quantity"))["quantity__sum"] or 0

        return cat_limit - cat_count

import itertools

from collections import defaultdict

from collections import namedtuple

from django.db.models import Sum

from django.utils import timezone

from registrasion import models as rego

ConditionAndRemainder = namedtuple(

    "ConditionAndRemainder",

    (

        "condition",

        "remainder",

    ),

)

class ConditionController(object):

    ''' Base class for testing conditions that activate EnablingCondition

    or Discount objects. '''

    def __init__(self):

        pass

    @staticmethod

    def for_condition(condition):

        CONTROLLERS = {

            rego.CategoryEnablingCondition: CategoryConditionController,

            rego.IncludedProductDiscount: ProductConditionController,

            rego.ProductEnablingCondition: ProductConditionController,

            rego.TimeOrStockLimitDiscount:

                TimeOrStockLimitDiscountController,

            rego.TimeOrStockLimitEnablingCondition:

                TimeOrStockLimitEnablingConditionController,

            rego.VoucherDiscount: VoucherConditionController,

            rego.VoucherEnablingCondition: VoucherConditionController,

        }

        try:

            return CONTROLLERS[type(condition)](condition)

        except KeyError:

            return ConditionController()

    SINGLE = True

    PLURAL = False

    NONE = True

    SOME = False

    MESSAGE = {

        NONE: {

            SINGLE:

                "%(items)s is no longer available to you",

            PLURAL:

                "%(items)s are no longer available to you",

        },

        SOME: {

            SINGLE:

                "Only %(remainder)d of the following item remains: %(items)s",

            PLURAL:

                "Only %(remainder)d of the following items remain: %(items)s"

        },

    }

    @classmethod

    def test_enabling_conditions(

            cls, user, products=None, product_quantities=None):

        ''' Evaluates all of the enabling conditions on the given products.

        If `product_quantities` is supplied, the condition is only met if it

        will permit the sum of the product quantities for all of the products

        it covers. Otherwise, it will be met if at least one item can be

        accepted.

        If all enabling conditions pass, an empty list is returned, otherwise

        a list is returned containing all of the products that are *not

        enabled*. '''

        if products is not None and product_quantities is not None:

            raise ValueError("Please specify only products or "

                             "product_quantities")

        elif products is None:

            products = set(i[0] for i in product_quantities)

            quantities = dict((product, quantity)

                              for product, quantity in product_quantities)

        elif product_quantities is None:

            products = set(products)

            quantities = {}

        # Get the conditions covered by the products themselves

            for product in products

        # All mandatory conditions on a product need to be met

        mandatory = defaultdict(lambda: True)

        # At least one non-mandatory condition on a product must be met

        # if there are no mandatory conditions

        non_mandatory = defaultdict(lambda: False)

        messages = {}

        for condition in all_conditions:

            cond = cls.for_condition(condition)

            remainder = cond.user_quantity_remaining(user)

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

            # from the categories covered by this condition

            cond_products = condition.products.all()

            from_category = rego.Product.objects.filter(

                category__in=condition.categories.all(),

            ).all()

            # Remove the products that we aren't asking about

            if quantities:

                consumed = sum(quantities[i] for i in all_products)

            else:

                consumed = 1

            met = consumed <= remainder

            if not met:

                items = ", ".join(str(product) for product in all_products)

                base = cls.MESSAGE[remainder == 0][len(all_products) == 1]

                message = base % {"items": items, "remainder": remainder}

            for product in all_products:

                if condition.mandatory:

                    mandatory[product] &= met

                else:

                    non_mandatory[product] |= met

                if not met and product not in messages:

                    messages[product] = message

        valid = defaultdict(lambda: True)

        for product in itertools.chain(mandatory, non_mandatory):

            if product in mandatory:

                # If there's a mandatory condition, all must be met

                valid[product] = mandatory[product]

            else:

                # Otherwise, we need just one non-mandatory condition met

                valid[product] = non_mandatory[product]

        error_fields = [

            (product, messages[product])

            for product in valid if not valid[product]

        ]

        return error_fields

    def user_quantity_remaining(self, user):

        ''' Returns the number of items covered by this enabling condition the

        user can add to the current cart. This default implementation returns

        a big number if is_met() is true, otherwise 0.

        Either this method, or is_met() must be overridden in subclasses.

        '''

        return 99999999 if self.is_met(user) else 0

import itertools

from conditions import ConditionController

from registrasion import models as rego

from django.db.models import Sum

class DiscountAndQuantity(object):

    def __init__(self, discount, clause, quantity):

        self.discount = discount

        self.clause = clause

        self.quantity = quantity

    def __repr__(self):

            self.discount, self.clause, self.quantity,

        )

def available_discounts(user, categories, products):

    ''' Returns all discounts available to this user for the given categories

    and products. The discounts also list the available quantity for this user,

    not including products that are pending purchase. '''

    # discounts that match provided categories

    category_discounts = rego.DiscountForCategory.objects.filter(

        category__in=categories

    )

    # discounts that match provided products

    product_discounts = rego.DiscountForProduct.objects.filter(

        product__in=products

    )

    # discounts that match categories for provided products

    product_category_discounts = rego.DiscountForCategory.objects.filter(

        category__in=(product.category for product in products)

    )

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

    # The set of all potential discounts

    potential_discounts = set(itertools.chain(

        product_discounts,

    ))

    discounts = []

    # Markers so that we don't need to evaluate given conditions more than once

    accepted_discounts = set()

    failed_discounts = set()

    for discount in potential_discounts:

        real_discount = rego.DiscountBase.objects.get_subclass(

            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.

        past_uses = rego.DiscountItem.objects.filter(

            cart__user=user,

            cart__active=False,  # Only past carts count

            cart__released=False,  # You can reuse refunded discounts

        )

        agg = past_uses.aggregate(Sum("quantity"))

        past_use_count = agg["quantity__sum"]

        if past_use_count is None:

            past_use_count = 0

        if past_use_count >= discount.quantity:

            # This clause has exceeded its use count

            pass

        elif real_discount not in failed_discounts:

            # This clause is still available

            if real_discount in accepted_discounts or cond.is_met(user):

                # This clause is valid for this user

                discounts.append(DiscountAndQuantity(

                    discount=real_discount,

                    clause=discount,

                    quantity=discount.quantity - past_use_count,

                ))

                accepted_discounts.add(real_discount)

            else:

                # This clause is not valid for this user

                failed_discounts.add(real_discount)

    return discounts

import itertools

from django.db.models import Sum

from registrasion import models as rego

from category import CategoryController

from conditions import ConditionController

class ProductController(object):

    def __init__(self, product):

        self.product = product

    @classmethod

    def available_products(cls, user, category=None, products=None):

        ''' Returns a list of all of the products that are available per

        enabling conditions from the given categories.

        TODO: refactor so that all conditions are tested here and

        can_add_with_enabling_conditions calls this method. '''

        if category is None and products is None:

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

        if category is not None:

            all_products = rego.Product.objects.filter(category=category)

        else:

            all_products = []

        if products is not None:

        passed_limits = set(

            product

            for product in all_products

            if cls(product).user_quantity_remaining(user) > 0

        )

        failed_and_messages = ConditionController.test_enabling_conditions(

            user, products=passed_limits

        )

        failed_conditions = set(i[0] for i in failed_and_messages)

        out = list(passed_limits - failed_conditions)

        out.sort(key=lambda product: product.order)

        return out

    def user_quantity_remaining(self, user):

        ''' Returns the quantity of this product that the user add in the

        current cart. '''

        prod_limit = self.product.limit_per_user

        if prod_limit is None:

            # Don't need to run the remaining queries

            return 999999  # We can do better

        carts = rego.Cart.objects.filter(

            user=user,

            active=False,

            released=False,

        )

        items = rego.ProductItem.objects.filter(

            cart__in=carts,

            product=self.product,

        )

        prod_count = items.aggregate(Sum("quantity"))["quantity__sum"] or 0

        return prod_limit - prod_count

from registrasion import models as rego

from registrasion.controllers.category import CategoryController

from collections import namedtuple

from django import template

from django.db.models import Sum

register = template.Library()

ProductAndQuantity = namedtuple("ProductAndQuantity", ["product", "quantity"])

@register.assignment_tag(takes_context=True)

def available_categories(context):

    ''' Returns all of the available product categories '''

    return CategoryController.available_categories(context.request.user)

@register.assignment_tag(takes_context=True)

def invoices(context):

    ''' Returns all of the invoices that this user has. '''

    return rego.Invoice.objects.filter(cart__user=context.request.user)

@register.assignment_tag(takes_context=True)

def items_pending(context):

    ''' Returns all of the items that this user has in their current cart,

    and is awaiting payment. '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=True,

    return all_items

@register.assignment_tag(takes_context=True)

def items_purchased(context, category=None):

    ''' Returns all of the items that this user has purchased, optionally

    from the given category. '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=False,

    if category:

        all_items = all_items.filter(product__category=category)

    out = []

    return out

@register.filter

def multiply(value, arg):

    ''' Multiplies value by arg '''

    return value * arg

    except ObjectDoesNotExist:

        profile = None

    if not profile:

        # TODO: if voucherform is invalid, make sure

        # that profileform does not save

        voucher_form, voucher_handled = handle_voucher(request, "voucher")

        profile_form, profile_handled = handle_profile(request, "profile")

        voucher_section = GuidedRegistrationSection(

            title="Voucher Code",

            form=voucher_form,

        )

        profile_section = GuidedRegistrationSection(

            title="Profile and Personal Information",

            form=profile_form,

        )

        title = "Attendee information"

        current_step = 1

        sections.append(voucher_section)

        sections.append(profile_section)

    else:

        # We're selling products

        last_category = attendee.highest_complete_category

        # Get the next category

        cats = rego.Category.objects

        cats = cats.filter(id__gt=last_category).order_by("order")

        if cats.count() == 0:

            # We've filled in every category

            attendee.completed_registration = True

            attendee.save()

            return next_step

        if last_category == 0:

            # Only display the first Category

            title = "Select ticket type"

            current_step = 2

            cats = [cats[0]]

        else:

            # Set title appropriately for remaining categories

            current_step = 3

            title = "Additional items"

        for category in cats:

            prefix = "category_" + str(category.id)

            p = handle_products(request, category, products, prefix)

            products_form, discounts, products_handled = p

            section = GuidedRegistrationSection(

                title=category.name,

                description=category.description,

                discounts=discounts,

                form=products_form,

            )

            if products:

                # This product category does not exist for this user

                sections.append(section)

            if request.method == "POST" and not products_form.errors:

                if category.id > attendee.highest_complete_category:

                    # This is only saved if we pass each form with no errors.

                    attendee.highest_complete_category = category.id

    if sections and request.method == "POST":

        for section in sections:

            if section.form.errors:

                break

        else:

            attendee.save()

            # We've successfully processed everything

            return next_step

    data = {

        "current_step": current_step,

        "sections": sections,

        "title": title,

        "total_steps": 3,

    }

    return render(request, "registrasion/guided_registration.html", data)

@login_required

def edit_profile(request):

    form, handled = handle_profile(request, "profile")

    if handled and not form.errors:

        messages.success(

            request,

            "Your attendee profile was updated.",

        )

        return redirect("dashboard")