from registrasion.models import commerce

from registrasion.models import inventory

from django import forms

class ApplyCreditNoteForm(forms.Form):

    def __init__(self, user, *a, **k):

        ''' User: The user whose invoices should be made available as

        choices. '''

        self.user = user

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

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

    def _unpaid_invoices_for_user(self):

        invoices = commerce.Invoice.objects.filter(

            status=commerce.Invoice.STATUS_UNPAID,

            user=self.user,

        )

        return [

            (invoice.id, "Invoice %(id)d - $%(value)d" % invoice.__dict__)

            for invoice in invoices

        ]

    invoice = forms.ChoiceField(

        required=True,

    )

class ManualCreditNoteRefundForm(forms.ModelForm):

    class Meta:

        model = commerce.ManualCreditNoteRefund

        fields = ["reference"]

class ManualPaymentForm(forms.ModelForm):

    class Meta:

        model = commerce.ManualPayment

        fields = ["reference", "amount"]

# Products forms -- none of these have any fields: they are to be subclassed

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

    cat = inventory.Category

    RENDER_TYPES = {

        cat.RENDER_TYPE_QUANTITY: _QuantityBoxProductsForm,

        cat.RENDER_TYPE_RADIO: _RadioButtonProductsForm,

        cat.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):

    PRODUCT_PREFIX = "product_"

    ''' Base class for product entry forms. '''

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

        if "product_quantities" in k:

            initial = self.initial_data(k["product_quantities"])

            k["initial"] = initial

            del k["product_quantities"]

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

    @classmethod

    def field_name(cls, product):

        return cls.PRODUCT_PREFIX + ("%d" % product.id)

    @classmethod

    def set_fields(cls, category, products):

        ''' Sets the base_fields on this _ProductsForm to allow selecting

        from the provided products. '''

        pass

    @classmethod

    def initial_data(cls, product_quantites):

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

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

        return {}

    def product_quantities(self):

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

        cleaned form data. '''

        return iter([])

    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

class _QuantityBoxProductsForm(_ProductsForm):

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

    of desired products. '''

    @classmethod

    def set_fields(cls, category, products):

        for product in products:

            if product.description:

                help_text = "$%d each -- %s" % (

                    product.price,

                    product.description,

                )

            else:

                help_text = "$%d each" % product.price

            field = forms.IntegerField(

                label=product.name,

                help_text=help_text,

                min_value=0,

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

            )

            cls.base_fields[cls.field_name(product)] = field

    @classmethod

    def initial_data(cls, product_quantities):

        initial = {}

        for product, quantity in product_quantities:

            initial[cls.field_name(product)] = quantity

        return initial

    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.

                        attendee.guided_categories_complete.add(category)

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

        for section in sections:

            if section.form.errors:

                break

        else:

            attendee.save()

            if SESSION_KEY in request.session:

                del request.session[SESSION_KEY]

            # 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):

    ''' View for editing an attendee's profile

    The user must be logged in to edit their profile.

    Returns:

        redirect or render:

            In the case of a ``POST`` request, it'll redirect to ``dashboard``,

            or otherwise, it will render ``registrasion/profile_form.html``

            with data::

                {

                    "form": form,  # Instance of ATTENDEE_PROFILE_FORM.

                }

    '''

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

    if handled and not form.errors:

        messages.success(

            request,

            "Your attendee profile was updated.",

        )

        return redirect("dashboard")

    data = {

        "form": form,

    }

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

def _handle_profile(request, prefix):

    ''' Returns a profile form instance, and a boolean which is true if the

    form was handled. '''

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

    try:

        profile = attendee.attendeeprofilebase

        profile = people.AttendeeProfileBase.objects.get_subclass(

            pk=profile.id,

        )

    except ObjectDoesNotExist:

        profile = None

    ProfileForm = get_form(settings.ATTENDEE_PROFILE_FORM)

    # Load a pre-entered name from the speaker's profile,

    # if they have one.

    try:

        speaker_profile = request.user.speaker_profile

        speaker_name = speaker_profile.name

    except ObjectDoesNotExist:

        speaker_name = None

    name_field = ProfileForm.Meta.model.name_field()

    initial = {}

    if profile is None and name_field is not None:

        initial[name_field] = speaker_name

    form = ProfileForm(

        request.POST or None,

        initial=initial,

        instance=profile,

        prefix=prefix

    )

    handled = True if request.POST else False

    if request.POST and form.is_valid():

        form.instance.attendee = attendee

        form.save()

    return form, handled

@login_required

def product_category(request, category_id):

    ''' Form for selecting products from an individual product category.

    Arguments:

        category_id (castable to int): The id of the category to display.

    Returns:

        redirect or render:

            If the form has been sucessfully submitted, redirect to

            ``dashboard``. Otherwise, render

            ``registrasion/product_category.html`` with data::

                {

                    "category": category,         # An inventory.Category for

                                                  # category_id

                    "discounts": discounts,       # A list of

                                                  # DiscountAndQuantity

                    "form": products_form,        # A form for selecting

                                                  # products

                    "voucher_form": voucher_form, # A form for entering a

                                                  # voucher code

                }

    '''

    PRODUCTS_FORM_PREFIX = "products"

    VOUCHERS_FORM_PREFIX = "vouchers"

    # Handle the voucher form *before* listing products.

    # Products can change as vouchers are entered.

    v = _handle_voucher(request, VOUCHERS_FORM_PREFIX)

    voucher_form, voucher_handled = v

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

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

    with BatchController.batch(request.user):

        products = ProductController.available_products(

            request.user,

            category=category,

        )

        if not products:

            messages.warning(

                request,

                (

                    "There are no products available from category: " +

                    category.name

                ),

            )

            return redirect("dashboard")

        p = _handle_products(request, category, products, PRODUCTS_FORM_PREFIX)

        products_form, discounts, products_handled = p

    if request.POST and not voucher_handled and not products_form.errors:

        # Only return to the dashboard if we didn't add a voucher code

        # and if there's no errors in the products form

        messages.success(

            request,

            "Your reservations have been updated.",

        )

        return redirect("dashboard")

    data = {

        "category": category,

        "discounts": discounts,

        "form": products_form,

        "voucher_form": voucher_form,

    }

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

def _handle_products(request, category, products, prefix):

    ''' Handles a products list form in the given request. Returns the

    form instance, the discounts applicable to this form, and whether the

    contents were handled. '''

    current_cart = CartController.for_user(request.user)

    ProductsForm = forms.ProductsForm(category, products)

    # Create initial data for each of products in category

    items = commerce.ProductItem.objects.filter(

        product__in=products,

        cart=current_cart.cart,

    ).select_related("product")

    quantities = []

    seen = set()

    for item in items:

        quantities.append((item.product, item.quantity))

        seen.add(item.product)

    zeros = set(products) - seen

    for product in zeros:

        quantities.append((product, 0))

    products_form = ProductsForm(

        request.POST or None,

        product_quantities=quantities,

        prefix=prefix,

    )

    if request.method == "POST" and products_form.is_valid():

        if products_form.has_changed():

            _set_quantities_from_products_form(products_form, current_cart)

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

        # in an active+valid cart

        if category.required:

            carts = commerce.Cart.objects.filter(user=request.user)

            items = commerce.ProductItem.objects.filter(

                product__category=category,

                cart=carts,

            )

            if len(items) == 0:

                products_form.add_error(

                    None,

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

                )

    handled = False if products_form.errors else True

    # Making this a function to lazily evaluate when it's displayed

    # in templates.

    discounts = util.lazy(

        DiscountController.available_discounts,

        request.user,

        [],

        products,

    )

    return products_form, discounts, handled

def _set_quantities_from_products_form(products_form, current_cart):