class Donation(db.Model):
__tablename__ = "donations"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
hospital_id = db.Column(db.Integer,
db.ForeignKey('hospitals.id'),
nullable=False)
donor_id = db.Column(db.Integer,
db.ForeignKey('donors.id'),
nullable=False)
volume_of_blood = db.Column(db.Integer)
onset_time = db.Column(db.DateTime())
termination_time = db.Column(db.DateTime())
torfru = db.Column(db.DateTime())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def _asdict(self):
return {
c.key: getattr(self, c.key)
for c in db.inspect(self).mapper.column_attrs
}
@hybrid_method
def update_donor_dolbd(self):
if self.donor:
self.donor.update_dolbd(self.created_at)
class Deferral(db.Model):
__tablename__ = "deferrals"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
donor_id = db.Column(db.Integer,
db.ForeignKey('donors.id'),
nullable=False)
reason = db.Column(db.String(100))
ndefbd = db.Column(db.DateTime())
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def _asdict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
@hybrid_method
def update_donor_ndefbd(self):
if self.donor:
print("UPDATE MASTER")
self.donor.update_ndefbd(self.ndefbd)
class User(db.Model):
"""
User Model for storing user related details
"""
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
bday = db.Column(db.DateTime(), nullable=False)
fullname = db.Column(db.String(), nullable=False)
job = db.Column(db.String(), nullable=True)
country = db.Column(db.String(), nullable=True)
registered_on = db.Column(db.DateTime, nullable=False)
is_confirmed = db.Column(db.Boolean, nullable=True, default=False)
device_list = db.relationship('DeviceList', backref='user', lazy='dynamic')
def __init__(self,
email,
password,
bday,
fullname,
job=None,
country=None):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')).decode()
self.registered_on = datetime.datetime.now()
self.bday = bday
self.fullname = fullname
self.country = country
self.job = job
@staticmethod
def get_user_by_email(user_email):
return User.query.filter_by(email=user_email).first()
@staticmethod
def get_user_by_id(user_id):
return User.query.filter_by(id=user_id).first()
@staticmethod
def encode_auth_token(user_id,
modulus=None,
exponent=None,
main_key=None,
hasRoot=False):
"""
Generates the Auth Token
:param user_id key:
:return: string
"""
try:
if main_key:
hasRoot = True
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1),
'iat': datetime.datetime.utcnow(),
'sub': user_id,
'modulus': modulus if modulus else "No modulus is available",
'exponent':
exponent if exponent else "No exponent is available",
'key': main_key if main_key else "No main key is available",
'hasRoot': hasRoot
}
return jwt.encode(
payload,
app.config.get('SECRET_KEY'),
)
except Exception as e:
return e
@staticmethod
def decode_public_key(auth_token):
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['modulus'], payload['exponent']
except:
return 'Invalid auth token'
@staticmethod
def decode_auth_token_key(auth_token):
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token:
return 'Token is blacklisted. Please login again.'
else:
key = [payload['modulus'], payload['exponent']]
return payload['sub'], key
except jwt.ExpiredSignatureError:
return 'Signature expired. Please login again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please login again.'
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the authentication token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token:
return 'Token is blacklisted. Please login again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please login again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please login again.'
@staticmethod
def decode_auth_key(auth_token):
try:
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['modulus'], payload['exponent']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please login again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please login again.'
class Subscriber(db.Model):
__tablename__ = "subscribers"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sn = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
transfusions = db.relationship('Transfusion',
backref='subscriber',
lazy=True)
hospital_id = db.Column(db.Integer,
db.ForeignKey('hospitals.id'),
nullable=False)
medical_conditions = db.Column(db.String(100))
current_medications = db.Column(db.String(100))
first_name = db.Column(db.String(100))
middle_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
home_address = db.Column(db.String(100))
city = db.Column(db.String(100))
region = db.Column(db.String(100))
phone1 = db.Column(db.String(100))
phone2 = db.Column(db.String(100))
cni = db.Column(db.String(100))
cni_doi = db.Column(db.DateTime())
cni_poi = db.Column(db.String())
dob = db.Column(db.DateTime())
pob = db.Column(db.String(100))
gender = db.Column(db.String(100))
blood_group = db.Column(db.String(100))
rhesus_factor = db.Column(db.String(100))
allergies = db.Column(db.String(100))
active = db.Column(db.Boolean(), default=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self):
self.active = True
# def __init__(self, email, first_name, middle_name, last_name, home_address,
# city, phone1, phone2, cni, cni_doi, cni_poi, dob,
# pob, gender, blood_group, active=True):
# self.email = email
# self.first_name = first_name
# self.middle_name = middle_name
# self.last_name = last_name
# self.home_address = home_address
# self.city = city
# self.phone1 = phone1
# self.phone2 = phone2
# self.cni = cni
# self.cni_doi = cni_doi
# self.cni_poi = cni_poi
# self.dob = dob
# self.pob = pob
# self.gender = gender
# self.blood_group = blood_group
# self.active = active
def generate_sn(self):
self.sn = "DN" + self.first_name[0] + self.middle_name[0] + str(
random.randint(10000, 99999))
def _asdict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
def _return_data(self):
from project.server.models.Donor import Donor
sub_arr = self._asdict()
sub_arr['transfusions'] = [
trans._asdict() for trans in self.transfusions
]
for j in range(len(self.transfusions)):
sub_arr['transfusions'][j]['hospital'] = self.transfusions[
j].hospital._asdict()
match = Donor().query.filter(
Donor.blood_group.in_(DONOR_MATCH[sub_arr['blood_group']])).all()
sub_arr['match'] = [bg._asdict() for bg in match]
sub_arr['done_at'] = self.done_at._asdict()
return sub_arr
class Donor(db.Model):
__tablename__ = "donors"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sn = db.Column(db.String, unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
donations = db.relationship('Donation', backref='donor', lazy=False)
deferrals = db.relationship('Deferral', backref='donor', lazy=False)
hospital_id = db.Column(db.Integer,
db.ForeignKey('hospitals.id'),
nullable=False)
medical_conditions = db.Column(db.String(100))
current_medications = db.Column(db.String(100))
first_name = db.Column(db.String(100))
middle_name = db.Column(db.String(100))
last_name = db.Column(db.String(100))
home_address = db.Column(db.String(100))
city = db.Column(db.String(100))
region = db.Column(db.String(100))
phone1 = db.Column(db.String(100))
phone2 = db.Column(db.String(100))
cni = db.Column(db.String(100))
cni_doi = db.Column(db.DateTime())
cni_poi = db.Column(db.String())
dob = db.Column(db.DateTime())
pob = db.Column(db.String(100))
gender = db.Column(db.String(100))
blood_group = db.Column(db.String(100))
allergies = db.Column(db.String(100))
rhesus_factor = db.Column(db.String(100))
dolbd = db.Column(db.DateTime())
ndefbd = db.Column(db.DateTime())
status = db.Column(db.String(100))
referrer_id = db.Column(db.Integer, db.ForeignKey('donors.id'))
referrees = db.relationship('Donor',
backref=(db.backref('referrer',
remote_side=[id])))
active = db.Column(db.Boolean(), default=True)
created_at = db.Column(db.DateTime, default=db.func.now())
updated_at = db.Column(db.DateTime, default=db.func.now())
def __init__(self):
"""intitialization here"""
def generate_sn(self):
self.sn = "DN" + self.first_name[0] + self.middle_name[0] + str(
random.randint(10000, 99999))
def update_active(self):
self.active = True if (self.ndefbd -
datetime.datetime.now()).days <= 0 else False
def update_status(self):
if self.referrees and self.donations:
if len(self.referrees) < 2 and len(self.donations) < 2:
self.status = "Bronze"
elif len(self.referrees) < 6 and len(self.donations) < 3:
self.status = "Silver"
elif len(self.referrees) >= 6 and len(self.donations) >= 3:
self.status = "Gold"
else:
self.status = "Bronze"
db.session.add(self)
db.session.commit()
def update_dolbd(self, value):
self.dolbd = value
self.update_ndefbd()
self.update_status()
db.session.add(self)
db.session.commit()
def update_ndefbd(self, ndefbd_t=""):
if ndefbd_t == "":
self.ndefbd = self.dolbd + datetime.timedelta(days=90)
self.update_active()
else:
self.ndefbd = ndefbd_t
self.update_active()
db.session.add(self)
db.session.commit()
def _asdict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
def _return_data(self):
from project.server.models.Subscriber import Subscriber
donor_data = self._asdict()
donor_data['donations'] = [don._asdict() for don in self.donations]
for j in range(len(self.donations)):
donor_data['donations'][j]['hospital'] = self.donations[
j].hospital._asdict()
match = Subscriber().query.filter(
Subscriber.blood_group.in_(
RECEIVE_MATCH[donor_data['blood_group']])).all()
donor_data['match'] = [bg._asdict() for bg in match]
donor_data['referrer'] = self.referrer._asdict(
) if self.referrer else None
donor_data['deferrals'] = [
deferral._asdict() for deferral in self.deferrals
]
donor_data['referrees'] = [ref._asdict() for ref in self.referrees]
donor_data['done_at'] = self.done_at._asdict()
return donor_data