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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Player_Hero(db.Model):
id = db.Column(db.Integer, primary_key=True)
hero_id = db.Column(db.String(256), nullable=False)
energy = db.Column(db.Float, nullable=False)
active = db.Column(db.Boolean, default=False)
recovery_rate = db.Column(db.DateTime,
default=datetime.datetime.now() +
datetime.timedelta(minutes=30))
user_id = db.Column(db.String(),
db.ForeignKey('user.username'),
nullable=False)
def __init__(self, hero_id, energy, recovery_rate, user_id):
self.hero_id = hero_id
self.energy = energy
self.user_id = user_id
self.recovery_rate = recovery_rate
def save_to_db(self):
db.session.add(self)
db.session.commit()
return self
def delele_from_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_playerHero(self, username):
try:
player_hero = Player_Hero.query.filter_by(user_id=username)
hero_list = []
for hero in player_hero:
hero_list.append(int(hero.hero_id))
return hero_list
except:
return None
@classmethod
def get_active_playerHero(self, username):
try:
player_hero = Player_Hero.query.filter_by(user_id=username)
hero_list = []
for hero in player_hero:
if hero.active:
hero_list.append(int(hero.hero_id))
return hero_list
except:
return None
def get_oneHero(username, hero_id):
return Player_Hero.query.filter(
Player_Hero.user_id == username,
Player_Hero.hero_id == hero_id).first()
@classmethod
def get_exist_playerHero(self, username, hero_id):
try:
player_hero = self.get_oneHero(username, hero_id)
return player_hero
except:
return None
@classmethod
def boost_energy(self, username, hero_id):
try:
player_hero = self.get_oneHero(username, hero_id)
hero = Hero.get_hero_by_heroID(hero_id)
player_hero.energy = hero.energy
return player_hero
except:
return None
@classmethod
def start_game(self, username, hero1, hero2, hero3):
player_hero = Player_Hero.query.filter_by(user_id=username)
hero_list = []
for hero in player_hero:
if (hero.hero_id == hero1 or hero.hero_id == hero2
or hero.hero_id == hero3):
if (hero.energy > 0):
hero.energy -= 1
hero_list.append(hero.hero_id)
hero.active = True
if self.update_db(self):
return hero_list
return None
#balad nistam khob :)
def update_energy_by_username(self, username):
player_hero = Player_Hero.query.filter_by(user_id=username).first()
for hero in player_hero:
if (datetime.datetime.now() > hero.recovery_rate()):
hero.energy += 1
hero.recovery_rate = datetime.datetime.now(
) + datetime.timedelta(minutes=30)
db.session.commit()
Object definition file for dashboard app
"""
from dashboard import db
import utils
from hashlib import md5
from sqlalchemy.orm import validates
from flask_login import UserMixin
import os
import logging
logger = logging.getLogger(__name__)
study_site_table = db.Table(
'study_site', db.Column('study_id', db.Integer,
db.ForeignKey('studies.id')),
db.Column('site_id', db.Integer, db.ForeignKey('sites.id')))
study_scantype_table = db.Table(
'study_scantypes',
db.Column('study_id', db.Integer, db.ForeignKey('studies.id')),
db.Column('scantype_id', db.Integer, db.ForeignKey('scantypes.id')))
study_people_table = db.Table(
'study_people',
db.Column('study_id', db.Integer, db.ForeignKey('studies.id')),
db.Column('person_id', db.Integer, db.ForeignKey('people.id')))
study_user_table = db.Table(
'study_users',
db.Column('study_id', db.Integer, db.ForeignKey('studies.id')),
db.Column('user_id', db.Integer, db.ForeignKey('users.id')))
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
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
