def get(self):
'''returns all the bucketlists of the user'''
usr_id = g.user.id
# set limit for pagination
if 'limit' in request.args:
if request.args['limit'].isdigit():
limit = int(request.args['limit'])
else:
abort(400, message='limit parameter should be an integer')
else:
limit = 20
# set page of pagination
if 'page' in request.args:
if request.args['page'].isdigit():
page = int(request.args['page'])
else:
abort(400, message='page parameter should be an integer')
else:
page = 1
# get the bucketlists and implement search if required
if 'q' in request.args:
query = db_session.query(BucketList).\
filter_by(created_by=usr_id).\
filter(BucketList.name.like('%'+request.args['q']+'%'))
paginator = Paginator(query, limit)
current_page = paginator.page(page)
bucketlists = current_page.object_list
else:
# get all bucketlists for this user and implement pagination
query = db_session.query(BucketList).filter_by(created_by=usr_id)
paginator = Paginator(query, limit)
current_page = paginator.page(page)
bucketlists = current_page.object_list
if bucketlists is None:
rv = {'bucketlists': 'none'}
else:
ls = []
schema = BucketListSchema()
for bucketlist in bucketlists:
ls.append(schema.dump(bucketlist).data)
rv = {
'total_objects': current_page.paginator.count,
'total_pages': current_page.paginator.total_pages,
'current_page': current_page.number,
'has_next_page': current_page.has_next(),
'has_previous_page': current_page.has_previous(),
'bucketlists': ls
}
return rv, 200
def test_pagination(self):
query = self.session.query(self.Person)
paginator = Paginator(query, 10)
page = paginator.page(2)
self.assertEquals(paginator.total_pages,
100,
msg="Total page= %s, expected= %s" %
(paginator.total_pages, 100))
self.assertEquals(paginator.count,
1000,
msg="Total records= %s, expected= %s" %
(paginator.count, 1000))
self.assertEquals(len(page.object_list),
10,
msg="Total records in page= %s, expected= %s" %
(len(page.object_list), 10))
self.assertEquals(page.previous_page_number,
1,
msg="Previous page number= %s, expected= %s" %
(page.previous_page_number, 1))
self.assertEquals(page.next_page_number,
3,
msg="Next page number= %s, expected= %s" %
(page.next_page_number, 3))
self.assertEquals(page.start_index,
11,
msg="Start index of page= %s, expected= %s" %
(page.start_index, 11))
self.assertEquals(page.end_index,
20,
msg="End index of page= %s, expected= %s" %
(page.end_index, 20))
def get_words(self, limit, page_number, callback=None):
session = self.db_session
result = None
word = Word()
meta_obj = {}
try:
query = session.query(Word)
paginator = Paginator(query, int(limit))
page = paginator.page(int(page_number))
result = self.serialize_alchemy(page.object_list)
meta_obj = {
"page":
page_number,
"limit":
limit,
"next_page":
page.has_next() and page.next_page_number or None,
"previous_page":
page.has_previous() and page.previous_page_number or None,
"page_count":
paginator.total_pages,
"total_count":
paginator.count,
"Links":
generate_meta(
type(word).__name__.lower(), limit, page_number,
paginator.total_pages)
}
except Exception as e:
result = []
callback(result, meta_obj)
def home():
page = request.args.get('page',1,type=int)
query = session.query(Post).order_by(Post.date_posted.desc())
posts = Paginator(query, 5)
if page > posts.pages_range[-1]:
return render_template("errors/404.html")
posts_page = posts.page(page)
show_pages = pagination(page, posts.pages_range)
return render_template('home.html', posts_page=posts_page, posts=posts, show_pages=show_pages)
def user_posts(username):
page = request.args.get('page', 1, type=int)
user = session.query(User).filter_by(username=username).first()
if not user:
return render_template("errors/404.html")
query = session.query(Post).filter_by(author=user).order_by(
Post.date_posted.desc())
posts = Paginator(query, 5)
if page > posts.pages_range[-1]:
return render_template("errors/404.html")
posts_page = posts.page(page)
show_pages = pagination(page, posts.pages_range)
return render_template('user_posts.html',
query=query,
posts_page=posts_page,
posts=posts,
show_pages=show_pages,
user=user)
def get_reports_download_detail(self, start_date: datetime, end_date: datetime, acquirer: str, filters: list, page:int, pageSize: int):
df = []
keys = []
meta= {
"total": 0,
"current": page,
"pageSize": pageSize
}
try:
queue_files = self.session.query(QueueDetail, QueueProcesses.acquirer.label("acquirer"))\
.select_from(QueueDetail)\
.join(QueueProcesses, QueueDetail.processId==QueueProcesses.process_id)\
.filter(
between(QueueDetail.createdAt, start_date, end_date)
)
if acquirer != 'ALL':
queue_files= queue_files.filter(QueueProcesses.acquirer==acquirer)
if filters:
queue_files = self.make_search_query(filters, queue_files)
paginator = Paginator(queue_files, meta["pageSize"])
page = paginator.page(meta["current"])
meta["total"] = page.paginator.count
meta["countPages"] = page.paginator.total_pages
meta["previous_page_number"] = page.previous_page_number
meta["next_page_number"] = page.next_page_number
# queue_files = queue_files.limit(50)
# print(meta)
# print(page.object_list)
# df = pd.read_sql(queue_files.statement, self.session.bind)
objects = [
{
"detailId": item.detailId,
"clientCode": item.clientCode,
"shortName": item.shortName,
"storeCode": item.storeCode,
"merchantCode": item.merchantCode,
"text": item.text,
"error": item.error,
"statusCode": item.statusCode,
"fileDate": item.fileDate,
"createdAt": item.createdAt.isoformat() if item.createdAt else item.createdAt,
"endAt": item.endAt.isoformat() if item.endAt else item.endAt,
"isDone": item.isDone,
"isRunning": item.isRunning,
"retrys": item.retrys,
"webhookId": item.webhookId,
"acquirer": acquirer
} for item, acquirer in page.object_list
]
# print(objects)
if not objects: return
df = pd.DataFrame(objects)
# df.rename(columns={name: "".join([name.split('_')[0], name.split('_')[1].capitalize()]) if len(name.split('_'))>1 else name for name in df.columns}, inplace=True)
# print(len(df))
df['webhookId'] = df['webhookId'].fillna(0).astype(int)
keys = df.columns.tolist()
df = df.to_dict(orient='records')
# print(df)
except Exception as error:
print(str(error))
finally:
self.session.close()
return df, keys, meta
