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 import discount from registrasion.controllers.cart import CartController from registrasion.controllers.credit_note import CreditNoteController 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 import messages from django.core.exceptions import ObjectDoesNotExist from django.core.exceptions import ValidationError from django.http import Http404 from django.shortcuts import get_object_or_404 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") 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) 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 discounts = discount.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") product_quantities = [ (products.get(pk=i[0]), i[1]) for i in quantities ] field_names = dict( (i[0][0], i[1][2]) for i in zip(product_quantities, quantities) ) try: current_cart.set_quantities(product_quantities) except CartValidationError as ve: for ve_field in ve.error_list: product, message = ve_field.message if product in field_names: field = field_names[product] elif isinstance(product, inventory.Product): continue else: field = None products_form.add_error(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): ''' Runs the checkout process for the current cart. If the query string contains ``fix_errors=true``, Registrasion will attempt to fix errors preventing the system from checking out, including by cancelling expired discounts and vouchers, and removing any unavailable products. Returns: render or redirect: If the invoice is generated successfully, or there's already a valid invoice for the current cart, redirect to ``invoice``. If there are errors when generating the invoice, render ``registrasion/checkout_errors.html`` with the following data:: { "error_list", [str, ...] # The errors to display. } Runs checkout for the current cart of items, ideally generating an invoice. ''' current_cart = CartController.for_user(request.user) if "fix_errors" in request.GET and request.GET["fix_errors"] == "true": current_cart.fix_simple_errors() try: current_invoice = InvoiceController.for_cart(current_cart.cart) except ValidationError as ve: return _checkout_errors(request, ve) return redirect("invoice", current_invoice.invoice.id) def _checkout_errors(request, errors): error_list = [] for error in errors.error_list: if isinstance(error, tuple): error = error[1] error_list.append(error) data = { "error_list": error_list, } return render(request, "registrasion/checkout_errors.html", data) def invoice_access(request, access_code): ''' Redirects to the first unpaid invoice for the attendee that matches the given access code, if any. Arguments: access_code (castable to int): The access code for the user whose invoice you want to see. Returns: redirect: Redirect to the first unpaid invoice for that user. Raises: Http404: If there is no such invoice. ''' invoices = commerce.Invoice.objects.filter( user__attendee__access_code=access_code, status=commerce.Invoice.STATUS_UNPAID, ).order_by("issue_time") if not invoices: raise Http404() invoice = invoices[0] return redirect("invoice", invoice.id, access_code) def invoice(request, invoice_id, access_code=None): ''' Displays an invoice. 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) @login_required def manual_payment(request, invoice_id): ''' Allows staff to make manual payments or refunds on an invoice.''' FORM_PREFIX = "manual_payment" if not request.user.is_staff: raise Http404() 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 = inv form.save() current_invoice.update_status() form = forms.ManualPaymentForm(prefix=FORM_PREFIX) data = { "invoice": inv, "form": form, } return render(request, "registrasion/manual_payment.html", data) @login_required def refund(request, invoice_id): ''' Allows staff to refund payments against an invoice and request a credit note.''' if not request.user.is_staff: raise Http404() 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) def credit_note(request, note_id, access_code=None): ''' Displays an credit note for a given id. This view can only be seen by staff. ''' if not request.user.is_staff: raise Http404() current_note = CreditNoteController.for_id_or_404(note_id) apply_form = forms.ApplyCreditNoteForm( 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 = note refund_form.save() messages.success( request, "Applied manual refund to credit note." ) return redirect("invoice", invoice.id) data = { "credit_note": current_note.credit_note, "apply_form": apply_form, "refund_form": refund_form, } return render(request, "registrasion/credit_note.html", data)