class OrdersMaintenance(db.Model):
IdOrder = db.Column(db.Integer, primary_key=True)
OrderNumber = db.Column(db.String(250), nullable=True)
FirstName = db.Column(db.String(250), nullable=True)
LastName = db.Column(db.String(250), nullable=True)
PhoneNumber = db.Column(db.String(250), nullable=True)
Email = db.Column(db.String(250), nullable=True)
Address = db.Column(db.String(250), nullable=True)
IdService = db.Column(db.Integer, db.ForeignKey('service.IdService'))
IdAgent = db.Column(db.Integer, db.ForeignKey('agent.IdAgent'))
Price = db.Column(db.String(250), nullable=True)
IdPriority = db.Column(db.Integer, db.ForeignKey('priority.IdPriority'))
latit = db.Column(db.String(250), nullable=True)
lon = db.Column(db.String(250), nullable=True)
IdOrderStatus = db.Column(db.Integer,
db.ForeignKey('order_status.IdOrderStatus'))
Ordertime = db.Column(db.String(250), nullable=True)
Time = db.Column(db.Integer, db.ForeignKey('time.IdTime'))
Comment = db.Column(db.String(250), nullable=True)
CreatedAt = db.Column(db.DateTime, nullable=False)
service = db.relationship("Service", backref="OrdersMaintenance")
priority = db.relationship("Priority", backref="OrdersMaintenance")
status = db.relationship("OrderStatus", backref="OrdersMaintenance")
time = db.relationship("Time", backref="OrdersMaintenance")
agent = db.relationship("Agent", backref="OrdersMaintenance")
def __repr__(self):
return f"OrdersMaintenance('{self.IdOrder}',{self.OrderNumber}','{self.FirstName}','{self.LastName}','{self.PhoneNumber}','{self.Email}','{self.IdService}','{self.Price}','{self.IdPriority}','{self.IdOrderStatus}','{self.Ordertime}','{self.Time}','{self.IdAgent}','{self.latit}','{self.lon}','{self.Comment}')"
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 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 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 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 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 ScanComment(db.Model):
__tablename__ = 'scan_comments'
id = db.Column(db.Integer, primary_key=True)
scan_id = db.Column(db.Integer, db.ForeignKey('scans.id'), nullable=False)
scan = db.relationship('Scan', back_populates="analysis_comments")
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', back_populates="analysis_comments")
analysis_id = db.Column(db.Integer,
db.ForeignKey('analyses.id'),
nullable=False)
analysis = db.relationship('Analysis', back_populates="analysis_comments")
excluded = db.Column(db.Boolean, default=False)
comment = db.Column(db.String)
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 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 OrdersCleaning(db.Model):
IdOrder = db.Column(db.Integer, primary_key=True)
OrderNumber = db.Column(db.String(250), nullable=True)
FirstName = db.Column(db.String(250), nullable=True)
LastName = db.Column(db.String(250), nullable=True)
PhoneNumber = db.Column(db.String(250), nullable=True)
Email = db.Column(db.String(250), nullable=True)
Address = db.Column(db.String(250), nullable=True)
Service = db.Column(db.String(250), nullable=True)
Price = db.Column(db.String(250), nullable=True)
BookingType = db.Column(db.Integer, nullable=True)
IdOrderStatus = db.Column(db.Integer,
db.ForeignKey('order_status.IdOrderStatus'))
Time = db.Column(db.String(250), nullable=True)
latit = db.Column(db.String(250), nullable=True)
lon = db.Column(db.String(250), nullable=True)
Maid = db.Column(db.String(250), nullable=True)
OrderDate = db.Column(db.String(250), nullable=True)
Comment = db.Column(db.String(250), nullable=True)
CreatedAt = db.Column(db.DateTime, nullable=False)
status = db.relationship("OrderStatus", backref="OrdersCleaning")
def __repr__(self):
return f"OrdersCleaning('{self.IdOrder}',{self.OrderNumber}','{self.FirstName}','{self.LastName}','{self.PhoneNumber}','{self.Email}','{self.Service}','{self.Price}','{self.Maid}','{self.OnceDate}','{self.BookingType}','{self.IdOrderStatus}','{self.Ordertime}','{self.Time}','{self.Comment}','{self.StartDate}','{self.latit}','{self.lon}','{self.EndDate}')"
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 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 Agent(db.Model):
IdAgent = db.Column(db.Integer, primary_key=True)
FirstName = db.Column(db.String(250), nullable=True)
LastName = db.Column(db.String(250), nullable=True)
Password = db.Column(db.String(250), nullable=True)
PhoneNumber = db.Column(db.String(250), nullable=True)
Address = db.Column(db.String(250), nullable=True)
IdService = db.Column(db.Integer, db.ForeignKey('service.IdService'))
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
Time = db.Column(db.Integer, db.ForeignKey('time.IdTime'))
lat = db.Column(db.String(250), nullable=True)
lon = db.Column(db.String(250), nullable=True)
CreatedAt = db.Column(db.DateTime, nullable=False)
service = db.relationship('Service', backref="Agent")
time = db.relationship('Time', backref="Agent")
situation = db.relationship('Situation', backref='Agent')
def __repr__(self):
return f"Agent('{self.IdAgent}',{self.FirstName}','{self.LastName}','{self.Password}','{self.PhoneNumber}','{self.Address}','{self.IdService}','{self.Time}',,'{self.lat}','{self.lon}','{self.CreatedAt}')"
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 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 Products(db.Model):
IdProduct = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(250), nullable=True)
Description = db.Column(db.String(250), nullable=True)
Benefit = db.Column(db.String(250), nullable=True)
Usage = db.Column(db.String(250), nullable=True)
ImageUrl = db.Column(db.String(250), nullable=True)
IdSize = db.Column(db.Integer, db.ForeignKey('size.IdSize'))
IdUser = db.Column(db.Integer, db.ForeignKey('users.IdUser'))
Enabled = db.Column(db.Integer, db.ForeignKey('situation.IdSituation'))
IdCategory = db.Column(db.Integer, db.ForeignKey('categories.IdCategory'))
Price = db.Column(db.String(250), nullable=True)
CreatedAt = db.Column(db.DateTime, nullable=False)
size = db.relationship("Size", backref="Products")
user = db.relationship('Users', backref="Products")
cat = db.relationship('Categories', backref="Products")
situation = db.relationship('Situation', backref='Products')
def __repr__(self):
return f"Products('{self.IdProduct}',{self.Name}','{self.Description}','{self.Benefit}','{self.Usage}','{self.ImageUrl}','{self.IdSize}','{self.Enabled}','{self.IdUser}','{self.IdCategory}','{self.Price}','{self.CreatedAt}')"
@property
def serialize(self):
"""Return object data in easily serializable format"""
return {
'IdProduct': self.IdProduct,
'Name': self.Name,
'Description': self.Description,
'Benefit': self.Benefit,
'ImageUrl': self.ImageUrl,
'IdSize': self.size.Size,
'IdCategory': self.cat.Category,
'Enabled': self.Enabled,
'Price': self.Price,
'CreatedAt': self.CreatedAt
}
class LoGrade(db.Model):
__tablename__ = "lo_grades"
grade_id = db.Column(db.Integer, primary_key=True)
lo_id = db.Column(db.Integer, db.ForeignKey(Lo.lo_id))
user_id = db.Column(db.Integer, db.ForeignKey(Lo.user_id))
score = db.Column(db.Integer) # Score (1-5)
weight = db.Column(db.Integer) # Score Weight
time = db.Column(db.DateTime) # Date and time the score was received
assignment = db.Column(db.Boolean) # Whether the score was received for an assignment
__table_args__ = (db.ForeignKeyConstraint([lo_id, user_id],
[Lo.lo_id, Lo.user_id]),
{'extend_existing': True})
lo = db.relationship("Lo", foreign_keys=[lo_id, user_id], back_populates="grades")
class HcGrade(db.Model):
__tablename__ = "hc_grades"
grade_id = db.Column(db.Integer, primary_key=True)
hc_id = db.Column(db.Integer, db.ForeignKey('hcs.hc_id'))
user_id = db.Column(db.Integer, db.ForeignKey('hcs.user_id'))
score = db.Column(db.Integer) # Score (1-5)
weight = db.Column(db.Integer) # Score Weight
time = db.Column(db.DateTime) # Date and time the grade was received
assignment = db.Column(db.Boolean) # Whether the grade was received for an assignment
transfer = db.Column(db.Boolean) # Whether the grade counts for transfer
__table_args__ = (db.ForeignKeyConstraint([hc_id, user_id],
[Hc.hc_id, Hc.user_id]),
{'extend_existing': True})
hc = db.relationship("Hc", foreign_keys=[hc_id, user_id], back_populates="grades")
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 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 User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True)
password = db.Column(db.String(128), nullable=False)
nickname = db.Column(db.String(128))
coin = db.Column(db.Integer, default=1000)
level = db.Column(db.Integer, default=1)
hero = db.relationship('Player_Hero', backref='user', lazy=True)
def __init__(self, username, password, email, nickname):
self.username = username
self.password = password
self.email = email
self.nickname = nickname
def save_to_db(self):
try:
db.session.add(self)
db.session.commit()
return self
except:
return None
def delete_form_db(self):
try:
db.session.delete(self)
db.session.commit()
return self
except:
return None
def update_db(self):
try:
db.session.commit()
return True
except:
return False
@classmethod
def get_user_by_username(self, username):
try:
user = User.query.filter_by(username=username).first()
return user
except:
return None
@classmethod
def get_user_by_email(self, email):
try:
user = User.query.filter_by(email=email).first()
return user
except:
return None
'''
def update_username(self, old_username, new_username):
try:
user = User.query.filter_by(username = old_username).first()
user.name = new_username
db.session.commit()
return user
except:
return None
'''
def buy_coin():
pass
@classmethod
def check_coin(self, user_coin, hero_price):
if user_coin >= hero_price:
return True
return False
@classmethod
def check_level(self, user_level, hero_level):
if user_level >= hero_level:
return True
return False
@classmethod
def get_coin(self, username):
try:
user = User.query.filter_by(username=username).first()
return user.coin
except:
return None
def update_coin(self, change):
self.coin += change
@classmethod
def get_nickname_by_username(self, username):
try:
user = User.query.filter_by(username=username).first()
return user.nickname
except:
return None
def set_level(self, username, new_level):
try:
user = User.query.filter_by(username=username).first()
user.level = new_level
db.session.commit()
return user
except:
return None
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
realname = db.Column(db.String(64))
username = db.Column(db.String(64), index=True)
email = db.Column(db.String(120), index=True)
studies = db.relationship('Study',
secondary=study_user_table,
back_populates='users')
is_admin = db.Column(db.Boolean, default=False)
has_phi = db.Column(db.Boolean, default=False)
analysis_comments = db.relationship('ScanComment')
incidental_findings = db.relationship('IncidentalFinding')
def get_studies(self):
# returns the list of studies that a user has access to
if self.is_admin:
studies = Study.query.order_by(Study.nickname).all()
else:
studies = self.studies
return (studies)
def has_study_access(self, study):
if not isinstance(study, Study):
# see is we can get by id
study = Study.query.get(study)
if not study:
study = Study.query.filter_by(nickname=study)
if self.is_admin or study in self.studies:
return True
else:
return
@staticmethod
def make_unique_nickname(nickname):
if User.query.filter_by(username=nickname).first() is None:
return nickname
version = 2
while True:
new_nickname = nickname + str(version)
if User.query.filter_by(username=new_nickname).first() is None:
break
version += 1
return new_nickname
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return True
def get_id(self):
try:
return unicode(self.id) # python 2
except:
return str(self.id) # python 3
def avatar(self, size):
if self.email:
return 'http://www.gravatar.com/avatar/{}?d=mm&s={}'.format(
md5(self.email.encode('utf-8')).hexdigest(), size)
else:
return 'http://www.gravatar.com/avatar/{}?d=mm&s={}'.format(
md5('this isnt here').hexdigest(), size)
class Scan(db.Model):
__tablename__ = 'scans'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), index=True, unique=True)
description = db.Column(db.String(128))
session_id = db.Column(db.Integer,
db.ForeignKey('sessions.id'),
nullable=False)
session = db.relationship('Session', back_populates='scans')
scantype_id = db.Column(db.Integer,
db.ForeignKey('scantypes.id'),
nullable=False)
scantype = db.relationship('ScanType', back_populates="scans")
metricvalues = db.relationship('MetricValue', cascade="all, delete-orphan")
bl_comment = db.Column(db.String(1024))
series_number = db.Column(db.Integer, nullable=False)
repeat_number = db.Column(db.Integer)
analysis_comments = db.relationship('ScanComment')
def __repr__(self):
return ('<Scan {}>'.format(self.name))
def is_blacklisted(self):
if self.bl_comment:
return True
@property
def comment_count(self):
return len(self.analysis_comments)
@validates('bl_comment')
def validate_comment(self, key, comment):
"""
check the comment isn't empty and that the blacklist.csv can be updated
"""
assert comment, 'Comment not provided for scan:{}'.format(self.name)
try:
utils.update_blacklist('{}_{}'.format(self.name, self.description),
comment,
study_name=self.session.study.nickname)
except:
logger.error('Failed updating blacklist for scan:{}'.format(
self.name))
return False
return comment
def get_file_path(self):
nii_path = utils.get_study_folder(study=self.session.study.nickname,
folder_type='nii')
file_name = '_'.join([self.name, self.description]) + '.nii.gz'
path = os.path.join(nii_path, self.session.name, file_name)
return (path)
def get_hcp_path(self):
"""
Returns the path to the scan hcp pipelines folder
False if subject folder doesnt exists
"""
hcp_path = utils.get_study_folder(study=self.session.study.nickname,
folder_type='hcp')
sub_path = os.path.join(hcp_path, 'qc_MNIfsaverage32k',
self.session.name)
if not os.path.isdir(sub_path):
return False
return sub_path
grade_id = db.Column(db.Integer, primary_key=True)
lo_id = db.Column(db.Integer, db.ForeignKey(Lo.lo_id))
user_id = db.Column(db.Integer, db.ForeignKey(Lo.user_id))
score = db.Column(db.Integer) # Score (1-5)
weight = db.Column(db.Integer) # Score Weight
time = db.Column(db.DateTime) # Date and time the score was received
assignment = db.Column(db.Boolean) # Whether the score was received for an assignment
__table_args__ = (db.ForeignKeyConstraint([lo_id, user_id],
[Lo.lo_id, Lo.user_id]),
{'extend_existing': True})
lo = db.relationship("Lo", foreign_keys=[lo_id, user_id], back_populates="grades")
Lo.grades = db.relationship("LoGrade", foreign_keys=[LoGrade.lo_id, LoGrade.user_id], back_populates="lo")
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.
# mean would ideally be a numeric but sqlite does not support numerics
class Session(db.Model):
__tablename__ = 'sessions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256))
date = db.Column(db.DateTime)
study_id = db.Column(db.Integer,
db.ForeignKey('studies.id'),
nullable=False)
study = db.relationship('Study', back_populates='sessions')
site_id = db.Column(db.Integer, db.ForeignKey('sites.id'), nullable=False)
site = db.relationship('Site', back_populates='sessions')
scans = db.relationship('Scan',
order_by="Scan.series_number",
cascade="all, delete-orphan")
is_phantom = db.Column(db.Boolean)
is_repeated = db.Column(db.Boolean)
repeat_count = db.Column(db.Integer)
last_repeat_qc_generated = db.Column(db.Integer, default=1)
last_repeat_qcd = db.Column(db.Integer)
cl_comment = db.Column(db.String(1024))
gh_issue = db.Column(db.Integer)
redcap_record = db.Column(db.Integer) # ID of the record in redcap
redcap_entry_date = db.Column(db.Date) # date of record entry in redcap
redcap_user = db.Column(
db.Integer) # ID of the user who filled in the redcap record
redcap_comment = db.Column(db.String(1024)) # Redcap comment field
redcap_url = db.Column(db.String(1024)) # URL for the redcap server
redcap_projectid = db.Column(db.Integer) # ID for redcap Project
redcap_instrument = db.Column(db.String(1024)) # name of the redcap form
incidental_findings = db.relationship('IncidentalFinding')
def __repr__(self):
return ('<Session {} from Study {} at Site {}>'.format(
self.name, self.study.nickname, self.site.name))
def is_qcd(self):
"""checks if session has (ever) been quality checked"""
if self.cl_comment:
return True
def is_current_qcd(self):
"""
checks if the most recent repeat of a session has been quality checked
"""
if self.last_repeat_qcd == self.repeat_count:
return True
def get_qc_doc(self):
"""Return the absolute path to the session qc doc if it exists"""
return (utils.get_qc_doc(str(self.name)))
def flush_changes(self):
"""Flush changes to the object back to the database"""
db.session.add(self)
db.session.commit()
def scan_count(self):
return len(self.scans)
@property
def incidental_finding(self):
return len(self.incidental_findings)
@validates('cl_comment')
def validate_comment(self, key, comment):
"""
check the comment isn't empty and that the checklist.csv can be updated
"""
assert comment
assert utils.update_checklist(self.name,
comment,
study_name=self.study.nickname)
self.last_repeat_qcd = self.repeat_count
return comment
