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 Message(db.Model):
__tablename__ = 'message'
id = db.Column(db.Integer, primary_key=True)
sender_address = db.Column(db.String, db.ForeignKey('contact.address'))
sender_nickname = db.Column(db.String, nullable=False)
room_hash = db.Column(db.String, db.ForeignKey('room.hash'))
msg = db.Column(db.String, nullable=False)
status = db.Column(db.Enum(MessageStatus))
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
sender = db.relationship("Contact")
# room = db.relationship("Room")
room = db.relationship("Room", back_populates="messages")
def save(self):
if not self.id:
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self, **kwargs):
for key, value in kwargs.items():
if hasattr(self, key):
setattr(self, key, value)
self.save()
class MessageQueue(db.Model):
__tablename__ = 'message_queue'
id = db.Column(db.Integer, primary_key=True)
receiver_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
msg_id = db.Column(db.Integer, db.ForeignKey('message.id'))
status = db.Column(db.Enum(MessageStatus))
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
receiver = db.relationship("Contact")
message = db.relationship("Message")
def save(self):
if not self.id:
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self, **kwargs):
for key, value in kwargs.items():
if hasattr(self, key):
setattr(self, key, value)
self.save()
# If all queued messages of a message id had been send we edit the message status to DISPATCHED
queued_messages = MessageQueue.query.filter_by(
msg_id=self.msg_id,
status=MessageStatus.QUEUED
).all()
if len(queued_messages) == 0:
message = Message.query.get(self.msg_id)
message.update(status=MessageStatus.DISPATCHED)
class Action(db.Model):
id = db.Column(db.BigInteger, primary_key=True)
derivative_id = db.Column(db.BigInteger, db.ForeignKey('derivative.id'))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tree_id = db.Column(db.Integer)
type = db.Column(db.Enum(ActionType), nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.now)
update_log = db.Column(db.JSON)
def __str__(self):
return f'<Action : {self.id}>'
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 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 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}>'