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

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

    @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([])

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

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,

            )

            }

class VoucherForm(forms.Form):

    voucher = forms.CharField(

        label="Voucher code",

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

        required=False,

    )

import datetime

from django.db import models

from django.utils.encoding import python_2_unicode_compatible

from django.utils.translation import ugettext_lazy as _

# Inventory Models

@python_2_unicode_compatible

class Category(models.Model):

    ''' Registration product categories, used as logical groupings for Products

    in registration forms.

    Attributes:

        name (str): The display name for the category.

        description (str): Some explanatory text for the category. This is

            displayed alongside the forms where your attendees choose their

            items.

        required (bool): Requires a user to select an item from this category

            during initial registration. You can use this, e.g., for making

            sure that the user has a ticket before they select whether they

            want a t-shirt.

        render_type (int): This is used to determine what sort of form the

            attendee will be presented with when choosing Products from this

            category. These may be either of the following:

            ``RENDER_TYPE_RADIO`` presents the Products in the Category as a

            list of radio buttons. At most one item can be chosen at a time.

            This works well when setting limit_per_user to 1.

            ``RENDER_TYPE_QUANTITY`` shows each Product next to an input field,

            where the user can specify a quantity of each Product type. This is

            useful for additional extras, like Dinner Tickets.

        limit_per_user (Optional[int]): This restricts the number of items

            from this Category that each attendee may claim. This extends

            across multiple Invoices.

        display_order (int): An ascending order for displaying the Categories

            available. By convention, your Category for ticket types should

            have the lowest display order.

    '''

    class Meta:

        app_label = "registrasion"

        verbose_name = _("inventory - category")

        verbose_name_plural = _("inventory - categories")

        ordering = ("order", )

    def __str__(self):

        return self.name

    RENDER_TYPE_RADIO = 1

    RENDER_TYPE_QUANTITY = 2

    CATEGORY_RENDER_TYPES = [

        (RENDER_TYPE_RADIO, _("Radio button")),

        (RENDER_TYPE_QUANTITY, _("Quantity boxes")),

    ]

    name = models.CharField(

        max_length=65,

        verbose_name=_("Name"),

    )

    description = models.CharField(

        max_length=255,

        verbose_name=_("Description"),

    )

    limit_per_user = models.PositiveIntegerField(

        null=True,

        blank=True,

        verbose_name=_("Limit per user"),

        help_text=_("The total number of items from this category one "

                    "attendee may purchase."),

    )

    required = models.BooleanField(

        blank=True,

        help_text=_("If enabled, a user must select an "

                    "item from this category."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

        db_index=True,

    )

    render_type = models.IntegerField(

        choices=CATEGORY_RENDER_TYPES,

        verbose_name=_("Render type"),

        help_text=_("The registration form will render this category in this "

                    "style."),

    )

@python_2_unicode_compatible

class Product(models.Model):

    ''' Products make up the conference inventory.

    Attributes:

        name (str): The display name for the product.

        description (str): Some descriptive text that will help the user to

            understand the product when they're at the registration form.

        category (Category): The Category that this product will be grouped

            under.

        price (Decimal): The price that 1 unit of this product will sell for.

            Note that this should be the full price, before any discounts are

            applied.

        limit_per_user (Optional[int]): This restricts the number of this

            Product that each attendee may claim. This extends across multiple

            Invoices.

        reservation_duration (datetime): When a Product is added to the user's

            tentative registration, it is marked as unavailable for a period of

            time. This allows the user to build up their registration and then

            pay for it. This reservation duration determines how long an item

            should be allowed to be reserved whilst being unpaid.

        display_order (int): An ascending order for displaying the Products

            within each Category.

    '''

    class Meta:

        app_label = "registrasion"

        verbose_name = _("inventory - product")

        ordering = ("category__order", "order")

    def __str__(self):

        return "%s - %s" % (self.category.name, self.name)

    name = models.CharField(

        max_length=65,

        verbose_name=_("Name"),

    )

    description = models.CharField(

        max_length=255,

        verbose_name=_("Description"),

        null=True,

        blank=True,

    )

    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(

        null=True,

        blank=True,

        verbose_name=_("Limit per user"),

    )

    reservation_duration = models.DurationField(

        default=datetime.timedelta(hours=1),

        verbose_name=_("Reservation duration"),

        help_text=_("The length of time this product will be reserved before "

                    "it is released for someone else to purchase."),

    )

    order = models.PositiveIntegerField(

        verbose_name=("Display order"),

        db_index=True,

    )

@python_2_unicode_compatible

class Voucher(models.Model):

    ''' Vouchers are used to enable Discounts or Flags for the people who hold

    the voucher code.

    Attributes:

        recipient (str): A display string used to identify the holder of the

            voucher on the admin page.

        code (str): The string that is used to prove that the attendee holds

            this voucher.

        limit (int): The number of attendees who are permitted to hold this

            voucher.

     '''

    class Meta:

        app_label = "registrasion"

    # 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

    @classmethod

    def normalise_code(cls, code):

        return code.upper()

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

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

        self.code = self.normalise_code(self.code)

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

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

    quantities = list(products_form.product_quantities())

    pks = [i[0] for i in quantities]

    products = inventory.Product.objects.filter(

        id__in=pks,

    ).select_related("category").order_by("id")

    quantities.sort(key = lambda i: i[0])

    product_quantities = [

        (product, id_to_quantity[product.id]) for product in products

    ]

    try:

        current_cart.set_quantities(product_quantities)

    except CartValidationError as ve:

        for ve_field in ve.error_list:

            product, message = ve_field.message

def _handle_voucher(request, prefix):

    ''' Handles a voucher form in the given request. Returns the voucher

    form instance, and whether the voucher code was handled. '''

    voucher_form = forms.VoucherForm(request.POST or None, prefix=prefix)

    current_cart = CartController.for_user(request.user)

    if (voucher_form.is_valid() and

            voucher_form.cleaned_data["voucher"].strip()):

        voucher = voucher_form.cleaned_data["voucher"]

        voucher = inventory.Voucher.normalise_code(voucher)

        if len(current_cart.cart.vouchers.filter(code=voucher)) > 0:

            # This voucher has already been applied to this cart.

            # Do not apply code

            handled = False

        else:

            try:

                current_cart.apply_voucher(voucher)

            except Exception as e:

                voucher_form.add_error("voucher", e)

            handled = True

    else:

        handled = False

    return (voucher_form, handled)

@login_required

def checkout(request):