class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
private = db.Column(db.Boolean, default=False)
posts = db.relationship('Blog', backref='user', lazy=False)
def __int__(self, user_id, username):
self.user_id = user_id
self.username = username
self.private = False
#get user by id
@classmethod
def find_by_id(cls, user_id):
return cls.query.filter_by(user_id = user_id).first()
def to_object(self):
return {
"user_id": self.user_id,
"username": self.username,
"private": self.private,
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Exam(db.Model):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
description = db.Column(db.String(250), nullable=False)
date = db.Column(db.String(50), nullable=True)
score = db.Column(db.String(2), nullable=True)
# parent
subject_id = db.Column(db.Integer,
db.ForeignKey('subject.id'),
nullable=False)
def __repr__(self):
return f"Exam('{self.description}', '{self.date}', '{self.score}')"
def serialize(self):
d = Serializer.serialize(self)
del d['subject']
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class TrainingSession(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(ct.NAME_LEN), unique=True, index=True)
weights_save_path = db.Column(db.String(ct.SAVE_PATH_LEN))
epochs = db.Column(db.Integer)
clean_dataset_id = db.Column(db.Integer, db.ForeignKey("dataset.id"))
noisy_dataset_id = db.Column(db.Integer, db.ForeignKey("dataset.id"))
denoiser_id = db.Column(db.Integer, db.ForeignKey("denoiser.id"))
learning_stategy_id = db.Column(db.Integer, db.ForeignKey("learning_strategy.id"), nullable=True)
completed_epochs = db.Column(db.Integer, default=0)
last_loss = db.Column(db.Float, default=2**30)
def __repr__(self):
return "<TrainingSession {0}>.".format(
str(self.id) + ";;" + self.name + ";;" + str(self.epochs) + ";;" + str(self.clean_dataset_id) + ";;" + str(self.noisy_dataset_id) + ";;" + str(self.denoiser_id)
)
def as_dict(self):
training_session_dict = {
'id': self.id,
'name': self.name,
'epochs': self.epochs,
'clean_dataset_id': self.clean_dataset_id,
'noisy_dataset_id': self.noisy_dataset_id,
'denoiser_id': self.denoiser_id,
'completed_epochs': self.completed_epochs,
'last_loss': self.last_loss
}
return training_session_dict
class User(db.Model, UserMixin):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
email = db.Column(db.String(250), unique=True, nullable=False)
security_social_number = db.Column(db.String(250),
unique=True,
nullable=False)
password = db.Column(db.String(250), nullable=False)
# son
appointment = db.relationship('Appointment', backref='user', lazy=True)
def __repr__(self):
return f"User('email: {self.email}', 'social_security_number: {self.social_security_number}')"
def serialize(self):
d = Serializer.serialize(self)
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class Worker(db.Model, UserMixin):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
email = db.Column(db.String(250), unique=True, nullable=False)
security_social_number = db.Column(db.String(250),
unique=True,
nullable=False)
password = db.Column(db.String(250), nullable=False)
worker_id = db.Column(db.String(250), unique=True, nullable=False)
def __repr__(self):
return f"Worker('email: {self.email}', 'social_security_number: {self.social_security_number}', 'worker_id: {self.worker_id}')"
def serialize(self):
d = Serializer.serialize(self)
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class User(db.Model, UserMixin):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
dni = db.Column(db.Integer, unique=True, nullable=False)
legajo = db.Column(db.Integer, unique=True, nullable=False)
name = db.Column(db.String(250), nullable=False)
password = db.Column(db.String(250), nullable=False)
# son
subjects = db.relationship('Subject', backref='user', lazy=True)
def __repr__(self):
return f"User('dni: {self.dni}', 'name: {self.name}', 'legajo: {self.legajo}')"
def serialize(self):
d = Serializer.serialize(self)
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class Login(db.Model):
__bind_key__ = 'auth'
user_id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(80), unique = True, nullable = False)
password = db.Column(db.String(80), nullable = False)
moderator = db.Column(db.Boolean, default = False)
def __init__(self,username, plaintext_password, moderator = False):
self.username = username
self.password = bcrypt.generate_password_hash(plaintext_password)
self.moderator = moderator
#add user to db
def save_to_db(self):
db.session.add(self)
db.session.commit()
new_user = User(
user_id = self.user_id,
username = self.username)
new_user.save_to_db()
#get user by username
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username = username).first()
#password handling
def set_password(self, plaintext_password): #for testing password hashing
self.password = bcrypt.generate_password_hash(plaintext_password)
def is_correct_password(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
class NoiseGenerator(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(ct.NAME_LEN), unique=True, index=True)
save_path = db.Column(db.String(ct.SAVE_PATH_LEN))
def __repr__(self):
return "<Dataset {0}>.".format(
str(self.id) + ";;" + self.name
)
class Accident(db.Model):
id = db.Column(db.Integer, primary_key=True)
location = db.Column(db.JSON, nullable=False)
n_people = db.Column(db.Integer, nullable=False, default=0)
n_cars_involved = db.Column(db.Integer, nullable=False, default=0)
damage = db.Column(db.Float, default=0.0)
n_people_injured = db.Column(db.Integer, default=0)
video_location = db.Column(db.String, nullable=True)
video_id = db.Column(db.Integer, nullable=False)
date = db.Column(db.DateTime, default=datetime.now)
cars = db.relationship('Car', backref='car', lazy=True)
def __init__(self,
location,
video_id,
n_people=0,
n_cars_involved=0,
n_people_injured=0,
damage=0.0):
self.location = location
self.video_id = video_id
self.n_people = n_people
self.n_cars_involved = n_cars_involved
self.n_people_injured = n_people_injured
self.damage = damage
class Revoked_Token(db.Model):
__tablename__ = 'revoked_tokens'
__bind_key__ = 'auth'
id = db.Column(db.Integer, primary_key = True)
jti = db.Column(db.String(120))
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti = jti).first()
return bool(query)
class Dataset(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(ct.NAME_LEN), unique=True, index=True)
description = db.Column(db.String(ct.DESCRIPTION_LEN))
save_path = db.Column(db.String(ct.SAVE_PATH_LEN))
# training_sessions = db.relationship('TrainingSession', backref='dataset', lazy='dynamic')
def __repr__(self):
return "<Dataset {0}>.".format(
str(self.id) + ";;" + self.name + ";;" + self.description
)
def as_dict(self):
dataset_dict = {
'id': self.id,
'name': self.name,
'description': self.description
}
return dataset_dict
class Appointment(db.Model):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
day = db.Column(db.String(50), nullable=False)
initial_hour = db.Column(db.String(50), nullable=False)
final_hour = db.Column(db.String(50), nullable=False)
# parent
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
appointment_type = db.Column(db.Integer,
db.ForeignKey('appointmenttype.id'),
nullable=True)
def __repr__(self):
return f"Appointment('Day: {self.day}', 'From: {self.initial_hour}', 'To: {self.final_hour}')"
def serialize(self):
d = Serializer.serialize(self)
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class Appointmenttype(db.Model):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
name = db.Column(db.String(50), nullable=False)
initial_hour = db.Column(db.String(50), nullable=False)
final_hour = db.Column(db.String(50), nullable=False)
duration = db.Column(db.String(10), nullable=False)
spots = db.Column(db.String(10), nullable=False)
# son
appointment = db.relationship('Appointment',
backref='Appointmenttype',
lazy=True)
def __repr__(self):
return f"Appointment Type('Name: {self.name}', 'From: {self.initial_hour}', 'To: {self.final_hour}', 'Duration: {self.duration}', 'Spots: {self.spots}')"
def serialize(self):
d = Serializer.serialize(self)
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class Subject(db.Model):
id = db.Column('id',
db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
name = db.Column(db.String(250), nullable=False)
theory_ddhhhh = db.Column(db.String(6), nullable=True)
practice_ddhhhh = db.Column(db.String(6), nullable=True)
division = db.Column(db.String(3), nullable=False)
score = db.Column(db.String(2), nullable=True)
condition = db.Column(db.String(10), nullable=False)
theory_professor = db.Column(db.String(250), nullable=True)
practice_professor = db.Column(db.String(250), nullable=True)
# parent
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
# children
exams = db.relationship('Exam', backref='subject', lazy=True)
tasks = db.relationship('Task', backref='subject', lazy=True)
def __repr__(self):
return f"Subject('{self.name}', '{self.division}', '{self.score}', '{self.condition}'," \
f"'{self.practice_ddhhhh}', '{self.theory_ddhhhh}', '{self.theory_professor}', '{self.practice_professor}')"
def serialize(self):
d = Serializer.serialize(self)
del d['user']
return d
@staticmethod
def serialize_list(elements):
d = Serializer.serialize_list(elements)
return d
class Dataset(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
exposure_method = db.Column(db.String(30), nullable=False)
outlier_fraction = db.Column(db.Float(), nullable=False)
dataset_location = db.Column(db.String(1000), nullable=False)
pickle_location = db.Column(db.String(1000), nullable=False)
def __repr__(self):
return f"Dataset('{self.name}', '{self.exposure_method}, {self.outlier_fraction}, {self.location}')"
class Car(db.Model):
id = db.Column(db.Integer, primary_key=True)
velocity = db.Column(db.Float, default=0.0)
n_people = db.Column(db.Integer, default=0)
temperature = db.Column(db.Float, default=0.0)
airbag = db.Column(db.Boolean)
ABS = db.Column(db.Boolean) # , nullable=False)
overturned = db.Column(db.Boolean) # , nullable=False)
damage = db.Column(db.Float, default=0.0)
accident_id = db.Column(db.Integer,
db.ForeignKey('accident.id'),
nullable=False)
def __init__(self, velocity, n_people, temperature, airbag, ABS,
overturned, damage):
self.velocity = velocity
self.n_people = n_people
self.temperature = temperature
self.airbag = airbag
self.ABS = ABS
self.overturned = overturned
self.damage = damage
class DBCall(db.Model):
id = db.Column(db.Integer, primary_key=True)
# Not storing the phone number!
timestamp = db.Column(db.DateTime)
language = db.Column(db.String) # "" if not answered
answer_1 = db.Column(db.Integer) # 0 if not answered
answer_2 = db.Column(db.Integer) # 0 if not answered
zip_code = db.Column(db.String) # "" if not answered
def __repr__(self):
return f"DBCall(id: {self.id}, " \
f"timestamp: {self.timestamp.strftime('%d.%m.%Y, %H:%M:%S')}, " \
f"language: \"{self.language}\", " \
f"answer_1: {self.answer_1}, " \
f"answer_2: {self.answer_2}, " \
f"zip_code: \"{self.zip_code}\")"
class Denoiser(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(ct.NAME_LEN), unique=True, index=True)
description = db.Column(db.String(ct.DESCRIPTION_LEN))
structure = db.Column(db.String(ct.STRING_MAX_LEN))
trainable = db.Column(db.Boolean)
save_path = db.Column(db.String(ct.SAVE_PATH_LEN))
training_sessions = db.relationship('TrainingSession', backref='denoiser', lazy='dynamic')
def __repr__(self):
return "<Denoiser {0}>.".format(
str(self.id) + ";;" + self.name + ";;" + self.description + ";;" + str(self.trainable)
)
def as_dict(self):
denoiser_dict = {
'id': self.id,
'name': self.name,
'description': self.description,
'structure': json.loads(self.structure)
}
return denoiser_dict
class Blog(db.Model):
post_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'), nullable=False)
title = db.Column(db.String(80), nullable=False)
content = db.Column(db.String(500), nullable=False)
popularity = db.Column(db.Integer, default=0)
tag = db.Column(db.String, nullable=False)
created = db.Column(db.DateTime, default=datetime.today())
flagged = db.Column(db.Integer, default=False)
def __init__(self, user_id, title, content, tag, created=datetime.today(), popularity=0, flagged = False):
self.user_id = user_id
self.title = title
self.content = content
self.tag = tag
self.created = created
self.popularity = popularity
self.flagged = flagged
def to_object(self):
return {
"post_id": self.post_id,
"user_id": self.user_id,
"title": self.title,
"content": self.content,
"popularity": self.popularity,
"tag": self.tag,
"created": self.created,
"flagged": self.flagged,
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
#update by id
@classmethod
def edit_by_id(cls, id, title, content, tag, popularity):
edit_blog =cls.find_by_id(id)
edit_blog.title = title
edit_blog.content = content
edit_blog.popularity = popularity
edit_blog.save_to_db()
#get post by id
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(post_id = id).first()
#delete post by id
@classmethod
def delete_by_id(cls,id):
cls.query.filter_by(post_id=id).delete()
db.session.commit()
#get all posts by filter
@classmethod
def find_posts(cls, filter="pop"):
if(filter == "pop"):
return cls.query.order_by(cls.popularity.desc()).limit(10).all()
elif(filter == "unpop"):
return cls.query.order_by(cls.popularity.asc()).limit(10).all()
elif(filter == "new"):
return cls.query.order_by(cls.created.desc()).limit(10).all()
elif(filter == "old"):
return cls.query.order_by(cls.created.asc()).limit(10).all()
@classmethod
def find_user_posts(cls,user_id, filter="new"):
if(filter == "pop"):
return cls.query.filter(cls.user_id == user_id).order_by(cls.popularity.desc()).all()
elif(filter == "unpop"):
return cls.query.filter(cls.user_id == user_id).order_by(cls.popularity.asc()).all()
elif(filter == "new"):
return cls.query.filter(cls.user_id == user_id).order_by(cls.created.desc()).all()
elif(filter == "old"):
return cls.query.filter(cls.user_id == user_id).order_by(cls.created.asc()).all()
#get all posts for a tag
@classmethod
def find_tag_posts(cls, tag, filter="pop"):
if(filter == "pop"):
return cls.query.filter(cls.tag == tag).order_by(cls.popularity.desc()).limit(10).all()
elif(filter == "unpop"):
return cls.query.filter(cls.tag == tag).order_by(cls.popularity.asc()).limit(10).all()
elif(filter == "new"):
return cls.query.filter(cls.tag == tag).order_by(cls.created.desc()).limit(10).all()
elif(filter == "old"):
return cls.query.filter(cls.tag == tag).order_by(cls.created.asc()).limit(10).all()
class LearningStrategy(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(ct.NAME_LEN), unique=True, index=True)
description = db.Column(db.String(ct.DESCRIPTION_LEN))
save_path = db.Column(db.String(ct.SAVE_PATH_LEN))
class Stock(db.Model):
name = db.Column(db.String(64), primary_key=True)
class Index(db.Model):
name = db.Column(db.String(64), primary_key=True)
