class FoodKind(BaseMixin, UserDefinedNameMixin, db.Model):
user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('app_user.id'))
unit_of_measurement_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('unit_of_measurement.id'),
default=UNIT_OF_MEASURE_IS_SELF_ID)
serving_size = db.Column(db.Float, default=0.0)
unit_of_measurement = db.relationship('UnitOfMeasurement', lazy='joined')
nutrition_info = db.relationship('FoodKindNutritionInfo',
lazy='joined',
uselist=False)
categories = db.relationship('FoodCategory',
secondary='food_kind_category',
lazy='subquery',
backref=db.backref('food_kinds', lazy=True))
stock_items = db.relationship('StockItem', lazy=True)
def full_dict(self):
remove = ['unit_of_measurement_id']
return {
**{
key: getattr(self, key)
for key in self.cols_dict().keys() if key not in remove
}, 'unit_of_measurement': self.unit_of_measurement,
'categories': self.categories,
'nutrition_info': self.nutrition_info or {}
}
class Stock(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model):
name = db.Column(db.String, nullable=False)
items = db.relationship('StockItem',
lazy=True,
backref=db.backref('stock', lazy=False))
maintainers = db.relationship('Maintainer',
lazy=True,
secondary='stock_maintainer',
backref=db.backref('stocks', lazy=False))
class Item(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model):
name = db.Column(db.String, nullable=False)
description = db.Column(db.String)
tags = db.relationship('Tag',
lazy=False,
secondary='item_tag',
backref=db.backref('items', lazy=True))
instances = db.relationship('StockItem',
lazy=True,
backref=db.backref('item', lazy=False))
class RegisteredUser(db.Model):
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
oauth_openid = db.Column(
db.String, unique=True) # if the user registered through OAuth2
username = db.Column(db.String)
email = db.Column(db.String, unique=True, nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey('user_role.id'))
role = db.relationship('UserRole', lazy='joined')
logins = db.relationship('UserLogin', lazy='dynamic')
posts = db.relationship('Post', lazy='dynamic')
prompts = db.relationship('Prompt', lazy='dynamic')
def __repr__(self):
return f"RegisteredUser {self.id} - {self.email} - {self.username} - {self.role}"
@classmethod
def get_profile_user(cls, user_id):
'''Use this method to fetch data to display when any given logged on user views
their profile information'''
user = cls.query.get(user_id)
if user:
return dict(
id=user.id,
username=user.username,
email=user.email,
role=user.role,
posts=[p for p in user.posts.all()],
prompts=[p for p in user.prompts.all()],
)
@classmethod
def get_profile_admin(cls, user_id):
'''Use this method to fetch data about users for admins to review/use in their tasks'''
user = cls.query.get(user_id)
if user:
return dict(
id=user.id,
username=user.username,
email=user.email,
role=user.role,
posts=[p.with_reviews() for p in user.posts.all()],
prompts=[p.with_reviews() for p in user.prompts.all()],
logins=[l for l in user.logins.all()],
)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Post(db.Model):
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
date_created = db.Column(TIMESTAMP(timezone=True), default=datetime.utcnow)
created_by = db.Column(UUID(as_uuid=True),
db.ForeignKey('registered_user.id'),
nullable=False)
content = db.Column(db.String(1000), nullable=False)
status = db.Column(db.String,
db.ForeignKey('review_status_kind.name'),
default='pending')
prompt_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('prompt.id'),
nullable=False)
reviews = db.relationship('PostReview', lazy='dynamic')
def with_reviews(self):
self.reviews = [r for r in self.reviews.all()]
return self
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_pending(cls):
return cls.query.filter_by(status='pending').all()
@classmethod
def get_approved(cls):
return cls.query.filter_by(status='approved').all()
@classmethod
def get_rejected(cls):
return cls.query.filter_by(status='rejected').all()
class StockItem(UuidPrimaryKeyMixin, CreatedUpdatedTimestampMixin, db.Model):
stock_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('stock.id'),
nullable=False)
item_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('item.id'),
nullable=False)
snapshots = db.relationship('StockItemSnapshot', lazy=True)
class StockItemState(TimestampMixin, db.Model):
stock_item_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock_item.id'))
packaging_kind_id = db.Column(UUID(as_uuid=True), db.ForeignKey('packaging_kind.id'))
packaging_state_id = db.Column(UUID(as_uuid=True), db.ForeignKey('packaging_state.id'))
quantity = db.Column(db.Integer, default=0)
# has lazy loaded 'backref'ed relationship field 'food_item'
packaging_kind = db.relationship('PackagingKind', lazy='joined')
packaging_state = db.relationship('PackagingState', lazy='joined')
def full_dict(self):
remove = ['packaging_kind_id', 'packaging_state_id']
return {
**{ key: getattr(self, key) for key in self.cols_dict().keys() if key not in remove },
'packaging_kind': self.packaging_kind,
'packaging_state': self.packaging_state
}
class StockItem(TimestampMixin, db.Model):
stock_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock.id'))
food_kind_id = db.Column(UUID(as_uuid=True), db.ForeignKey('food_kind.id'))
date_item_was_new = db.Column(DATE(), default=datetime.utcnow)
expiration_date = db.Column(DATE(), nullable=False)
# 'states' field in StockItem instance is sqlalchemy query object which can
# be used to specify whether or not to grab all previous 'StockItemState's (a lot)
# or just the most recent one...or something else
states = db.relationship('StockItemState', lazy='dynamic', backref=db.backref('food_item', lazy=True))
food_kind = db.relationship('FoodKind', lazy='joined')
def full_dict(self):
current_state = self.states.order_by(text('date_created desc')).first()
return {
**self.cols_dict(),
'food_kind': self.food_kind.full_dict(),
'current_state': current_state.full_dict() if current_state else None,
}
class User(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(256), unique=True, nullable=False)
password = db.Column(db.String(256), nullable=False)
role = db.Column(db.String(20), nullable=False, default="cliente")
curriculum = db.relationship('Curriculum',
backref='user',
lazy=False,
cascade='all, delete-orphan')
applications = db.relationship('Application',
backref='user',
lazy=False,
cascade='all, delete-orphan')
notifications = db.relationship('Notification',
backref='user',
lazy=False,
cascade='all, delete-orphan')
ratings = db.relationship('Rating', backref='user', lazy=False)
#messages = db.relationship('Message', backref='user', lazy=False, cascade='all, delete-orphan')
interviews = db.relationship('Interview',
backref='user',
lazy=False,
cascade='all, delete-orphan')
#para estadisticas
created_at = db.Column(db.DateTime, default=datetime.utcnow)
last_login = db.Column(db.DateTime)
def __init__(self, email, password):
self.email = email
self.password = Bcrypt().generate_password_hash(password).decode()
def password_is_valid(self, password):
return Bcrypt().check_password_hash(self.password, password)
@classmethod
def get_by_email(cls, email):
return cls.query.filter(User.email == email).first()
@classmethod
def search_by_email(cls, email):
filtro = cls.query.filter(User.email.contains(email))
return filtro.paginate(1, 5, False).items
class Company(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
info = db.Column(db.String)
logo = db.Column(db.String)
jobs = db.relationship('Job',
backref='company',
lazy=False,
cascade='all, delete-orphan')
ratings = db.relationship('Rating', backref='company', lazy=False)
def __init__(self, name):
self.name = name
@classmethod
def get_by_name(cls, name):
return cls.query.filter(Company.name == name).first()
@classmethod
def get_by_id(cls, id):
return cls.query.filter(Company.id == id).first()
@classmethod
def get_pag(cls, data):
filtro = cls.query
filtro = filtro.filter(db.or_(~Company.name.contains('Workana')))
if 'search' in data and data['search'] is not None:
filtro = filtro.filter(
db.or_(Company.name.contains(data['search'].strip())))
if 'page' in data and 'per_page' in data:
return filtro.paginate(int(data['page']), int(data['per_page']),
False, 40)
else:
return filtro.paginate(1, 10, False)
@classmethod
def get_id(cls):
filtro = db.engine.execute(
"select setval('company_id_seq', (select max(id) from company));")
return [row for row in filtro]
class UserProfile(TimestampMixin, db.Model):
user_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('registered_user.id'),
primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('user_role.id'))
username = db.Column(db.String, unique=True, nullable=False)
role = db.relationship('UserRole', lazy='joined')
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Stock(TimestampMixin, UserDefinedNameMixin, db.Model):
user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('app_user.id'))
# each snapshot is a collection of 'stock_item_state's. a snapshot
# represents the state of a 'stock' at a given moment in time
snapshots = db.relationship('Snapshot',
lazy='dynamic',
backref=db.backref('stock', lazy=True))
# represents the 'food_item's in a 'stock'
stock_items = db.relationship('StockItem', lazy='joined')
def __init__(self, **kwargs):
super(Stock, self).__init__(**kwargs)
self.user_id = kwargs.get('user_id')
def full_dict(self):
return {
**self.cols_dict(), 'snapshots': [s for s in self.snapshots.all()],
'items': [item.full_dict() for item in self.stock_items]
}
class Curriculum_Category(db.Model, BaseModelMixin):
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
primary_key=True)
curriculum_id = db.Column(db.Integer,
db.ForeignKey('curriculum.id'),
primary_key=True)
category = db.relationship("Category")
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self):
pass
class UserRole(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
permission = db.relationship('UserPermission',
secondary='user_role_permission',
lazy='joined')
def __repr__(self):
return f"UserRole {self.id} - {self.name} - {self.permission}"
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Subcategory(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
jobs = db.relationship('Job', backref='subcategory', lazy=False, cascade='all, delete-orphan')
category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, name):
self.name = name
@classmethod
def getByName(cls, name):
return cls.query.filter(cls.name == name).first()
class ItemModel(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
item = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"))
store = db.relationship('StoreModel')
def __init__(self, item, price, store_id):
self.item = item
self.price = price
self.store_id = store_id
def json(self):
return {
"name": self.item,
"price": self.price,
"store_id": self.store_id
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(item=name).first()
# @classmethod
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def delete_all(cls):
return cls.query.delete()
class StoreModel(db.Model):
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.Column(db.String(80))
items = db.relationship("ItemModel", lazy="dynamic")
# why use lazy dynamic -- > creates a query builder and therefore we have an option
def __init__(self, name):
self.name = name
def json(self):
return {
"name": self.name,
"items": [item.json() for item in self.items.all()]
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
# @classmethod
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def delete_all(cls):
return cls.query.delete()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False, unique=True)
password = db.Column(db.String(), nullable=False, server_default='')
name = db.Column(db.String(50))
email = db.Column(db.String(50))
roles = db.relationship('Role', backref='user', lazy='dynamic')
def __init__(self, username, password, name, email):
self.username = username
self.password = password
self.name = name
def json(self):
return {
"id": self.id,
"username": self.username,
"name": self.name,
"email": self.email
}, 200
def save_to_db(self):
db.session.add(self)
db.session.commit()
def remove_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_user_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class Interview(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
date_interview = db.Column(db.DateTime)
#Los 4 estados van a ser: created, accepted, finished, cancelled
status = db.Column(db.String, nullable=False, default='created')
#las anotaciones que haga el entrevistador
results = db.Column(db.String)
# created_by = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
created_by = db.Column(db.Integer, nullable=False)
to_user = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
to_job = db.Column(db.Integer, db.ForeignKey('job.id'))
messages = db.relationship('Message',
backref='interview',
lazy=False,
cascade='all, delete-orphan')
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, created_by, to_user, to_job):
self.created_by = created_by
self.to_user = to_user
self.to_job = to_job
@classmethod
def get_by_user_and_job(cls, user, job):
return cls.query.filter(cls.to_user == user.id,
cls.to_job == job.id).first()
@classmethod
def get_pag(cls, data):
filtro = cls.query
filtro = filtro.filter(cls.status == data['status'])
if 'user' in data:
filtro = filtro.filter(cls.to_user == data['user'])
if 'job' in data:
filtro = filtro.filter(cls.to_job == data['job'])
if 'unread' in data:
if data['unread']:
filtro = filtro.filter(Message.status == 'unread').filter(
Message.created_by != Interview.created_by).join(
Interview.messages)
if 'order' in data and data[
'order'] is not None and data['order'] != 'any':
if data['order'] == 'asc':
filtro = filtro.order_by(cls.created_at.asc())
elif data['order'] == 'desc':
filtro = filtro.order_by(cls.created_at.desc())
elif 'orderByInterviewDate' in data and data[
'orderByInterviewDate'] is not None and data[
'orderByInterviewDate'] != 'any':
if data['orderByInterviewDate'] == 'asc':
filtro = filtro.order_by(cls.date_interview.asc())
elif data['orderByInterviewDate'] == 'desc':
filtro = filtro.order_by(cls.date_interview.desc())
if 'page' in data and 'per_page' in data:
return filtro.paginate(int(data['page']), int(data['per_page']),
False, 40)
else:
return filtro.paginate(1, 10, False)
class Curriculum(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
birth_date = db.Column(db.DateTime)
phone = db.Column(db.String)
country = db.Column(db.String)
address = db.Column(db.String)
avatar = db.Column(db.String)
description = db.Column(db.String)
education = db.relationship('Education',
backref='curriculum',
lazy=False,
cascade='all, delete-orphan')
workexperience = db.relationship('WorkExperience',
backref='curriculum',
lazy=False,
cascade='all, delete-orphan')
languages = db.relationship('Language',
backref='curriculum',
lazy=False,
cascade='all, delete-orphan')
categories = db.relationship('Curriculum_Category')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, name):
self.name = name
@classmethod
def get_by_user_id(cls, id):
return cls.query.filter(cls.user_id == id).first()
@classmethod
def get_all_by_job_id(cls, id):
res = db.engine.execute(
'select distinct u.* from "user" as u, job as j, curriculum as c, category as cat, subcategory as sc, curriculum__category as cc where j.id = '
+ str(id) +
' and j.subcategory_id = sc.id and cc.category_id = sc.category_id and cc.curriculum_id = c.id and u.id = c.user_id'
)
return [row for row in res]
@classmethod
def get_all_recommended_users_by_filters(cls, data):
sqlQueryStringBeforeWhere = 'select distinct u.* from "user" as u, curriculum as c, category as cat'
sqlQueryStringAfterWhere = ' where u."role" = ' + "'cliente' and c.user_id = u.id"
if 'category' in data['filters'] and data['filters'][
'category'] is not None:
sqlQueryStringBeforeWhere += ', curriculum__category as cc'
sqlQueryStringAfterWhere += ' and cc.curriculum_id = c.id and u.id = c.user_id and cat.id = ' + str(
data['filters']['category']) + ' and cc.category_id = cat.id'
if 'language' in data['filters'] and data['filters'][
'language'] is not None and len(
data['filters']['language']
) > 0 and data['filters']['language'][0] != ' ':
sqlQueryStringBeforeWhere += ', language as l'
sqlQueryStringAfterWhere += " and l.name = '" + data['filters'][
'language'] + "' and l.curriculum_id = c.id"
if 'ageRange' in data['filters'] and data['filters'][
'ageRange'] is not None:
if 'maxAge' in data['filters']['ageRange'] and data['filters'][
'ageRange']['maxAge']:
sqlQueryStringAfterWhere += " and DATE_PART('year', now()::date) - DATE_PART('year', c.birth_date::date) <= " + str(
data['filters']['ageRange']['maxAge'])
if 'minAge' in data['filters']['ageRange'] and data['filters'][
'ageRange']['minAge']:
sqlQueryStringAfterWhere += " and DATE_PART('year', now()::date) - DATE_PART('year', c.birth_date::date) >= " + str(
data['filters']['ageRange']['minAge'])
sqlQueryString = sqlQueryStringBeforeWhere + sqlQueryStringAfterWhere + ';'
print(sqlQueryString)
res = db.engine.execute(sqlQueryString)
return [row for row in res]
class Snapshot(TimestampMixin, db.Model):
stock_id = db.Column(UUID(as_uuid=True), db.ForeignKey('stock.id'))
stock_item_states = db.relationship('StockItemState',
secondary='snapshot_stock_item_state',
lazy='subquery')
# has lazy loaded 'backref' prop 'stock'
class Job(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String, nullable=False)
title = db.Column(db.String, nullable=False)
location = db.Column(db.String)
workday = db.Column(db.String)
contract_type = db.Column(db.String)
salary = db.Column(db.Integer)
salary_max = db.Column(db.Integer)
description = db.Column(db.String)
requirements = db.relationship('Requirement',
backref='job',
lazy=False,
cascade='all, delete-orphan')
applications = db.relationship('Application',
backref='job',
lazy=False,
cascade='all, delete-orphan')
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
interviews = db.relationship('Interview',
backref='job',
lazy=False,
cascade='all, delete-orphan')
subcategory_id = db.Column(db.Integer, db.ForeignKey('subcategory.id'))
active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, url, title):
self.url = url
self.title = title
@classmethod
def get_pag(cls, data):
filtro = cls.query
filtro = filtro.filter(Job.active == True)
if 'search' in data and data['search'] is not None:
filtro = filtro.filter(
db.or_(Job.title.contains(data['search'].strip()),
Job.description.contains(data['search'].strip())))
if 'workday' in data and data['workday'] is not None:
filtro = filtro.filter(Job.workday == data['workday'])
if 'category' in data and data['category'] is not None:
categoryId = str(data['category'])
subcat = [
row for row in db.engine.execute(
'select * from subcategory where subcategory.category_id = '
+ categoryId)
]
filtro = filtro.filter(Job.subcategory_id == subcat[0]['id'])
if 'minSalary' in data and data['minSalary'] is not None:
filtro = filtro.filter(Job.salary > int(data['minSalary']))
if 'location' in data and data['location'] is not None:
if data['location'] == 'remote':
filtro = filtro.filter(Job.location == data['location'])
else:
filtro = filtro.filter(
func.lower(Job.location).contains(
data['location'].strip().lower()))
if 'freelance' in data and data[
'freelance'] is not None and data['freelance'] is True:
filtro = filtro.filter(func.lower(Job.url).contains('workana'))
if 'page' in data and 'per_page' in data:
return filtro.paginate(data['page'], data['per_page'], False, 40)
else:
return filtro.paginate(1, 10, False)
@classmethod
def get_pag_company(cls, data):
filtro = cls.query
if 'company_id' in data and data['company_id'] is not None:
filtro = filtro.filter(Job.company_id == data['company_id'])
if 'page' in data and 'per_page' in data:
return filtro.paginate(data['page'], data['per_page'], False, 40)
else:
return filtro.paginate(1, 10, False)
@classmethod
def search_by_title(cls, title):
filtro = cls.query.filter(Job.title.contains(title))
return filtro.paginate(1, 5, False).items
@classmethod
def search_by_url(cls, url):
filtro = cls.query.filter(Job.url == url)
filtro = filtro.filter(Job.active == True).first()
return filtro
@classmethod
def get_all_by_url(cls, url):
filtro = cls.query.filter(Job.url.contains(url))
return filtro
@classmethod
def get_id(cls):
filtro = db.engine.execute(
"select setval('job_id_seq', (select max(id) from job));")
return [row for row in filtro]
@classmethod
def search_by_id(cls, id):
filtro = cls.query.filter(Job.id == id)
filtro = filtro.filter(Job.active == True).first()
return filtro
class Prompt(db.Model):
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
date_created = db.Column(TIMESTAMP(timezone=True), default=datetime.utcnow)
created_by = db.Column(UUID(as_uuid=True),
db.ForeignKey('registered_user.id'),
nullable=False)
content = db.Column(db.String(240), nullable=False)
status = db.Column(db.String,
db.ForeignKey('review_status_kind.name'),
default='pending')
posts = db.relationship('Post',
lazy='dynamic',
backref=db.backref('prompt',
lazy='joined',
uselist=False))
reviews = db.relationship('PromptReview', lazy='dynamic')
# def as_dict(self, include_reviews=False):
# ret = {}
# if include_reviews:
# ret.update({'reviews': self.reviews.all()})
# ret.update({ c.name: getattr(self, c.name) for c in self.__table__.columns })
# return ret
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def get_paginated(cls, status='', include_reviews=False, desc=True):
result = cls.query.filter_by(status=status)\
.order_by(cls.date_created.desc() if desc else cls.date_created.asc())\
.paginate()
return dict(page=result.page,
has_next=result.has_next,
per_page=result.per_page,
items=[x.as_dict(include_reviews) for x in result.items])
@classmethod
def new_to_old(cls, status='', cursor=None, limit=50):
if not status:
raise ValueError('no status provied')
conditions = cls.status == status, # tuple
if cursor:
prompt = cls.query.get(cursor)
conditions = cls.status == status, cls.date_created < prompt.date_created # tuple
return cls.query.filter(*conditions)\
.order_by(cls.date_created.desc())\
.limit(limit)\
.all()
@classmethod
def old_to_new(cls, status='', cursor=None, limit=50):
if not status:
raise ValueError('no status provied')
conditions = cls.status == status,
if cursor:
prompt = cls.query.get(cursor)
conditions = cls.status == status, cls.date_created > prompt.date_created
return cls.query.filter(*conditions)\
.order_by(cls.date_created.asc())\
.limit(limit)\
.all()