if user == self.invoice.user:

            return True

        if user.is_staff:

            return True

        if self.invoice.user.attendee.access_code == access_code:

            return True

        return False

    def _refresh(self):

        ''' Refreshes the underlying invoice and cart objects. '''

        self.invoice.refresh_from_db()

        if self.invoice.cart:

            self.invoice.cart.refresh_from_db()

    def validate_allowed_to_pay(self):

        ''' Passes cleanly if we're allowed to pay, otherwise raise

        a ValidationError. '''

        self._refresh()

from registrasion.controllers.cart import CartController

from registrasion.controllers.invoice import InvoiceController

from registrasion import models as rego

from django.core.exceptions import ObjectDoesNotExist

class TestingCartController(CartController):

    def set_quantity(self, product, quantity, batched=False):

        ''' Sets the _quantity_ of the given _product_ in the cart to the given

        _quantity_. '''

        self.set_quantities(((product, quantity),))

    def add_to_cart(self, product, quantity):

        ''' Adds _quantity_ of the given _product_ to the cart. Raises

        self.cart.save()

class TestingInvoiceController(InvoiceController):

    def pay(self, reference, amount):

        ''' Testing method for simulating an invoice paymenht by the given

        amount. '''

        self.validate_allowed_to_pay()

        ''' Adds a payment '''

            invoice=self.invoice,

            reference=reference,

            amount=amount,

        )

        self.update_status()

import pytz

from decimal import Decimal

from registrasion import models as rego

from registrasion.controllers import discount

from controller_helpers import TestingCartController

from test_cart import RegistrationCartTestCase

UTC = pytz.timezone('UTC')

class DiscountTestCase(RegistrationCartTestCase):

    @classmethod

    def add_discount_prod_1_includes_prod_2(

            cls,

            amount=Decimal(100),

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

        current_cart.add_to_cart(self.PROD_1, 1)

        invoice_1 = TestingInvoiceController.for_cart(current_cart.cart)

        invoice_1.pay("Reference", invoice_1.invoice.value)

        with self.assertRaises(ValidationError):

            invoice_1.void()

    def test_cannot_generate_blank_invoice(self):

        current_cart = TestingCartController.for_user(self.USER_1)

        with self.assertRaises(ValidationError):

    def test_cannot_pay_implicitly_void_invoice(self):

        cart = TestingCartController.for_user(self.USER_1)

        cart.add_to_cart(self.PROD_1, 1)

        invoice = TestingInvoiceController.for_cart(self.reget(cart.cart))

        # Implicitly void the invoice

        cart.add_to_cart(self.PROD_1, 1)

        with self.assertRaises(ValidationError):

            invoice.validate_allowed_to_pay()

    # TODO: test partially paid invoice cannot be void until payments

    # are refunded

    # TODO: test overpaid invoice results in credit note

    # TODO: test credit note generation more generally

import string

from django.utils.crypto import get_random_string

def generate_access_code():

    ''' Generates an access code for users' payments as well as their

    fulfilment code for check-in.

    The access code will 4 characters long, which allows for 1,500,625

    unique codes, which really should be enough for anyone. '''

    length = 4

    # all upper-case letters + digits 1-9 (no 0 vs O confusion)

    chars = string.uppercase + string.digits[1:]

    # 4 chars => 35 ** 4 = 1500625 (should be enough for anyone)

    return get_random_string(length=length, allowed_chars=chars)

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