Django>=1.11

pinax-theme-bootstrap==7.3.0

pinax-eventlog==1.1.1

django-formset-js==0.5.0

dj-static==0.0.6

dj-database-url==0.4.2

pylibmc==1.5.1

django-debug-toolbar>=1.7

django-bootstrap-form

djangosaml2

django-gapc-storage>=0.4.1

# database

mysqlclient>=1.3.3

# For testing

django-nose>=1.4.4

coverage==4.0.3

# Symposion reqs

django-appconf==1.0.1

django-model-utils>=3.0.0

django-reversion==1.10.1

django-sitetree>=1.8.0

django-taggit==0.18.0

django-timezone-field>=2.0

easy-thumbnails>=2.4.1

bleach

pytz==2015.7

django-ical==1.4

django-nested-admin==2.2.6

# Registripe

django-countries>=4.3

pinax-stripe==3.2.1

requests>=2.11.1

stripe==1.38.0

from .reporting import views as rv

from django.conf.urls import include

from django.conf.urls import url

from .views import (

    amend_registration,

    user_badge,

    badge,

    badger,

    checkout,

    credit_note,

    edit_profile,

    extend_reservation,

    guided_registration,

    invoice,

    invoice_access,

    invoice_mailout,

    manual_payment,

    product_category,

    refund,

    review,

    voucher_code,

)

public = [

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

    url(r"^mybadge$", user_badge, name="user_badge"),

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

    url(r"^badger/([A-Za-z0-9]+)$", badger, name="badger"),

    url(r"^badger/", badger, name="badger"),

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

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

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

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

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

    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"^invoice_mailout$", invoice_mailout, name="invoice_mailout"),

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

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

    url(r"^voucher$", voucher_code, name="voucher_code"),

    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_data/?$", rv.attendee_data, name="attendee_data"),

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

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

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

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

    url(

        r"^product_line_items/?$",

        rv.product_line_items,

        name="product_line_items",

    ),

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

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

    url(

        r"^paid_invoices_by_date/?$",

        rv.paid_invoices_by_date,

        name="paid_invoices_by_date"

    ),

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

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

    url(

        r"^speaker_registrations/?$",

        rv.speaker_registrations,

        name="speaker_registrations",

    ),

]

urlpatterns = [

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

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

]

import datetime

import zipfile

import os

import logging

from django.contrib import messages

from . import forms

from . import util

from .models import commerce

from .models import inventory

from .models import people

from .controllers.batch import BatchController

from .controllers.cart import CartController

from .controllers.category import CategoryController

from .controllers.credit_note import CreditNoteController

from .controllers.discount import DiscountController

from .controllers.invoice import InvoiceController

from .controllers.item import ItemController

from .controllers.product import ProductController

from .exceptions import CartValidationError

from collections import namedtuple

from django import forms as django_forms

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.auth.models import User

from django.contrib import messages

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.core.mail import send_mass_mail

from django.http import Http404, HttpResponse

from django.shortcuts import redirect

from django.shortcuts import render

from django.template import Context, Template, loader

from lxml import etree

from copy import deepcopy

from registrasion.forms import BadgeForm, ticket_selection

from registrasion.contrib.badger import (

                                         collate,

                                         svg_badge,

                                         InvalidTicketChoiceError

                                         )

_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

@login_required

def guided_registration(request, page_number=None):

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

    all valid categories.

    The user must be logged in to see this view.

    Parameter:

        page_number:

            1) Profile form (and e-mail address?)

            2) Ticket type

            3) Remaining products

            4) Mark registration as complete

    Returns:

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

            with the following data::

                {

                    "previous_step": int(),  # Previous step

                    "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

                }

    '''

    PAGE_PROFILE = 1

    PAGE_TICKET = 2

    PAGE_TERMS = 3

    PAGE_PRODUCTS = 4

    PAGE_PRODUCTS_MAX = 5

    TOTAL_PAGES = 5

    ticket_category = inventory.Category.objects.get(

        id=settings.TICKET_PRODUCT_CATEGORY

    )

    cart = CartController.for_user(request.user)

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

    # This guided registration process is only for people who have

    # not completed registration (and has confusing behaviour if you go

    # back to it.)

    if attendee.completed_registration:

        return redirect(review)

    # Calculate the current maximum page number for this user.

    has_profile = hasattr(attendee, "attendeeprofilebase")

    if not has_profile:

        # If there's no profile, they have to go to the profile page.

        max_page = PAGE_PROFILE

        redirect_page = PAGE_PROFILE

    else:

        # We have a profile.

        # Do they have a ticket?

        products = inventory.Product.objects.filter(

            productitem__cart=cart.cart

        )

        tickets = products.filter(category=ticket_category)

        if tickets.count() == 0:

            # If no ticket, they can only see the profile or ticket page.

            max_page = PAGE_TICKET

            redirect_page = PAGE_TICKET

        elif products.count() == 1:

            # They have a ticket, now to accept terms and conditions

            max_page = PAGE_TERMS

            redirect_page = PAGE_TERMS

        else:

            # If there's a ticket, they should *see* the general products page#

            # but be able to go to the overflow page if needs be.

            max_page = PAGE_PRODUCTS_MAX

            redirect_page = PAGE_PRODUCTS

    if page_number is None or int(page_number) > max_page:

        return redirect("guided_registration", redirect_page)

    page_number = int(page_number)

    prev_step = page_number - 1

    next_step = redirect("guided_registration", page_number + 1)

    with BatchController.batch(request.user):

        # This view doesn't work if the conference has sold out.

        available = ProductController.available_products(

            request.user, category=ticket_category

        )

        if not available:

            messages.error(request, "There are no more tickets available.")

            return redirect("dashboard")

        sections = []

        # Build up the list of sections

        if page_number == PAGE_PROFILE:

            # Profile bit

            title = "Attendee information"

            sections = _guided_registration_profile_and_voucher(request)

        elif page_number == PAGE_TICKET:

            # Select ticket

            title = "Select ticket type"

            sections = _guided_registration_products(

                request, GUIDED_MODE_TICKETS_ONLY

            )

        elif page_number == PAGE_TERMS:

            # Accept terms

            title = "Terms and Conditions"

            sections = _guided_registration_products(

                request, GUIDED_MODE_TERMS

            )

        elif page_number == PAGE_PRODUCTS:

            # Select additional items

            title = "Additional items"

            sections = _guided_registration_products(

                request, GUIDED_MODE_ALL_ADDITIONAL

            )

        elif page_number == PAGE_PRODUCTS_MAX:

            # Items enabled by things on page 3 -- only shows things

            # that have not been marked as complete.

            title = "More additional items"

            sections = _guided_registration_products(

                request, GUIDED_MODE_EXCLUDE_COMPLETE

            )

        if not sections:

            # We've filled in every category

            attendee.completed_registration = True

            attendee.save()

            return redirect("review")

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

            for section in sections:

                if section.form.errors:

                    break

            else:

                # We've successfully processed everything

                return next_step

    data = {

        "previous_step": prev_step,

        "current_step": page_number,

        "sections": sections,

        "title": title,

        "total_steps": TOTAL_PAGES,

    }

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

GUIDED_MODE_TICKETS_ONLY = 2

GUIDED_MODE_TERMS = 3

GUIDED_MODE_ALL_ADDITIONAL = 4

GUIDED_MODE_EXCLUDE_COMPLETE =5

@login_required

def _guided_registration_products(request, mode):

    sections = []

    SESSION_KEY = "guided_registration"

    MODE_KEY = "mode"

    CATS_KEY = "cats"

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

    # Get the next category

    cats = inventory.Category.objects.order_by("order")  # TODO: default order?

    # Fun story: If _any_ of the category forms result in an error, but other

    # new products get enabled with a flag, those new products will appear.

    # We need to make sure that we only display the products that were valid

    # in the first place. So we track them in a session, and refresh only if

    # the page number does not change. Cheap!

    if SESSION_KEY in request.session:

        session_struct = request.session[SESSION_KEY]

        old_mode = session_struct[MODE_KEY]

        old_cats = session_struct[CATS_KEY]

    else:

        old_mode = None

        old_cats = []

    if mode == old_mode:

        cats = cats.filter(id__in=old_cats)

    elif mode == GUIDED_MODE_TICKETS_ONLY:

        cats = cats.filter(id=settings.TICKET_PRODUCT_CATEGORY)

    elif mode == GUIDED_MODE_ALL_ADDITIONAL:

        cats = cats.exclude(id=settings.TICKET_PRODUCT_CATEGORY)

    elif mode == GUIDED_MODE_EXCLUDE_COMPLETE:

        cats = cats.exclude(id=settings.TICKET_PRODUCT_CATEGORY)

        cats = cats.exclude(id__in=old_cats)

    # We update the session key at the end of this method

    # once we've found all the categories that have available products

    all_products = inventory.Product.objects.filter(

        category__in=cats,

    ).select_related("category")

    seen_categories = []

    with BatchController.batch(request.user):

        available_products = set(ProductController.available_products(

            request.user,

            products=all_products,

        ))

        if len(available_products) == 0:

            return []

        has_errors = False

@user_passes_test(_staff_only)

def refund(request, invoice_id):

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

    full amount paid against the invoice.

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

    Arguments:

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

    Returns:

        redirect:

            Redirects to ``invoice``.

    '''

    current_invoice = InvoiceController.for_id_or_404(invoice_id)

    try:

        current_invoice.refund()

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

    except ValidationError as ve:

        messages.error(request, ve)

    return redirect("invoice", invoice_id)

@user_passes_test(_staff_only)

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

    ''' Displays a credit note.

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

    a credit note will be processed.

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

    Arguments:

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

    Returns:

        render or redirect:

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

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

            with the following data::

                {

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

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

                                         # to an invoice.

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

                                         # refund of the credit note.

                    "cancellation_fee_form" : form, # A form for generating an

                                                    # invoice with a

                                                    # cancellation fee

                }

    '''

    note_id = int(note_id)

    current_note = CreditNoteController.for_id_or_404(note_id)

    apply_form = forms.ApplyCreditNoteForm(

        current_note.credit_note.invoice.user,

        request.POST or None,

        prefix="apply_note"

    )

    refund_form = forms.ManualCreditNoteRefundForm(

        request.POST or None,

        prefix="refund_note"

    )

    cancellation_fee_form = forms.CancellationFeeForm(

        request.POST or None,

        prefix="cancellation_fee"

    )

    if request.POST and apply_form.is_valid():

        inv_id = apply_form.cleaned_data["invoice"]

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

        current_note.apply_to_invoice(invoice)

        messages.success(

            request,

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

        )

        return redirect("invoice", invoice.id)

    elif request.POST and refund_form.is_valid():

        refund_form.instance.entered_by = request.user

        refund_form.instance.parent = current_note.credit_note

        refund_form.save()

        messages.success(

            request,

            "Applied manual refund to credit note."

        )

        refund_form = forms.ManualCreditNoteRefundForm(

            prefix="refund_note",

        )

    elif request.POST and cancellation_fee_form.is_valid():

        percentage = cancellation_fee_form.cleaned_data["percentage"]

        invoice = current_note.cancellation_fee(percentage)

        messages.success(

            request,

            "Generated cancellation fee for credit note %d." % note_id,

        )

        return redirect("invoice", invoice.invoice.id)

    data = {

        "credit_note": current_note.credit_note,

        "apply_form": apply_form,

        "refund_form": refund_form,

        "cancellation_fee_form": cancellation_fee_form,

    }

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

@user_passes_test(_staff_only)

def amend_registration(request, user_id):

    ''' Allows staff to amend a user's current registration cart, and etc etc.

    '''

    user = User.objects.get(id=int(user_id))

    current_cart = CartController.for_user(user)

    items = commerce.ProductItem.objects.filter(

        cart=current_cart.cart,

    ).select_related("product")

    initial = [{"product": i.product, "quantity": i.quantity} for i in items]

    StaffProductsFormSet = forms.staff_products_formset_factory(user)

    formset = StaffProductsFormSet(

        request.POST or None,

        initial=initial,

        prefix="products",

    )

    for item, form in zip(items, formset):

        queryset = inventory.Product.objects.filter(id=item.product.id)

        form.fields["product"].queryset = queryset

    voucher_form = forms.VoucherForm(

        request.POST or None,

        prefix="voucher",

    )

    if request.POST and formset.is_valid():

        pq = [

            (f.cleaned_data["product"], f.cleaned_data["quantity"])

            for f in formset

            if "product" in f.cleaned_data and

            f.cleaned_data["product"] is not None

        ]

        try:

            current_cart.set_quantities(pq)

            return redirect(amend_registration, user_id)

        except ValidationError as ve:

            for ve_field in ve.error_list:

                product, message = ve_field.message

                for form in formset:

                    if "product" not in form.cleaned_data:

                        # This is the empty form.

                        continue

                    if form.cleaned_data["product"] == product:

                        form.add_error("quantity", message)

    if request.POST and voucher_form.has_changed() and voucher_form.is_valid():

        try:

            current_cart.apply_voucher(voucher_form.cleaned_data["voucher"])

            return redirect(amend_registration, user_id)

        except ValidationError as ve:

            voucher_form.add_error(None, ve)

    ic = ItemController(user)

    data = {

        "user": user,

        "paid": ic.items_purchased(),

        "cancelled": ic.items_released(),

        "form": formset,

        "voucher_form": voucher_form,

    }

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

@user_passes_test(_staff_only)

def extend_reservation(request, user_id, days=7):

    ''' Allows staff to extend the reservation on a given user's cart.

    '''

    user = User.objects.get(id=int(user_id))

    cart = CartController.for_user(user)

    cart.extend_reservation(datetime.timedelta(days=days))

    return redirect(request.META["HTTP_REFERER"])

Email = namedtuple(

    "Email",

    ("subject", "body", "from_email", "recipient_list"),

)

@user_passes_test(_staff_only)

def invoice_mailout(request):

    ''' Allows staff to send emails to users based on their invoice status. '''

    category = request.GET.getlist("category", [])

    product = request.GET.getlist("product", [])

    status = request.GET.get("status")

    form = forms.InvoiceEmailForm(

        request.POST or None,

        category=category,

        product=product,

        status=status,

    )

    emails = []

    if form.is_valid():

        emails = []

        for invoice in form.cleaned_data["invoice"]:

            # datatuple = (subject, message, from_email, recipient_list)

            from_email = form.cleaned_data["from_email"]

            subject = form.cleaned_data["subject"]

            body = Template(form.cleaned_data["body"]).render(

                Context({

                    "invoice": invoice,

                    "user": invoice.user,

                })

            )

            recipient_list = [invoice.user.email]

            emails.append(Email(subject, body, from_email, recipient_list))

        if form.cleaned_data["action"] == forms.InvoiceEmailForm.ACTION_SEND:

            # Send e-mails *ONLY* if we're sending.

            send_mass_mail(emails)

            messages.info(request, "The e-mails have been sent.")

    data = {

        "form": form,

        "emails": emails,

    }

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

def _get_badge_template_name():

    return os.path.join(settings.PROJECT_ROOT, 'pinaxcon', 'templates',

                        settings.BADGER_DEFAULT_SVG)

@login_required

    '''Shows the logged-in user their badge'''

@user_passes_test(_staff_only)

    ''' Renders a single user's badge (SVG). '''

    user_id = int(user_id)

    user = User.objects.get(pk=user_id)

    rendered = render_badge_svg(user)

    response = HttpResponse(rendered)

    return response

def render_badge_svg(user):

    ''' Renders a single user's badge as SVG. '''

    data = {

        "user": user,

    }

    t = loader.get_template('registrasion/badge.svg')

    return t.render(data)

def badges(request):

    '''

    *** NOT USED FOR PYCONAU 2017 MELBOURNE  (I.e., not supported in badger module.) ***

    Either displays a form containing a list of users with badges to

    render, or returns a .zip file containing their badges. '''

    category = request.GET.getlist("category", [])

    product = request.GET.getlist("product", [])

    status = request.GET.get("status")

    form = forms.InvoicesWithProductAndStatusForm(

        request.POST or None,

        category=category,

        product=product,

        status=status,

    )

    if form.is_valid():

        response = HttpResponse()

        response["Content-Type"] = "application.zip"

        response["Content-Disposition"] = 'attachment; filename="badges.zip"'

        z = zipfile.ZipFile(response, "w")

        for invoice in form.cleaned_data["invoice"]:

            user = invoice.user

            badge = render_badge(user)

            z.writestr("badge_%d.svg" % user.id, badge.encode("utf-8"))

        return response

    data = {

        "form": form,

    }

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

def collate_from_form(form):

    '''

    Does what collate does, but using form data as its input source

    rather than User record.

    '''

        # Build the thing we'll pass to svg_badge() later.

    data = dict()

    # Get the name bits ...

    at_nm = form.data['name'].split()

    if at_nm[0].lower() in 'mr dr ms mrs miss'.split():

        at_nm[0] = at_nm[0] + ' ' + at_nm[1]

        del at_nm[1]

    if at_nm:

        data['firstname'] = at_nm[0]

        data['lastname'] = ''.join(at_nm[1:])

    else:  # Can't happen -- form validator will check for this.

        pass

    # Free text -- only one line ... come on!

    data['line1'] = form.data['free_text_1']

    data['line2'] = form.data['free_text_2']

    # Email ...

    data['email'] = form.data['email']

    # Don't think we want to allow ad hoc organiser tickets ...

    data['organiser'] = False

    # Punt on shirts for now ...

    data['shirts'] = list()

    # Lots booleans ...

    for key in ['over18', 'paid', 'friday', 'speaker', 'tutorial',

                'sprints', 'company',]:

        data[key] = form.data.get(key, False)

    # This will throw InvalidTicketChoiceError if the ticket

    # choice isn't found in the ticket list or is the

    # "Plese select a valid tickt" choice.  (I.e., they forgot

    # to choose a ticket.)

    data['ticket'] = ticket_selection()[int(form.data['ticket'])][1]

    data['volunteer'] = data['ticket'].find("Volunteer") >= 0

    if 'Specialist Day Only' in data['ticket']:

        data['ticket'] = 'Friday Only'

        data['friday'] = True

    if 'Conference Organiser' in data['ticket']:

        data['ticket'] = ''

    if 'Conference Volunteer' in data['ticket']:

        data['ticket'] = ''

    data['promote_company'] = (

        data['organiser'] or data['volunteer'] or data['speaker'] or

        'Sponsor' in data['ticket'] or

        'Contributor' in data['ticket'] or

        'Professional' in data['ticket']

    )

    return data

@user_passes_test(_staff_only)

def badger(request, username=None):

    '''

    Renders a single user's badge from data supplied on

    a form rather than from Attendee data.

    If *username* is provided in the URL, an attempt

    will be made to look up this user and fill in the

    badge details from the User and Attendee records.

    '''

    if username is not None:

        # We have a username.  Try to populate our badge data

        # from User/Attendee model.

        try:

            data = collate({'usernames': [username,]}).next()

        except: # No matching User record (probably) ... just put up a blank form

            return render(request, settings.BADGER_DEFAULT_FORM, {'form': BadgeForm})

    else:

        form = BadgeForm(request.POST)

        if len(form.data) == 0:  # Empty or request to put up the form.

            return render(request, settings.BADGER_DEFAULT_FORM, {'form': BadgeForm})

        try:

            if form.is_valid():

               data = collate_from_form(form)