class Response(BaseModel):
__tablename__ = "responses"
id = db.Column(
UUID(as_uuid=True),
server_default=sqlalchemy.text("gen_random_uuid()"),
primary_key=True,
)
challenge = db.relationship("Challenge", backref="responses")
challenge_id = db.Column(UUID(as_uuid=True),
db.ForeignKey("challenges.id"),
primary_key=True)
user = db.relationship("User", backref="responses")
user_id = db.Column(UUID(as_uuid=True),
db.ForeignKey("users.id"),
primary_key=True)
video = db.relationship("Video",
backref=backref("response", uselist=False))
video_id = db.Column(UUID(as_uuid=True),
db.ForeignKey("videos.id"),
nullable=True)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
nullable=False)
updated_at = db.Column(
db.DateTime(timezone=True),
server_default=func.now(),
onupdate=datetime.utcnow,
nullable=False,
)
class Challenge(BaseModel):
__tablename__ = "challenges"
__table_args__ = (db.Index("challenges_by_user_id_listed", "user_id",
"listed"), )
id = db.Column(
UUID(as_uuid=True),
server_default=sqlalchemy.text("gen_random_uuid()"),
primary_key=True,
)
title = db.Column(db.Unicode(length=255), nullable=False)
instructions = db.Column(db.UnicodeText, nullable=False)
grading_notes = db.Column(db.UnicodeText, nullable=False)
listed = db.Column(db.Boolean, default=False, nullable=False, index=True)
user = db.relationship("User", backref="challenges")
user_id = db.Column(UUID(as_uuid=True), db.ForeignKey("users.id"))
video = db.relationship("Video",
backref=backref("challenges", uselist=False))
video_id = db.Column(UUID(as_uuid=True),
db.ForeignKey("videos.id"),
nullable=True)
deleted_at = db.Column(db.DateTime(timezone=True), nullable=True)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
nullable=False)
updated_at = db.Column(
db.DateTime(timezone=True),
server_default=func.now(),
onupdate=datetime.utcnow,
nullable=False,
)
class Image(db.Model):
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String)
url = db.Column(db.String)
ext = db.Column(db.String)
report_id = db.Column(db.Integer,
db.ForeignKey('report.id'),
nullable=False)
@classmethod
def from_arr(cls, arr, report_id):
arr = cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
image = cls(report_id=report_id)
db.session.add(image)
db.session.commit()
ext = '.jpg'
file_id = uuid.uuid4().int
filename = str(file_id) + ext
abs_fpath = os.path.join(app.config['MEDIA_FOLDER'], filename)
cv2.imwrite(abs_fpath, arr)
rel_path = os.path.join(os.path.basename(app.config['MEDIA_FOLDER']),
filename)
url = os.path.join('image', str(image.id))
image.path = rel_path
image.url = url
image.ext = ext
db.session.commit()
return image
class MentorStat(db.Model):
__tablename__ = 'mentorstats'
id = db.Column(db.Integer, primary_key=True)
id_mentor = db.Column(db.Integer,
db.ForeignKey('mentors.id'),
nullable=False)
rating = db.Column(db.Numeric(10, 2, asdecimal=False),
nullable=False,
server_default='0.00')
totalappointments = db.Column(db.Integer,
nullable=False,
server_default='0')
cancelledappointments = db.Column(db.Integer,
nullable=False,
server_default='0')
# relationship with 'mentors' table, Mentor Model Class
mentor = db.relationship('Mentor',
backref=backref('mentorstat',
lazy='joined',
uselist=False),
lazy=True)
def __init__(self, id_mentor):
self.id_mentor = id_mentor
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 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 Friendship(db.Model):
__tablename__ = 'friendship'
id = db.Column(db.Integer, primary_key=True)
requester_id = db.Column(db.Integer, db.ForeignKey('user.id'))
target_id = db.Column(db.Integer, db.ForeignKey('user.id'))
status = db.Column(db.Enum(FriendshipStatus),
default=FriendshipStatus.requested)
def serialize_short(self):
return {
'user':
User.query.filter(
or_(User.id == self.target_id,
User.id == self.requester_id)).first().serialize_short(),
'status':
self.status.name
}
class SetRecord(Auditable):
__tablename__ = 'set_record'
id = db.Column(db.Integer, primary_key=True)
set_number = db.Column(db.Integer)
score = db.Column(db.Integer)
lift_record_id = db.Column(db.Integer, db.ForeignKey('lift_record.id'))
def __init__(self, set_number, score):
self.set_number = set_number
self.score = score
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 LiftRecord(Auditable):
__tablename__ = 'lift_record'
id = db.Column(db.Integer, primary_key=True)
lift_id = db.Column(db.Integer, db.ForeignKey('lift.id'))
lift = relationship('Lift', back_populates='lift_records')
number_of_sets = db.Column(db.Integer)
reps_per_set = db.Column(db.Integer)
date = db.Column(db.DateTime, default = datetime.datetime.utcnow)
sets = relationship('SetRecord')
def __init__(self, number_of_sets, reps_per_set):
self.number_of_sets = number_of_sets
self.reps_per_set = reps_per_set
def get_highest(self):
return max(sets, key=lambda x: x.score)
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 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 FinancialSummary(db.Model):
"""
Financial Summary model
"""
__tablename__ = 'financial_summaries'
id = db.Column(db.Integer, primary_key=True)
company_id = db.Column(db.Integer, db.ForeignKey('company_profiles.id'))
capital_currency = db.Column(db.String(50))
market_cap = db.Column(db.BigInteger)
par_value = db.Column(db.BigInteger)
equity = db.Column(db.BigInteger)
listing_volume = db.Column(db.BigInteger)
listed_date = db.Column(db.DateTime)
initial_listed_price = db.Column(db.BigInteger)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
company = db.relationship('CompanyProfile',
uselist=False,
backref='financial_summary')
def __repr__(self):
return 'company_id : {}'.format(self.company_id)
class Mentor(db.Model):
__tablename__ = 'mentors'
id = db.Column(db.Integer, primary_key=True)
id_project42 = db.Column(db.Integer,
db.ForeignKey('projects.id_project42'),
nullable=False)
id_user42 = db.Column(db.Integer,
db.ForeignKey('users.id_user42'),
nullable=False)
finalmark = db.Column(db.Integer, nullable=False, server_default='0')
abletomentor = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.false())
last_appointment = db.Column(db.DateTime(timezone=True))
active = db.Column(db.Boolean,
nullable=False,
server_default=sa.sql.expression.false())
started_at = db.Column(db.DateTime(timezone=True),
nullable=False,
server_default=sa.func.now())
# relationship with 'Appointments' table, Appointment Model Class
appointments = db.relationship('Appointment',
backref=backref('mentor', lazy='joined'),
lazy=True)
def __init__(self, id_project42, id_user42, finalmark):
self.id_project42 = id_project42
self.id_user42 = id_user42
self.finalmark = 0 if finalmark is None else finalmark
@classmethod
def queryAll(cls):
query = cls.query.all()
if not query:
return None, "No mentors exist"
return mentors_schema.dump(query).data, None
@classmethod
def queryById(cls, mentorId):
query = cls.query.filter_by(id=mentorId).first()
if not query:
return None, "No mentor with id {} was found".format(mentorId)
return mentor_schema.dump(query).data, None
@classmethod
def queryManyByProject(cls, id):
query = cls.query.filter_by(id_project42=id).all()
if not query:
return None, "No mentors for project {}".format(id)
return mentors_schema.dump(query).data, None
@classmethod
def queryManyByUser(cls, id):
query = cls.query.filter_by(id_user42=id).all()
if not query:
return None, "No mentors for project {}".format(id)
return mentors_schema.dump(query).data, None
@classmethod
def queryByFilter(cls, **kwargs):
query = cls.query.filter_by(**kwargs).first()
if not query:
return None, "No mentor found"
return mentor_schema.dump(query).data, None
@classmethod
def queryManyByFilter(cls, **kwargs):
query = cls.query.filter_by(**kwargs).all()
if not query:
return None, "No mentors found"
return mentors_schema.dump(query).data, None
class User(BaseModel):
__tablename__ = "users"
id = db.Column(
UUID(as_uuid=True),
server_default=sqlalchemy.text("gen_random_uuid()"),
primary_key=True,
)
full_name = db.Column(db.Unicode(255), nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
_password = db.Column("password", db.String(255), nullable=False)
role = db.Column(
db.String(255),
db.ForeignKey("roles.id", name="fk_user_role"),
default="user",
nullable=False,
)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now(),
nullable=False)
updated_at = db.Column(
db.DateTime(timezone=True),
server_default=func.now(),
onupdate=datetime.utcnow,
nullable=False,
)
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = bcrypt.generate_password_hash(password).decode()
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
def create_access_token_with_claims(
self, expires_minutes=settings["JWT_EXPIRATION_MINUTES"]):
claims = {"role": self.role}
return create_access_token(
identity=self.id,
user_claims=claims,
expires_delta=timedelta(minutes=expires_minutes),
)
def create_refresh_token(
self, expires_hours=settings["JWT_REFRESH_EXPIRATION_HOURS"]):
return create_refresh_token(
identity=self.id, expires_delta=timedelta(hours=expires_hours))
@staticmethod
def get_or_create_super_admin():
user = User.where(email="*****@*****.**").one_or_none()
if not user:
user = User.create(
full_name="Super Admin",
email="*****@*****.**",
password="******",
role=Role.of("super_admin"),
)
return user
def __repr__(self):
return f"<User {self.email}>"
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)
lift_association_table = db.Table('lift_association', db.Model.metadata,
db.Column('lift_id', db.Integer, db.ForeignKey('lift.id')),
db.Column('movement_id', db.Integer, db.ForeignKey('movement.id'))
)
benchmark_association_table = db.Table('benchmark_association', db.Model.metadata,
db.Column('benchmark_id', db.Integer, db.ForeignKey('benchmark.id')),
db.Column('movement_id', db.Integer, db.ForeignKey('movement.id'))
)
custom_wod_association_table = db.Table('custom_workout_association', db.Model.metadata,
db.Column('custom_workout_id', db.Integer, db.ForeignKey('custom_workout.id')),
db.Column('movement_id', db.Integer, db.ForeignKey('movement.id'))
)
class Lift(db.Model):
from api.app import db
class FriendshipStatus(Enum):
requested = 'requested'
accepted = 'accepted'
accepted_second_level = 'accepted_second_level'
second_level = 'second_level'
user_interests = db.Table(
'users_interests',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('interests_id',
db.Integer,
db.ForeignKey('interests.id'),
primary_key=True))
class Friendship(db.Model):
__tablename__ = 'friendship'
id = db.Column(db.Integer, primary_key=True)
requester_id = db.Column(db.Integer, db.ForeignKey('user.id'))
target_id = db.Column(db.Integer, db.ForeignKey('user.id'))
status = db.Column(db.Enum(FriendshipStatus),
default=FriendshipStatus.requested)
class Appointment(db.Model):
__tablename__ = 'appointments'
id = db.Column(db.Integer, primary_key=True)
id_mentor = db.Column(db.Integer, db.ForeignKey('mentors.id'), nullable=False)
id_user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
start_time = db.Column(db.DateTime)
feedback = db.Column(db.Text)
rating = db.Column(db.Numeric(10, 2, asdecimal=False), nullable=False, server_default='0.00')
status = db.Column(db.Integer, nullable=False, server_default='2')
def __init__(self, id_mentor, id_user, feedback=""):
self.id_mentor = id_mentor
self.id_user = id_user
self.feedback = feedback
# Creates an appointment for given user and mentor
# Sets up an appointment 15 minutes from actual date
@classmethod
def createAppointment(cls, mentorId, userId):
data = {"id_mentor": mentorId, "id_user": userId}
newappointment, error = appointment_schema.load(data)
if error:
return None, error
#creates an appointment 15 minutes ahead from creation
newappointment.start_time = datetime.now() + timedelta(minutes=15)
db.session.add(newappointment)
db.session.commit()
return appointment_schema.dump(newappointment).data, None
@classmethod
def queryCountProjectAppointmentsbyUser(cls, projectId, userId):
from api.models import Mentor
dateObject = datetime.now().date()
today = datetime(dateObject.year, dateObject.month, dateObject.day)
appointmentCount = cls.query.join(Mentor, cls.id_mentor == Mentor.id).filter(Mentor.id_project42 == projectId, cls.id_user == userId, cls.start_time > today).count()
return appointmentCount
# Query one appointment with the given 'id' parameter
@classmethod
def queryById(cls, appointmentId):
query = cls.query.filter_by(id=appointmentId).first()
if not query:
return None, "No appointment with id {} was found".format(appointmentId)
return appointment_schema.dump(query).data, None
# Query all appointments with the given parameters for a user (mentee) perspective
@classmethod
def queryManyAsUser(cls, userId):
query = cls.query.filter(cls.id_user==userId).all()
if not query:
return None, "No appointments for user {}".format(userId)
return appointments_schema.dump(query).data, None
# Query all appointments with the given parameters from a mentor perspective
@classmethod
def queryManyAsMentor(cls, userId):
from api.models import Mentor
query = cls.query.join(Mentor, cls.id_mentor == Mentor.id).filter(Mentor.id_user42 == userId).all()
if not query:
return None, "No appointments to mentor for user {}".format(userId)
return appointments_schema.dump(query).data, None
# Query multiple *PENDING* appointments with the given parameters from a user perspective
@classmethod
def queryManyPendingAsUser(cls, userId):
query = cls.query.filter(cls.id_user==userId, cls.status == 2).all()
if not query:
return None, "No pending appointments requested by user {}".format(userId)
return appointments_schema.dump(query).data, None
# Query multiple *PENDING* appointments with the given parameters from a mentor perspective
@classmethod
def queryManyPendingAsMentor(cls, userId):
from api.models import Mentor, User
query = cls.query.join(Mentor).join(User, Mentor.id_user42==User.id_user42).filter(Mentor.id_user42 == userId, cls.status == 2).all()
#query = cls.query.join(Mentor, cls.id_mentor == Mentor.id).filter(Mentor.id_user42 == userId, cls.status == 2).all()
query = cls.query.join(Mentor)
if not query:
return None, "No pending appointments to mentor for user {}".format(userId)
return appointments_schema.dump(query).data, None
class DriverModel(db.Model):
__tablename__ = 'drivers'
id = db.Column(db.Integer, primary_key=True, index=True)
first_name = db.Column(db.String(64))
last_name = db.Column(db.String(64), unique=True, index=True)
number = db.Column(db.Integer, unique=True)
team_id = db.Column(db.Integer, db.ForeignKey('teams.id'))
team = db.relationship('TeamModel')
country = db.Column(db.String(64))
podium = db.Column(db.Integer, default=0)
points = db.Column(db.Integer, default=0)
championships = db.Column(db.Integer, default=0)
birthday = db.Column(db.DateTime)
def __init__(self, first_name, last_name, number, team_id, country,
podium=0,
points=0,
championships=0,
birthday=date(1990, 1, 1)):
self.first_name = first_name
self.last_name = last_name
self.number = number
self.team_id = team_id
self.country = country
self.podium = podium
self.points = points
self.championships = championships
self.birthday = birthday
def json(self):
return {
'id': self.id,
'name': "{} {}".format(self.first_name, self.last_name),
'number': self.number,
'team_id': self.team_id,
'country': self.country,
'podiums': self.podium,
'points': self.points,
'championships': self.championships,
'birthday': '{0.month}/{0.day}/{0.year}'.format(self.birthday),
}
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_number(cls, number):
return cls.query.filter_by(number=number).first()
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@db_check_or_return_500
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class Report(db.Model):
id = db.Column(db.Integer, primary_key=True)
reporter_id = db.Column(db.Integer)
timestamp = db.Column(db.Integer)
longitude = db.Column(db.Float)
latitude = db.Column(db.Float)
report_type = db.Column(db.String)
description = db.Column(db.String)
video_id = db.Column(db.Integer, db.ForeignKey('video.id'))
video = db.relationship('Video', backref='report', uselist=False)
images = db.relationship('Image', backref='report')
analysis_complete = db.Column(db.Boolean, default=False)
car_color = db.Column(db.String)
probability = db.Column(db.Integer)
profile_id = db.Column(db.Integer, db.ForeignKey('profile.id'))
def __init__(self,
reporter_id,
report_type,
timestamp,
longitude,
latitude,
analysis_complete=False,
video_id=None):
self.reporter_id = reporter_id
self.report_type = report_type
self.timestamp = timestamp
self.longitude = longitude
self.latitude = latitude
self.analysis_complete = analysis_complete
self.video_id = video_id
@staticmethod
def validate_json(data):
missing = []
if 'user_id' not in data:
missing.append('user_id')
if 'timestamp' not in data:
missing.append('timestamp')
if 'report_type' not in data:
missing.append('report_type')
if 'location' not in data:
missing.append('location')
if 'longitude' not in data.get('location'):
missing.append('longitude')
if 'latitude' not in data.get('location'):
missing.append('latitude')
if len(missing):
return False, missing
else:
return True, None
def to_dict(self):
obj = {}
obj['id'] = self.id
obj['reporter_id'] = self.reporter_id
obj['timestamp'] = self.timestamp
obj['location'] = {'lat': self.longitude, 'lng': self.latitude}
obj['video_url'] = self.video.url if self.video is not None else ''
obj['image_urls'] = [image.url for image in self.images]
obj['analysis_complete'] = self.analysis_complete
obj['car_color'] = self.car_color if self.car_color is not None else ''
obj['description'] = self.description if self.description is not None else ''
obj['probability'] = self.probability
return obj
from api.app import db
event_interests = db.Table(
'event_interests',
db.Column('event_id',
db.Integer,
db.ForeignKey('events.id'),
primary_key=True),
db.Column('interests_id',
db.Integer,
db.ForeignKey('interests.id'),
primary_key=True))
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':