def product_quantities(self):

        for name, value in self.cleaned_data.items():

            if name.startswith(self.PRODUCT_PREFIX):

                product_id = int(name[len(self.PRODUCT_PREFIX):])

                yield (product_id, value)

class _RadioButtonProductsForm(_ProductsForm):

    ''' Products entry form that allows users to enter quantities

    of desired products. '''

    FIELD = "chosen_product"

    @classmethod

    def set_fields(cls, category, products):

        choices = []

        for product in products:

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

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

        if not category.required:

            choices.append((0, "No selection"))

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

            label=category.name,

            widget=forms.RadioSelect,

            choices=choices,

            empty_value=0,

            coerce=int,

        )

    @classmethod

    def initial_data(cls, product_quantities):

        initial = {}

        for product, quantity in product_quantities:

            if quantity > 0:

                initial[cls.FIELD] = product.id

                break

        return initial

    def product_quantities(self):

        ours = self.cleaned_data[self.FIELD]

        choices = self.fields[self.FIELD].choices

        for choice_value, choice_display in choices:

            if choice_value == 0:

                continue

            yield (

                choice_value,

                1 if ours == choice_value else 0,

                self.FIELD,

            )

    def add_product_error(self, product, error):

        self.add_error(self.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)

class VoucherForm(forms.Form):

    voucher = forms.CharField(

        label="Voucher code",

        help_text="If you have a voucher code, enter it here",

        required=False,

    )

from reporting import views as rv

from django.conf.urls import include

from django.conf.urls import url

from .views import (

    product_category,

    checkout,

    credit_note,

    invoice,

    manual_payment,

    refund,

    invoice_access,

    edit_profile,

    guided_registration,

)

public = [

    url(r"^category/([0-9]+)$", product_category, name="product_category"),

    url(r"^checkout$", checkout, name="checkout"),

    url(r"^credit_note/([0-9]+)$", credit_note, name="credit_note"),

    url(r"^invoice/([0-9]+)$", invoice, name="invoice"),

    url(r"^invoice/([0-9]+)/([A-Z0-9]+)$", invoice, name="invoice"),

    url(r"^invoice/([0-9]+)/manual_payment$",

        manual_payment, name="manual_payment"),

    url(r"^invoice/([0-9]+)/refund$",

        refund, name="refund"),

    url(r"^invoice_access/([A-Z0-9]+)$", invoice_access,

        name="invoice_access"),

    url(r"^profile$", edit_profile, name="attendee_edit"),

    url(r"^register$", guided_registration, name="guided_registration"),

    url(r"^register/([0-9]+)$", guided_registration,

        name="guided_registration"),

]

reports = [

    url(r"^$", rv.reports_list, name="reports_list"),

    url(r"^attendee/?$", rv.attendee, name="attendee"),

    url(r"^attendee/([0-9]*)$", rv.attendee, name="attendee"),

    url(r"^credit_notes/?$", rv.credit_notes, name="credit_notes"),

    url(r"^items_sold/?$", rv.items_sold, name="items_sold"),

    url(r"^product_status/?$", rv.product_status, name="product_status"),

    url(r"^reconciliation/?$", rv.reconciliation, name="reconciliation"),

]

urlpatterns = [

    url(r"^reports/", include(reports)),

    url(r"^", include(public))  # This one must go last.

]

import sys

from registrasion import forms

from registrasion import util

from registrasion.models import commerce

from registrasion.models import inventory

from registrasion.models import people

from registrasion.controllers.batch import BatchController

from registrasion.controllers.cart import CartController

from registrasion.controllers.credit_note import CreditNoteController

from registrasion.controllers.discount import DiscountController

from registrasion.controllers.invoice import InvoiceController

from registrasion.controllers.product import ProductController

from registrasion.exceptions import CartValidationError

from collections import namedtuple

from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.contrib.auth.decorators import user_passes_test

from django.contrib import messages

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.http import Http404

from django.shortcuts import redirect

from django.shortcuts import render

_GuidedRegistrationSection = namedtuple(

    "GuidedRegistrationSection",

    (

        "title",

        "discounts",

        "description",

        "form",

    )

)

@util.all_arguments_optional

class GuidedRegistrationSection(_GuidedRegistrationSection):

    ''' Represents a section of a guided registration page.

    Attributes:

       title (str): The title of the section.

       discounts ([registrasion.contollers.discount.DiscountAndQuantity, ...]):

            A list of discount objects that are available in the section. You

            can display ``.clause`` to show what the discount applies to, and

            ``.quantity`` to display the number of times that discount can be

            applied.

       description (str): A description of the section.

       form (forms.Form): A form to display.

    '''

    pass

def get_form(name):

    dot = name.rindex(".")

    mod_name, form_name = name[:dot], name[dot + 1:]

    __import__(mod_name)

    return getattr(sys.modules[mod_name], form_name)

@login_required

def guided_registration(request):

    ''' Goes through the registration process in order, making sure user sees

    all valid categories.

    The user must be logged in to see this view.

    Returns:

        render: Renders ``registrasion/guided_registration.html``,

            with the following data::

                {

                    "current_step": int(),  # The current step in the

                                            # registration

                    "sections": sections,   # A list of

                                            # GuidedRegistrationSections

                    "title": str(),         # The title of the page

                    "total_steps": int(),   # The total number of steps

                }

    '''

    SESSION_KEY = "guided_registration_categories"

    ASK_FOR_PROFILE = 777  # Magic number. Meh.

    next_step = redirect("guided_registration")

    sections = []

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

    if attendee.completed_registration:

        return render(

            request,

            "registrasion/guided_registration_complete.html",

            {},

        )

    # Step 1: Fill in a badge and collect a voucher code

    try:

        profile = attendee.attendeeprofilebase

    except ObjectDoesNotExist:

        profile = None

    # Figure out if we need to show the profile form and the voucher form

    show_profile_and_voucher = False

    if SESSION_KEY not in request.session:

        if not profile:

            show_profile_and_voucher = True

    else:

        if request.session[SESSION_KEY] == ASK_FOR_PROFILE:

            show_profile_and_voucher = True

    if show_profile_and_voucher:

        # Keep asking for the profile until everything passes.

        request.session[SESSION_KEY] = ASK_FOR_PROFILE

        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

        starting = attendee.guided_categories_complete.count() == 0

        # Get the next category

        cats = inventory.Category.objects

        if SESSION_KEY in request.session:

            _cats = request.session[SESSION_KEY]

            cats = cats.filter(id__in=_cats)

        else:

            cats = cats.exclude(

                id__in=attendee.guided_categories_complete.all(),

            )

        cats = cats.order_by("order")

        request.session[SESSION_KEY] = []

        if starting:

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

        all_products = inventory.Product.objects.filter(

            category__in=cats,

        ).select_related("category")

        with BatchController.batch(request.user):

            available_products = set(ProductController.available_products(

                request.user,

                products=all_products,

            ))

            if len(available_products) == 0:

                # We've filled in every category

                attendee.completed_registration = True

                attendee.save()

                return next_step

            for category in cats:

                products = [

                    i for i in available_products

                    if i.category == category

                ]

                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 has items to show.

                    sections.append(section)

                    # Add this to the list of things to show if the form

                    # errors.

                    request.session[SESSION_KEY].append(category.id)

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

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

                        # errors, and if the form actually has products.

    This view is not authenticated, but it will only allow access to either:

    the user the invoice belongs to; staff; or a request made with the correct

    access code.

    Arguments:

        invoice_id (castable to int): The invoice_id for the invoice you want

            to view.

        access_code (Optional[str]): The access code for the user who owns

            this invoice.

    Returns:

        render:

            Renders ``registrasion/invoice.html``, with the following

            data::

                {

                    "invoice": models.commerce.Invoice(),

                }

    Raises:

        Http404: if the current user cannot view this invoice and the correct

            access_code is not provided.

    '''

    current_invoice = InvoiceController.for_id_or_404(invoice_id)

    if not current_invoice.can_view(

            user=request.user,

            access_code=access_code,

            ):

        raise Http404()

    data = {

        "invoice": current_invoice.invoice,

    }

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

def _staff_only(user):

    ''' Returns true if the user is staff. '''

    return user.is_staff

@user_passes_test(_staff_only)

def manual_payment(request, invoice_id):

    ''' Allows staff to make manual payments or refunds on an invoice.

    This form requires a login, and the logged in user needs to be staff.

    Arguments:

        invoice_id (castable to int): The invoice ID to be paid

    Returns:

        render:

            Renders ``registrasion/manual_payment.html`` with the following

            data::

                {

                    "invoice": models.commerce.Invoice(),

                    "form": form,   # A form that saves a ``ManualPayment``

                                    # object.

                }

    '''

    FORM_PREFIX = "manual_payment"

    current_invoice = InvoiceController.for_id_or_404(invoice_id)

    form = forms.ManualPaymentForm(

        request.POST or None,

        prefix=FORM_PREFIX,

    )

    if request.POST and form.is_valid():

        form.instance.invoice = current_invoice.invoice

        form.instance.entered_by = request.user

        form.save()

        current_invoice.update_status()

        form = forms.ManualPaymentForm(prefix=FORM_PREFIX)

    data = {

        "invoice": current_invoice.invoice,

        "form": form,

    }

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

@user_passes_test(_staff_only)

def refund(request, invoice_id):

    ''' Marks an invoice as refunded and requests a credit note for the

    full amount paid against the invoice.

    This view requires a login, and the logged in user must be staff.

    Arguments:

        invoice_id (castable to int): The ID of the invoice to refund.

    Returns:

        redirect:

            Redirects to ``invoice``.

    '''

    current_invoice = InvoiceController.for_id_or_404(invoice_id)

    try:

        current_invoice.refund()

        messages.success(request, "This invoice has been refunded.")

    except ValidationError as ve:

        messages.error(request, ve)

    return redirect("invoice", invoice_id)

@user_passes_test(_staff_only)

def credit_note(request, note_id, access_code=None):

    ''' Displays a credit note.

    If ``request`` is a ``POST`` request, forms for applying or refunding

    a credit note will be processed.

    This view requires a login, and the logged in user must be staff.

    Arguments:

        note_id (castable to int): The ID of the credit note to view.

    Returns:

        render or redirect:

            If the "apply to invoice" form is correctly processed, redirect to

            that invoice, otherwise, render ``registration/credit_note.html``

            with the following data::

                {

                    "credit_note": models.commerce.CreditNote(),

                    "apply_form": form,  # A form for applying credit note

                                         # to an invoice.

                    "refund_form": form, # A form for applying a *manual*

                                         # refund of the credit note.

                }

    '''

    note_id = int(note_id)

    current_note = CreditNoteController.for_id_or_404(note_id)

    apply_form = forms.ApplyCreditNoteForm(

        current_note.credit_note.invoice.user,

        request.POST or None,

        prefix="apply_note"

    )

    refund_form = forms.ManualCreditNoteRefundForm(

        request.POST or None,

        prefix="refund_note"

    )

    if request.POST and apply_form.is_valid():

        inv_id = apply_form.cleaned_data["invoice"]

        invoice = commerce.Invoice.objects.get(pk=inv_id)

        current_note.apply_to_invoice(invoice)

        messages.success(

            request,

            "Applied credit note %d to invoice." % note_id,

        )

        return redirect("invoice", invoice.id)

    elif request.POST and refund_form.is_valid():

        refund_form.instance.entered_by = request.user

        refund_form.instance.parent = current_note.credit_note

        refund_form.save()

        messages.success(

            request,

            "Applied manual refund to credit note."

        )

        refund_form = forms.ManualCreditNoteRefundForm(

            prefix="refund_note",

        )

    data = {

        "credit_note": current_note.credit_note,

        "apply_form": apply_form,

        "refund_form": refund_form,

    }

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