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 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 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 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 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 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 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) 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 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 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 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 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 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 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 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 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)
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()