symposion_app Changeset - 01b9adbaf46e

Changeset - 01b9adbaf46e

Parent rev.

Child rev.

[Not reviewed]

0 3 1

Christopher Neugebauer - 8 years ago 2016-04-08 09:43:34
chrisjrn@gmail.com

Re-writes the guided registration to individually track completed categories, and keep the form page the same until every category is finished. Resolves #14

4 files changed with 61 insertions and 15 deletions:

registrasion/migrations/0017_auto_20160408_0731.py

registrasion/models.py

registrasion/templatetags/registrasion_tags.py

registrasion/views.py

0 comments (0 inline, 0 general)

registrasion/migrations/0017_auto_20160408_0731.py

➞

Show inline comments

 new file 100644
 # -*- coding: utf-8 -*-
 # Generated by Django 1.9.2 on 2016-04-08 07:31
 from __future__ import unicode_literals
 from django.db import migrations, models
 class Migration(migrations.Migration):
     dependencies = [
         ('registrasion', '0016_auto_20160408_0234'),
+    ]
     operations = [
         migrations.RemoveField(
             model_name='attendee',
             name='highest_complete_category',
         ),
         migrations.AddField(
             model_name='attendee',
             name='guided_categories_complete',
             field=models.ManyToManyField(to='registrasion.Category'),
         ),
+    ]

registrasion/models.py

➞

Show inline comments

 from __future__ import unicode_literals
 import util
 import datetime
 import itertools
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.exceptions import ValidationError
 from django.contrib.auth.models import User
 from django.db import models
 from django.db.models import F, Q
 from django.utils import timezone
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.translation import ugettext_lazy as _
 from model_utils.managers import InheritanceManager
 # User models
 @python_2_unicode_compatible
 class Attendee(models.Model):
     ''' Miscellaneous user-related data. '''
     def __str__(self):
         return "%s" % self.user
     @staticmethod
     def get_instance(user):
         ''' Returns the instance of attendee for the given user, or creates
         a new one. '''
         try:
             return Attendee.objects.get(user=user)
         except ObjectDoesNotExist:
             return Attendee.objects.create(user=user)
     def save(self, *a, **k):
         while not self.access_code:
             access_code = util.generate_access_code()
             if Attendee.objects.filter(access_code=access_code).count() == 0:
                 self.access_code = access_code
         return super(Attendee, self).save(*a, **k)
     user = models.OneToOneField(User, on_delete=models.CASCADE)
     # Badge/profile is linked
     access_code = models.CharField(
         max_length=6,
         unique=True,
         db_index=True,
+    )
     completed_registration = models.BooleanField(default=False)
-    highest_complete_category = models.IntegerField(default=0)
+    guided_categories_complete = models.ManyToManyField("category")
 class AttendeeProfileBase(models.Model):
     ''' Information for an attendee's badge and related preferences.
     Subclass this in your Django site to ask for attendee information in your
     registration progess.
      '''
     objects = InheritanceManager()
     @classmethod
     def name_field(cls):
         ''' This is used to pre-fill the attendee's name from the
         speaker profile. If it's None, that functionality is disabled. '''
         return None
     def invoice_recipient(self):
         ''' Returns a representation of this attendee profile for the purpose
         of rendering to an invoice. Override in subclasses. '''
         # Manual dispatch to subclass. Fleh.
         slf = AttendeeProfileBase.objects.get_subclass(id=self.id)
         # Actually compare the functions.
         if type(slf).invoice_recipient != type(self).invoice_recipient:
             return type(slf).invoice_recipient(slf)
         # Return a default
         return slf.attendee.user.username
     attendee = models.OneToOneField(Attendee, on_delete=models.CASCADE)
 # Inventory Models
 @python_2_unicode_compatible
 class Category(models.Model):
     ''' Registration product categories '''
     class Meta:
         verbose_name_plural = _("categories")
     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):
     ''' Registration products '''
     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):
     ''' Registration vouchers '''
     # 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"))
 # Product Modifiers
 @python_2_unicode_compatible
 class DiscountBase(models.Model):
     ''' Base class for discounts. Each subclass has controller code that
     determines whether or not the given discount is available to be added to
     the current cart. '''
     objects = InheritanceManager()
     def __str__(self):
         return "Discount: " + self.description
     def effects(self):
         ''' Returns all of the effects of this discount. '''
         products = self.discountforproduct_set.all()
         categories = self.discountforcategory_set.all()
         return itertools.chain(products, categories)
     description = models.CharField(
         max_length=255,
         verbose_name=_("Description"),
         help_text=_("A description of this discount. This will be included on "
                     "invoices where this discount is applied."),
+        )
 @python_2_unicode_compatible
 class DiscountForProduct(models.Model):
     ''' Represents a discount on an individual product. Each Discount can
     contain multiple products and categories. Discounts can either be a
     percentage or a fixed amount, but not both. '''
     def __str__(self):
         if self.percentage:
             return "%s%% off %s" % (self.percentage, self.product)
         elif self.price:
             return "$%s off %s" % (self.price, self.product)
     def clean(self):
         if self.percentage is None and self.price is None:
             raise ValidationError(
                 _("Discount must have a percentage or a price."))
         elif self.percentage is not None and self.price is not None:
             raise ValidationError(
                 _("Discount may only have a percentage or only a price."))
         prods = DiscountForProduct.objects.filter(
             discount=self.discount,
             product=self.product)
         cats = DiscountForCategory.objects.filter(
             discount=self.discount,
             category=self.product.category)
         if len(prods) > 1:
             raise ValidationError(
                 _("You may only have one discount line per product"))
         if len(cats) != 0:
             raise ValidationError(
                 _("You may only have one discount for "
                     "a product or its category"))
     discount = models.ForeignKey(DiscountBase, on_delete=models.CASCADE)
     product = models.ForeignKey(Product, on_delete=models.CASCADE)
     percentage = models.DecimalField(
         max_digits=4, decimal_places=1, null=True, blank=True)
     price = models.DecimalField(
         max_digits=8, decimal_places=2, null=True, blank=True)
     quantity = models.PositiveIntegerField()
 @python_2_unicode_compatible
 class DiscountForCategory(models.Model):
     ''' Represents a discount for a category of products. Each discount can
     contain multiple products. Category discounts can only be a percentage. '''
     def __str__(self):
         return "%s%% off %s" % (self.percentage, self.category)
     def clean(self):
         prods = DiscountForProduct.objects.filter(
             discount=self.discount,
             product__category=self.category)
         cats = DiscountForCategory.objects.filter(
             discount=self.discount,
             category=self.category)
         if len(prods) != 0:
             raise ValidationError(
                 _("You may only have one discount for "
                     "a product or its category"))
         if len(cats) > 1:
             raise ValidationError(
                 _("You may only have one discount line per category"))
     discount = models.ForeignKey(DiscountBase, on_delete=models.CASCADE)
     category = models.ForeignKey(Category, on_delete=models.CASCADE)
     percentage = models.DecimalField(
         max_digits=4,
         decimal_places=1)
     quantity = models.PositiveIntegerField()
 class TimeOrStockLimitDiscount(DiscountBase):
     ''' Discounts that are generally available, but are limited by timespan or
     usage count. This is for e.g. Early Bird discounts. '''
     class Meta:
         verbose_name = _("Promotional discount")
     start_time = models.DateTimeField(
         null=True,
         blank=True,
         verbose_name=_("Start time"),
         help_text=_("This discount will only be available after this time."),
+    )
     end_time = models.DateTimeField(
         null=True,
         blank=True,
         verbose_name=_("End time"),
         help_text=_("This discount will only be available before this time."),
+    )
     limit = models.PositiveIntegerField(
         null=True,
         blank=True,
         verbose_name=_("Limit"),
         help_text=_("This discount may only be applied this many times."),
+    )
 class VoucherDiscount(DiscountBase):
     ''' Discounts that are enabled when a voucher code is in the current
     cart. '''
     voucher = models.OneToOneField(
         Voucher,
         on_delete=models.CASCADE,
         verbose_name=_("Voucher"),
         db_index=True,
+    )
 class IncludedProductDiscount(DiscountBase):
     ''' Discounts that are enabled because another product has been purchased.
     e.g. A conference ticket includes a free t-shirt. '''
     class Meta:
         verbose_name = _("Product inclusion")
     enabling_products = models.ManyToManyField(
         Product,
         verbose_name=_("Including product"),
         help_text=_("If one of these products are purchased, the discounts "
                     "below will be enabled."),
+    )
 class RoleDiscount(object):
     ''' Discounts that are enabled because the active user has a specific
     role. This is for e.g. volunteers who can get a discount ticket. '''
     # TODO: implement RoleDiscount
     pass
 @python_2_unicode_compatible
 class EnablingConditionBase(models.Model):
     ''' This defines a condition which allows products or categories to
     be made visible. If there is at least one mandatory enabling condition
     defined on a Product or Category, it will only be enabled if *all*
     mandatory conditions are met, otherwise, if there is at least one enabling
     condition defined on a Product or Category, it will only be enabled if at
     least one condition is met. '''
     objects = InheritanceManager()
     def __str__(self):
         return self.description
     def effects(self):
         ''' Returns all of the items enabled by this condition. '''
         return itertools.chain(self.products.all(), self.categories.all())
     description = models.CharField(max_length=255)
     mandatory = models.BooleanField(
         default=False,
         help_text=_("If there is at least one mandatory condition defined on "
                     "a product or category, all such conditions must be met. "
                     "Otherwise, at least one non-mandatory condition must be "
                     "met."),
+    )
     products = models.ManyToManyField(
         Product,
         blank=True,
         help_text=_("Products that are enabled if this condition is met."),
+    )
     categories = models.ManyToManyField(
         Category,
         blank=True,
         help_text=_("Categories whose products are enabled if this condition "
                     "is met."),
+    )
 class TimeOrStockLimitEnablingCondition(EnablingConditionBase):
     ''' Registration product ceilings '''
     class Meta:
         verbose_name = _("ceiling")
     start_time = models.DateTimeField(
         null=True,
         blank=True,
         help_text=_("Products included in this condition will only be "
                     "available after this time."),
+    )
     end_time = models.DateTimeField(
         null=True,
         blank=True,
         help_text=_("Products included in this condition will only be "
                     "available before this time."),
+    )
     limit = models.PositiveIntegerField(
         null=True,
         blank=True,
         help_text=_("The number of items under this grouping that can be "
                     "purchased."),
+    )
 @python_2_unicode_compatible
 class ProductEnablingCondition(EnablingConditionBase):
     ''' The condition is met because a specific product is purchased. '''
     def __str__(self):
         return "Enabled by products: " + str(self.enabling_products.all())
     enabling_products = models.ManyToManyField(
         Product,
         help_text=_("If one of these products are purchased, this condition "
                     "is met."),
+    )
 @python_2_unicode_compatible
 class CategoryEnablingCondition(EnablingConditionBase):
     ''' The condition is met because a product in a particular product is
     purchased. '''
     def __str__(self):
         return "Enabled by product in category: " + str(self.enabling_category)
     enabling_category = models.ForeignKey(
         Category,
         help_text=_("If a product from this category is purchased, this "
                     "condition is met."),
+    )
 @python_2_unicode_compatible
 class VoucherEnablingCondition(EnablingConditionBase):
     ''' The condition is met because a Voucher is present. This is for e.g.
     enabling sponsor tickets. '''
     def __str__(self):
         return "Enabled by voucher: %s" % self.voucher
     voucher = models.OneToOneField(Voucher)
 # @python_2_unicode_compatible
 class RoleEnablingCondition(object):
     ''' The condition is met because the active user has a particular Role.
     This is for e.g. enabling Team tickets. '''
     # TODO: implement RoleEnablingCondition
     pass
 # Commerce Models
 @python_2_unicode_compatible
 class Cart(models.Model):
     ''' Represents a set of product items that have been purchased, or are
     pending purchase. '''
     class Meta:
         index_together = [
             ("active", "time_last_updated"),
             ("active", "released"),
             ("active", "user"),
             ("released", "user"),
+        ]
     def __str__(self):
         return "%d rev #%d" % (self.id, self.revision)
     user = models.ForeignKey(User)
     # ProductItems (foreign key)
     vouchers = models.ManyToManyField(Voucher, blank=True)
     time_last_updated = models.DateTimeField(
         db_index=True,
+    )
     reservation_duration = models.DurationField()
     revision = models.PositiveIntegerField(default=1)
     active = models.BooleanField(
         default=True,
         db_index=True,
+    )
     released = models.BooleanField(
         default=False,
         db_index=True
     )  # Refunds etc
     @classmethod
     def reserved_carts(cls):
         ''' Gets all carts that are 'reserved' '''
         return Cart.objects.filter(
             (Q(active=True) &
                 Q(time_last_updated__gt=(
                     timezone.now()-F('reservation_duration')
                                         ))) |
             (Q(active=False) & Q(released=False))
+        )
 @python_2_unicode_compatible
 class ProductItem(models.Model):
     ''' Represents a product-quantity pair in a Cart. '''
     def __str__(self):
         return "product: %s * %d in Cart: %s" % (
             self.product, self.quantity, self.cart)
     cart = models.ForeignKey(Cart)
     product = models.ForeignKey(Product)
     quantity = models.PositiveIntegerField(db_index=True)
 @python_2_unicode_compatible
 class DiscountItem(models.Model):
     ''' Represents a discount-product-quantity relation in a Cart. '''
     def __str__(self):
         return "%s: %s * %d in Cart: %s" % (
             self.discount, self.product, self.quantity, self.cart)
     cart = models.ForeignKey(Cart)
     product = models.ForeignKey(Product)
     discount = models.ForeignKey(DiscountBase)
     quantity = models.PositiveIntegerField()
 @python_2_unicode_compatible
 class Invoice(models.Model):
     ''' An invoice. Invoices can be automatically generated when checking out
     a Cart, in which case, it is attached to a given revision of a Cart. '''
     STATUS_UNPAID = 1
     STATUS_PAID = 2
     STATUS_REFUNDED = 3
     STATUS_VOID = 4

registrasion/templatetags/registrasion_tags.py

➞

Show inline comments

 from registrasion import models as rego
 from registrasion.controllers.category import CategoryController
 from collections import namedtuple
 from django import template
 from django.db.models import Sum
 register = template.Library()
 ProductAndQuantity = namedtuple("ProductAndQuantity", ["product", "quantity"])
 @register.assignment_tag(takes_context=True)
 def available_categories(context):
     ''' Returns all of the available product categories '''
     return CategoryController.available_categories(context.request.user)
 @register.assignment_tag(takes_context=True)
 def invoices(context):
     ''' Returns all of the invoices that this user has. '''
     return rego.Invoice.objects.filter(cart__user=context.request.user)
 @register.assignment_tag(takes_context=True)
 def items_pending(context):
     ''' Returns all of the items that this user has in their current cart,
     and is awaiting payment. '''
     all_items = rego.ProductItem.objects.filter(
         cart__user=context.request.user,
         cart__active=True,
     ).select_related("product", "product__category")
     ).select_related(
         "product",
         "product__category",
     ).order_by(
         "product__category__order",
         "product__order",
+    )
     return all_items
 @register.assignment_tag(takes_context=True)
 def items_purchased(context, category=None):
     ''' Returns all of the items that this user has purchased, optionally
     from the given category. '''
     all_items = rego.ProductItem.objects.filter(
         cart__user=context.request.user,
         cart__active=False,
         cart__released=False,
     ).select_related("product", "product__category")
     if category:
         all_items = all_items.filter(product__category=category)
     pq = all_items.values("product").annotate(quantity=Sum("quantity")).all()
     products = rego.Product.objects.all()
     out = []
     for item in pq:
         prod = products.get(pk=item["product"])
         out.append(ProductAndQuantity(prod, item["quantity"]))
     return out
 @register.filter
 def multiply(value, arg):
     ''' Multiplies value by arg '''
     return value * arg

registrasion/views.py

➞

Show inline comments

 import sys
 from registrasion import forms
 from registrasion import models as rego
 from registrasion.controllers import discount
 from registrasion.controllers.cart import CartController
 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",
+    )
+)
 GuidedRegistrationSection.__new__.__defaults__ = (
     (None,) * len(GuidedRegistrationSection._fields)
+)
 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, page_id=0):
     ''' Goes through the registration process in order,
     making sure user sees all valid categories.
     WORK IN PROGRESS: the finalised version of this view will allow
     grouping of categories into a specific page. Currently, it just goes
     through each category one by one
     '''
     SESSION_KEY = "guided_registration_categories"
     next_step = redirect("guided_registration")
     sections = []
     attendee = rego.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
     if not profile:
         # TODO: if voucherform is invalid, make sure
         # that profileform does not save
         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
-        last_category = attendee.highest_complete_category
+        starting = attendee.guided_categories_complete.count() == 0
         # Get the next category
         cats = rego.Category.objects
         cats = cats.filter(id__gt=last_category).order_by("order")
         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(),
+            )
         if cats.count() == 0:
             # We've filled in every category
             attendee.completed_registration = True
             attendee.save()
             return next_step
         cats = cats.order_by("order")
         request.session[SESSION_KEY] = []
-        if last_category == 0:
+        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 = rego.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 does not exist for this user
+                # 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:
                 if category.id > attendee.highest_complete_category:
                     # This is only saved if we pass each form with no errors.
                     attendee.highest_complete_category = 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):
     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 = rego.Attendee.get_instance(request.user)
     try:
         profile = attendee.attendeeprofilebase
         profile = rego.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):
     ''' Registration selections form for a specific category of items.
     '''
     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 = rego.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 = rego.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 = rego.Cart.objects.filter(user=request.user)
             items = rego.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 = rego.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, rego.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 = rego.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 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. '''
     invoices = rego.Invoice.objects.filter(
         user__attendee__access_code=access_code,
         status=rego.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 for a given invoice id.
     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.
     '''
     invoice_id = int(invoice_id)
     inv = rego.Invoice.objects.get(pk=invoice_id)
     current_invoice = InvoiceController(inv)
     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()
     invoice_id = int(invoice_id)
     inv = get_object_or_404(rego.Invoice, pk=invoice_id)
     current_invoice = InvoiceController(inv)
     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)

0 comments (0 inline, 0 general)