from __future__ import unicode_literals

import datetime

import itertools

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

        attendees = Attendee.objects.filter(user=user)

        if len(attendees) > 0:

            return attendees[0]

        else:

            attendee = Attendee(user=user)

            attendee.save()

            return attendee

    user = models.OneToOneField(User, on_delete=models.CASCADE)

    # Badge/profile is linked

    completed_registration = models.BooleanField(default=False)

    highest_complete_category = models.IntegerField(default=0)

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.

     '''

    @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

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 rego.Category.objects.all()

@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,

    )

    return all_items

@register.assignment_tag(takes_context=True)

def items_purchased(context):

    ''' Returns all of the items that this user has purchased '''

    all_items = rego.ProductItem.objects.filter(

        cart__user=context.request.user,

        cart__active=False,

    )

    products = set(item.product for item in all_items)

    out = []

    for product in products:

        pp = all_items.filter(product=product)

        quantity = pp.aggregate(Sum("quantity"))["quantity__sum"]

        out.append(ProductAndQuantity(product, quantity))

    return out

@register.filter

def multiply(value, arg):

    ''' Multiplies value by arg '''

    return value * arg

        discounts = discount.available_discounts(self.USER_1, [self.CAT_1], [])

        self.assertEqual(0, len(discounts))

    def test_discount_quantity_is_correct_before_first_purchase(self):

        self.add_discount_prod_1_includes_cat_2(quantity=2)

        cart = CartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(2, discounts[0].quantity)

        inv = InvoiceController.for_cart(cart.cart)

        inv.pay("Dummy reference", inv.invoice.value)

        self.assertTrue(inv.invoice.paid)

    def test_discount_quantity_is_correct_after_first_purchase(self):

        self.test_discount_quantity_is_correct_before_first_purchase()

        cart = CartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_3, 1)  # Exhaust the quantity

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(1, discounts[0].quantity)

        inv = InvoiceController.for_cart(cart.cart)

        inv.pay("Dummy reference", inv.invoice.value)

        self.assertTrue(inv.invoice.paid)

    def test_discount_is_gone_after_quantity_exhausted(self):

        self.test_discount_quantity_is_correct_after_first_purchase()

        discounts = discount.available_discounts(self.USER_1, [self.CAT_2], [])

        self.assertEqual(0, len(discounts))

    def test_product_discount_enabled_twice_appears_twice(self):

        self.add_discount_prod_1_includes_prod_3_and_prod_4(quantity=2)

        cart = CartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        discounts = discount.available_discounts(

            self.USER_1,

            [],

            [self.PROD_3, self.PROD_4],

        )

        self.assertEqual(2, len(discounts))

    def test_discounts_are_released_by_refunds(self):

        self.add_discount_prod_1_includes_prod_2(quantity=2)

        cart = CartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)  # Enable the discount

        self.assertEqual(1, len(discounts))

        cart.cart.active = False  # Keep discount enabled

        cart.cart.save()

        cart = CartController.for_user(self.USER_1)

        cart.cart.active = False

        cart.cart.save()

        self.assertEqual(0, len(discounts))

        cart.cart.released = True

        cart.cart.save()

        self.assertEqual(1, len(discounts))

import pytz

from registrasion.controllers.cart import CartController

from registrasion.controllers.invoice import InvoiceController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class RefundTestCase(RegistrationCartTestCase):

    def test_refund_marks_void_and_unpaid_and_cart_released(self):

        current_cart = CartController.for_user(self.USER_1)

        # Should be able to create an invoice after the product is added

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice = InvoiceController.for_cart(current_cart.cart)

        invoice.pay("A Payment!", invoice.invoice.value)

        self.assertFalse(invoice.invoice.void)

        self.assertTrue(invoice.invoice.paid)

        self.assertFalse(invoice.invoice.cart.released)

        invoice.refund("A Refund!", invoice.invoice.value)

        self.assertTrue(invoice.invoice.void)

        self.assertFalse(invoice.invoice.paid)

        self.assertTrue(invoice.invoice.cart.released)

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 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.db import transaction

from django.http import Http404

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

    '''

    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:

        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

        # Get the next category

        cats = rego.Category.objects

        cats = cats.filter(id__gt=last_category).order_by("order")

        if cats.count() == 0:

            # We've filled in every category

            attendee.completed_registration = True

            attendee.save()

            return next_step

        if last_category == 0:

            # 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"

        for category in cats:

            products = ProductController.available_products(

                request.user,

                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,

            )

            sections.append(section)

            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 sections and request.method == "POST":

        for section in sections:

            if section.form.errors:

                break

        else:

            attendee.save()

            # We've successfully processed everything

            return next_step

    data = {

        "current_step": current_step,

        "sections": sections,

        "total_steps": 3,

    }

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

@login_required

def edit_profile(request):

    form, handled = handle_profile(request, "profile")

    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

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

    )

    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

        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)

#!/usr/bin/env python

import os

from setuptools import setup, find_packages

import registrasion

def read_file(filename):

    """Read a file into a string."""

    path = os.path.abspath(os.path.dirname(__file__))

    filepath = os.path.join(path, filename)

    try:

        return open(filepath).read()

    except IOError:

        return ''

setup(

    name="registrasion",

    author="Christopher Neugebauer",

    author_email="_@chrisjrn.com",

    version=registrasion.__version__,

    url="http://github.com/chrisjrn/registrasion/",

    packages=find_packages(),

    include_package_data=True,

    classifiers=(

        "Development Status :: 2 - Pre-Alpha",

        "Programming Language :: Python",

        "Framework :: Django",

        "Intended Audience :: Developers",

        "Natural Language :: English",

        "License :: OSI Approved :: Apache Software License",

    ),

    install_requires=read_file("requirements/base.txt").splitlines(),

)