class DriverModel(db.Model):
__tablename__ = 'drivers'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
licensePlate = db.Column(db.String(15))
carCapacity = db.Column(db.Float)
dynamicAddress = db.Column(db.String(100))
dynamicLocation = db.Column(db.String(100))
class StaticData(db.Model):
__tablename__ = 'static_data'
id = db.Column(db.Integer, primary_key = True)
host_name = db.Column(db.String(255))
device_type = db.Column(db.String(255))
operating_system = db.Column(db.String(255))
mac_address = db.Column(db.String(255), unique=True)
ip_address = db.Column(db.String(255))
snap_shots = db.relationship('DynamicData', back_populates='static_data')
class OrderModel(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
arrivalTime = db.Column(db.String(100))
status = db.Column(db.Integer)
objectID = db.Column(db.Integer)
weight = db.Column(db.Float)
profit = db.Column(db.Float)
location = db.Column(db.String(100))
address = db.Column(db.String(100))
sequence = db.Column(db.Integer)
UserID = db.Column(db.Integer, db.ForeignKey('users.id'))
RouteID = db.Column(db.Integer, db.ForeignKey('routes.id'))
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
vegeName = db.Column(db.String(100))
vegeQuantity = db.Column(db.Integer)
vegePrice = db.Column(db.Integer)
FarmerID = db.Column(db.Integer, db.ForeignKey('farmers.id'))
class OrderModel(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
arrivalTime = db.Column(db.String(100))
orderDate = db.Column(db.String(100))
status = db.Column(db.Integer)
address = db.Column(db.String(100))
sequence = db.Column(db.Integer)
foodName = db.Column(db.String(100))
foodQuantity = db.Column(db.Float)
foodPrice = db.Column(db.Float)
profit = db.Column(db.Float)
UserID = db.Column(db.Integer, db.ForeignKey('users.id'))
FarmerID = db.Column(db.Integer, db.ForeignKey('farmers.id'))
RouteID = db.Column(db.Integer, db.ForeignKey('routes.id'))
class DynamicData(db.Model):
__tablename__ = 'dynamic_data'
id = db.Column(db.Integer, primary_key = True)
static_data_id = db.Column(db.Integer, db.ForeignKey('static_data.id'), nullable=False)
static_data = db.relationship('StaticData', back_populates='snap_shots')
time_stamp = db.Column(db.String(255))
upload_speed = db.Column(db.Integer)
download_speed = db.Column(db.Integer)
active_connection = db.Column(db.Boolean)
class Authors(db.Model):
__tablename__ = 'authors'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(20))
last_name = db.Column(db.String(20))
created = db.Column(db.DateTime, server_default=db.func.now())
books = db.relationship('Book',
backref='Authors',
cascade="all, delete-orphan")
def __init__(self, first_name, last_name, books=[]):
self.first_name = first_name
self.last_name = last_name
self.books = books
def create(self):
db.session.add(self)
db.session.commit()
return self
class Device(db.Model):
__tablename__ = 'devices'
id = db.Column(db.Integer, primary_key=True)
host_name = db.Column(db.String(255))
device_type = db.Column(db.String(255))
operating_system = db.Column(db.String(255))
mac_address = db.Column(db.String(255), unique=True)
ip_address = db.Column(db.String(255))
upload_speed = db.Column(db.Integer)
download_speed = db.Column(db.Integer)
active_connection = db.Column(db.Boolean)
def __init__(self, host_name, device_type, operating_system, mac_address,
ip_address, upload_speed, download_speed, active_connection):
self.host_name = host_name
self.device_type = device_type
self.operating_system = operating_system
self.mac_address = mac_address
self.ip_address = ip_address
self.upload_speed = upload_speed
self.download_speed = download_speed
self.active_connection = active_connection
def update(self):
self.update_active_connection()
self.update_upload_download()
db.session.commit()
def update_active_connection(self):
if random.randint(1, 5) > 4:
self.active_connection = not self.active_connection
def update_upload_download(self):
if self.active_connection:
self.upload_speed = random.randint(0, 12)
self.download_speed = random.randint(0, 70)
else:
self.upload_speed = 0
self.download_speed = 0
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
def create(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
class FarmerModel(db.Model):
__tablename__ = 'farmers'
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(32), index = True)
name = db.Column(db.String(32))
password_hash = db.Column(db.String(64))
email = db.Column(db.String(50))
address = db.Column(db.String(100))
cellphone = db.Column(db.String(15))
latitude = db.Column(db.String(50))
longitude = db.Column(db.String(50))
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50))
year = db.Column(db.Integer)
author_id = db.Column(db.Integer,
db.ForeignKey('authors.id'),
nullable=False)
def __init__(self, title, year, author_id=None):
self.title = title
self.year = year
self.author_id = author_id
def create(self):
db.session.add(self)
db.session.commit()
return self
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
name = db.Column(db.String(32))
password_hash = db.Column(db.String(64))
email = db.Column(db.String(50))
address = db.Column(db.String(100))
cellphone = db.Column(db.String(15))
permission = db.Column(db.Integer, default=0)
order = db.relationship('OrderModel')
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
name = db.Column(db.String(80))
password = db.Column(Password)
role = db.Column(db.String(20), server_default='user', nullable=False)
email = db.Column(db.String(120))
load_finding_files = db.Column(Boolean, server_default='1', nullable=False)
created_on = db.Column(db.DateTime)
last_login_on = db.Column(db.DateTime)
last_login_from = db.Column(db.String(80))
worklist = db.relationship('WorkItem', order_by='WorkItem.id')
def __init__(self,
username,
name,
password,
created_on,
email,
role='user',
load_finding_files=True):
self.username = username
self.name = name
self.password = password
self.role = role
self.email = email
self.created_on = created_on
self.load_finding_files = load_finding_files
def __repr__(self):
return "<User(username='******', name='%s')>" % (self.username, self.name)
@validates('password')
def _validate_password(self, key, password):
return getattr(type(self), key).type.validator(password)
@property
def is_admin(self):
return self.role == 'admin'
def to_json_dict(self):
last_login = "******" if self.last_login_on is None else self.last_login_on.strftime(
'%Y-%m-%d')
created_on = "Not Available" if self.created_on is None else self.created_on.strftime(
'%Y-%m-%d')
last_login_from = "Not Available" if self.last_login_from is None else self.last_login_from
email = "" if self.email is None else self.email
load_finding_files = self.load_finding_files
return {
'id': self.id,
'username': self.username,
'name': self.name,
'role': self.role,
'created_on': created_on,
'last_login_on': last_login,
'email': email,
'last_login_from': last_login_from,
'load_finding_files': load_finding_files
}
class Finding(db.Model):
__tablename__ = 'findings'
id = db.Column(db.Integer, primary_key=True)
work_item_id = db.Column(db.Integer, db.ForeignKey('work_items.id'))
series_id = db.Column(db.Integer, db.ForeignKey('series.id'))
finding_uid = db.Column(db.Integer)
status = db.Column(db.String)
label = db.Column(db.String(50))
key_slice = db.Column(db.Integer)
visualization_type = db.Column(db.String)
locations = db.Column(db.String)
original_locations = db.Column(db.String)
order = db.Column(db.Integer)
comment = db.Column(db.String)
input_source_index = db.Column(Integer, server_default='0', nullable=False)
contour = db.Column(db.String, server_default=None)
def __init__(self,
work_item_id,
series_id,
finding_uid,
status,
label,
key_slice,
visualization_type,
locations,
order,
original_locations=None,
comment=None,
input_source_index=0,
contour=None):
self.work_item_id = work_item_id
self.series_id = series_id
self.finding_uid = finding_uid
self.status = status
self.label = label
self.key_slice = key_slice
self.visualization_type = visualization_type
self.locations = locations
self.order = order
self.original_locations = original_locations
self.comment = comment
self.input_source_index = input_source_index
self.contour = contour
def __repr__(self):
return "<Finding(finding_uid='{}', status='{}', key_slice='{}')>".format(
self.finding_uid, self.status, self.key_slice)
def to_json_dict(self):
return {
'id':
self.id,
'series_id':
self.series_id,
'finding_uid':
self.finding_uid,
'label':
self.label,
'status':
self.status,
'key_slice':
self.key_slice,
'visualization_type':
self.visualization_type,
'locations':
json.loads(self.locations),
'original_locations':
None if self.original_locations is None else json.loads(
self.original_locations),
'comment':
self.comment,
'order':
self.order,
'input_source_index':
self.input_source_index,
'contour':
None if self.contour is None else json.loads(self.contour)
}
