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