class CardTransaction(transaction.Transaction):
"""Model for representing a card transaction."""
__tablename__ = 'card_transaction'
__mapper_args__ = {'polymorphic_identity': 'Card'}
object_id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction.object_id'),
primary_key=True)
eway_transaction_id = DB.Column(
DB.Integer(),
DB.ForeignKey('eway_transaction.object_id'),
nullable=True)
eway_transaction = DB.relationship('EwayTransaction',
backref=DB.backref('transactions',
lazy='dynamic'))
def __init__(self, user, eway_trans=None):
super(CardTransaction, self).__init__(user, 'Card')
if eway_transaction is not None:
self.eway_transaction = eway_trans
def __repr__(self):
return '<CardTransaction({0}): {1} item(s)>'.format(
self.object_id, self.items.count())
class RoundupDonation(DB.Model):
"""Model for representing a roundup donation"""
__tablename__ = 'roundup_donation'
object_id = DB.Column(DB.Integer, primary_key=True)
base_donation_amt = DB.Column(
DB.Integer(),
nullable = False
)
total_amount = DB.Column(
DB.Integer(),
nullable = False
)
charged_to_id = DB.Column(
DB.Integer,
DB.ForeignKey('user.object_id'),
nullable = False
)
charged_to = DB.relationship(
'User',
backref = DB.backref(
'roundup_donation',
lazy = 'dynamic'
),
foreign_keys=[charged_to_id]
)
def __init__(self, amount, charged_to):
# Internal representaion of amt is integer. So need to multiply by
# 100
self.base_donation_amt = amount
self.charged_to = charged_to
self.total_amount = 0
def __repr__(self):
return '<RoundupDonation {0}:'
return '<RoundupDonation {0}: £{1}>'.format(self.object_id, self.amount_pounds)
@property
def amount_pounds(self):
"""Get the fee amount as a string of pounds and pence."""
amount = '{0:03d}'.format(self.total_amount)
return amount[:-2] + '.' + amount[-2:]
def apply(self, tickets):
"""Apply the roundup donation to a set of tickets
"""
return [self.apply_to_ticket(t) for t in tickets]
def apply_to_ticket(self, ticket):
# TODO: Make sure that this is correct (it looks like the prices
# are being represented by an int that is multiplied by 10???)
ticket.price = ticket.price + self.base_donation_amt
self.total_amount = self.total_amount + self.base_donation_amt
ticket.add_note('Roundup donation amt {0}'.format(self.base_donation_amt))
return ticket
class Postage(DB.Model):
"""Model for representing postage for one or more tickets."""
__tablename__ = 'postage'
object_id = DB.Column(DB.Integer, primary_key=True)
paid = DB.Column(DB.Boolean(), default=False, nullable=False)
postage_type = DB.Column(DB.Unicode(50), nullable=False)
price = DB.Column(DB.Integer(), nullable=False)
address = DB.Column(DB.Unicode(200), nullable=True)
cancelled = DB.Column(DB.Boolean(), default=False, nullable=False)
posted = DB.Column(DB.Boolean(), default=False, nullable=False)
tickets = DB.relationship('Ticket',
secondary=POSTAGE_TICKET_LINK,
backref=DB.backref('postage',
lazy=False,
uselist=False),
lazy='dynamic')
owner_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=True)
owner = DB.relationship('User',
backref=DB.backref('postage_entries',
lazy='dynamic'))
def __init__(self, owner, postage_option, tickets, address=None):
self.owner = owner
self.postage_type = postage_option.name
self.price = postage_option.price
self.address = address
self.tickets = tickets
if self.price == 0:
self.paid = True
class Waiting(DB.Model):
"""Model for entries on the waiting list."""
__tablename__ = 'waiting'
object_id = DB.Column(DB.Integer, primary_key=True)
waiting_since = DB.Column(DB.DateTime(), nullable=False)
waiting_for = DB.Column(DB.Integer(), nullable=False)
user_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=False)
user = DB.relationship('User',
backref=DB.backref('waiting', lazy='dynamic'),
foreign_keys=[user_id])
def __init__(self, user, waiting_for):
self.user = user
self.waiting_for = waiting_for
self.waiting_since = datetime.datetime.utcnow()
def __repr__(self):
return '<Waiting: {0} for {1} ticket{2}>'.format(
self.user.full_name, self.waiting_for,
'' if self.waiting_for == 1 else 's')
class GenericTransactionItem(transaction_item.TransactionItem):
"""Model for representing a generic item in a transaction."""
__tablename__ = 'generic_transaction_item'
__mapper_args__ = {'polymorphic_identity': 'Generic'}
object_id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction_item.object_id'),
primary_key=True)
value = DB.Column(DB.Integer(), nullable=True)
description = DB.Column(DB.Unicode(100), nullable=True)
def __init__(self, transaction, value, description):
super(GenericTransactionItem, self).__init__(transaction, 'Generic')
self.value = value
self.description = description
class AdminFee(DB.Model):
"""Model for representing an administration fee."""
__tablename__ = 'admin_fee'
object_id = DB.Column(DB.Integer, primary_key=True)
amount = DB.Column(DB.Integer(), nullable=False)
reason = DB.Column(DB.UnicodeText(), nullable=False)
paid = DB.Column(DB.Boolean(), nullable=False, default=False)
charged_to_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=False)
charged_to = DB.relationship('User',
backref=DB.backref('admin_fees_charged',
lazy='dynamic'),
foreign_keys=[charged_to_id])
charged_by_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=False)
charged_by = DB.relationship('User',
backref=DB.backref('admin_fees_created',
lazy='dynamic'),
foreign_keys=[charged_by_id])
def __init__(self, amount, reason, charged_to, charged_by):
self.amount = amount
self.reason = reason
self.charged_to = charged_to
self.charged_by = charged_by
def __repr__(self):
return '<AdminFee {0}: £{1}>'.format(self.object_id,
self.amount_pounds)
@property
def amount_pounds(self):
"""Get the fee amount as a string of pounds and pence."""
amount = '{0:03d}'.format(self.amount)
return amount[:-2] + '.' + amount[-2:]
def mark_as_paid(self):
"""Email the creator of this fee when it has been paid."""
self.paid = True
if "Ticket Upgrade:" in self.reason:
possible_tickets = [int(x) for x in self.reason[16:].split(',')]
for ticket in self.charged_to.active_tickets:
if ticket.object_id in possible_tickets:
ticket.add_note('Upgrade')
else:
APP.email_manager.send_template(self.charged_by.email,
'Administration fee paid.',
'admin_fee_paid.email',
fee=self)
class BattelsTransaction(transaction.Transaction):
"""Model for representing a battels transaction."""
__tablename__ = 'battels_transaction'
__mapper_args__ = {'polymorphic_identity': 'Battels'}
object_id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(
DB.Integer(),
DB.ForeignKey('transaction.object_id'),
primary_key=True
)
battels_term = DB.Column(
DB.Unicode(4),
nullable=True
)
def __init__(self, user):
super(BattelsTransaction, self).__init__(user, 'Battels')
def __repr__(self):
return '<BattelsTransaction {0}: {1} item(s)>'.format(
self.object_id,
self.items.count()
)
def charge(self, term):
"""Charge this transaction to the user's battels account."""
self.battels_term = term
self.user.battels.charge(self.value, term)
self.mark_as_paid()
APP.log_manager.log_event(
'Completed Battels Payment',
tickets=self.tickets,
user=self.user,
transaction=self,
commit=False
)
class TicketTransactionItem(transaction_item.TransactionItem):
"""Model for representing a ticket in a transaction."""
__tablename__ = 'ticket_transaction_item'
__mapper_args__ = {'polymorphic_identity': 'Ticket'}
object_id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction_item.object_id'),
primary_key=True)
is_refund = DB.Column(DB.Boolean, nullable=False, default=False)
ticket_id = DB.Column(DB.Integer,
DB.ForeignKey('ticket.object_id'),
nullable=False)
ticket = DB.relationship('Ticket',
backref=DB.backref('transaction_items',
lazy='dynamic'))
def __init__(self, transaction, ticket, is_refund=False):
super(TicketTransactionItem, self).__init__(transaction, 'Ticket')
self.ticket = ticket
self.is_refund = is_refund
@property
def value(self):
"""Get the value of this transaction item."""
if self.is_refund:
return 0 - self.ticket.price
else:
return self.ticket.price
@property
def description(self):
"""Get a description of the transaction item."""
return '{0}{1} Ticket ({2:05d})'.format(
'Refund of ' if self.is_refund else '', self.ticket_type,
self.ticket_id)
class PostageTransactionItem(transaction_item.TransactionItem):
"""Model for representing postage in a transaction."""
__tablename__ = 'postage_transaction_item'
__mapper_args__ = {'polymorphic_identity': 'Postage'}
object_id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction_item.object_id'),
primary_key=True)
is_refund = DB.Column(DB.Boolean, nullable=False, default=False)
postage_id = DB.Column(DB.Integer,
DB.ForeignKey('postage.object_id'),
nullable=False)
postage = DB.relationship('Postage',
backref=DB.backref('transaction_items',
lazy='dynamic'))
def __init__(self, transaction, postage, is_refund=False):
super(PostageTransactionItem, self).__init__(transaction, 'Postage')
self.postage = postage
self.is_refund = is_refund
@property
def value(self):
"""Get the value of this transaction item."""
if self.is_refund:
return 0 - self.postage.price
else:
return self.postage.price
@property
def description(self):
"""Get a description of transaction item."""
return '{0}{1} Postage'.format('Refund of ' if self.is_refund else '',
self.postage.postage_type)
class AdminFeeTransactionItem(transaction_item.TransactionItem):
"""Model for representing an admin fee in a transaction."""
__tablename__ = 'admin_fee_transaction_item'
__mapper_args__ = {'polymorphic_identity': 'AdminFee'}
# id = DB.Column(DB.Integer, primary_key=True)
object_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction_item.object_id'),
primary_key=True)
is_refund = DB.Column(DB.Boolean, nullable=False, default=False)
admin_fee_id = DB.Column(DB.Integer,
DB.ForeignKey('admin_fee.object_id'),
nullable=False)
admin_fee = DB.relationship('AdminFee',
backref=DB.backref('transaction_items',
lazy='dynamic'))
def __init__(self, transaction, admin_fee, is_refund=False):
super(AdminFeeTransactionItem, self).__init__(transaction, 'AdminFee')
self.admin_fee = admin_fee
self.is_refund = is_refund
@property
def value(self):
"""Get the value of this transaction item."""
if self.is_refund:
return 0 - self.admin_fee.amount
else:
return self.admin_fee.amount
@property
def description(self):
"""Get a description of the item."""
return '{0} Admin Fee'.format('Refund of ' if self.is_refund else '')
class Statistic(DB.Model):
"""Model for representing a statistic in a timeseries."""
__tablename__ = 'statistic'
object_id = DB.Column(DB.Integer, primary_key=True)
timestamp = DB.Column(DB.DateTime, nullable=False)
group = DB.Column(DB.Enum(*STATISTIC_GROUPS.keys()), nullable=False)
statistic = DB.Column(DB.Unicode(25), nullable=False)
value = DB.Column(DB.Integer(), nullable=False)
def __init__(self, group, statistic, value):
if group not in STATISTIC_GROUPS:
raise ValueError(
'{0} is not a valid statistic group'.format(group))
self.timestamp = datetime.datetime.utcnow()
self.group = group
self.statistic = statistic
self.value = value
def __repr__(self):
return '<Statistic {0}/{1}/{2}: {3}>'.format(
self.group, self.statistic,
self.timestamp.strftime('%Y-%m-%d %H:%m (UTC)'), self.value)
class EwayTransaction(DB.Model):
"""Model for representing an eWay Transaction."""
__tablename__ = 'eway_transaction'
object_id = DB.Column(DB.Integer, primary_key=True)
# This holds the order_id
access_code = DB.Column(
DB.Unicode(200),
nullable=False
)
charged = DB.Column(
DB.Integer(),
nullable=False
)
completed = DB.Column(
DB.DateTime(),
nullable=True
)
result_code = DB.Column(
DB.Unicode(2),
nullable=True
)
# This holds the PASREF field for realex
eway_id = DB.Column(
DB.String(50),
nullable=True
)
refunded = DB.Column(
DB.Integer(),
nullable=False,
default=0
)
def __init__(self, access_code, charged):
self.access_code = access_code
self.charged = charged
@property
def status(self):
"""Get a better representation of the status of this transaction.
The eWay API returns statuses as 2 digit codes; this function provides
a mapping from these codes to a boolean success value and associated
explanation.
Returns:
(bool, str) pair of success value and explanation
"""
try:
return REALEX_RESULT_CODES[self.result_code[0]]
except KeyError as err:
return (False, 'Unknown response: {0}'.format(err.args[0]))
@property
def success(self):
"""Get whether the transaction was completed successfully."""
success = self.status[0]
if success is None:
return 'Uncompleted'
elif success:
return 'Successful'
else:
return 'Unsuccessful'
class Ticket(DB.Model):
"""Model for tickets."""
__tablename__ = 'ticket'
object_id = DB.Column(DB.Integer, primary_key=True)
ticket_type = DB.Column(DB.Unicode(50), nullable=False)
paid = DB.Column(DB.Boolean(), default=False, nullable=False)
entered = DB.Column(DB.Boolean(), default=False, nullable=False)
cancelled = DB.Column(DB.Boolean(), default=False, nullable=False)
price_ = DB.Column(DB.Integer(), nullable=False)
note = DB.Column(DB.UnicodeText(), nullable=True)
expires = DB.Column(DB.DateTime(), nullable=True)
barcode = DB.Column(DB.Unicode(20), unique=True, nullable=True)
claim_code = DB.Column(
DB.Unicode(17), # 3 groups of 5 digits separated by dashes
nullable=True)
claims_made = DB.Column(DB.Integer, nullable=False, default=0)
owner_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=False)
owner = DB.relationship('User',
backref=DB.backref('tickets',
lazy='dynamic',
order_by=b'Ticket.cancelled'),
foreign_keys=[owner_id])
holder_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=True)
holder = DB.relationship('User',
backref=DB.backref('held_ticket', uselist=False),
foreign_keys=[holder_id])
holder_name = DB.Column(DB.String(60), nullable=True, default="Unassigned")
def __init__(self, owner, ticket_type, price):
self.owner = owner
self.ticket_type = ticket_type
self.price = price
self.expires = (datetime.datetime.utcnow() +
APP.config['TICKET_EXPIRY_TIME'])
self.claim_code = '-'.join(
util.generate_key(5, string.digits)
for _ in xrange(3)).decode('utf-8')
def __repr__(self):
return '<Ticket {0} owned by {1} ({2})>'.format(
self.object_id, self.owner.full_name, self.owner.object_id)
def can_be_cancelled(self):
if datetime.datetime.utcnow() < datetime.datetime(
2018, 5, 11) and not self.cancelled and not self.paid:
return True
return False
def can_be_resold(self):
return False
def can_be_claimed(self):
if self.status == 'Awaiting ticket holder.':
return True
return False
def can_be_reclaimed(self):
# if self.paid and datetime.datetime.utcnow()<datetime.datetime(2018,5,11) and not self.cancelled and self.holder_id==self.owner_id:
# return True
return False
def has_holder(self):
if not self.holder_id == None:
return True
return False
def can_be_paid_for(self):
if self.paid == 0:
return True
return False
def can_be_collected(self):
if self.paid:
return True
return False
def is_assigned(self):
if self.holder_name == 'Unassigned':
return False
return True
@staticmethod
def get_by_claim_code(code):
return Ticket.query.filter_by(claim_code=code).first()
@property
def price_pounds(self):
"""Get the price of this ticket as a string of pounds and pence."""
price = '{0:03d}'.format(self.price)
return price[:-2] + '.' + price[-2:]
@property
def transaction(self):
"""Get the transaction this ticket was paid for in."""
for transaction_item in self.transaction_items:
if transaction_item.transaction.paid:
return transaction_item.transaction
return None
@property
def payment_method(self):
"""Get the payment method for this ticket."""
transaction = self.transaction
if transaction:
return transaction.payment_method
else:
return 'Unknown Payment Method'
@property
def price(self):
"""Get the price of the ticket."""
return self.price_
@property
def status(self):
"""Get the status of this ticket."""
if self.cancelled:
return 'Cancelled.'
elif not self.paid:
return 'Awaiting payment. Expires {0}.'.format(
self.expires.strftime('%H:%M %d/%m/%Y'))
elif self.entered:
return 'Used for entry.'
elif self.collected and self.holder:
return 'Ticket Sent to {0}.'.format(self.holder.full_name)
elif self.collected:
return 'Collected as {0}.'.format(self.barcode)
# elif self.holder is None:
# return 'Awaiting ticket holder.'
elif self.holder_name == 'Unassigned':
return 'Awaiting ticket holder.'
elif APP.config['REQUIRE_USER_PHOTO']:
if not self.holder.photo.verified:
return 'Awaiting verification of holder photo.'
else:
# return 'Held by {0}.'.format(self.holder.full_name)
return 'Assigned to {0}.'.format(self.holder_name)
@price.setter
def price(self, value):
"""Set the price of the ticket."""
self.price_ = max(value, 0)
if self.price_ == 0:
self.mark_as_paid()
@hybrid.hybrid_property
def collected(self):
"""Has this ticket been assigned a barcode."""
return self.barcode != None # pylint: disable=singleton-comparison
def mark_as_paid(self):
"""Mark the ticket as paid, and clear any expiry."""
self.paid = True
self.expires = None
def add_note(self, note):
"""Add a note to the ticket."""
if not note.endswith('\n'):
note = note + '\n'
if self.note is None:
self.note = note
else:
self.note = self.note + note
@staticmethod
def count():
"""How many tickets have been sold."""
# TODO
return Ticket.query.filter(Ticket.cancelled == False).count() # pylint: disable=singleton-comparison
@staticmethod
def write_csv_header(csv_writer):
"""Write the header of a CSV export file."""
csv_writer.writerow([
'Ticket ID',
'Ticket Type',
'Paid',
'Collected',
'Entered',
'Cancelled',
'Price (Pounds)',
'Holder\'s Name',
'Notes',
'Expires',
'Barcode',
'Owner\' User ID',
'Owner\'s Name',
])
def write_csv_row(self, csv_writer):
"""Write this object as a row in a CSV export file."""
csv_writer.writerow([
self.object_id,
self.ticket_type,
'Yes' if self.paid else 'No',
'Yes' if self.collected else 'No',
'Yes' if self.entered else 'No',
'Yes' if self.cancelled else 'No',
self.price_pounds,
self.holder.full_name.encode('utf-8')
if self.holder is not None else 'N/A',
self.note,
self.expires.strftime('%Y-%m-%d %H:%M:%S')
if self.expires is not None else 'N/A',
self.barcode if self.barcode is not None else 'N/A',
self.owner_id,
self.owner.full_name.encode('utf-8'),
])
class Log(DB.Model):
"""Model for log entries persisted to the database."""
__tablename__ = 'log'
object_id = DB.Column(DB.Integer, primary_key=True)
timestamp = DB.Column(DB.DateTime, nullable=False)
ip_address = DB.Column(DB.Unicode(45), nullable=False)
action = DB.Column(DB.UnicodeText())
actor_id = DB.Column(DB.Integer(),
DB.ForeignKey('user.object_id'),
nullable=True)
actor = DB.relationship('User',
backref=DB.backref('actions', lazy='dynamic'),
foreign_keys=[actor_id])
user_id = DB.Column(DB.Integer(),
DB.ForeignKey('user.object_id'),
nullable=True)
user = DB.relationship('User',
backref=DB.backref('events', lazy='dynamic'),
foreign_keys=[user_id])
tickets = DB.relationship('Ticket',
secondary=LOG_TICKET_LINK,
backref=DB.backref('events', lazy='dynamic'),
lazy='dynamic')
transaction_id = DB.Column(DB.Integer(),
DB.ForeignKey('transaction.object_id'),
nullable=True)
transaction = DB.relationship('Transaction',
backref=DB.backref('events', lazy='dynamic'))
purchase_group_id = DB.Column(DB.Integer(),
DB.ForeignKey('purchase_group.object_id'),
nullable=True)
purchase_group = DB.relationship('PurchaseGroup',
backref=DB.backref('events',
lazy='dynamic'))
admin_fee_id = DB.Column(DB.Integer(),
DB.ForeignKey('admin_fee.object_id'),
nullable=True)
admin_fee = DB.relationship('AdminFee',
backref=DB.backref('events', lazy='dynamic'))
def __init__(self,
ip_address,
action,
actor,
user,
tickets=None,
transaction=None,
purchase_group=None,
admin_fee=None):
if tickets is None:
tickets = []
self.timestamp = datetime.datetime.utcnow()
self.ip_address = ip_address
self.action = action
self.actor = actor
self.user = user
self.tickets = tickets
self.transaction = transaction
self.purchase_group = purchase_group
self.admin_fee = admin_fee
def __repr__(self):
return '<Log {0}: {1}>'.format(
self.object_id, self.timestamp.strftime('%Y-%m-%d %H:%m (UTC)'))
@staticmethod
def write_csv_header(csv_writer):
"""Write the header of a CSV export file."""
csv_writer.writerow([
'Log Entry ID',
'Timestamp',
'IP Address',
'Action',
'Actor\'s User ID',
'Actor\'s Name',
'Target\'s User ID',
'Target\'s Name',
'Relevant Ticket IDs',
'Relevant Transaction ID',
'Relevant Purchase Group ID',
'Relevant Admin Fee ID',
])
def write_csv_row(self, csv_writer):
"""Write this object as a row in a CSV export file."""
csv_writer.writerow([
self.object_id,
self.timestamp.strftime('%Y-%m-%d %H:%M:%S'),
self.ip_address,
self.action,
self.actor_id if self.actor_id is not None else 'N/A',
self.actor if self.actor is not None else 'N/A',
self.user_id if self.user_id is not None else 'N/A',
self.user if self.user is not None else 'N/A',
','.join(str(ticket.object_id) for ticket in self.tickets),
(self.transaction_id
if self.transaction_id is not None else 'N/A'),
(self.purchase_group_id
if self.purchase_group_id is not None else 'N/A'),
(self.admin_fee_id if self.admin_fee_id is not None else 'N/A'),
])
class Battels(DB.Model):
"""Model for battels charges for current students."""
__tablename__ = 'battels'
object_id = DB.Column(DB.Integer, primary_key=True)
battels_id = DB.Column(DB.Unicode(10), unique=True, nullable=True)
email = DB.Column(DB.Unicode(120), unique=True, nullable=True)
title = DB.Column(DB.Unicode(10), nullable=True)
surname = DB.Column(DB.Unicode(60), nullable=True)
forenames = DB.Column(DB.Unicode(60), nullable=True)
michaelmas_charge = DB.Column(DB.Integer(), default=0, nullable=False)
hilary_charge = DB.Column(DB.Integer(), default=0, nullable=False)
manual = DB.Column(DB.Boolean(), default=False, nullable=False)
def __init__(self,
battelsid=None,
email=None,
title=None,
surname=None,
forenames=None,
manual=False):
self.battelsid = battelsid
self.email = email
self.title = title
self.surname = surname
self.forenames = forenames
self.manual = manual
def __repr__(self):
return '<Battels {0}: {1}>'.format(self.object_id, self.battelsid)
@property
def michaelmas_charge_pounds(self):
"""Get the amount charged in Michaelmas as a pounds/pence string."""
michaelmas_charge = '{0:03d}'.format(self.michaelmas_charge)
return michaelmas_charge[:-2] + '.' + michaelmas_charge[-2:]
@property
def hilary_charge_pounds(self):
"""Get the amount charged in Hilary as a pounds/pence string."""
hilary_charge = '{0:03d}'.format(self.hilary_charge)
return hilary_charge[:-2] + '.' + hilary_charge[-2:]
def charge(self, amount, term):
"""Apply a charge to this battels account."""
if term == 'MTHT':
# Integer division fails for negative numbers (i.e. refunds), as the
# number is rounded the wrong way. Instead, we do floating point
# division, and truncate.
half = int(amount / 2.0)
self.michaelmas_charge += half
self.hilary_charge += amount - half
elif term == 'MT':
self.michaelmas_charge += amount
elif term == 'HT':
self.hilary_charge += amount
else:
raise ValueError(
'Term "{0}" cannot be charged to battels'.format(term))
def refund(self, amount, term):
"""Refund a ticket and mark it as cancelled."""
if APP.config['CURRENT_TERM'] == 'MT':
if term == 'MTHT':
half = amount // 2
self.michaelmas_charge -= half
self.hilary_charge -= amount - half
elif term == 'MT':
self.michaelmas_charge -= amount
elif term == 'HT':
self.hilary_charge -= amount
elif APP.config['CURRENT_TERM'] == 'HT':
self.hilary_charge -= amount
else:
raise ValueError(
'Can\'t refund battels tickets in the current term')
class Voucher(DB.Model):
"""Model for a discount voucher."""
__tablename__ = 'voucher'
object_id = DB.Column(DB.Integer, primary_key=True)
code = DB.Column(DB.Unicode(30), nullable=False)
expires = DB.Column(DB.DateTime(), nullable=True)
discount_type = DB.Column(DB.Enum('Fixed Price', 'Fixed Discount',
'Percentage Discount'),
nullable=False)
discount_value = DB.Column(DB.Integer(), nullable=False)
applies_to = DB.Column(DB.Enum('Ticket', 'Transaction'), nullable=False)
single_use = DB.Column(DB.Boolean(), nullable=False)
used = DB.Column(DB.Boolean(), default=False, nullable=True)
used_by_id = DB.Column(DB.Integer,
DB.ForeignKey('user.object_id'),
nullable=True)
used_by = DB.relationship('User',
backref=DB.backref('vouchers_used',
lazy='dynamic'))
def __init__(self, code, expires, discount_type, discount_value,
applies_to, single_use):
if discount_type not in [
'Fixed Price', 'Fixed Discount', 'Percentage Discount'
]:
raise ValueError(
'{0} is not a valid discount type'.format(discount_type))
if applies_to not in ['Ticket', 'Transaction']:
raise ValueError(
'{0} is not a valid application'.format(applies_to))
self.code = code
self.discount_type = discount_type
self.discount_value = discount_value
self.applies_to = applies_to
self.single_use = single_use
if isinstance(expires, datetime.timedelta):
self.expires = datetime.datetime.utcnow() + expires
else:
self.expires = expires
def __repr__(self):
return '<Voucher: {0}/{1}>'.format(self.object_id, self.code)
@staticmethod
def get_by_code(code):
"""Get an Announcement object by a voucher code."""
return Voucher.query.filter(Voucher.code == code).first()
def apply(self, tickets, user):
"""Apply the voucher to a set of tickets.
Checks if the voucher can be used, and applies its discount to the
tickets.
Args:
tickets: (list(Ticket)) list of tickets to apply the voucher to
user: (User) user who is using the voucher
Returns:
(bool, list(tickets), str/None) whether the voucher was applied, the
mutated tickets, and an error message
"""
if self.single_use and self.used:
return (False, tickets, 'Voucher has already been used.')
if (self.expires is not None
and self.expires < datetime.datetime.utcnow()):
return (False, tickets, 'Voucher has expired.')
self.used = True
if self.single_use:
self.used_by = user
if self.applies_to == 'Ticket':
tickets[0] = self.apply_to_ticket(tickets[0])
return (True, tickets, None)
else:
return (True, [self.apply_to_ticket(t) for t in tickets], None)
def apply_to_ticket(self, ticket):
"""Apply the voucher to a single ticket.
Recalculates the price of the ticket, and notes on the ticket that a
voucher was used
Args:
ticket: (Ticket) the ticket to apply the voucher to
Returns:
(ticket) the mutated ticket
"""
if self.discount_type == 'Fixed Price':
ticket.price = self.discount_value
elif self.discount_type == 'Fixed Discount':
ticket.price = ticket.price - self.discount_value
else:
ticket.price = ticket.price * (100 - self.discount_value) / 100
ticket.add_note('Used voucher {0}/{1}'.format(self.object_id,
self.code))
return ticket
