class Task(db.Model):
# look primary key is STRING not Integer WTF!? :D
# because this id is NOT SQLAlchemy id
# but RQ job identificator
id = db.Column(db.String(36), primary_key=True)
name = db.Column(db.String(128), index=True)
description = db.Column(db.String(128))
complete = db.Column(db.Boolean, default=False)
def get_rq_job(self):
try:
rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis)
except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError):
return None
return rq_job
def get_progress(self):
job = self.get_rq_job()
return job.meta.get('progress', 0) if job is not None else 100
@classmethod
def launch_task(cls, name, description):
rq_job = current_app.task_queue.enqueue('app.tasks.' + name)
print('\n---job_id!!')
print(rq_job.get_id())
task = cls(id=rq_job.get_id(), name=name, description=description)
print(task)
db.session.add(task)
print('----')
return task
class WishModel(BaseModel, db.Model):
"""
Wish Model
"""
__tablename__ = 'wishes'
__table_args__ = (db.UniqueConstraint('name', 'owner_id', 'is_active'), )
name = db.Column(db.String(128), nullable=False)
price = db.Column(db.Numeric, nullable=False)
description = db.Column(db.String(256), nullable=True)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
def __init__(self,
name: str,
price: float,
owner_id: int,
description: str = None):
self.name = name
self.price = abs(price)
self.owner_id = owner_id
self.description = description
super(WishModel, self).__init__()
def __str__(self):
return '{} - {} - $ {}'.format(self.id, self.name, self.price)
class Account(db.Model):
__tablename__ = "accounts"
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(50), nullable=False)
lastname = db.Column(db.String(50), nullable=False)
username = db.Column(db.String(50), nullable=False)
password = db.Column(db.Text, nullable=False)
customer = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.true())
developer = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.false())
admin = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.false())
active = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.true())
def __init__(self, firstname, lastname, username, password):
self.firstname = firstname
self.lastname = lastname
self.username = username
self.password = password
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_name = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(50), nullable=False)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(20), nullable=False)
password = db.Column(BYTEA)
interests = db.relationship('Interest', secondary=user_interests)
friendship = db.relationship('Friendship', secondary=user_friendship)
def serialize_short(self):
return {
'id':
self.id,
'user_name':
self.user_name,
'first_name':
self.first_name,
'last_name':
self.last_name,
'email':
self.email,
'interests':
[interest.serialize_short() for interest in self.interests]
}
class Auditable(db.Model):
__abstract__ = True
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
created_by = db.Column(db.String(64))
updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
updated_by = db.Column(db.String(64))
class Images(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80)) # TODO create a unique index
path = db.Column(db.String(1024))
def serialize(self):
ret = dict()
ret['name'] = self.name
ret['path'] = self.path
return ret
@classmethod
def update(cls, model, path, name):
model.name = name
model.path = path
db.session.commit()
return model
@classmethod
def create(cls, path, name):
model = cls()
model.name = name
model.path = path
db.session.add(model)
db.session.commit()
return model
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), index=True, unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
def __init__(self, email, password):
self.email = email
self.password = password
def __repr__(self):
return '<User {}>'.format(self.email)
class ScoreTypes(db.Model):
__tablename__ = 'score_types'
def __init__(self, code, label):
self.code = code
self.label = label
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(64), index=True, unique=True)
label = db.Column(db.String(64))
def __repr__(self):
return '<id {}>'.format(self.id)
class CarModel(db.Model):
__tablename__ = "carmodels"
id = db.Column(db.Integer, primary_key=True)
cartype = db.Column(db.String(100))
model = db.Column(db.String(100))
year = db.Column(db.Integer)
description = db.Column(db.Text)
def __init__(self, cartype, model, year, description=""):
self.cartype = cartype
self.model = model
self.year = year
self.description = description
class Affiliate(Auditable):
__tablename__ = 'affiliate'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(64), index=True, unique=True)
name = db.Column(db.String(64))
address = db.Column(db.Text, index=False, unique=False)
def __init__(self, code, name, address = None):
self.name = name
self.code = code
self.address = address
def __repr__(self):
return '<id {}>'.format(self.id)
class Application(db.Model):
__tablename__ = "applications"
id = db.Column(db.Integer, primary_key=True)
appname = db.Column(db.String(200), nullable=False)
runningversion = db.Column(db.Integer, nullable=False, server_default='0')
author = db.Column(db.String(100), nullable=False)
datecreated = db.Column(db.DateTime, nullable=False, server_default=sa.func.now())
datelastupdate = db.Column(db.DateTime)
description = db.Column(db.Text)
active = db.Column(db.Boolean, nullable=False, server_default=sa.sql.expression.false())
def __init__(self, appname, author, description):
self.appname = appname
self.author = author
self.description = description
class Movement(db.Model):
__tablename__ = 'movement'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(5))
label = db.Column(db.String(64), index=True, unique=True)
standard = db.Column(db.String(64))
load_measurement = db.Column(db.Enum(MeasurementEnum))
def __init__(self, code, label, load=None):
self.code = code
self.label = label
self.load_measurement = load
def __repr__(self):
return '<id {}>'.format(self.id)
class Tweet(db.Model):
""""""
__tablename__ = 'tweet'
id = db.Column(db.Integer, primary_key=True)
tweet_id = db.Column(db.Integer)
name = db.Column(db.String(100))
text = db.Column(db.String(300))
tweet_created = db.Column(db.String(50))
user_timezone = db.Column(db.String(50))
def __init__(self, tweet_id, name, text, tweet_created, user_timezone):
self.tweet_id = tweet_id
self.name = name
self.text = text
self.tweet_created = tweet_created
self.user_timezone = user_timezone
class UserModel(BaseModel, db.Model):
"""
User Model
"""
__tablename__ = 'users'
full_name = db.Column(db.String(128), nullable=True)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=True)
address = db.Column(JSON)
wishes = db.relationship('WishModel', backref='users', lazy=True)
def __init__(self, full_name: str, email: str, password: str,
address: dict):
self.full_name = full_name
self.email = email
self.password = password
self.address = address
super(UserModel, self).__init__()
def save(self):
self.password = self.__generate_password_hash(self.password)
super(UserModel, self).save()
def update(self, **kwargs):
super(UserModel, self).update(**kwargs)
def set_password(self, password):
password_hash = self.__generate_password_hash(password)
super(UserModel, self).update(**{'password': password_hash})
@staticmethod
def __generate_password_hash(password):
return bcrypt.generate_password_hash(password,
rounds=10).decode('utf-8')
def check_password_hash(self, password):
return bcrypt.check_password_hash(self.password, password)
@property
def first_name(self):
return self.full_name.split(' ')[0] if self.full_name else ''
def __str__(self):
return '<{} - {}>'.format(self.full_name, self.email)
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(256))
expire = db.Column(db.Date())
def delete_myself(self):
db.session.delete(self)
db.session.commit()
class WorkoutTypes(db.Model):
__tablename__ = 'workout_types'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.Enum(WorkoutTypeEnum))
label = db.Column(db.String(64), index=True, unique=True)
category = db.Column(db.Enum(WorkoutCategoryEnum))
description = db.Column(db.String(64), index=False, unique=False)
def __init__(self, code, label, category, description = None):
self.code = code
self.label = label
self.category = category
self.description = description
def __repr__(self):
return '<id {}>'.format(self.id)
class RequestType(db.Model):
__tablename__ = "requesttypes"
id = db.Column(db.Integer, primary_key=True)
requesttype = db.Column(db.String(40), nullable=False)
def __init__(self, requesttype):
self.requesttype = requesttype
class Project(db.Model):
__tablename__ = 'projects'
id = db.Column(db.Integer, primary_key=True)
id_project42 = db.Column(db.Integer, unique=True, nullable=False)
name = db.Column(db.String(100), nullable=False)
slug = db.Column(db.String(100), nullable=False)
tier = db.Column(db.Integer, nullable=False)
active = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.true())
# relationship with 'Mentors' table, Mentor Model Class
mentors = db.relationship('Mentor',
backref=backref('project', lazy='joined'),
lazy=True)
def __init__(self, id_project42, name, slug, tier, active=True):
self.id_project42 = id_project42
self.name = name
self.slug = slug
self.tier = tier
self.active = active
@classmethod
def queryProject(cls, id42=0, name=None):
if id42 is not 0:
query = cls.query.filter_by(id_project42=id42).first()
if query is None:
return None, "No project with 42 id {}".format(id42)
elif name:
query = cls.query.filter_by(name=name).first()
if query is None:
return None, "No project named {}".format(name)
else:
return None, "No data provided to query"
return project_schema.dump(query).data, None
@classmethod
def queryAll(cls):
query = cls.query.all()
if query is None:
return None, "No projects exist"
return projects_schema.dump(query).data, None
class User(Auditable):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), unique=True)
affiliate_id = db.Column(db.Integer, db.ForeignKey(Affiliate.id))
affiliate = relationship('Affiliate')
password_hash = db.Column(db.String(128))
def __init__(self, username, email, password, affiliate):
self.username = username
self.email = email
self.password_hash = password
self.affiliate = affiliate
self.affiliate_id = affiliate.id
def __repr__(self):
return '<username {}>'.format(self.username)
class Role(BaseModel):
__tablename__ = "roles"
id = db.Column(db.String(255), primary_key=True)
def __repr__(self):
return f"<Role {self.id}>"
@staticmethod
def of(id):
return Role.where(id=id).one_or_none()
class Interest(db.Model):
__tablename__ = 'interests'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
def serialize_short(self):
return {
'id': self.id,
'title': self.title,
}
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(80))
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
is_admin = db.Column(db.Boolean(), default=False)
def __init__(self, username, password, is_admin=False):
self.username = username
self.password = password
self.is_admin = is_admin
def json(self):
return {
'username': self.username
}
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Car(db.Model):
__tablename__ = "cars"
id = db.Column(db.Integer, primary_key=True)
vin = db.Column(db.Text, nullable=False)
carmodel = db.Column(db.Integer, nullable=False)
raspbpi = db.Column(db.Integer)
piIP = db.Column(db.String(50), nullable=False)
registereddate = db.Column(db.DateTime)
def __init__(self, vin, carmodel, raspbpi, piIP):
self.vin = vin
self.carmodel = carmodel
self.raspbpi = raspbpi
self.piIP = piIP
class Result(db.Model):
__tablename__ = 'results'
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String())
result_all = db.Column(JSON)
result_no_stop_words = db.Column(JSON)
def __init__(self, url, result_all, result_no_stop_words):
self.url = url
self.result_all = result_all
self.result_no_stop_words = result_no_stop_words
def __repr__(self):
return '<id {}>'.format(self.id)
class Benchmark(db.Model):
__tablename__ = 'benchmark'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
workout_type_id = db.Column(db.Integer, db.ForeignKey('workout_types.id'))
workout_type = relationship('WorkoutTypes')
score_type_id = db.Column(db.Integer, db.ForeignKey('score_types.id'))
score_type = relationship('ScoreTypes')
movements = relationship('Movement', secondary=benchmark_association_table)
def __init__(self, name, workout_type, score_type):
self.name = name
self.workout_type = workout_type
self.workout_type_id = workout_type.id
self.score_type = score_type
self.score_type_id = score_type.id
class Communities(db.Model):
__tablename__ = 'communities'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text)
userscount = db.Column(db.Integer)
# Union between this table & interests name
def serialize_short(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'userscount': self.userscount
}
class CompanyProfile(db.Model):
"""
Company Profile model
"""
__tablename__ = 'company_profiles'
id = db.Column(db.Integer, primary_key=True)
company_url = db.Column(db.String(100))
company_name = db.Column(db.String(200))
company_email = db.Column(db.String(50))
company_website = db.Column(db.String(50))
company_street_address = db.Column(db.String(255))
company_description = db.Column(db.String(3000))
country = db.Column(db.String(50))
industry = db.Column(db.String(100))
company_phone_number = db.Column(db.JSON)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
def __repr__(self):
return 'company_name : {}'.format(self.company_name)
class Event(db.Model):
__tablename__ = 'events'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
description = db.Column(db.Text)
creator_id = db.Column(db.ForeignKey('user.id'))
interests = db.relationship('Interest', secondary=event_interests)
def serialize_short(self):
return {
'id':
self.id,
'title':
self.title,
'description':
self.description,
'interests':
[interest.serialize_short() for interest in self.interests]
}
class Lift(db.Model):
__tablename__ = 'lift'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
workout_type_id = db.Column(db.Integer, db.ForeignKey('workout_types.id'))
workout_type = relationship('WorkoutTypes')
score_type_id = db.Column(db.Integer, db.ForeignKey('score_types.id'))
score_type = relationship('ScoreTypes')
movements = relationship('Movement', secondary=lift_association_table)
lift_records = relationship('LiftRecord', back_populates='lift')
def __init__(self, name, workout_type, score_type):
self.name = name
self.workout_type = workout_type
self.workout_type_id = workout_type.id
self.score_type = score_type
self.score_type_id = score_type.id
def get_pr(self):
return max(lift_records, key=lambda x: x.get_highest())
class ApplicationVersion(db.Model):
__tablename__ = "applicationversions"
id = db.Column(db.Integer, primary_key=True)
app = db.Column(db.Integer, nullable=False)
description = db.Column(db.Text)
version = db.Column(db.String(50), nullable=False)
approved = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.false())
datecreated = db.Column(db.DateTime,
nullable=False,
server_default=sa.func.now())
datelastupdate = db.Column(db.DateTime)
checksum = db.Column(db.Text)
status = db.Column(db.Integer, nullable=False, server_default='5')
def __init__(self, app, version, description):
self.app = app
self.version = version
self.description = description
