from django.core.exceptions import ValidationError

# and the fields added as needs be. ProductsForm (the function) is responsible

# for the subclassing.

def ProductsForm(category, products):

    ''' Produces an appropriate _ProductsForm subclass for the given render

    type. '''

    # Each Category.RENDER_TYPE value has a subclass here.

    RENDER_TYPES = {

        inventory.Category.RENDER_TYPE_QUANTITY: _QuantityBoxProductsForm,

        inventory.Category.RENDER_TYPE_RADIO: _RadioButtonProductsForm,

        inventory.Category.RENDER_TYPE_ITEM_QUANTITY: _ItemQuantityProductsForm,

    }

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

    class ProductsForm(RENDER_TYPES[category.render_type]):

        pass

    ProductsForm.set_fields(category, products)

    if category.render_type == inventory.Category.RENDER_TYPE_ITEM_QUANTITY:

        ProductsForm = forms.formset_factory(

            ProductsForm,

            formset=_ItemQuantityProductsFormSet,

        )

    return ProductsForm

class _HasProductsFields(object):

        super(_HasProductsFields, self).__init__(*a, **k)

    def add_product_error(self, product, error):

        ''' Adds an error to the given product's field '''

        ''' if product in field_names:

            field = field_names[product]

        elif isinstance(product, inventory.Product):

            return

        else:

            field = None '''

        self.add_error(self.field_name(product), error)

class _ProductsForm(_HasProductsFields, forms.Form):

    pass

                yield (product_id, value)

    def add_product_error(self, product, error):

        self.add_error(cls.FIELD, error)

class _ItemQuantityProductsForm(_ProductsForm):

    ''' Products entry form that allows users to select a product type, and

     enter a quantity of that product. This version _only_ allows a single

     product type to be purchased. This form is usually used in concert with the

     _ItemQuantityProductsFormSet to allow selection of multiple products.'''

    CHOICE_FIELD = "choice"

    QUANTITY_FIELD = "quantity"

    @classmethod

    def set_fields(cls, category, products):

        choices = []

        if not category.required:

            choices.append((0, "---"))

        for product in products:

            choice_text = "%s -- $%d each" % (product.name, product.price)

            choices.append((product.id, choice_text))

        cls.base_fields[cls.CHOICE_FIELD] = forms.TypedChoiceField(

            label=category.name,

            widget=forms.Select,

            choices=choices,

            initial=0,

            empty_value=0,

            coerce=int,

        )

        cls.base_fields[cls.QUANTITY_FIELD] = forms.IntegerField(

            label="Quantity",  # TODO: internationalise

            min_value=0,

            max_value=500,  # Issue #19. We should figure out real limit.

        )

    @classmethod

    def initial_data(cls, product_quantities):

        initial = {}

        for product, quantity in product_quantities:

            if quantity > 0:

                initial[cls.CHOICE_FIELD] = product.id

                initial[cls.QUANTITY_FIELD] = quantity

                break

        return initial

    def product_quantities(self):

        our_choice = self.cleaned_data[self.CHOICE_FIELD]

        our_quantity = self.cleaned_data[self.QUANTITY_FIELD]

        choices = self.fields[self.CHOICE_FIELD].choices

        for choice_value, choice_display in choices:

            if choice_value == 0:

                continue

            yield (

                choice_value,

                our_quantity if our_choice == choice_value else 0,

            )

    def add_product_error(self, product, error):

        if self.CHOICE_FIELD not in self.cleaned_data:

            return

        if product.id == self.cleaned_data[self.CHOICE_FIELD]:

            self.add_error(self.CHOICE_FIELD, error)

            self.add_error(self.QUANTITY_FIELD, error)

class _ItemQuantityProductsFormSet(_HasProductsFields, forms.BaseFormSet):

    @classmethod

    def set_fields(cls, category, products):

        raise ValueError("set_fields must be called on the underlying Form")

    @classmethod

    def initial_data(cls, product_quantities):

        ''' Prepares initial data for an instance of this form.

        product_quantities is a sequence of (product,quantity) tuples '''

        f = [

            {

                _ItemQuantityProductsForm.CHOICE_FIELD: product.id,

                _ItemQuantityProductsForm.QUANTITY_FIELD: quantity,

            }

            for product, quantity in product_quantities

            if quantity > 0

        ]

        return f

    def product_quantities(self):

        ''' Yields a sequence of (product, quantity) tuples from the

        cleaned form data. '''

        products = set()

        # Track everything so that we can yield some zeroes

        all_products = set()

        for form in self:

            if form.empty_permitted and not form.cleaned_data:

                # This is the magical empty form at the end of the list.

                continue

            for product, quantity in form.product_quantities():

                all_products.add(product)

                if quantity == 0:

                    continue

                if product in products:

                    form.add_error(

                        _ItemQuantityProductsForm.CHOICE_FIELD,

                        "You may only choose each product type once.",

                    )

                    form.add_error(

                        _ItemQuantityProductsForm.QUANTITY_FIELD,

                        "You may only choose each product type once.",

                    )

                products.add(product)

                yield product, quantity

        for product in (all_products - products):

            yield product, 0

    def add_product_error(self, product, error):

        for form in self.forms:

            form.add_product_error(product, error)

# -*- coding: utf-8 -*-

# Generated by Django 1.9.2 on 2016-08-22 00:34

from __future__ import unicode_literals

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [

        ('registrasion', '0001_initial'),

    ]

    operations = [

        migrations.AlterField(

            model_name='category',

            name='render_type',

            field=models.IntegerField(choices=[(1, 'Radio button'), (2, 'Quantity boxes'), (3, 'Product selector and quantity box')], help_text='The registration form will render this category in this style.', verbose_name='Render type'),

        ),

    ]

            ``RENDER_TYPE_ITEM_QUANTITY`` shows a select menu to select a

            Product type, and an input field, where the user can specify the

            quantity for that Product type. This is useful for categories that

            have a lot of options, from which the user is not going to select

            all of the options.

    RENDER_TYPE_ITEM_QUANTITY = 3

        (RENDER_TYPE_ITEM_QUANTITY, _("Product selector and quantity box")),

    # Makes id_to_quantity, a dictionary from product ID to its quantity

    id_to_quantity = dict(quantities)

    # Get the actual product objects

    # Match the product objects to their quantities

            products_form.add_product_error(product, message)