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 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 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 Hc(db.Model):
__tablename__ = "hcs"
__table_args__ = {'extend_existing': True}
hc_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40)) # Short HC name. Example: #powerdynamics
description = db.Column(db.String(500)) # Longer HC description
course = db.Column(db.String(10)) # Short Course name. Example: EA
mean = db.Column(db.String(4)) # Mean of HC score.
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 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 Postdevice(db.Model):
# make the device list for the posts and save in the SQLite database of Flask
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text, nullable=False)
crownID = db.Column(db.String(100), nullable=False)
macAddress = db.Column(db.String(100), nullable=False)
startDate = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
endDate = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
def __repr__(self):
return f"Postdevice('{self.name}', '{self.crownID}','{self.macAddress}', '{self.startDate}','{self.endDate}')"
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 Device(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
mac = db.Column(db.String(17), nullable=False)
data_measured = db.Column(db.String(30), nullable=False)
api_key = db.Column(db.String(32), unique=True, nullable=False)
dam_id = db.Column(db.Integer, db.ForeignKey('dam.id'), nullable=False)
data = db.relationship('Data', backref='collected_by', lazy=True)
def __repr__(self):
return f"Device({self.name}, {self.mac}, {self.data_measured})"
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 Person(db.Model):
__tablename__ = 'people'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
role = db.Column(db.String(64))
email = db.Column(db.String(255))
phone1 = db.Column(db.String(20))
phone2 = db.Column(db.String(20))
def __repr__(self):
return ('<Contact {}>'.format(self.name))
class Study(db.Model):
__tablename__ = 'studies'
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(12), index=True, unique=True)
name = db.Column(db.String(64))
scantypes = db.relationship('ScanType',
secondary=study_scantype_table,
back_populates='studies')
sites = db.relationship('Site',
secondary=study_site_table,
back_populates='studies')
sessions = db.relationship('Session')
description = db.Column(db.String(1024))
fullname = db.Column(db.String(1024))
primary_contact_id = db.Column(db.Integer, db.ForeignKey('people.id'))
primary_contact = db.relationship('Person')
users = db.relationship('User',
secondary=study_user_table,
back_populates='studies')
def __repr__(self):
return ('<Study {}>'.format(self.nickname))
def get_valid_metric_names(self):
"""return a list of metric names with duplicates removed"""
valid_fmri_scantypes = ['IMI', 'RST', 'EMP', 'OBS', 'SPRL', 'VN-SPRL']
names = []
for scantype in self.scantypes:
for metrictype in scantype.metrictypes:
if scantype.name.startswith('DTI'):
names.append(('DTI', metrictype.name))
elif scantype.name in valid_fmri_scantypes:
names.append(('FMRI', metrictype.name))
elif scantype.name == 'T1':
names.append(('T1', metrictype.name))
names = sorted(set(names))
return (names)
def session_count(self, type=None):
if type.lower() == 'human':
sessions = [
session for session in self.sessions if not session.is_phantom
]
elif type.lower() == 'phantom':
sessions = [
session for session in self.sessions if session.is_phantom
]
else:
sessions = [session for session in self.sessions]
return (len(sessions))
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 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 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 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 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 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)
author_name = db.Column(db.String(60), nullable=False)
author_role = db.Column(db.String(20), nullable=False)
def __repr__(self):
return f"Post('{self.title}', '{self.date_posted}')"
def __init__(self, title, content, author_name, author_role):
self.title = title
self.content = content
self.author_name = author_name
self.author_role = author_role
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 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 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)
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 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 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 Employee(UserMixin, db.Model):
"""
Create an Employee table
"""
# Ensures table will be named in plural and not in singular
# as is the name of the model
__tablename__ = 'employee'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(60), index=True, unique=True)
username = db.Column(db.String(60), index=True, unique=True)
first_name = db.Column(db.String(60), index=True)
last_name = db.Column(db.String(60), index=True)
password_hash = db.Column(db.String(228))
is_admin = db.Column(db.Boolean, default=False)
@property
def password(self):
"""
Prevent pasword from being accessed
"""
raise AttributeError('password is not a readable attribute.')
@password.setter
def password(self, password):
"""
Set password to a hashed password
"""
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
"""
Check if hashed password matches actual password
"""
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<Employee: {}>'.format(self.username)
class Car(db.Model):
"""
Create a Role table
"""
_tablename_ = 'cars'
id = db.Column(db.Integer, primary_key=True)
vendeur = db.Column(db.String(60))
constructeur = db.Column(db.String(60))
modele = db.Column(db.String(60))
kilometrage = db.Column(db.String(60))
carburant = db.Column(db.String(60))
annee = db.Column(db.String(60))
localisation = db.Column(db.String(60))
contact = db.Column(db.String(60))
transmission = db.Column(db.String(60))
prix = db.Column(db.Float)
vendeur = db.Column(db.String(60))
def _repr_(self):
return '<Car: {}>'.format(self.vendeur)
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 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))
