class Task(db.Model):
__tablename__ = 'tasks'
id = db.Column(db.String(), primary_key=True, nullable=False)
name = db.Column(db.String(), index=True, nullable=False)
description = db.Column(db.String())
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', name='FK_users_tasks'))
complete = db.Column(
db.Boolean,
default=False,
)
created = db.Column(db.DateTime(), default=db.func.now())
updated = db.Column(db.DateTime(),
default=db.func.now(),
onupdate=db.func.now())
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
class Purpose(db.Model):
__tablename__ = 'purposes'
id = db.Column(INTEGER(unsigned=True), primary_key=True)
record_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey('records.id', onupdate='CASCADE', ondelete='CASCADE'))
purpose_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey('purpose_masters.id',
onupdate='CASCADE',
ondelete='CASCADE'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
created_by = db.Column(db.String(255), nullable=False)
updated_by = db.Column(db.String(255), nullable=False)
def __init__(self, record_id, purpose_id, created_by):
self.record_id = record_id
self.purpose_id = purpose_id
self.created_by = created_by
self.updated_by = created_by
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(80), unique=True)
password_hash = db.Column(db.String(240), unique=False)
is_online = db.Column(db.Boolean, unique=False)
def __init__(self, username, email, password, is_online=False):
self.username = username
self.email = email
self.password_hash = hash_password(password)
self.is_online = is_online
def __repr__(self):
return '<User %r>' % self.username
def create(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def update(self):
db.session.add(self)
db.session.commit()
class Ad(db.Model):
id = db.Column(db.String(80), primary_key=True)
title = db.Column(db.String(160))
type = db.Column(db.String(80))
content = db.Column(db.String(1000))
def __repr__(self):
return '<Ad: {}>'.format(self.title)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(160))
category = db.Column(db.String(80))
# posts relationship
posts = db.relationship('Post', back_populates='user')
# represents the table
def __repr__(self):
return '<User {}>'.format(self.username)
class BasePersonModel(PkModel):
__abstract__ = True
first_name = Column(db.String(100))
last_name = Column(db.String(100))
pronouns = Column(db.String(50))
email = Column(db.String(100))
mobile_phone = Column(db.String(15))
address = Column(db.String(255))
address2 = Column(db.String(255))
city = Column(db.String(100))
state = Column(db.String(50))
zip_code = Column(db.String(20))
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
file_name = db.Column(db.String(), nullable=False, unique=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', name='FK_users_images'))
url = db.Column(db.String(), nullable=False, unique=True)
timestamp = db.Column(db.DateTime, index=True, default=db.func.now())
def __repr__(self):
return '<id {}:{}>'.format(self.id, self.file_name)
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
email = Column(db.String(80), unique=True, nullable=False)
password = Column(db.LargeBinary(128), nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({email!r})>'.format(email=self.email)
class BlacklistedToken(db.Model):
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False)
user_identity = db.Column(db.String(50), nullable=False)
expires = db.Column(db.DateTime, nullable=False)
def as_json(self):
"""Get the JSON representation of a BlacklistedToken object.
Returns:
The JSON representation of a BlacklistedToken object.
"""
return {
'id': self.id,
'jti': self.jti,
'user': self.user_identity,
'expires': self.expires
}
class PurposeMaster(db.Model):
__tablename__ = 'purpose_masters'
id = db.Column(INTEGER(unsigned=True), primary_key=True)
content = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(
db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
created_by = db.Column(db.String(255), nullable=False)
updated_by = db.Column(db.String(255), nullable=False)
def __init__(self, content, created_by):
self.content = content
self.created_by = created_by
self.updated_by = created_by
class Tags(Model):
__tablename__ = 'tags'
id = db.Column(db.Integer, primary_key=True)
tagname = db.Column(db.String(100))
def __init__(self, tagname):
db.Model.__init__(self, tagname=tagname)
def __repr__(self):
return self.tagname
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
class FootSize(SurrogatePK, Model):
"""The hair colors."""
__tablename__ = 'foot_sizes'
size = Column(db.String(3), nullable=True)
def __init__(self, size, **kwargs):
"""Create instance."""
db.Model.__init__(self, size=size, **kwargs)
def __repr__(self):
return '<FootSize({size})>'.format(size=self.size)
class DrivingLicense(SurrogatePK, Model):
"""The driving license."""
__tablename__ = 'driving_licenses_types'
type = Column(db.String(4), nullable=True)
def __init__(self, type, **kwargs):
"""Create instance."""
db.Model.__init__(self, type=type, **kwargs)
def __repr__(self):
return '<DivingLicense({type})>'.format(type=self.type)
class EyeColor(SurrogatePK, Model):
"""The hair colors."""
__tablename__ = 'eye_colors'
name = Column(db.String(80), nullable=True)
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
return '<EyeColor({name})>'.format(name=self.name)
class Province(SurrogatePK, Model):
"""The provinces."""
__tablename__ = 'provinces'
name = Column(db.String(80), nullable=False)
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
return '<Province({name})>'.format(name=self.name)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True)
name = db.Column(db.String(255), nullable=False)
nfc_id = db.Column(db.String(16), nullable=False, unique=True)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
created_by = db.Column(db.String(255), nullable=False)
updated_by = db.Column(db.String(255), nullable=False)
records = db.relationship("Record", backref="user")
def __init__(self, name, nfc_id, created_by):
self.name = name
self.nfc_id = nfc_id
self.created_by = created_by
self.updated_by = created_by
class User(SurrogatePK, Model):
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(100), unique=True, nullable=False)
password = Column(db.Binary(128), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
updated_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
bio = Column(db.String(300), nullable=True)
image = Column(db.String(120), nullable=True)
def __init__(self, username, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def token(self):
return _default_jwt_encode_handler(self).decode('utf-8')
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
class Locality(SurrogatePK, Model):
"""The localities."""
__tablename__ = 'localities'
name = Column(db.String(80), nullable=False)
postal_code = Column(db.Integer(), nullable=False)
province_id = reference_col('provinces', nullable=False)
province = relationship('Province', backref='localities')
def __init__(self, name, **kwargs):
"""Create instance."""
db.Model.__init__(self, name=name, **kwargs)
def __repr__(self):
return '<Locality({name})>'.format(name=self.name)
class Bike(PkModel):
__tablename__ = 'bike'
name = Column(db.String(150))
color = Column(db.String(100))
size_chart_to_use = Column(db.String(50))
bottom_tube_length = Column(db.Integer)
brakes = Column(db.String(50))
shifters = Column(db.String(50))
water_bottle = Column(db.Boolean)
lights = Column(db.Boolean)
bell = Column(db.Boolean)
rack = Column(db.Boolean)
pannier = Column(db.Boolean)
kickstand = Column(db.Boolean)
notes = Column(db.Text)
intake_date = Column(db.DateTime)
bike_tech_review_date = Column(db.DateTime)
drop_off_date = Column(db.DateTime)
mechanic_id = reference_col('mechanic', nullable=True)
mechanic = relationship('Mechanic', backref='bike')
donor_id = reference_col('donor', nullable=True)
donor = relationship('Donor', backref='bike')
class NotaFiscal(db.Model):
__tablename__ = 'nfe'
id = db.Column(db.Integer, primary_key=True)
access_key = db.Column(db.String(120),
unique=True,
index=True,
nullable=False,
server_default='')
total_value = db.Column(db.Float, nullable=False, default=0)
def __repr__(self):
return f'Nfe: {self.access_key} {self.total_value}'
def to_dict(self):
return {'access_key': self.access_key, 'total_value': self.total_value}
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(160))
slug = db.Column(db.String(160))
body = db.Column(db.String(3000))
dateCreated = db.Column(db.String(80))
category = db.Column(db.String(80))
image = db.Column(db.String(160))
# user relationship
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='posts')
# defines the init function
def __init__(self, *args, **kwargs):
# creates the slug
if not 'slug' in kwargs:
kwargs['slug'] = slugify(kwargs.get('title', ''))
super().__init__(*args, **kwargs)
# represents the table
def __repr__(self):
return '<Post {}>'.format(self.title)
class Article(SurrogatePK, Model):
__tablename__ = 'article'
id = db.Column(db.Integer, primary_key=True)
slug = Column(db.Text, unique=True)
title = Column(db.String(100), nullable=False)
description = Column(db.Text, nullable=False)
body = Column(db.Text)
createdAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
updatedAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
author_id = reference_col('userprofile', nullable=False)
author = relationship('UserProfile', backref=db.backref('articles'))
favoriters = relationship('UserProfile',
secondary=favoriter_assoc,
backref='favorites',
lazy='dynamic')
tagList = relationship('Tags', secondary=tag_assoc, backref='articles')
comments = relationship('Comment',
backref=db.backref('article'),
lazy='dynamic')
def __init__(self, author, title, body, description, slug=None, **kwargs):
db.Model.__init__(self,
author=author,
title=title,
description=description,
body=body,
slug=slug or slugify(title),
**kwargs)
def favourite(self, profile):
if not self.is_favourite(profile):
self.favoriters.append(profile)
return True
return False
def unfavourite(self, profile):
if self.is_favourite(profile):
self.favoriters.remove(profile)
return True
return False
def is_favourite(self, profile):
return bool(
self.query.filter(
favoriter_assoc.c.favoriter == profile.id).count())
def add_tag(self, tag):
if tag not in self.tagList:
self.tagList.append(tag)
return True
return False
def remove_tag(self, tag):
if tag in self.tagList:
self.tagList.remove(tag)
return True
return False
@property
def favoritesCount(self):
return len(self.favoriters.all())
@property
def favorited(self):
if current_identity:
profile = current_identity.profile
return self.query.join(Article.favoriters).filter(
UserProfile.id == profile.id).count() == 1
return False
class Accessory(PkModel):
__tablename__ = 'accessory'
item_name = Column(db.String(200))
donor_id = reference_col('donor')
donor = relationship('Donor', backref='accessory')
class Donor(BasePersonModel):
__tablename__ = 'donor'
pickup_date = Column(db.DateTime)
platform = Column(db.String(100))
class User(SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
email = Column(db.String(80), unique=True, nullable=False)
password = Column(db.String(255), nullable=True)
created_at = Column(db.DateTime, nullable=False,
default=dt.datetime.utcnow)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
def encode_auth_token(self, user_id):
try:
payload = {
'exp': dt.datetime.utcnow() + dt.timedelta(days=0, seconds=5),
'iat': dt.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(token):
"""
Validates the auth token
:param token:
:return: integer|string
"""
try:
payload = jwt.decode(token, current_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.'
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'email': self.email,
'created_at': self.created_at,
'active': self.active,
'is_admin': self.is_admin
}
class Extra(SurrogatePK, Model):
"""A extra profile."""
__tablename__ = 'extras'
user_id = reference_col('users', nullable=True)
user = relationship('User', backref='extras')
name = Column(db.String(80), nullable=True)
last_name = Column(db.String(255), nullable=True)
birthday = Column(db.DateTime(), nullable=True)
phone = Column(db.Integer(), nullable=True)
genre = Column(db.String(6), nullable=True)
address = Column(db.String(200), nullable=True)
province_id = reference_col('provinces', nullable=True)
province = relationship('Province', backref='extras')
locality_id = reference_col('localities', nullable=True)
locality = relationship('Locality', backref='extras')
nationality = Column(db.String(20), nullable=True)
vat_number = Column(db.String(11), unique=True, nullable=True)
insurance_number = Column(db.BigInteger(), unique=True, nullable=True)
height = Column(db.Integer(), nullable=True)
weight = Column(db.Integer(), nullable=True)
tshirt_size_id = reference_col('tshirt_sizes', nullable=True)
tshirt_size = relationship('TshirtSize', backref='extras')
trouser_size_id = reference_col('trouser_sizes', nullable=True)
trouser_size = relationship('TrouserSize', backref='extras')
foot_size_id = reference_col('foot_sizes', nullable=True)
foot_size = relationship('FootSize', backref='extras')
eye_color_id = reference_col('eye_colors', nullable=True)
eye_color = relationship('EyeColor', backref='extras')
hair_color_id = reference_col('hair_colors', nullable=True)
hair_color = relationship('HairColor', backref='extras')
profession = Column(db.String(80), nullable=True)
availability = Column(db.String(255), nullable=True)
driving_license = Column(db.Boolean(), nullable=True)
driving_license_type_id = reference_col('driving_licenses_types',
nullable=True)
driving_license_type = relationship('DrivingLicense', backref='extras')
hobbies = Column(db.String(200), nullable=True)
extra_experience = Column(db.Boolean(), nullable=True)
dance_experience = Column(db.Boolean(), nullable=True)
singing_experience = Column(db.Boolean(), nullable=True)
sea_experience = Column(db.Boolean(), nullable=True)
waiter_experience = Column(db.Boolean(), nullable=True)
other_experience = Column(db.String(80), nullable=True)
face_image = Column(db.String(255), nullable=True)
body_image = Column(db.String(255), nullable=True)
created_at = Column(db.DateTime(),
nullable=True,
default=dt.datetime.utcnow)
def __init__(self, vat_number, **kwargs):
"""Create instance."""
db.Model.__init__(self, vat_number=vat_number, **kwargs)
def __repr__(self):
return '<Extra({vat_number})>'.format(vat_number=self.vat_number)
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(
db.Integer,
primary_key=True,
autoincrement=True,
nullable=False
)
username = db.Column(
db.String(),
index=True,
unique=True,
nullable=False
)
email = db.Column(
db.String(),
index=True,
unique=True,
nullable=False
)
password_hash = db.Column(
db.String(),
nullable=False,
)
tasks = db.relationship(
'Task',
backref='user',
lazy='dynamic'
)
images = db.relationship(
'Image',
backref='user',
lazy='dynamic'
)
@staticmethod
def verify_reset_password_token(token):
try:
decoded = jwt.decode(
token,
current_app.config['SECRET_KEY'],
algorithms=['HS256']
)
id = decoded['reset_password']
except: # noqa: E722 TODO: figure out excepction thrown and catch it
return
return User.query.get(id)
def __repr__(self):
return '<User {}:{}>'.format(
self.id,
self.username
)
def get_reset_password_token(self, expires_in=3000):
return jwt.encode(
{'reset_password': self.id, 'exp': time() + expires_in},
current_app.config['SECRET_KEY'],
algorithm='HS256'
).decode('utf-8')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def add_image(self, file_name):
im = Image(file_name=file_name, user_id=self.id)
db.session.add(im)
return im
def get_images(self):
return Image.query.filter_by(user_id=self.id)
def launch_task(self, task, params, name, description, priority, *args, **kwargs):
rq_job = current_app.task_queues[priority].enqueue_call(func=task, args=params, *args, **kwargs)
task = Task(id=rq_job.get_id(), name=name, description=description, user_id=self.id)
db.session.add(task)
return task
def get_tasks_in_progress(self, name):
return Task.query.filter_by(name=name, user_id=self.id, complete=False).all()
