class BlacklistToken(db.Model):
"""
Token Model for storing JWT tokens
"""
__tablename__ = 'blacklist_tokens'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(500), unique=True, nullable=False)
blacklisted_on = db.Column(db.DateTime, nullable=False)
def __init__(self, token):
self.token = token
self.blacklisted_on = datetime.datetime.now()
def __repr__(self):
return '<id: token: {}'.format(self.token)
@staticmethod
def check_blacklist(auth_token):
# check whether auth token has been blacklisted
res = BlacklistToken.query.filter_by(token=str(auth_token)).first()
if res:
return True
else:
return False
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True)
associated_room = db.Column(
db.Integer,
db.ForeignKey('room.id',ondelete='CASCADE')
)
name = db.Column(db.Text, nullable=False)
description = db.Column(db.Text)
who_owns = db.Column(db.Text, nullable=False)
who_has_current = db.Column(db.Text)
how_long_can_borrow = db.Column(db.Text)
due_back = db.Column(db.DateTime)
date_posted = db.Column(db.DateTime, default=func.now(), nullable=False)
active = db.Column(db.Boolean, default=True)
history = db.relationship('BorrowHistory', cascade='all, delete-orphan')
def __init__(self, room, name, who_owns):
self.associated_room = room.id
self.name = name
self.who_owns = who_owns
def get_info(self):
d = {}
for i in self.__table__.columns:
d[i.name] = getattr(self, i.name)
d['history'] = [j.get_history_info() for j in self.history]
return d
class RoomProductivity(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room_id = db.Column(db.Integer, db.ForeignKey('rooms.id'))
count_usage = db.Column(db.Integer)
standard_usage = db.Column(db.Integer)
def __repr__(self):
return '<RoomProductivity {}>'.format(self.id)
class MedicalDeviceType(db.Model):
__tablename__ = 'medical_devices_type'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
type_name = db.Column(db.String(120))
type_desc = db.Column(db.String(240))
devices = db.relationship('MedicalDevice',
backref='device_type',
lazy='dynamic')
class RoomSecurity(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room_id = db.Column(db.Integer, db.ForeignKey('rooms.id'))
is_unauthorized = db.Column(db.Boolean)
is_locked = db.Column(db.Boolean)
is_pic_exist = db.Column(db.Boolean)
def __repr__(self):
return '<RoomSecurity {}>'.format(self.id)
class BedSecurity(db.Model):
__tablename__ = 'beds_security'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
bed_id = db.Column(db.Integer, db.ForeignKey('beds.id'))
current_loc = db.Column(db.String(60)) # refer to a place
current_pic = db.Column(db.String(60)) # refer to a staff
def __repr__(self):
return '<BedSecurity {}>'.format(self.security_bed.current_security)
class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
def __init__(self, email, password, admin=False):
self.email = email
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
self.registered_on = datetime.datetime.now()
self.admin = admin
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=5),
'iat': datetime.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Validates the auth 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 blacklisted. Please log in again.'
else:
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class MedicalDeviceProductivity(db.Model):
__tablename__ = 'medical_devices_productivity'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.Integer, db.ForeignKey('medical_devices.id'))
count_usage = db.Column(db.Integer)
standard_usage = db.Column(db.Integer)
def __repr__(self):
return '<DeviceProductivity {}>'.format(
self.productivity_device.current_productivity)
class Testcase(db.Model):
id = db.Column(db.Integer, primary_key=True)
nodeid = db.Column(db.String(80), nullable=False)
remark = db.Column(db.String(120))
def as_dict(self):
"""
返回一个标准的Python结构体
:return:
"""
return {'id': self.id, 'nodeid': self.nodeid, 'remark': self.remark}
class MedicalDeviceSecurity(db.Model):
__tablename__ = 'medical_devices_security'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.Integer, db.ForeignKey('medical_devices.id'))
current_loc = db.Column(db.String(60)) # refer to a place
current_pic = db.Column(db.String(60)) # refer to a staff
def __repr__(self):
return '<DeviceSecurity {}>'.format(
self.security_device.current_security)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
scope = db.Column(db.String(60), nullable=False)
state_id = db.Column(db.Integer, db.ForeignKey('states.id'))
hospital_id = db.Column(db.Integer, db.ForeignKey('hospitals.id'))
users = db.relationship('User', backref='user_role', lazy='dynamic')
def __repr__(self):
return '<Role: {}>'.format(self.scope)
class BedProductivity(db.Model):
__tablename__ = 'beds_productivity'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
bed_id = db.Column(db.Integer, db.ForeignKey('beds.id'))
count_usage = db.Column(db.Integer)
standard_usage = db.Column(db.Integer)
turnover_usage = db.Column(db.Integer)
def __repr__(self):
return '<BedProductivity {}>'.format(
self.productivity_bed.current_productivity)
class RevokedToken(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
jti = db.Column(db.String(120), nullable=False)
def __init__(self, jti):
self.jti = jti
@classmethod
def is_token_revoked(cls, jti):
query = cls.query.filter_by(jti = jti).first()
return bool(query)
def db_commit(self):
db.session.add(self)
db.session.commit()
class Room(db.Model):
__tablename__ = 'rooms'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room_name = db.Column(db.String(60), nullable=False)
room_pic = db.Column(db.String(60)) # refer to staff/person/etc.
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
level_id = db.Column(db.Integer, db.ForeignKey('levels.id'))
rooms_history = db.relationship('RoomHistory',
backref='history_room',
lazy='dynamic')
rooms_safety = db.relationship('RoomSafety',
backref='safety_room',
lazy='dynamic')
rooms_security = db.relationship('RoomSecurity',
backref='security_room',
lazy='dynamic')
rooms_productivity = db.relationship('RoomProductivity',
backref='productivity_room',
lazy='dynamic')
def __repr__(self):
return '<Room {}>'.format(self.room_name)
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
# 人物执行的相关数据信息
remark = db.Column(db.String(120))
report = db.Column(db.String(120))
# 指定时间格式，默认值为当前时间
create_at = db.Column(db.DateTime, default=datetime.datetime.now)
def as_dict(self):
"""
返回一个标准的Python结构体
:return:
"""
return {'id': self.id,
'remark': self.remark,
'report': self.report,
# 强转为字符串的格式
'create_at': str(self.create_at)
}
class Room(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True, unique=True)
room_name = db.Column(db.Text, nullable=False)
encoded_room_name = db.Column(db.Text, nullable=False)
date_created = db.Column(db.DateTime, default=func.now(), nullable=False)
private = db.Column(db.Boolean, default=False)
password = db.Column(db.Text)
items = db.relationship('Item', cascade='all, delete-orphan')
def __init__(self, room_name):
self.room_name = room_name
self.encoded_room_name = self.encode_room(room_name)
def encode_room(self, room_name):
rooms_with_same_name = Room.query.filter_by(room_name=room_name)
if rooms_with_same_name.count() >= 1:
room_name = "".join([room_name, str(rooms_with_same_name.count())])
hashed_room_name = hashlib.md5(room_name.encode()).digest()
room_encoding = base64.urlsafe_b64encode(hashed_room_name).decode()
return room_encoding.strip('=')
def get_items(self):
d = {}
for i in self.__table__.columns:
if i.name in ['encoded_room_name', 'password']:
continue
else:
d[i.name] = getattr(self, i.name)
d['items'] = [j.get_info() for j in self.items]
return d
class BedSafety(db.Model):
__tablename__ = 'beds_safety'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
bed_id = db.Column(db.Integer, db.ForeignKey('beds.id'))
bed_age = db.Column(db.Integer)
last_maintenance_date = db.Column(db.DateTime)
standar_maintenance = db.Column(db.Integer)
is_reported = db.Column(db.Boolean)
def __repr__(self):
return '<BedSafety {}>'.format(self.safety_bed.current_safety)
class BedHistory(db.Model):
__tablename__ = 'beds_history'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
bed_id = db.Column(db.Integer, db.ForeignKey('beds.id'))
date_time = db.Column(db.DateTime)
record_safety = db.Column(db.Integer)
record_security = db.Column(db.Integer)
record_productivity = db.Column(db.Integer)
def __repr__(self):
return '<BedHistory {}>'.format(self.history_bed.bed_name)
class StateHistory(db.Model):
__tablename__ = 'states_history'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
state_id = db.Column(db.Integer, db.ForeignKey('states.id'))
date_time = db.Column(db.DateTime)
record_safety = db.Column(db.Integer)
record_security = db.Column(db.Integer)
record_productivity = db.Column(db.Integer)
def __repr__(self):
return '<StateHistory: {}>'.format(self.id)
class Level(db.Model):
__tablename__ = 'levels'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
level_name = db.Column(db.String(60), nullable=False)
level_pic = db.Column(db.String(60),
nullable=True) # refer to staff/person/etc.
count_rooms = db.Column(db.Integer)
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
building_id = db.Column(db.Integer, db.ForeignKey('buildings.id'))
rooms = db.relationship('Room', backref='room_level', lazy='dynamic')
levels_history = db.relationship('LevelHistory',
backref='history_level',
lazy='dynamic')
def __repr__(self):
return '<Level {}>'.format(self.level_name)
class MedicalDeviceHistory(db.Model):
__tablename__ = 'medical_devices_history'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.Integer, db.ForeignKey('medical_devices.id'))
date_time = db.Column(db.DateTime)
record_safety = db.Column(db.Integer)
record_security = db.Column(db.Integer)
record_productivity = db.Column(db.Integer)
def __repr__(self):
return '<DeviceHistory {}>'.format(self.history_device.device_name)
class MedicalDeviceSafety(db.Model):
__tablename__ = 'medical_devices_safety'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.Integer, db.ForeignKey('medical_devices.id'))
device_age = db.Column(db.Integer)
last_maintenance_date = db.Column(db.DateTime)
standar_maintenance = db.Column(db.Integer)
is_reported = db.Column(db.Boolean)
def __repr__(self):
return '<DeviceSafety {}>'.format(self.safety_device.current_safety)
class Hospital(db.Model):
__tablename__ = 'hospitals'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
hospital_name = db.Column(db.String(60), nullable=False)
count_buildings = db.Column(db.Integer)
count_rooms = db.Column(db.Integer)
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
state_id = db.Column(db.Integer, db.ForeignKey('states.id'))
roles = db.relationship('Role', backref='role_hospital', lazy='dynamic')
buildings = db.relationship('Building',
backref='building_hospital',
lazy='dynamic')
hospitals_history = db.relationship('HospitalHistory',
backref='history_hospital',
lazy='dynamic')
def __repr__(self):
return '<Hospital {}>'.format(self.hospital_name)
class BorrowHistory(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
associated_item = db.Column(db.Integer,
db.ForeignKey('item.id', ondelete='CASCADE'),
nullable=False
)
who_borrowed = db.Column(db.Text, nullable=False)
date_borrowed = db.Column(db.DateTime)
due_back = db.Column(db.DateTime)
returned = db.Column(db.Boolean, default=False)
date_returned = db.Column(db.DateTime)
notes = db.Column(db.Text)
def __init__(self, associated, who_borrowed):
self.associated_item = associated.id
self.who_borrowed = who_borrowed
def get_history_info(self):
d = {}
for i in self.__table__.columns:
d[i.name] = getattr(self, i.name)
return d
class State(db.Model):
__tablename__ = 'states'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
state_name = db.Column(db.String(60), nullable=False)
count_hospitals = db.Column(db.Integer)
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
roles = db.relationship('Role', backref='role_state', lazy='dynamic')
hospitals = db.relationship('Hospital', backref='hospital_state', lazy='dynamic')
states_history = db.relationship('StateHistory', backref='history_state', lazy='dynamic')
def __repr__(self):
return '<State: {}>'.format(self.state_name)
class Bed(db.Model):
__tablename__ = 'beds'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
bed_name = db.Column(db.String(60), nullable=False)
bed_desc = db.Column(db.String(120))
bed_loc = db.Column(
db.String(60)) # refer to a place (room, level, or building)
bed_pic = db.Column(db.String(60)) # refer to staff/person/etc.
bed_status = db.Column(
db.Boolean) # refer to (used, unused, etc.) need to list more
production_date = db.Column(db.DateTime)
is_used = db.Column(db.Boolean)
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
bed_history = db.relationship('BedHistory',
backref='history_bed',
lazy='dynamic')
bed_safety = db.relationship('BedSafety',
backref='safety_bed',
lazy='dynamic')
bed_security = db.relationship('BedSecurity',
backref='security_bed',
lazy='dynamic')
bed_productivity = db.relationship('BedProductivity',
backref='productivity_bed',
lazy='dynamic')
def __repr__(self):
return '<Bed {}>'.format(self.bed_name)
class MedicalDevice(db.Model):
__tablename__ = 'medical_devices'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_name = db.Column(db.String(60), nullable=False)
device_desc = db.Column(db.String(120))
device_loc = db.Column(
db.String(60)) # refer to a place (room, level, or building)
device_pic = db.Column(db.String(60)) # refer to staff/person/etc.
device_status = db.Column(
db.Boolean) # refer to (used, unused, etc.) need to list more
production_date = db.Column(db.DateTime)
is_on = db.Column(db.Boolean)
current_safety = db.Column(db.Integer)
current_security = db.Column(db.Integer)
current_productivity = db.Column(db.Integer)
device_type_id = db.Column(db.Integer,
db.ForeignKey('medical_devices_type.id'))
device_history = db.relationship('MedicalDeviceHistory',
backref='history_device',
lazy='dynamic')
device_safety = db.relationship('MedicalDeviceSafety',
backref='safety_device',
lazy='dynamic')
device_security = db.relationship('MedicalDeviceSecurity',
backref='security_device',
lazy='dynamic')
device_productivity = db.relationship('MedicalDeviceProductivity',
backref='productivity_device',
lazy='dynamic')
def __repr__(self):
return '<Device {}>'.format(self.device_name)
class RoomSafety(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room_id = db.Column(db.Integer, db.ForeignKey('rooms.id'))
current_temperature = db.Column(db.Integer)
current_humidity = db.Column(db.Integer)
current_smoke = db.Column(db.Integer)
current_co = db.Column(db.Integer)
current_methane = db.Column(db.Integer)
current_lpg = db.Column(db.Integer)
current_light = db.Column(db.Integer)
current_led = db.Column(db.Integer)
current_freq = db.Column(db.Integer)
def __repr__(self):
return '<RoomSafety {}>'.format(self.id)
