class Role(db.Model):
IdRole = db.Column(db.Integer, primary_key=True)
Role = db.Column(db.String(250), nullable=False)
CreatedAt = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return f"Role('{self.IdRole}','{self.Role},'{self.CreatedAt}')"
class Employee(db.Model):
__tablename__ = 'employee'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
country = db.Column(db.String(12))
city = db.Column(db.String(12))
salary = db.Column(db.Integer)
class OrderStatus(db.Model):
IdOrderStatus = db.Column(db.Integer, primary_key=True)
OrderStatus = db.Column(db.String(250), nullable=False)
CreatedAt = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return f"OrderStatus('{self.IdOrderStatus}','{self.OrderStatus}','{self.CreatedAt}')"
class Situation(db.Model):
IdSituation = db.Column(db.Integer, primary_key=True)
Situation = db.Column(db.String(250), nullable=False)
CreatedAt = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return f"Situation('{self.IdSituation}','{self.Situation}','{self.CreatedAt}')"
class Time(db.Model):
IdTime = db.Column(db.Integer, primary_key=True)
TimeDec = db.Column(db.String(250), nullable=False)
CreatedAt = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return f"Time('{self.IdTime}','{self.TimeDec }','{self.CreatedAt}')"
class Priority(db.Model):
IdPriority = db.Column(db.Integer, primary_key=True)
PriorityName = db.Column(db.String(250), nullable=False)
CreatedAt = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return f"Priority('{self.IdPriority}','{self.PriorityName}','{self.CreatedAt}')"
class Users(db.Model, UserMixin):
__tablename__ = 'Users'
__bind_key__ = 'flask'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
email = db.Column(db.String(64), unique=True)
password = db.Column(db.LargeBinary)
def __init__(self, **kwargs):
for property, value in kwargs.items():
# depending on whether value is an iterable or not, we must
# unpack it's value (when **kwargs is request.form, some values
# will be a 1-element list)
if hasattr(value, '__iter__') and not isinstance(value, str):
# the ,= unpack of a singleton fails PEP8 (travis flake8 test)
value = value[0]
if property == 'password':
value = hash_pass(value) # we need bytes here (not plain str)
setattr(self, property, value)
# repr method represents how one object of this datatable
# will look like
def __repr__(self):
return str(self.username)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
dam_id = db.Column(db.Integer, db.ForeignKey('dam.id'), nullable=False)
def __repr__(self):
return f"User({self.username}, {self.dam_id})"
class Size(db.Model):
IdSize = db.Column(db.Integer, primary_key=True)
Size = db.Column(db.String(250), nullable=False)
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
CreatedAt = db.Column(db.DateTime, nullable=False)
situation = db.relationship('Situation', backref='Size')
def __repr__(self):
return f"Portion('{self.IdSize }','{self.Enabled }','{self.Size }','{self.CreatedAt}')"
class Categories(db.Model):
IdCategory = db.Column(db.Integer, primary_key=True)
Category = db.Column(db.String(250), nullable=False)
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
CreatedAt = db.Column(db.DateTime, nullable=False)
situation = db.relationship('Situation', backref='Categories')
def __repr__(self):
return f"Categories('{self.IdCategory}','{self.Category },'{self.Enabled}','{self.CreatedAt}')"
class IncidentalFinding(db.Model):
__tablename__ = 'incidental_findings'
id = db.Column(db.Integer, primary_key=True)
session_id = db.Column(db.Integer,
db.ForeignKey('sessions.id'),
nullable=False)
session = db.relationship('Session', back_populates="incidental_findings")
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates="incidental_findings")
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True, nullable=False)
role = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def __repr__(self):
return f"User('{self.name}', '{self.email}')"
class ExtraService(db.Model):
IdService = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(250), nullable=False)
Price = db.Column(db.String(250), nullable=False)
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
CreatedAt = db.Column(db.DateTime, nullable=False)
situation = db.relationship('Situation', backref='ExtraService')
def __repr__(self):
return f"ExtraService('{self.IdService}','{self.Name},'{self.Price}','{self.Enabled}','{self.CreatedAt}')"
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
class Data(db.Model):
id = db.Column(db.Integer, primary_key=True)
data = db.Column(db.Integer, nullable=False)
timestamp = db.Column(db.DateTime,
nullable=False,
default=datetime.datetime.utcnow())
device_id = db.Column(db.Integer,
db.ForeignKey('device.id'),
nullable=False)
def __repr__(self):
return f"Data({self.data}, {self.timestamp})"
class User(db.Model, UserMixin):
# define a user with username and password and email adress. Only users can add devices to the device list
id = db.Column(db.Integer, primary_key=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)
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Site(db.Model):
__tablename__ = 'sites'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
studies = db.relationship('Study',
secondary=study_site_table,
back_populates='sites')
sessions = db.relationship('Session')
def __repr__(self):
return ('<Site {}>'.format(self.name))
class ScanType(db.Model):
__tablename__ = 'scantypes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
metrictypes = db.relationship('MetricType', back_populates="scantype")
scans = db.relationship("Scan", back_populates='scantype')
studies = db.relationship("Study",
secondary=study_scantype_table,
back_populates="scantypes")
def __repr__(self):
return ('<ScanType {}>'.format(self.name))
class MetricValue(db.Model):
__tablename__ = 'scanmetrics'
id = db.Column(db.Integer, primary_key=True)
_value = db.Column('value', db.String)
scan_id = db.Column(db.Integer, db.ForeignKey('scans.id'), nullable=False)
scan = db.relationship('Scan', back_populates="metricvalues")
metrictype_id = db.Column(db.Integer, db.ForeignKey('metrictypes.id'))
metrictype = db.relationship('MetricType', back_populates="metricvalues")
@property
def value(self):
"""Returns the value field from the database.
The value is stored as a string.
If the value contains '::' character this will convert it to a list,
otherwise it will attempt to cast to Float.
Failing that the value is returned as a string.
"""
if self._value is None:
return (None)
value = self._value.split('::')
try:
value = [float(v) for v in value]
except ValueError:
return (''.join(value))
if len(value) == 1:
return (value[0])
else:
return (value)
@value.setter
def value(self, value, delimiter=None):
"""Stores the value in the database as a string.
If the delimiter is specified any characters matching delimiter are
replaced with '::' for storage.
Keyword arguments:
[delimiter] -- optional character string that is replaced by '::' for
database storage.
"""
if delimiter is not None:
try:
value = value.replace(delimiter, '::')
except AttributeError:
pass
self._value = str(value)
def __repr__(self):
return ('<Scan {}: Metric {}: Value {}>'.format(
self.scan.name, self.metrictype.name, self.value))
class MetricType(db.Model):
__tablename__ = 'metrictypes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(12))
scantype_id = db.Column(db.Integer,
db.ForeignKey('scantypes.id'),
nullable=False)
scantype = db.relationship('ScanType', back_populates='metrictypes')
metricvalues = db.relationship('MetricValue')
db.UniqueConstraint('name', 'scantype_id')
def __repr__(self):
return ('<MetricType {}>'.format(self.name))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True, nullable=False)
role = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
def __repr__(self):
return f"User('{self.name}', '{self.email}'')"
def __init__(self, name, role, email, password):
self.name = name
self.role = role
self.email = email
self.password = password
class Card(db.Model):
__tablename__ = 'card'
id = db.Column(db.Integer, primary_key=True)
header = db.Column(db.String(20))
icon = db.Column(db.String(10))
category = db.Column(db.String(10))
title = db.Column(db.String(12))
footer_icon = db.Column(db.String(10))
footer_title = db.Column(db.String(12))
footer_text = db.Column(db.String(20))
class Lo(db.Model):
__tablename__ = "los"
__table_args__ = {'extend_existing': True} # Makes sure database is updated and we don't get errors on restart
lo_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String(40), primary_key=True)
name = db.Column(db.String(40)) # Short LO name. Example: #linearsystems
description = db.Column(db.String(500)) # Longer LO description
term = db.Column(db.Integer) # Integer indicating the term. For example, 22 means Spring 2021
co_id = db.Column(db.Integer) # ID of associated Course Outcome
co_desc = db.Column(db.String(500)) # Description of associated Course Outcome
course = db.Column(db.String(10)) # Short Course name. Example: CS162
mean = db.Column(db.String(4)) # Mean of HC score
class Post(db.Model):
__tablename__ = "posts"
title = db.Column(db.String(255))
link = db.Column(db.String(255))
tag = db.Column(db.String(60))
datetime = db.Column(db.String(60))
origin = db.Column(db.String(60))
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 外键名为 '表名.字段名'
author_id = db.Column(db.Integer, db.ForeignKey("authors.id"))
# 创建一个属性代表它的作者对象
author = db.relationship("Author", back_populates="posts")
def __init__(self, title, link, tag, origin, author):
self.title = title
self.link = link
self.tag = tag
self.origin = origin
self.datetime = None
self.author = author
if isinstance(author, Author):
self.author_id = author.id
else:
# 抛出异常
raise Exception(TypeError)
@dateTimeFormatter
def setDateTime(self, date=None):
self.datetime = date
# 重写输出函数，方便打印
def __repr__(self):
return "Class:{}<id:{} title:{} link:{} tag:{} datetime:{} origin:{}>".format(
"Post", self.id, self.title, self.link, self.tag, self.datetime,
self.origin)
class Analysis(db.Model):
__tablename__ = 'analyses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
description = db.Column(db.String, nullable=False)
software = db.Column(db.String)
analysis_comments = db.relationship('ScanComment')
def get_users(self):
"""
Returns a list of unique user objects who have posted comments
on this analysis.
"""
user_ids = [comment.user_id for comment in self.analysis_comments]
user_ids = set(user_ids)
users = [User.query.get(uid) for uid in user_ids]
return users
def __repr__(self):
return ('<Analysis:{} {}>'.format(self.id, self.name))
class Dam(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True, nullable=False)
status = db.Column(db.String(10), nullable=False, default="NORMAL")
location = db.Column(db.String(60), nullable=False)
state = db.Column(db.String(20), nullable=False)
latitude = db.Column(db.String(10), nullable=False)
longitude = db.Column(db.String(10), nullable=False)
frl = db.Column(db.Integer, nullable=False)
devices = db.relationship('Device', backref='installed_at', lazy=True)
users = db.relationship('User', backref='works_at', lazy=True)
def __repr__(self):
return f"Dam({self.name}, {self.state}, {self.frl})"
class Author(db.Model):
__tablename__ = "authors"
name = db.Column(db.String(255))
link = db.Column(db.String(255))
create_time = db.Column(db.String(60))
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 创建一个属性记录属于他的文章
posts = db.relationship("Post", back_populates="author")
def __init__(self, link, name):
self.link = link
self.name = name
self.create_time = None
@dateTimeFormatter
def setCreateTime(self, date=None):
self.create_time = date
# 重写输出函数，方便打印
def __repr__(self):
return "Class:{}<id:{} name:{} link:{} create_time:{}>".format(
"Author", self.id, self.name, self.link, self.create_time)
class temperatur(db.Model):
temp_id = db.Column(db.Integer, primary_key=True)
temp_date = db.Column(db.DateTime, default=datetime.utcnow)
temp_fahrenheit = db.Column(db.Float)
temp_celcius = db.Column(db.Float)
temp_humidity = db.Column(db.Float)
temp_sensor_desc = db.Column(db.String(100))
temp_sensor_pin = db.Column(db.String(25))
def __repr__(self):
return f'<Sensor {temp_sensor_pin} Desc {temp_sensor_desc} Date {temp_date.strftime("%Y-%m-%d %H:%M:%S")} Temp {temp_fahrenheit}/{temp_celcius} Hum {temp_humidity}'
class Users(db.Model, UserMixin):
IdUser = db.Column(db.Integer, primary_key=True)
IdRole = db.Column(db.Integer, db.ForeignKey('role.IdRole'))
FirstName = db.Column(db.String(250), nullable=True)
LastName = db.Column(db.String(250), nullable=True)
Email = db.Column(db.String(250), nullable=True)
PhoneNumber = db.Column(db.String(250), nullable=True)
Address = db.Column(db.String(250), nullable=True)
Pasword = db.Column(db.String(250), nullable=True)
CreatedAt = db.Column(db.DateTime, nullable=False)
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
role = db.relationship('Role', backref="Users")
situation = db.relationship('Situation', backref='Users')
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.IdUser}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except TypeError:
print('Type error in verify reset token')
except Exception as e:
print("Error '{0}' occurred. Arguments {1}.".format(
e.message, e.args))
finally:
if user_id is None:
user_id = None
return Users.query.get(user_id)
def __repr__(self):
return f"Users('{self.IdUser}','{self.IdRole},'{self.FirstName}','{self.LastName}','{self.Email}','{self.PhoneNumber}','{self.Address}','{self.Pasword}','{self.CreatedAt}','{self.Enabled}')"
def get_id(self):
return (self.IdUser)
class Tasks(db.Model):
__tablename__ = 'Tasks'
__bind_key__ = 'flask'
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime, default=datetime.utcnow)
ownerid = db.Column(db.Integer, db.ForeignKey('Users.id'))
marketid = db.Column(db.String(64), nullable=False)
taskid = db.Column(db.String(64), nullable=False)
taskicon = db.Column(db.String(64), nullable=False)
taskname = db.Column(db.String(64), nullable=False)
progress = db.Column(db.String(64), default='?/?')
completion = db.Column(db.Integer, default=0)
# repr method represents how one object of this datatable
# will look like
def __repr__(self):
return str(self.taskname)
