class Permissions(db.Model):
__tablename__ = 'Permissions'
id = db.Column(db.String(100), primary_key=True)
isUser = db.Column(db.Boolean, default=False)
isAdmin = db.Column(db.Boolean, default=False)
isSales = db.Column(db.Boolean, default=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getPermissions(cls, permissions_id):
return cls.query.filter_by(id=permissions_id).first()
@classmethod
def get_by_uid(cls, uid=None):
return cls.query.filter_by(user_id=uid).first()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, nullable=False)
password = db.Column(db.String(32), nullable=False)
def __repr__(self):
return f'<User {self.username}>'
def add_user(self):
db.session.add(self)
db.session.commit()
def remove_user(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def find_by_username(value):
db.create_all()
return db.session.query(User).filter_by(username=value).first()
@staticmethod
def find_by_id(value):
db.create_all()
return db.session.query(User).filter_by(id=value).first()
class Admin(db.Model):
__tablename__ = 'Admin'
id = db.Column(db.String(100), primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(100))
email = db.Column(db.String(100))
photoURL = db.Column(db.String())
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
else:
self.photoURL = 'Some default asset'
def save_to_db(self):
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getAdmin(cls, admin_id=None, username=None):
if username is None:
return cls.query.filter_by(id=admin_id).first()
if admin_id is None:
return cls.query.filter_by(username=username).first()
class Employee(db.Model):
__tablename__ = "employee"
id = db.Column(UUIDType(), db.ForeignKey(User.id), primary_key=True)
user = db.relationship('User')
name = db.Column(db.String(45), nullable=False)
gender = db.Column(db.String(45), nullable=False)
tel = db.Column(db.String(45), nullable=False)
# stat = db.Column(db.Integer, nullable=False)
level = db.Column(db.Integer, nullable=False)
@staticmethod
def new_employee(id, name, gender, tel, level=0) -> "Employee":
# Test that employee id exists in user table
user = User.get_by_id(id)
return Employee(
id=id,
name=name,
gender=gender,
tel=tel,
level=level,
# stat = stat
)
@staticmethod
def get_by_id(id) -> "Employee":
if type(id) != UUID:
try:
id = UUID(id)
except:
raise AttributeError("Invalid UUID")
query = Employee.query.filter_by(id=id)
if query.count() == 0:
raise ValueError(f"Employee {str(id)} not found.")
return query.first()
@staticmethod
def id_exists(id) -> bool:
id = to_uuid(id)
query = Employee.query.filter_by(id=id)
if query.count() > 0:
return True
return False
def json(self) -> dict:
return {
"id": str(self.id),
"name": self.name,
"gender": self.gender,
"tel": self.tel,
"level": self.level,
}
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
f_name = db.Column(db.String(32), nullable=False)
l_name = db.Column(db.String(32), nullable=False)
email = db.Column(db.String(32), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
profile_image = db.Column(db.String(30000))
def __str__(self):
return f'<User : {self.id}>'
class ProductSeller(db.Model):
# Bind schema to external database
__bind_key__ = 'external'
# Composite key (company_id, product_name)
company_id = db.Column(db.String(6),
db.ForeignKey('company.id'),
primary_key=True)
product_name = db.Column(db.String(32),
db.ForeignKey('product.name'),
primary_key=True)
class Appointment(db.Model):
__tablename__ = 'appointments'
id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
doctor_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
description = db.Column(db.String(120))
doctor_notes = db.Column(db.String(120))
date = db.Column(db.Date, nullable=False)
start = db.Column(db.Time, nullable=False)
status = db.Column(db.Enum(AppointmentStatus), nullable=False)
patient = db.relationship('User',
foreign_keys=[patient_id],
backref='p_appointments')
doctor = db.relationship('User',
foreign_keys=[doctor_id],
backref='d_appointments')
def __init__(self,
description,
date,
start,
status=AppointmentStatus.PENDING):
self.description = description
self.date = date
self.start = start
self.status = status
def serialize(self, user_type):
payload = {
"id": self.id,
"description": self.description,
"doctor_notes": self.doctor_notes,
"date": self.date.strftime("%Y-%m-%d"),
"start": self.start.strftime("%H:%M"),
"status": self.status.name
}
if user_type == UserType.DOCTOR:
payload['patient'] = self.patient.serialize()
elif user_type == UserType.PATIENT:
payload['doctor'] = self.doctor.serialize()
else:
payload['patient'] = self.patient.serialize()
payload['doctor'] = self.doctor.serialize()
return payload
class User(db.Model, JSONStripped):
__tablename__ = 'user'
def __init__(self, *args, **kwargs):
super(User, self).__init__(*args, **kwargs)
id = \
db.Column(db.Integer, primary_key=True)
login = \
db.Column(db.String(50), unique=True, nullable=False)
password_hash = \
db.Column(db.String(255), nullable=False)
creation_time = \
db.Column(db.DateTime, index=True, default=datetime.utcnow)
st_login = \
db.Column(db.String(10), unique=True, nullable=True)
course = \
db.Column(db.String(255), index=True, nullable=True)
username = \
db.Column(db.String(50), index=True, nullable=False)
is_public = \
db.Column(db.Boolean, default=True)
score_second_lang = \
db.Column(db.Boolean, default=False)
gpa = \
db.Column(db.Float, default=0)
scores = \
db.relationship('UserSubject', lazy='subquery', cascade='all, delete-orphan')
priorities = \
db.relationship('UserTrack', lazy='subquery', cascade='all, delete-orphan')
def __repr__(self):
return '<User %r>' % self.login
@staticmethod
def insert(**kwargs):
user = User(**kwargs)
db.session.add(user)
db.session.commit()
return user
@staticmethod
def get_all(**kwargs):
return User.query.filter_by(**kwargs)
@staticmethod
def get_one(**kwargs):
return User.query.filter_by(**kwargs).first()
class Item(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False)
price = db.Column(db.Integer(), nullable=False)
def __repr__(self):
return f'<Item {self.name}>'
@staticmethod
def get_item(name):
item = Item.query.filter(Item.name == name).first()
return item
def add_item(self):
db.session.add(self)
db.session.commit()
@staticmethod
def change_item(name, price):
db.session.query(Item).filter(Item.name == name).update({'price': price})
db.session.commit()
def delete_item(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def get_items():
return Item.query.all()
@staticmethod
def delete_items():
db.session.query(Item).delete()
db.session.commit()
class Track(db.Model, JSONStripped):
__tablename__ = 'track'
__tracks__ = [
'Marketing',
'FM',
'Logistics',
'HR',
'IM',
]
def __init__(self, *args, **kwargs):
super(Track, self).__init__(*args, **kwargs)
id = \
db.Column(db.Integer, primary_key=True)
name = \
db.Column(db.String(30), unique=True)
def __repr__(self):
return '<Track %r>' % self.name
@staticmethod
def fill():
db.session.add_all([Track(name=name) for name in Track.__tracks__])
db.session.commit()
@staticmethod
def get_one(**kwargs):
return Track.query.filter_by(**kwargs).first()
class Prescription(db.Model):
__tablename__ = 'prescriptions'
id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
doctor_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
drug = db.Column(db.String(50), nullable=False)
dosage = db.Column(db.String(50), nullable=False)
date = db.Column(db.Date, nullable=False)
status = db.Column(db.Enum(PrescriptionStatus), nullable=False)
patient = db.relationship('User',
foreign_keys=[patient_id],
backref='p_prescriptions')
doctor = db.relationship('User',
foreign_keys=[doctor_id],
backref='d_prescriptions')
def __init__(self, drug, dosage, date, status=PrescriptionStatus.ACTIVE):
self.drug = drug
self.date = date
self.dosage = dosage
self.status = status
def serialize(self, user_type):
payload = {
"id": self.id,
"drug": self.drug,
"date": self.date.strftime("%Y-%m-%d"),
"dosage": self.dosage,
"status": self.status.name
}
if user_type == UserType.DOCTOR:
payload['patient'] = self.patient.serialize()
elif user_type == UserType.PATIENT:
payload['doctor'] = self.doctor.serialize()
else:
payload['patient'] = self.patient.serialize()
payload['doctor'] = self.doctor.serialize()
return payload
class Product(db.Model):
# Bind schema to external database
__bind_key__ = 'external'
# Composite key (name, valuation_date)
name = db.Column(db.String(32), primary_key=True)
valuation_date = db.Column(db.Date, primary_key=True)
market_price = db.Column(db.Float, nullable=False)
currency_code = db.Column(db.CHAR(3), db.ForeignKey('currency.code'))
class File(db.Model):
__tablename__ = 'File'
id = db.Column(db.String(100))
filename = db.Column(db.String(100), nullable=False, primary_key=True)
filetype = db.Column(db.String(100), nullable=False)
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
class CompanyStock(db.Model):
# Bind schema to external database
__bind_key__ = 'external'
# Composite key (company_id, valuation_date)
company_id = db.Column(db.String(6),
db.ForeignKey('company.id'),
primary_key=True)
valuation_date = db.Column(db.Date, primary_key=True)
stock_price = db.Column(db.Float, nullable=False)
currency_code = db.Column(db.CHAR(3), db.ForeignKey('currency.code'))
class Specialization(db.Model):
__tablename__ = 'specializations'
id = db.Column(db.Integer, primary_key=True)
spec = db.Column(db.String(50), unique=True)
def __init__(self, spec):
self.spec = spec
def serialize(self):
return {"id": self.id, "spec": self.spec}
class Edge(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
request = db.Column(db.Integer, db.ForeignKey('request.id'))
visit_number = db.Column(db.Integer)
src_url = db.Column(db.String(1024), nullable=False)
dst_url = db.Column(db.String(1024), nullable=False)
depth = db.Column(db.Integer, nullable=False)
had_keyword = db.Column(db.Boolean)
create_date = db.Column(db.DateTime)
db.UniqueConstraint('request',
'src_url',
'dst_url',
'depth',
name="_request_src_dst_uc")
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def __init__(self,
request,
visit_number,
src_url,
dst_url,
depth,
had_keyword=False):
self.request = request
self.visit_number = visit_number
self.src_url = src_url
self.dst_url = dst_url
self.depth = depth
self.had_keyword = had_keyword
self.create_date = datetime.datetime.now()
def __repr__(self):
return 'Edge([request: %d] %s ----> %s)' % (self.request, self.src_url,
self.dst_url)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(200), nullable=False)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
dob = db.Column(db.Date)
phone_number = db.Column(db.String(20))
created_at = db.Column(db.DateTime,
server_default=func.current_timestamp())
user_type = db.Column(db.Enum(UserType), nullable=False)
user_status = db.Column(db.Enum(UserStatus), nullable=False)
specialization_id = db.Column(db.Integer,
db.ForeignKey('specializations.id'))
specialization = db.relationship('Specialization', backref='doctors')
def __init__(self, email, username, first_name, last_name, dob,
phone_number, user_type, user_status):
self.email = email
self.username = username
self.first_name = first_name
self.last_name = last_name
self.dob = dob
self.phone_number = phone_number
self.user_type = user_type
self.user_status = user_status
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def serialize(self):
payload = {
"id": self.id,
"email": self.email,
"username": self.username,
"first_name": self.first_name,
"last_name": self.last_name,
"user_type": self.user_type.name,
"user_status": self.user_status.name
}
if self.user_type == UserType.PATIENT:
payload['dob'] = self.dob.strftime("%Y-%m-%d")
payload['phone_number'] = self.phone_number
elif self.user_type == UserType.DOCTOR:
payload['dob'] = self.dob.strftime("%Y-%m-%d")
payload['phone_number'] = self.phone_number
payload['specialization'] = self.specialization.spec
return payload
class Request(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
url = db.Column(db.String(1024), nullable=False)
create_date = db.Column(db.DateTime)
searchmode = db.Column(db.String(3), nullable=False)
depth = db.Column(db.Integer, nullable=False)
keyword = db.Column(db.String(255))
def __init__(self, url, searchmode='DFS', depth=10, keyword=None):
self.url = url
self.keyword = keyword
self.create_date = datetime.datetime.now()
if searchmode not in ['DFS', 'BFS']:
raise ValueError('searchmode provided was not valid. got %s' %
(searchmode))
else:
self.searchmode = searchmode
if int(depth) not in range(1, 11):
raise ValueError('depth provided was not valid. got %s' % (depth))
else:
self.depth = int(depth)
def __repr__(self):
return 'Request(Build me a graph for %s !)' % (self.url)
class UserSubject(db.Model, JSONStripped):
__tablename__ = '$user$subject'
def __init__(self, *args, **kwargs):
super(UserSubject, self).__init__(*args, **kwargs)
user_id = \
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True)
subject_id = \
db.Column('subject_id', db.Integer, db.ForeignKey('subject.id'), primary_key=True)
mark = \
db.Column('mark', db.String(2), nullable=False)
is_relevant = \
db.Column('is_relevant', db.Boolean, default=True)
subject = db.relationship('Subject', lazy='subquery')
def __repr__(self):
return '<UserSubject %r %r>' % self.user_id % self.subject_id
class Subject(db.Model, JSONStripped):
__tablename__ = 'subject'
def __init__(self, *args, **kwargs):
super(Subject, self).__init__(*args, **kwargs)
id = \
db.Column(db.Integer, primary_key=True)
name = \
db.Column(db.String(255))
term = \
db.Column(db.Integer, index=True, nullable=False)
def __repr__(self):
return '<Subject %r>' % self.name
@staticmethod
def insert(**kwargs):
subject = Subject(**kwargs)
db.session.add(subject)
db.session.commit()
return subject
@staticmethod
def get_all(**kwargs):
return Subject.query.filter_by(**kwargs)
@staticmethod
def get_one(**kwargs):
return Subject.query.filter_by(**kwargs).first()
@staticmethod
def get_or_insert(**kwargs):
with db.session.no_autoflush:
subject = Subject.get_one(**kwargs)
return Subject.insert(**kwargs) if subject is None else subject
class User(db.Model):
__tablename__ = 'User'
id = db.Column(db.String(100), primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(100))
email = db.Column(db.String(100))
photoURL = db.Column(db.String, default=_photoURL)
allowed_usage = db.Column(db.Integer)
ftl = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
files = db.relationship('File', backref='uploader')
badges = db.relationship('Badges', backref='creator')
permissions = db.relationship('Permissions',
backref=db.backref('user_permissions'),
lazy='dynamic')
siteAdmin = db.Column(db.Boolean, default=False)
last_login_ip = db.Column(db.String, nullable=True)
last_login_date = db.Column(db.DateTime, nullable=True)
def __init__(self, id_, username, password, email, photoURL=None):
self.id = id_
self.username = username
self.allowed_usage = 200
if password:
self.password = generate_password_hash(password)
self.email = email
if photoURL:
self.photoURL = photoURL
def create_site_admin(self):
self.siteAdmin = True
self.save_to_db()
def save_to_db(self):
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_user(self):
db.session.delete(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
@classmethod
def getUser(cls, user_id=None, username=None, email=None):
if user_id:
return cls.query.filter_by(id=user_id).first()
if username:
return cls.query.filter_by(username=username).first()
if email:
return cls.query.filter_by(email=email).first()
class Company(db.Model):
# Bind schema to external database
__bind_key__ = 'external'
# Primary key (id)
id = db.Column(db.String(6), primary_key=True)
name = db.Column(db.String(32), nullable=False)
class User(Base): #, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
#image_file = db.Column(db.String(20), nullable=False, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
registered_on = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
confirmed = db.Column(db.Boolean)
admin = db.Column(db.Boolean, nullable=False, default=False)
#posts = db.relationship('Post', backref='author', lazy=True)
#games = db.relationship('GameModel', backref='author', lazy=True)
own_games = relationship("GameModel",
back_populates="owner",
foreign_keys="[GameModel.owner_id]")
active_games = relationship("GameModel",
back_populates="active",
foreign_keys="[GameModel.active_id]")
own_notes = relationship("Notes",
back_populates="player",
foreign_keys="[Notes.player_id]")
def __init__(self,
email,
username,
password,
admin=False,
confirmed=False):
self.email = email
self.username = username
self.set_password(password)
#hashed_password = generate_password_hash(password)
#self.password = hashed_password
self.registered_on = datetime.datetime.now()
self.confirmed = confirmed
self.admin = admin
def check_password(self, password):
return check_password_hash(self.password, password)
def set_password(self, password):
hashed_password = generate_password_hash(password)
self.password = hashed_password
def get_reset_token(self, expires_sec=86400):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}, salt='reset').decode('utf-8')
def get_token(self, expires_sec=2592000): #2592000sec=30days
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
def get_registration_token(self, expires_sec=86400): # 86400 = 1 day
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({
'user_id': self.id
}, salt='registration').decode('utf-8')
@staticmethod
def verify_token(token, salt=None):
s = Serializer(current_app.config['SECRET_KEY'])
"""
print("try: ")
stoken = s.loads(token)
user_id = stoken['user_id']
"""
try:
user_id = s.loads(token, salt=salt)['user_id']
except:
return None
return Session.query(User).get(user_id)
def dict(self, includeGames=False):
# return the user in dict format
user = {}
user['username'] = self.username
user['id'] = self.id
return user
def __repr__(self):
return f"User('{self.id}', '{self.username}', '{self.email}', " \
f"'{self.password}', '{self.admin}', '{self.registered_on}'," \
f"'{self.confirmed}')"
class Badges(db.Model):
__tablename__ = 'Badges'
id = db.Column(db.String(100), primary_key=True)
image = db.Column(db.String, nullable=False)
csv = db.Column(db.String(100), nullable=False)
csv_type = db.Column(db.String(100), nullable=False)
ticket_types = db.Column(db.String, nullable=False)
badge_size = db.Column(db.String(100), nullable=False)
download_link = db.Column(db.String)
image_link = db.Column(db.String)
logo_image_link = db.Column(db.String)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
deleted_at = db.Column(db.DateTime, nullable=True)
badge_name = db.Column(db.String(100), default='My Badge')
user_id = db.Column(db.String(100),
db.ForeignKey('User.id', ondelete='CASCADE'))
logo_text = db.Column(db.String)
logo_color = db.Column(db.String)
logo_image = db.Column(db.String)
font_color_1 = db.Column(db.String(100), nullable=False)
font_color_2 = db.Column(db.String(100), nullable=False)
font_color_3 = db.Column(db.String(100), nullable=False)
font_color_4 = db.Column(db.String(100), nullable=False)
font_color_5 = db.Column(db.String(100), nullable=False)
font_size_1 = db.Column(db.String)
font_size_2 = db.Column(db.String)
font_size_3 = db.Column(db.String)
font_size_4 = db.Column(db.String)
font_size_5 = db.Column(db.String)
font_type_1 = db.Column(db.String(100), nullable=False)
font_type_2 = db.Column(db.String(100), nullable=False)
font_type_3 = db.Column(db.String(100), nullable=False)
font_type_4 = db.Column(db.String(100), nullable=False)
font_type_5 = db.Column(db.String(100), nullable=False)
paper_size = db.Column(db.String(100), nullable=False)
download_link = db.Column(db.String)
def save_to_db(self):
self.id = str(uuid.uuid4())
db.session.add(self)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
db.session.flush()
print(e)
def delete_from_db(self):
self.deleted_at = datetime.utcnow()
self.save_to_db()
@classmethod
def getBadge(cls, badge_id):
return cls.query.filter_by(id=badge_id)
class Order(db.Model):
__tablename__ = "orders"
id = db.Column(UUIDType(), primary_key=True)
item = db.Column(db.String(45), nullable=False)
customer_id = db.Column(UUIDType(),
db.ForeignKey(Customer.id),
nullable=False)
employee_id = db.Column(UUIDType(),
db.ForeignKey(Employee.id),
nullable=False)
customer = db.relationship('Customer',
backref=db.backref('orders', lazy=True))
employee = db.relationship('Employee',
backref=db.backref('orders', lazy=True))
order_time = db.Column(db.String(45), nullable=False)
star_rating = db.Column(db.Integer, nullable=True)
stat = db.Column(db.Integer, nullable=False)
@staticmethod
def new_order(id,
item,
customer_id,
employee_id,
order_time,
stat=0,
star_rating=None) -> "Order":
# Test that customer & employee ids are valid
customer = Customer.get_by_id(customer_id)
employee = Employee.get_by_id(employee_id)
return Order(id=id,
item=item,
customer_id=customer_id,
employee_id=employee_id,
order_time=order_time,
star_rating=star_rating,
stat=stat)
@staticmethod
def get_by_id(id) -> "Order":
id = to_uuid(id)
query = Order.query.filter_by(id=id)
if query.count() == 0:
raise ValueError(f"Order {str(id)} not found.")
return query.first()
def json(self) -> dict:
return {
"id": str(self.id),
"item": self.item,
"customer": self.customer,
"employee": self.employee,
"order_time": self.order_time,
"star_rating": self.star_rating,
"stat": self.stat,
}
@staticmethod
def get_by_participant_id(role, id) -> list:
id = to_uuid(id)
if role == 'customer':
query = Order.query.filter_by(customer_id=id)
elif role == 'employee':
query = Order.query.filter_by(employee_id=id)
else:
raise AttributeError(f"Role {role} not valid for order {str(id)}")
return query.all()
class DecisionTreeNode(db.Model):
id = db.Column(db.BigInteger, primary_key=True)
parent_id = db.Column(db.BigInteger)
true_node_id = db.Column(db.BigInteger)
false_node_id = db.Column(db.BigInteger)
feature = db.Column(db.Enum(Features))
criteria = db.Column(db.Text)
true_label = db.Column(db.Enum(Label))
false_label = db.Column(db.Enum(Label))
approved = db.Column(db.Boolean, nullable=False, default=False)
automated = db.Column(db.Boolean, nullable=False, default=False)
description = db.Column(db.String(500))
confidence = db.Column(db.Integer)
last_flag_count = db.Column(db.Integer)
suggested_feature = db.Column(db.String(100))
suggested_value = db.Column(db.String(100))
@property
def true_node(self):
return self.query.get(self.true_node_id)
@property
def false_node(self):
return self.query.get(self.false_node_id)
def calculateBuyingPartyFeature(self, item):
""" Calculate the buying party feature of a given item.
Args:
item (Derivative): The derivative to get the feature for
Returns:
Boolean: The value of the feature for the given item
"""
return item['derivative']['buying_party'] == self.criteria
def calculateSellingPartyFeature(self, item):
""" Calculate the selling party feature of a given item.
Args:
item (Derivative): The derivative to get the feature for
Returns:
Boolean: The value of the feature for the given item
"""
return item['derivative']['selling_party'] == self.criteria
def calculateAssetFeature(self, item):
""" Calculate the asset party feature of a given item.
Args:
item (Derivative): The derivative to get the feature for
Returns:
Boolean: The value of the feature for the given item
"""
return item['derivative']['asset'] == self.criteria
def calculateQuantityFeature(self, item, mean=0, standardDeviation=0):
""" Calculate the quantity feature of a given item.
Args:
item (Derivative): The derivative to get the feature for
mean (Integer): The mean to compare ``item`` to
standardDeviation (Integer): The standard deviation to compare ``item`` to
Returns:
Boolean: The value of the feature for the given item
"""
result = False
if self.criteria == 'less_than_mean':
result = item['derivative']['quantity'] < mean
elif self.criteria == 'more_than_mean':
result = item['derivative']['quantity'] > mean
elif self.criteria == '0_to_1_std':
result = abs(mean -
item['derivative']['quantity']) <= standardDeviation
elif self.criteria == '1_to_2_std':
deviation = abs(mean - item['derivative']['quantity'])
result = standardDeviation < deviation <= 2 * standardDeviation
elif self.criteria == '2_to_3_std':
deviation = abs(mean - item['derivative']['quantity'])
result = 2 * standardDeviation < deviation <= 3 * standardDeviation
elif self.criteria == '3_to_inf_std':
deviation = abs(mean - item['derivative']['quantity'])
result = deviation > 3 * standardDeviation
return result
def calculateStrikePriceFeature(self, item, mean=0, standardDeviation=0):
""" Calculate the strike price feature of a given item.
Args:
item (Derivative): The derivative to get the feature for
mean (Integer): The mean to compare ``item`` to
standardDeviation (Integer): The standard deviation to compare ``item`` to
Returns:
Boolean: The value of the feature for the given item
"""
result = False
if self.criteria == 'less_than_mean':
result = item['derivative']['strike_price'] < mean
elif self.criteria == 'more_than_mean':
result = item['derivative']['strike_price'] > mean
elif self.criteria == '0_to_1_std':
result = abs(
mean - item['derivative']['strike_price']) <= standardDeviation
elif self.criteria == '1_to_2_std':
deviation = abs(mean - item['derivative']['strike_price'])
result = standardDeviation < deviation <= 2 * standardDeviation
elif self.criteria == '2_to_3_std':
deviation = abs(mean - item['derivative']['strike_price'])
result = 2 * standardDeviation < deviation <= 3 * standardDeviation
elif self.criteria == '3_to_inf_std':
deviation = abs(mean - item['derivative']['strike_price'])
result = deviation > 3 * standardDeviation
return result
def split(self, data): # noqa: C901
""" Split given data on this node.
Args:
data (List of Derivative): The data to split
Returns:
(List of Derivative, List of Derivative): The split data. The first
item is the data that matches this node's feature, the second item
is the remaining data
"""
trueSplit = []
falseSplit = []
if self.feature == Features.BUYING_PARTY:
trueSplit = filter(self.calculateBuyingPartyFeature, data)
falseSplit = filter(
lambda x: not self.calculateBuyingPartyFeature(x), data)
elif self.feature == Features.SELLING_PARTY:
trueSplit = filter(self.calculateSellingPartyFeature, data)
falseSplit = filter(
lambda x: not self.calculateSellingPartyFeature(x), data)
elif self.feature == Features.SELLING_PARTY:
trueSplit = filter(self.calculateSellingPartyFeature, data)
falseSplit = filter(
lambda x: not self.calculateSellingPartyFeature(x), data)
elif self.feature == Features.ASSET:
trueSplit = filter(self.calculateAssetFeature, data)
falseSplit = filter(lambda x: not self.calculateAssetFeature(x),
data)
elif self.feature == Features.QUANTITY:
mean = 0
standardDeviation = 0
if len(data) <= 2:
trueSplit = data
falseSplit = []
else:
if 'label' in data[0]:
statsData = [x for x in data if x['label'] == Label.VALID]
else:
statsData = data
if self.criteria == 'less_than_mean' or self.criteria == 'more_than_mean':
mean = statistics.mean(
[x['derivative']['quantity'] for x in statsData])
else:
standardDeviation = statistics.stdev(
[x['derivative']['quantity'] for x in statsData])
trueSplit = filter(
lambda x: self.calculateQuantityFeature(
x, mean, standardDeviation), data)
falseSplit = filter(
lambda x: not self.calculateQuantityFeature(
x, mean, standardDeviation), data)
elif self.feature == Features.STRIKE_PRICE:
mean = 0
standardDeviation = 0
if len(data) <= 2:
trueSplit = data
falseSplit = []
else:
if 'label' in data[0]:
statsData = [x for x in data if x['label'] == Label.VALID]
else:
statsData = data
if self.criteria == 'less_than_mean' or self.criteria == 'more_than_mean':
mean = statistics.mean(
[x['derivative']['strike_price'] for x in statsData])
else:
standardDeviation = statistics.stdev(
[x['derivative']['strike_price'] for x in statsData])
trueSplit = filter(
lambda x: self.calculateStrikePriceFeature(
x, mean, standardDeviation), data)
falseSplit = filter(
lambda x: not self.calculateStrikePriceFeature(
x, mean, standardDeviation), data)
return list(trueSplit), list(falseSplit)
def __str__(self):
return f'<DecisionTreeNode : {self.id}, {self.feature}: {self.criteria}>'
class Derivative(db.Model):
id = db.Column(db.BigInteger, primary_key=True)
code = db.Column(db.String(16), nullable=False)
buying_party = db.Column(db.String(6), nullable=False)
selling_party = db.Column(db.String(6), nullable=False)
asset = db.Column(db.String(128), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
strike_price = db.Column(db.Float, nullable=False)
notional_curr_code = db.Column(db.CHAR(3), nullable=False)
date_of_trade = db.Column(db.Date, nullable=False)
maturity_date = db.Column(db.Date, nullable=False)
reported = db.Column(db.Boolean, nullable=False, default=False)
deleted = db.Column(db.Boolean, nullable=False, default=False)
@property
def absolute(self):
# Determine time diff between date of trade and now
delta = date.today() - self.date_of_trade
# The derivative is absolute if it was traded over a month ago
return self.deleted or delta.days >= 30
@property
def associated_actions(self):
# Form query for all associated actions
query = Action.query.filter_by(derivative_id=self.id)
# Order actions chronologically
query = query.order_by(Action.timestamp.desc())
# Return the ids of all the actions
return [action.id for action in query.all()]
# TODO: revisit
@property
def underlying_price(self):
up, _ = external_management.getAssetPrice(self.asset,
self.selling_party)
return up
# TODO: revisit
@property
def underlying_curr_code(self):
_, ucc = external_management.getAssetPrice(self.asset,
self.selling_party)
return ucc
# TODO: revisit
@property
def notional_value(self):
up = self.underlying_price
ucc = self.underlying_curr_code
n_ex_rate = external_management.getUSDExchangeRate(
self.notional_curr_code)
u_ex_rate = external_management.getUSDExchangeRate(ucc)
return self.quantity * up * u_ex_rate / n_ex_rate
@property
def notional_curr_symbol(self):
return utils.getCurrencySymbol(self.notional_curr_code)
@property
def underlying_curr_symbol(self):
return utils.getCurrencySymbol(self.underlying_curr_code)
def __str__(self):
return f'<Derivative : {self.id}>'
class User(db.Model):
__tablename__ = 'user'
id = db.Column(UUIDType(), primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
hash = db.Column(db.BINARY(32), nullable=False)
salt = db.Column(db.BINARY(32), nullable=False)
role = db.Column(db.String(10), nullable=False)
@staticmethod
def new_user(username, password, role="customer") -> 'User':
if not role in roles:
raise ValueError(f"Invalid role '{role}'")
hash, salt = User.create_hash(password)
return User(id=uuid4(),
username=username,
hash=hash,
salt=salt,
role=role)
@staticmethod
def new_user_with_id(uid, username, password, role="customer") -> 'User':
if not role in roles:
raise ValueError(f"Invalid role '{role}'")
hash, salt = User.create_hash(password)
return User(
id=UUID(uid),
username=username,
hash=hash,
salt=salt,
role=role,
)
@staticmethod
def create_hash(password, salt=None) -> (bytes, bytes):
if salt == None:
salt = os.urandom(32)
hash = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt,
100000)
return hash, salt
@staticmethod
def username_available(username) -> bool:
result = User.query.filter_by(username=username).all()
return len(result) == 0
def check_password(self, password) -> bool:
input_hash, salt = User.create_hash(password, self.salt)
return self.hash == input_hash
def json(self) -> dict:
return {
"id": str(self.id),
"username": self.username,
"role": self.role
}
@staticmethod
def get_by_id(id) -> 'User':
if type(id) != UUID:
try:
id = UUID(id)
except:
raise AttributeError("Invalid UUID")
query = User.query.filter_by(id=id)
if query.count() == 0:
raise ValueError(f"User {str(id)} not found.")
return query.first()
@staticmethod
def get_by_username(username) -> 'User':
query = User.query.filter_by(username=username)
if query.count() == 0:
raise ValueError(f"User '{username}' not found.")
return query.first()
@staticmethod
def get_by_role(role) -> 'User':
query = User.query.filter_by(role=role)
return query.all()
