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

    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: