class Episode(db.Model):
id = db.Column(db.Integer, primary_key=True)
episodeJSONFileName = db.Column(db.String(30), nullable=False, unique=True)
def __init__(self, episodeJSONFileName):
self.episodeJSONFileName = episodeJSONFileName
def __repr__(self):
return '<id {}>'.format(self.id)
class Director(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
extras = db.Column(db.String(128))
movies = db.relationship('Movie', backref='writer', lazy='dynamic')
def __repr__(self):
return '<Director {}>'.format(self.name)
class Setting(db.Model):
""" represents persistent settings for the application """
__tablename__ = 'Settings'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
user_id = Column(Integer, ForeignKey('Users.id'))
key = db.Column(db.String(), nullable=False)
value = db.Column(db.String(), nullable=False)
class User(db.Model, UserMixin):
__searchable__ = ['username']
id = db.Column(db.Integer, primary_key=True)
joined_day = db.Column(db.DateTime, default=datetime.utcnow)
username = 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)
class TaskWebScheme(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
scheme_name = db.Column(db.String(50), nullable=False)
scheme_desc = db.Column(db.String(250), nullable=True)
def __init__(self, scheme_name, scheme_desc=None):
self.scheme_name = scheme_name
self.scheme_desc = scheme_desc
class Doctorpatient(db.Model, UserMixin):
__searchable__ = ['doctorname', 'patientname']
id = db.Column(db.Integer, primary_key=True)
doctorname = db.Column(db.String(20), unique=True, nullable=False)
patientname = db.Column(db.String(20), unique=True, nullable=False)
def __repr__(self):
return "Doctorpatient('{self.doctorname}','{self.patientname}')"
class Disease(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
diseasename = db.Column(db.String(20), unique=True, nullable=False)
chronic = db.Column(db.Boolean, unique=False, nullable=False)
speciality = db.Column(db.String, unique=False, nullable=False)
def __repr__(self):
return "Disease('{self.diseasename}','{self.chronic}','{self.speciality}')"
class PersonalInfo(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, default="")
is_public = db.Column(db.Boolean, default=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __str__(self):
return "Id: " + str(self.user_id) + ", name: " + self.name
class User(db.Model):
__tablename__ = "user"
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
login = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
access_level = db.Column(db.Integer, nullable=False)
personnel_number = db.Column(db.Integer,
db.ForeignKey('teacher.personnel_number',
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=True)
teacher = db.relationship("Teacher", back_populates="user")
def __init__(self, login, password, access_level=0, personnel_number=None):
self.login = login
self.password = flask_bcrypt.generate_password_hash(password).decode()
self.access_level = access_level
self.personnel_number = personnel_number
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password, password)
@staticmethod
def encode_auth_token(user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(
days=1, seconds=5), # TODO: edit expiration date
'iat':
datetime.datetime.utcnow(),
'sub':
user_id
}
return jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(
auth_token,
app.config.get('SECRET_KEY'),
)
return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class TaskRuleFamilyRef(db.Model):
__tablename__ = 'task_rule_family_ref'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
task_id = db.Column(db.Integer, nullable=False)
rule_family_id = db.Column(db.Integer, nullable=False)
def __init__(self, task_id, rule_family_id):
self.task_id = task_id
self.rule_family_id = rule_family_id
def ClassFactory(name):
tabledict = {
'id': db.Column(db.Integer, primary_key=True),
'timestamp': db.Column(db.DateTime, index=True, default=time),
'username': db.Column(db.String(64), index=True),
'messages': db.Column(db.String(256), index=True),
}
return type(name, (db.Model, ), tabledict)
class Token(db.Model):
__tablename__ = "token"
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.String(420), unique=True, nullable=False)
expire_on = db.Column(db.String(8), unique=False, nullable=False)
created_on = db.Column(db.String(8), unique=False, nullable=False)
def __repr__(self):
return f"Token<{self.id}, {self.expire_on}, {self.created_on}>"
class Entry(db.Model):
""" Represents an entry in the purse """
__tablename__ = 'Entries'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
game_session = db.Column(db.Integer)
description = db.Column(db.String(150), default='')
amount = db.Column(db.Float)
character_id = Column(Integer, ForeignKey('Characters.id'))
class Character(db.Model):
""" Represents a character """
__tablename__ = 'Characters'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40), nullable=False)
is_dead = db.Column(db.Boolean, default=False)
entries = relationship('Entry', backref='character')
user_id = Column(Integer, ForeignKey('Users.id'))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
datasets = db.relationship('Dataset', backref='by', lazy=True)
def __repr__(self):
return f'User({self.email})'
class FileDataPoint(db.Model):
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.Float, unique=False, nullable=False)
y = db.Column(db.Float, unique=False, nullable=False)
@staticmethod
def make_point(xx, yy):
''' Returns the FileDataPoint (x, y). '''
return FileDataPoint(x=float(round(xx, 3)), y=float(round(yy, 3)))
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), nullable=False, unique=True)
token = db.Column(db.String(1024))
tokenLeaseStart = db.Column(db.DateTime)
authenticated = db.Column(db.Boolean, default=False, nullable=False)
def __repr__(self):
return "<Local User {}>".format(self.username)
class Historial(db.Model):
__tablename__ = 'historial'
id = db.Column(db.BigInteger().with_variant(sqlite.INTEGER(), 'sqlite'),
primary_key=True,
autoincrement=True)
ts = db.Column(db.DateTime(timezone=True), server_default=func.now())
trigger = db.Column(db.String(50))
mensaje = db.Column(db.String(50))
class EducationalOrganization(db.Model):
__tablename__ = 'edu_orgs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(132), nullable=False, unique=True)
short_name = db.Column(db.String(10), nullable=False)
departments = db.relationship('Department', backref='edu_org')
classrooms = db.relationship('Classroom', backref='edu_org')
def __init__(self, name, short_name):
self.name = name
self.short_name = short_name
def save(self):
db.session.add(self)
db.session.commit()
def get_department(self, name=None, short_name=None):
if name is not None:
name = name.lower()
filtered = filter(lambda d: d.name.lower() == name, self.departments)
elif short_name is not None:
short_name = short_name.lower()
filtered = filter(lambda d: d.short_name.lower() == short_name, self.departments)
filtered = list(filtered)
if len(filtered) > 1:
raise DepartmentIsNotUniqueException('More than one department for a educational organization with definite name')
elif len(filtered) == 1:
return filtered[0]
else:
return None
def get_classroom(self, name):
name = name.lower()
classrooms = filter(lambda c: c.get_name().lower() == name.lower(), self.classrooms)
classrooms = list(classrooms)
if len(classrooms) > 1:
raise ClassroomIsNotUniqueException('More than one group for a department with definite name')
elif len(classrooms) == 1:
return classrooms[0]
else:
return None
@staticmethod
def get_all():
return EducationalOrganization.query.all()
@staticmethod
def get(id=None, name=None, short_name=None):
if id is not None:
return EducationalOrganization.query.filter_by(id=id).first()
if name is not None:
return EducationalOrganization.query.filter_by(name=name).first()
if short_name is not None:
return EducationalOrganization.query.filter_by(short_name=short_name).all()
return None
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), index=True)
author = db.Column(db.String(64), index=True)
genre = db.Column(db.String(64), index=True)
date = db.Column(db.Date)
def __repr__(self):
return '<Book {}>'.format(self.title)
class demo_video(db.Model):
id = db.Column(db.Integer, primary_key=True)
video_id = db.Column(db.String(100), nullable=False, unique=True)
def __init__(self, video_id):
self.video_id = video_id
def __repr__(self):
return '<video id %r>' % self.video_id
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True, nullable=False)
prof_img = db.Column(db.String(20), nullable=False,
default='default.jpg')
items = db.relationship('Products',
cascade='all,delete',
backref='category',
lazy=True)
class Control(db.Model):
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer, index=True)
language = db.Column(db.String(4), server_default='en', index=True)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(2048), nullable=False)
def __repr__(self):
return f'Control(number={self.number}, lang={self.language})'
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
items = db.relationship('Item', backref='category', lazy=True)
def __repr__(self):
return self.name
def all(self):
return [self.id, self.name]
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
language = db.Column(db.String, nullable=False)
content = db.Column(db.String, nullable=False)
user_id = db.Column(db.String, db.ForeignKey("user.id"), nullable=False)
def __repr__(self):
return f"<Project @user_id:{self.user_id}>"
class Ticker(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
subscriptions = db.relationship('TickerSubscription',
backref='ticker',
lazy='dynamic')
def __repr__(self):
return '<Ticker {}>'.format(self.name)
class Contact(db.Model):
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String(40),nullable=False)
first_name = db.Column(db.String(30),nullable=False)
last_name = db.Column(db.String(30),nullable=False)
phone_no = db.Column(db.String(20),nullable=False)
emails = db.relationship("Email",backref="contact",lazy=True)
def __str__(self):
return self.username
class WebRuleHttpCode(db.Model):
__tablename__ = 'web_rule_http_code'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
http_code = db.Column(db.Integer, nullable=False)
code_info = db.Column(db.String(200))
def __init__(self, http_code, code_info):
self.http_code = http_code
self.code_info = code_info
class Genres(db.Model):
__tablename__ = 'genres'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
version = db.Column(db.Integer, nullable=True)
__mapper_args__ = {'version_id_col': version}
def __init__(self, name, version=0):
self.name = name
self.version = version
class TaskRepModelRef(db.Model):
__tablename__ = 'task_rep_model_ref'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
task_id = db.Column(db.Integer, default=0, nullable=False)
rep_model_id = db.Column(db.Integer, default=0, nullable=False)
def __init__(self, task_id, rep_model_id):
self.task_id = task_id
self.rep_model_id = rep_model_id
