category = models.ForeignKey(Category, verbose_name=_("Product category"))

    price = models.DecimalField(max_digits=8,

                                decimal_places=2,

                                verbose_name=_("Price"))

    limit_per_user = models.PositiveIntegerField(

        blank=True,

        verbose_name=_("Limit per user"))

    reservation_duration = models.DurationField(

        default=datetime.timedelta(hours=1),

        verbose_name=_("Reservation duration"))

    order = models.PositiveIntegerField(verbose_name=("Display order"))

@python_2_unicode_compatible

class Voucher(models.Model):

    ''' Registration vouchers '''

    # Vouchers reserve a cart for a fixed amount of time, so that

    # items may be added without the voucher being swiped by someone else

    RESERVATION_DURATION = datetime.timedelta(hours=1)

    def __str__(self):

        return "Voucher for %s" % self.recipient

    def save(self, *a, **k):

        ''' Normalise the voucher code to be uppercase '''

        super(Voucher, self).save(*a, **k)

    recipient = models.CharField(max_length=64, verbose_name=_("Recipient"))

    code = models.CharField(max_length=16,

                            unique=True,

                            verbose_name=_("Voucher code"))

    limit = models.PositiveIntegerField(verbose_name=_("Voucher use limit"))

# Product Modifiers

@python_2_unicode_compatible

class DiscountBase(models.Model):

    ''' Base class for discounts. Each subclass has controller code that

    determines whether or not the given discount is available to be added to

    the current cart. '''

    objects = InheritanceManager()

    def __str__(self):

        return "Discount: " + self.description

    description = models.CharField(max_length=255,

                                   verbose_name=_("Description"))

    if request.POST and form.is_valid():

        form.instance.attendee = attendee

        form.save()

    data = {

        "form": form,

    }

    return render(request, "profile_form.html", data)

@login_required

def product_category(request, category_id):

    ''' Registration selections form for a specific category of items.

    '''

    PRODUCTS_FORM_PREFIX = "products"

    VOUCHERS_FORM_PREFIX = "vouchers"

    category_id = int(category_id)  # Routing is [0-9]+

    category = rego.Category.objects.get(pk=category_id)

    current_cart = CartController.for_user(request.user)

    attendee = rego.Attendee.get_instance(request.user)

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

    products = products.order_by("order")

    products = ProductController.available_products(

        request.user,

        products=products,

    )

    ProductsForm = forms.ProductsForm(products)

    if request.method == "POST":

        cat_form = ProductsForm(

            request.POST,

            request.FILES,

            prefix=PRODUCTS_FORM_PREFIX)

        elif cat_form.is_valid():

            try:

                handle_valid_cat_form(cat_form, current_cart)

            except ValidationError:

                pass

            # If category is required, the user must have at least one

            # in an active+valid cart

            if category.required:

                carts = rego.Cart.reserved_carts()

                carts = carts.filter(user=request.user)

                items = rego.ProductItem.objects.filter(

                    product__category=category,

                    cart=carts,

                )

                if len(items) == 0:

                    cat_form.add_error(

                        None,

                        "You must have at least one item from this category",

                    )

            if not cat_form.errors:

                if category_id > attendee.highest_complete_category:

                    attendee.highest_complete_category = category_id

                    attendee.save()

                return redirect("dashboard")

    else:

        # Create initial data for each of products in category

        items = rego.ProductItem.objects.filter(

            product__category=category,

            cart=current_cart.cart,

        )

        quantities = []

        for product in products:

            # Only add items that are enabled.

            try:

                quantity = items.get(product=product).quantity

            except ObjectDoesNotExist:

                quantity = 0

            quantities.append((product, quantity))

        cat_form = ProductsForm(

            prefix=PRODUCTS_FORM_PREFIX,

            product_quantities=quantities,

        )

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

    data = {

        "category": category,

        "discounts": discounts,

        "form": cat_form,

        "voucher_form": voucher_form,

    }

    return render(request, "product_category.html", data)

@transaction.atomic

def handle_valid_cat_form(cat_form, current_cart):

    for product_id, quantity, field_name in cat_form.product_quantities():

        product = rego.Product.objects.get(pk=product_id)

        try:

            current_cart.set_quantity(product, quantity, batched=True)

        except ValidationError as ve:

            cat_form.add_error(field_name, ve)

    if cat_form.errors:

        raise ValidationError("Cannot add that stuff")

    current_cart.end_batch()

@login_required

def checkout(request):

    ''' Runs checkout for the current cart of items, ideally generating an

    invoice. '''

    current_cart = CartController.for_user(request.user)

    current_invoice = InvoiceController.for_cart(current_cart.cart)

    return redirect("invoice", current_invoice.invoice.id)

@login_required

def invoice(request, invoice_id):

    ''' Displays an invoice for a given invoice id. '''

    invoice_id = int(invoice_id)

    inv = rego.Invoice.objects.get(pk=invoice_id)

    current_invoice = InvoiceController(inv)

    data = {

        "invoice": current_invoice.invoice,

    }