class Transaction(db.Model):
__tablename__ = "Transaction"
id_transaction = db.Column(db.String(18), primary_key=True)
id_user = db.Column(db.String(10), )
id_ticket = db.Column(db.BINARY(32), nullable=False)
total_price = db.Column(db.Float(), nullable=False)
datetime = db.Column(db.DateTime(), default=datetime.datetime.utcnow)
def __init__(self,id_transaction,id_user,id_ticket,total_price,datetime=None):
self.id_transaction = id_transaction
self.id_user = id_user
self.id_ticket = id_ticket
self.total_price = total_price
self.datetime = datetime
@staticmethod
def get_transaction(id_transaction,id_ticket):
e = Transaction.query.filter_by(id_transaction=id_transaction,id_ticket=unhexlify(id_ticket)).first()
if e == None:
raise ErrorCodeException(ErrorCode.TRANSACTION_DOESNT_EXISTS)
return e
@staticmethod
def add_transaction(transaction):
e = Transaction.query.filter_by(id_transaction=transaction.id_transaction, id_ticket=transaction.id_ticket).first()
if e != None:
raise ErrorCodeException(ErrorCode.TRANSACTION_EXISTS)
db.session.add(transaction)
db.session.commit()
class MealType(db.Model):
__tablename__ = "MealType"
id_meal_type = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(32), nullable=False, unique=True)
def __init__(self,name):
self.id_meal_type = None
self.name = name
@staticmethod
def get_meal_type(id_meal_type):
mt = MealType.query.filter_by(id_meal_type=id_meal_type).first()
if mt == None:
raise ErrorCodeException(ErrorCode.MEALTYPE_DOESNT_EXISTS)
return mt
@staticmethod
def get_by_name(name):
mt = MealType.query.filter_by(name=name).first()
if mt == None:
raise ErrorCodeException(ErrorCode.MEALTYPE_DOESNT_EXISTS)
return mt
@staticmethod
def get_all():
return MealType.query.all()
@staticmethod
def add_meal_type(meal_type):
try:
MealType.get_meal_type(meal_type.id_meal_type)
except ErrorCodeException:
db.session.add(meal_type)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.MEALTYPE_EXISTS)
@staticmethod
def delete(id_meal_type):
mt = MealType.query.filter(Meal.id_meal_type==id_meal_type)
if mt.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.MEALTYPE_DOESNT_EXISTS)
class Location(db.Model):
__tablename__ = "Location"
id_location = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(32), nullable=False, unique=True)
def __init__(self,name):
self.id_location = None
self.name = name
@staticmethod
def get_location(id_location):
l = Location.query.filter_by(id_location=id_location).first()
if l == None:
raise ErrorCodeException(ErrorCode.LOCATION_DOESNT_EXISTS)
return l
@staticmethod
def get_by_name(name):
l = Location.query.filter_by(name=name).first()
if l == None:
raise ErrorCodeException(ErrorCode.LOCATION_DOESNT_EXISTS)
return l
@staticmethod
def get_all():
return Location.query.all()
@staticmethod
def add_location(location):
try:
Location.get_location(location.id_location)
except ErrorCodeException:
db.session.add(location)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.LOCATION_EXISTS)
@staticmethod
def delete(id_location):
l = Location.query.filter(Location.id_location==id_location)
if l.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.LOCATION_DOESNT_EXISTS)
class TicketType(db.Model):
__tablename__ = "TicketType"
type = db.Column(db.Integer(), primary_key=True)
price = db.Column(db.Float(), nullable=False)
name = db.Column(db.String(25), nullable=False, unique=True)
def __init__(self, type, price, name):
self.type = type
self.price = price
self.name = name
@staticmethod
def get_type(type):
tt = TicketType.query.filter_by(type=type).first()
if tt == None:
raise ErrorCodeException(ErrorCode.TICKETTYPE_DOESNT_EXISTS)
return tt
@staticmethod
def get_all():
return TicketType.query.all()
@staticmethod
def add_type(type):
try:
TicketType.get_type(type.type)
except ErrorCodeException as ec:
db.session.add(type)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.TICKETTYPE_EXISTS)
@staticmethod
def delete(id_ticket):
t = TicketType.query.filter(TicketType.id_ticket == id_ticket)
if t.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.TICKETTYPE_DOESNT_EXISTS)
def to_json(self):
return {"type": self.type, "price": self.price, "name": self.name}
class Meal(db.Model):
__tablename__ = "Meal"
date = db.Column(db.Date(), primary_key=True)
id_location = db.Column(db.Integer(), primary_key=True)
id_meal_type = db.Column(db.Integer(), primary_key=True)
soup = db.Column(db.String(32), nullable=True)
main_dish = db.Column(db.String(32), nullable=True)
description = db.Column(db.String(64), nullable=True)
def __init__(self,date,id_location,id_meal_type,soup=None,main_dish=None,description=None):
self.date = date
self.id_location = id_location
self.id_meal_type = id_meal_type
self.soup = soup
self.main_dish = main_dish
self.description = description
@staticmethod
def get_meal(date,id_location,id_meal_type):
m = Meal.query.filter_by(date=date,id_location=id_location,id_meal_type=id_meal_type).first()
if m == None:
raise ErrorCodeException(ErrorCode.MEAL_DOESNT_EXISTS)
return m
@staticmethod
def get_all():
return Meal.query.all()
@staticmethod
def get_between(begin,end,id_meal_type=None,id_location=None):
flt = Meal.query.filter(Meal.date >= begin , Meal.date <= end)
if id_meal_type != None:
flt = flt.filter(Meal.id_meal_type==id_meal_type)
if id_location != None:
flt = flt.filter(Meal.id_location==id_location)
return flt
@staticmethod
def add_meal(meal):
try:
Meal.get_meal(meal.date,meal.id_location,meal.id_meal_type)
except ErrorCodeException:
db.session.add(meal)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.MEAL_EXISTS)
@staticmethod
def delete(date,id_location,id_meal_type):
m = Meal.query.filter(Meal.date==date,Meal.id_location==id_location,Meal.id_meal_type==id_meal_type)
if m.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.MEAL_DOESNT_EXISTS)
def to_json(self):
return {
"date" : str(self.date),
"location" : Location.get_location(self.id_location).name,
"meal_type" : MealType.get_meal_type(self.id_meal_type).name,
"soup" : self.soup,
"main_dish" : self.main_dish,
"description" : self.description
}
class User(db.Model):
__tablename__ = "User"
id_user = db.Column(db.String(10), primary_key=True)
email = db.Column(db.String(320), nullable=False)
password_hash = db.Column(db.String(200), nullable=False)
name = db.Column(db.String(100), nullable=True)
permissions = db.Column(db.Integer(), nullable=False, default=1)
def __init__(self, id_user, email, password, name=None, permissions=None):
self.id_user = id_user
self.email = email
self.password_hash = generate_password_hash(password)
self.name = name
self.permissions = permissions
@staticmethod
def get_user(id_user):
u = User.query.filter_by(id_user=id_user).first()
if u == None:
raise ErrorCodeException(ErrorCode.USER_DOESNT_EXISTS)
return u
@staticmethod
def get_all():
return User.query.all()
@staticmethod
def add_user(user):
try:
User.get_user(user.id_user)
except ErrorCodeException:
db.session.add(user)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.USER_EXISTS)
@staticmethod
def delete(id_user):
u = User.query.filter(User.id_user == id_user)
if u.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.USER_DOESNT_EXISTS)
def to_json(self):
return {
"id_user": self.id_user,
"email": self.email,
"permissions": self.permissions,
"name": self.name
}
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def check_permission(self, const_permition):
return self.permissions & const_permition
def set_password(self, password):
self.password_hash = generate_password_hash(password)
db.session.commit()
def __str__(self):
return self.id_user
class Ticket(db.Model):
__tablename__ = "Ticket"
id_ticket = db.Column(db.BINARY(32), primary_key=True)
id_user = db.Column(db.String(10), nullable=False)
type = db.Column(db.Integer(), nullable=False)
used = db.Column(db.Boolean(), nullable=False, default=0)
def __init__(self, id_user, type, id_ticket=None, used=None):
self.id_ticket = self.gen_id(id_user,
type) if id_ticket == None else id_ticket
self.id_user = id_user
self.type = type
self.used = used
@staticmethod
def get_ticket(id_ticket):
t = Ticket.query.filter_by(id_ticket=unhexlify(id_ticket)).first()
if t == None:
raise ErrorCodeException(ErrorCode.TICKET_DOESNT_EXISTS)
return t
@staticmethod
def get_all():
return Ticket.query.all()
@staticmethod
def get_not_used(id_user=None):
if id_user == None:
return Ticket.query.filter_by(used=0)
else:
return Ticket.query.filter_by(used=0, id_user=id_user)
@staticmethod
def add_ticket(ticket):
try:
Ticket.get_ticket(hexlify(ticket.id_ticket).decode('ascii'))
except ErrorCodeException:
db.session.add(ticket)
db.session.commit()
return
raise ErrorCodeException(ErrorCode.TICKET_EXISTS)
@staticmethod
def delete(id_ticket):
t = Ticket.query.filter(Ticket.id_ticket == unhexlify(id_ticket))
if t.delete() == 1:
db.session.commit()
else:
raise ErrorCodeException(ErrorCode.TICKET_DOESNT_EXISTS)
@staticmethod
def gen_id(id_user, type, salt=''):
from datetime import datetime
from hashlib import sha256
res = sha256(
(id_user + str(datetime.now()) + salt).encode('ascii')).digest()
return res
def set_used(self):
self.used = True
db.session.commit()
def to_json(self):
return {
"id_ticket": hexlify(self.id_ticket).decode('ascii'),
"id_user": self.id_user,
"type": self.type,
"used": self.used
}