class Project(db.Model):
__tablename__ = "project"
id = db.Column("id", db.Integer(), primary_key=True)
name = db.Column("name", db.String(32), nullable=False, unique=True)
creator_user_id = db.Column(
"creator_user_id", db.Integer(), db.ForeignKey("user.id"), nullable=False
)
api_key = db.Column("api_key", db.String(32), nullable=False, unique=True)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
users = db.relationship(
"User", secondary=user_project_table, back_populates="projects"
)
data = db.relationship("Data", backref="Project")
labels = db.relationship("Label", backref="Project")
creator_user = db.relationship("User")
class LabelValue(db.Model):
__tablename__ = "label_value"
id = db.Column("id", db.Integer(), primary_key=True)
label_id = db.Column(
"label_id", db.Integer(), db.ForeignKey("label.id"), nullable=False
)
value = db.Column("value", db.String(200), nullable=False)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
__table_args__ = (
db.UniqueConstraint("label_id", "value", name="_label_id_value_uc"),
)
label = db.relationship("Label", backref="LabelValue")
segmentations = db.relationship(
"Segmentation", secondary=annotation_table, back_populates="values"
)
def set_label_value(self, value):
self.value = value
class Segmentation(db.Model):
__tablename__ = "segmentation"
id = db.Column("id", db.Integer(), primary_key=True)
data_id = db.Column(
"data_id", db.Integer(), db.ForeignKey("data.id"), nullable=False
)
start_time = db.Column("start_time", db.Float(), nullable=False)
end_time = db.Column("end_time", db.Float(), nullable=False)
transcription = db.Column("transcription", db.Text(), nullable=True)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
values = db.relationship(
"LabelValue", secondary=annotation_table, back_populates="segmentations",
)
def set_start_time(self, start_time):
self.start_time = start_time
def set_end_time(self, end_time):
self.end_time = end_time
def set_transcription(self, transcription):
self.transcription = transcription
def to_dict(self):
return {
"start_time": self.start_time,
"end_time": self.end_time,
"transcription": self.transcription,
"created_at": self.created_at,
"last_modified": self.last_modified,
}
class UserSong(db.Model):
__tablename__ = 'user_song'
user_id = db.Column('user_id',
db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'),
primary_key=True)
song_id = db.Column('song_id',
db.Integer(),
db.ForeignKey('song.id', ondelete='RESTRICT'),
primary_key=True)
time_played = db.Column('time_played', db.DateTime(), primary_key=True)
user = db.relationship("User",
backref=db.backref('user_song', lazy='dynamic'))
song = db.relationship("Song")
def __init__(self, user, song, time_played):
self.user = user
self.song = song
self.time_played = time_played
def __repr__(self):
return '<User %s Song %s>' % (self.user.username, self.song.spot_id)
class Role(db.Model):
__tablename__ = "role"
id = db.Column("id", db.Integer(), primary_key=True)
role = db.Column("role", db.String(30), index=True, unique=True, nullable=False)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
class LabelType(db.Model):
__tablename__ = "label_type"
id = db.Column("id", db.Integer(), primary_key=True)
type = db.Column("type", db.String(32), nullable=False, unique=True)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
class User(db.Model):
__tablename__ = "user"
id = db.Column("id", db.Integer(), primary_key=True)
username = db.Column("username",
db.String(128),
index=True,
unique=True,
nullable=False)
password = db.Column("password", db.String(100), nullable=False)
role_id = db.Column("role_id",
db.Integer(),
db.ForeignKey("role.id"),
nullable=False)
created_at = db.Column("created_at",
db.DateTime(),
nullable=False,
default=db.func.now())
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
role = db.relationship("Role")
projects = db.relationship("Project",
secondary=user_project_table,
back_populates="users")
def set_role(self, role_id):
self.role_id = role_id
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Label(db.Model):
__tablename__ = "label"
id = db.Column("id", db.Integer(), primary_key=True)
name = db.Column("name", db.String(32), nullable=False)
project_id = db.Column("project_id",
db.Integer(),
db.ForeignKey("project.id"),
nullable=False)
type_id = db.Column("type_id",
db.Integer(),
db.ForeignKey("label_type.id"),
nullable=False)
created_at = db.Column("created_at",
db.DateTime(),
nullable=False,
default=db.func.now())
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
label_type = db.relationship("LabelType", backref="Label")
label_values = db.relationship("LabelValue", backref="Label")
__table_args__ = (db.UniqueConstraint("name",
"project_id",
name="_name_project_id_uc"), )
def set_label_type(self, label_type_id):
self.type_id = label_type_id
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return "%s %s" % (self.first_name, self.last_name)
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
confirmed_at = db.Column(db.DateTime(), default=datetime.datetime.utcnow())
roles = db.relationship('Role', secondary=roles_users,
backref=db.backref('user', lazy='dynamic'))
def __str__(self):
return "{}, {}".format(self.last_name, self.first_name)
class ResultsMetricsBase(db.Model):
__tablename__ = 'ResultsMetrics'
idResultsMetrics = db.Column(db.Integer, primary_key=True)
oximetry = db.Column(db.String(45), nullable=True)
heart = db.Column(db.String(45), nullable=True)
temperature = db.Column(db.String(45), nullable=True)
date_results = db.Column(db.DateTime(), nullable=True)
User_idUser = db.Column(db.Integer, db.ForeignKey('User.idUser'))
User_Devices_idDevices = db.Column(db.Integer, db.ForeignKey('User.Devices_idDevices'))
User_UserSettings_idUserSettings = db.Column(db.Integer, db.ForeignKey('User.UserSettings.idUserSettings'))
def __init__(self, *args, **kwargs):
for (attr_name, value) in kwargs.items():
setattr(self, attr_name, value)
def __repr__(self):
return "<ResultsMetrics%r>" % self.idResultsMetrics
class Message(db.Model):
message_id = db.Column(db.Integer(), primary_key=True)
content = db.Column(db.String(400), unique=False, nullable=False)
sender_id = db.Column(db.String(120), unique=False, nullable=False)
receiver_id = db.Column(db.String(120), unique=False, nullable=False)
timestamp = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.now())
conversation_id = db.Column(db.Integer,
db.ForeignKey('conversation.conversation_id'))
#attachments
def save_to_db(self):
db.session.add(self)
db.session.commit()
@staticmethod
def convert_to_datatime(time):
return datetime.datetime.fromtimestamp(time / 1000.0)
class ResultsMetricsHasAlertsBase(db.Model):
__tablename__ = 'ResultsMetrics_has_Alerts'
ResultMetrics_idResultsMetrics = db.Column(db.Integer, db.ForeignKey('ResultsMetrics.idResultsMetrics'))
ResultsMetrics_User_idUser = db.Column(db.Integer, db.ForeignKey('ResultsMetrics.User_idUSer'))
ResultsMetrics_User_Devices_idDevices = db.Column(db.Integer,
db.ForeignKey('ResultsMetrics.User_Devices_idDevices'))
ResultMetrics_User_UserSettings_idUserSettings = db.Column(
db.Integer, db.ForeignKey('ResultsMetrics.User_UserSettings_idUserSettings'))
Alerts_idAlerts = db.Column(db.Integer, db.ForeignKey('User.idUser'))
sendAlert = db.Column(db.Integer, nullable=True)
dateTimeLastSend = db.Column(db.DateTime(), nullable=True)
def __init__(self, *args, **kwargs):
for (attr_name, value) in kwargs.items():
setattr(self, attr_name, value)
def __repr__(self):
return "<ResultsMetricsHasAlerts%r>" % self.idResultsMetrics
from backend import db
annotation_table = db.Table(
"annotation",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
db.Column(
"segmentation_id",
db.Integer(),
db.ForeignKey("segmentation.id"),
nullable=False,
),
db.Column(
"label_value_id", db.Integer(), db.ForeignKey("label_value.id"), nullable=False
),
db.Column("created_at", db.DateTime(), nullable=False, default=db.func.now()),
db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
),
)
user_project_table = db.Table(
"user_project",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
db.Column("user_id", db.Integer(), db.ForeignKey("user.id"), nullable=False),
db.Column("project_id", db.Integer(), db.ForeignKey("project.id"), nullable=False),
class Data(db.Model):
__tablename__ = "data"
id = db.Column("id", db.Integer(), primary_key=True)
project_id = db.Column(
"project_id", db.Integer(), db.ForeignKey("project.id"), nullable=False
)
assigned_user_id = db.Column(
"assigned_user_id", db.Integer(), db.ForeignKey("user.id"), nullable=False
)
filename = db.Column("filename", db.String(100), nullable=False, unique=True)
original_filename = db.Column("original_filename", db.String(100), nullable=False)
reference_transcription = db.Column(
"reference_transcription", db.Text(), nullable=True
)
is_marked_for_review = db.Column(
"is_marked_for_review", db.Boolean(), nullable=False, default=False
)
created_at = db.Column(
"created_at", db.DateTime(), nullable=False, default=db.func.now()
)
last_modified = db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
)
project = db.relationship("Project")
assigned_user = db.relationship("User")
segmentations = db.relationship("Segmentation", backref="Data")
def update_marked_review(self, marked_review):
self.is_marked_for_review = marked_review
def set_segmentations(self, segmentations):
self.segmentations = segmentations
def to_dict(self):
return {
"original_filename": self.original_filename,
"filename": self.filename,
"url": f"/audios/{self.filename}",
"reference_transcription": self.reference_transcription,
"is_marked_for_review": self.is_marked_for_review,
"created_at": self.created_at,
"last_modified": self.last_modified,
"assigned_user": {
"id": self.assigned_user_id,
"username": self.assigned_user.username,
"role": self.assigned_user.role.role,
},
}
annotation_table = db.Table(
"annotation",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
db.Column(
"segmentation_id",
db.Integer(),
db.ForeignKey("segmentation.id"),
nullable=False,
),
db.Column("label_value_id",
db.Integer(),
db.ForeignKey("label_value.id"),
nullable=False),
db.Column("created_at",
db.DateTime(),
nullable=False,
default=db.func.now()),
db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
),
)
user_project_table = db.Table(
"user_project",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
