from registrasion.models import commerce

from registrasion.models import inventory

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

class ProductAndQuantity(_ProductAndQuantity):

    ''' Class that holds a product and a quantity.

    Attributes:

        product (models.inventory.Product)

        quantity (int)

    '''

    pass

@register.assignment_tag(takes_context=True)

def available_categories(context):

    ''' Gets all of the currently available products.

    Returns:

        [models.inventory.Category, ...]: A list of all of the categories that

            have Products that the current user can reserve.

    '''

    return CategoryController.available_categories(context.request.user)

@register.assignment_tag(takes_context=True)

def available_credit(context):

    ''' Calculates the sum of unclaimed credit from this user's credit notes.

    Returns:

        Decimal: the sum of the values of unclaimed credit notes for the

            current user.

    '''

    notes = commerce.CreditNote.unclaimed().filter(

        invoice__user=context.request.user,

    )

    ret = notes.values("amount").aggregate(Sum("amount"))["amount__sum"] or 0

    return 0 - ret

@register.assignment_tag(takes_context=True)

def invoices(context):

    '''

    Returns:

        [models.commerce.Invoice, ...]: All of the current user's invoices. '''

    return commerce.Invoice.objects.filter(user=context.request.user)

import datetime

import pytz

from decimal import Decimal

from django.contrib.auth.models import User

from django.core.exceptions import ObjectDoesNotExist

from django.core.exceptions import ValidationError

from django.core.management import call_command

from django.test import TestCase

from registrasion.models import commerce

from registrasion.models import conditions

from registrasion.models import inventory

from registrasion.models import people

from registrasion.controllers.product import ProductController

from controller_helpers import TestingCartController

from patch_datetime import SetTimeMixin

UTC = pytz.timezone('UTC')

class RegistrationCartTestCase(SetTimeMixin, TestCase):

    def setUp(self):

        super(RegistrationCartTestCase, self).setUp()

    def tearDown(self):

            # If you're seeing segfaults in tests, enable this.

                reset_sequences=False,

                allow_cascade=False,

        super(RegistrationCartTestCase, self).tearDown()

    @classmethod

    def setUpTestData(cls):

        super(RegistrationCartTestCase, cls).setUpTestData()

        cls.USER_1 = User.objects.create_user(

            username='testuser',

            email='test@example.com',

            password='top_secret')

        cls.USER_2 = User.objects.create_user(

            username='testuser2',

            email='test2@example.com',

            password='top_secret')

        attendee1 = people.Attendee.get_instance(cls.USER_1)

            attendee=attendee1,

        )

        attendee2 = people.Attendee.get_instance(cls.USER_2)

            attendee=attendee2,

        )

        cls.RESERVATION = datetime.timedelta(hours=1)

        cls.categories = []

        for i in xrange(2):

            cat = inventory.Category.objects.create(

                name="Category " + str(i + 1),

                description="This is a test category",

                order=i,

                render_type=inventory.Category.RENDER_TYPE_RADIO,

                required=False,

            )

            cls.categories.append(cat)

        cls.CAT_1 = cls.categories[0]

        cls.CAT_2 = cls.categories[1]

        cls.products = []

        for i in xrange(4):

            prod = inventory.Product.objects.create(

                name="Product " + str(i + 1),

                description="This is a test product.",

                category=cls.categories[i / 2],  # 2 products per category

                price=Decimal("10.00"),

                reservation_duration=cls.RESERVATION,

                limit_per_user=10,

                order=1,

            )

            cls.products.append(prod)

        cls.PROD_1 = cls.products[0]

        cls.PROD_2 = cls.products[1]

        cls.PROD_3 = cls.products[2]

        cls.PROD_4 = cls.products[3]

        cls.PROD_4.price = Decimal("5.00")

        cls.PROD_4.save()

        # Burn through some carts -- this made some past flag tests fail

        current_cart = TestingCartController.for_user(cls.USER_1)

        current_cart.next_cart()

        current_cart = TestingCartController.for_user(cls.USER_2)

        current_cart.next_cart()

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.auth.decorators import user_passes_test

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 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.

    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 an invoice for the attendee that matches the given access

    code, if any.

    If the attendee has multiple invoices, we use the following tie-break:

    - If there's an unpaid invoice, show that, otherwise

    - If there's a paid invoice, show the most recent one, otherwise

    - Show the most recent invoid of all

    Arguments:

        access_code (castable to int): The access code for the user whose

            invoice you want to see.

    Returns:

        redirect:

            Redirect to the selected invoice for that user.

    Raises:

        Http404: If the user has no invoices.

    '''

    invoices = commerce.Invoice.objects.filter(

        user__attendee__access_code=access_code,

    ).order_by("-issue_time")

    if not invoices:

        raise Http404()

    unpaid = invoices.filter(status=commerce.Invoice.STATUS_UNPAID)

    paid = invoices.filter(status=commerce.Invoice.STATUS_PAID)

    if unpaid:

        invoice = unpaid[0]  # (should only be 1 unpaid invoice?)

    elif paid:

        invoice = paid[0]  # Most recent paid invoice

    else:

        invoice = invoices[0]  # Most recent of any invoices

    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)

def _staff_only(user):

    ''' Returns true if the user is staff. '''

    return user.is_staff

@user_passes_test(_staff_only)

def manual_payment(request, invoice_id):

    ''' Allows staff to make manual payments or refunds on an invoice.

    This form requires a login, and the logged in user needs to be staff.

    Arguments:

        invoice_id (castable to int): The invoice ID to be paid

    Returns:

        render:

            Renders ``registrasion/manual_payment.html`` with the following

            data::

                {

                    "invoice": models.commerce.Invoice(),

                    "form": form,   # A form that saves a ``ManualPayment``

                                    # object.

                }

    '''

    FORM_PREFIX = "manual_payment"

    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 = current_invoice.invoice

        form.instance.entered_by = request.user

        form.save()

        current_invoice.update_status()

        form = forms.ManualPaymentForm(prefix=FORM_PREFIX)

    data = {

        "invoice": current_invoice.invoice,

        "form": form,

    }

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

@user_passes_test(_staff_only)

def refund(request, invoice_id):

[flake8]