def paginate(query: BaseQuery, schema: Schema) -> dict:
if not request.endpoint:
raise Exception("Cannot paginate outside of request context.")
page = request.args.get("page", DEFAULT_PAGE_NUMBER)
per_page = request.args.get("page_size", DEFAULT_PAGE_SIZE)
page_obj = query.paginate(page=page, per_page=per_page)
next_ = url_for(
request.endpoint,
page=page_obj.next_num if page_obj.has_next else page_obj.page,
per_page=per_page,
**request.view_args)
prev = url_for(
request.endpoint,
page=page_obj.prev_num if page_obj.has_prev else page_obj.page,
per_page=per_page,
**request.view_args)
return {
"total": page_obj.total,
"pages": page_obj.pages,
"next": next_,
"prev": prev,
"results": schema.dump(page_obj.items),
}
def get_pagination(query: BaseQuery) -> Tuple[list, dict]:
page = request.args.get("page", 1, type=int)
limit = request.args.get("limit",
current_app.config.get("PER_PAGE", 5),
type=int)
params = {k: v for k, v in request.args.items() if k != "page"}
paginate_object = query.paginate(page, limit, False)
pagination = {
"total_pages":
paginate_object.pages,
"total_records":
paginate_object.total,
"current_page":
url_for("api.users_api.get_users_info", page=page, **params),
}
if paginate_object.has_next:
pagination["next_page"] = url_for("api.users_api.get_users_info",
page=page + 1,
**params)
if paginate_object.has_prev:
pagination["previous_page"] = url_for(
"api.users_api.get_users_info", page=page - 1, **params)
return paginate_object.items, pagination
def get_pagination(query: BaseQuery, func_name: str) -> Tuple[list, dict]:
"""
Functionality of paginating response, returns modified query
page - page number to return
limit - number of items in one page to return
"""
page = request.args.get("page", 1, type=int)
limit = request.args.get("limit",
current_app.config.get("PER_PAGE", 5),
type=int)
params = {
key: value
for key, value in request.args.items() if key != "page"
}
paginate_obj = query.paginate(page, limit, False)
pagination = {
"total_pages": paginate_obj.pages,
"total_records": paginate_obj.total,
"current_page": url_for(func_name, page=page, **params),
}
if paginate_obj.has_next:
pagination["next_page"] = url_for(func_name, page=page + 1, **params)
if paginate_obj.has_prev:
pagination["previous_page"] = url_for(func_name,
page=page - 1,
**params)
return paginate_obj.items, pagination
def get_pagination(query: BaseQuery, func_name: str) -> Tuple[list, dict]:
page = request.args.get('page', 1, type=int)
limit = request.args.get('limit',
current_app.config.get('PER_PAGE', 5),
type=int)
params = {
key: value
for key, value in request.args.items() if key != 'page'
}
paginate_obj = query.paginate(page, limit, False)
pagination = {
'total_pages': paginate_obj.pages,
'total_records': paginate_obj.total,
'current_pages': url_for(func_name, page=page, **params)
}
if paginate_obj.has_next:
pagination['next_page'] = url_for(func_name, page=page + 1, **params)
if paginate_obj.has_prev:
pagination['previous_page'] = url_for(func_name,
page=page - 1,
**params)
return paginate_obj.items, pagination
def paginate(self, page=None, per_page=None, error_out=True, max_per_page=None): paginate = BaseQuery.paginate(self, page=page, per_page=per_page, error_out=error_out, max_per_page=max_per_page) return Pagination(self, paginate.page, paginate.per_page, paginate.total, paginate.items )
def paginate_query(query, page, per_page, **kwargs):
ret_page = BaseQuery.paginate(query, page, per_page, **kwargs)
if ret_page.has_prev:
ret_page.prev_link = "{}?{}".format(
request.base_url, urlencode({'page': ret_page.prev_num, 'per_page': ret_page.per_page}))
if ret_page.has_next:
ret_page.next_link = "{}?{}".format(
request.base_url, urlencode({'page': ret_page.next_num, 'per_page': ret_page.per_page}))
return ret_page
def get_limited_query(self, query: BaseQuery, **kwargs) -> Union[Pagination, BaseQuery]:
"""Apply pagination limits on query"""
per_page = int(kwargs.get('page_size', API_DEFAULT_PAGE_SIZE))
page = int(kwargs.get('page', 1))
if page < 0 or per_page < 1:
raise ProblemException(
title='Invalid paging parameters', detail='page and page_size should be greater than 0')
return query.paginate(page=page or 1, per_page=per_page, error_out=False)
def __init__(self, collection: BaseQuery, page_params: PaginationParameters):
"""Create a Page instance
:param sequence collection: base_query
:page PaginationParameters page_params: Pagination parameters
"""
# 使用 flask_sqlalchemy 提供的 分页函数进行分页
self.pagination = collection.paginate(page=page_params.page,
per_page=page_params.page_size)
super().__init__(collection, page_params)
def paginate(self,
page=None,
per_page=None,
error_out=True,
max_per_page=None):
# 使用paginator记的加上filter_by，用于默认添加status=1
paginator = BaseQuery.paginate(self,
page=page,
per_page=per_page,
error_out=error_out,
max_per_page=max_per_page)
return Pagination(self, paginator.page, paginator.per_page,
paginator.total, paginator.items)
def __init__(
self,
member_class: Type[T],
query: BaseQuery,
per_page: int,
page: int,
joined_relations: List[str] = None,
pagination: Pagination = None,
) -> None:
self.type = member_class
self.joined_relations = joined_relations
if pagination:
self.pagination = pagination
else:
self.pagination = query.paginate(per_page=per_page, page=page)
def ql_so_luong_ton(page):
if not current_user.is_authenticated or current_user.ma_loai_nguoi_dung != 2:
return redirect(url_for('log_in', next=request.url))
form = Form_tim_kiem()
query = BaseQuery(San_pham, dbSession)
page_filter = query.paginate(page,5,False)
if form.validate_on_submit():
tim_kiem = form.noi_dung.data
if tim_kiem.isdigit():
page_filter = query.filter(San_pham.ma_san_pham == int(tim_kiem)).paginate(page,5,False)
else:
chuoi_truy_van = '%'+tim_kiem.upper()+'%'
page_filter = query.filter(San_pham.ten_san_pham.like(chuoi_truy_van)).paginate(page,5,False)
if len(page_filter.items) == 0:
thong_bao = 'Không tìm thấy sản phẩm!'
return render_template('Quan_ly/QL_kho_hang/Ton_kho.html', form=form, page_filter = page_filter)
def force_pagination(query: BaseQuery, order=None):
query = query.order_by(order if order is not None else desc('id'))
page = int(request.values.get('page', 1))
per_page = int(request.values.get('per_page', FETCH_LIMIT))
pagination = query.paginate(page, per_page,
error_out=False) # type: Pagination
return jsonify({
'rows': [instance.to_json() for instance in pagination.items],
'max_page':
pagination.pages,
'curr_page':
pagination.page,
'next_page':
pagination.next_num,
'prev_page':
pagination.prev_num,
})
def paginate(
query: flask_sqlalchemy.BaseQuery, schema: BaseSchema
) -> Dict[str, Union[int, Dict[str, Union[int, str]], str, None]]:
"""Return paginated BaseQuery result."""
page = int(request.args.get("page", app.config["DEFAULT_PAGE_NUMBER"]))
per_page = int(
request.args.get("page_size", app.config["DEFAULT_PAGE_SIZE"]))
page_obj = query.paginate(page=page, per_page=per_page)
sort_args = {
"sort_by": request.args.get("sort_by"),
"order_by": request.args.get("order_by"),
}
if page_obj.has_next:
next_page: Optional[str] = url_for(
request.endpoint, # type: ignore
page=page_obj.next_num,
per_page=per_page,
**request.view_args,
**sort_args)
else:
next_page = None
if page_obj.has_prev:
prev_page: Optional[str] = url_for(
request.endpoint, # type: ignore
page=page_obj.prev_num,
per_page=per_page,
**request.view_args,
**sort_args)
else:
prev_page = None
return {
"count": page_obj.total,
"pages": page_obj.pages,
"next": next_page,
"prev": prev_page,
"results": schema.dump(page_obj.items, many=True),
}
def ql_don_hang_tao_don_moi_detail(ma_hd,page=1):
if not current_user.is_authenticated or current_user.ma_loai_nguoi_dung != 2:
return redirect(url_for('log_in', next=request.url))
form = Form_tim_kiem_nhap_hang()
hoa_don = dbSession.query(Hoa_don).filter(Hoa_don.ma_hoa_don == ma_hd).first()
don_hang = dbSession.query(Don_hang).filter(Don_hang.ma_hoa_don == ma_hd).all()
query = BaseQuery(San_pham, dbSession)
page_filter = query.paginate(page,10,False)
thong_bao = ''
if form.validate_on_submit() and form.noi_dung.data != '':
ten_sp = form.noi_dung.data.strip().lower()
if ten_sp.isdigit():
page_filter = query.filter_by(ma_san_pham = int(ten_sp)).paginate(page,10,False)
else:
page_filter = query.filter_by(ten_san_pham = ten_sp).paginate(page,10,False)
if len(page_filter.items) == 0:
thong_bao = 'Không tìm thấy sản phẩm!'
return render_template('Quan_ly/QL_don_hang/Chi_tiet_don_hang.html',don_hang = don_hang, thong_bao = thong_bao, page_filter = page_filter, form = form, hoa_don = hoa_don)
def paginate(query: BaseQuery, page: int = 1, rows_per_page: int = 1):
pagination = query.paginate(page=page,
per_page=rows_per_page,
error_out=False)
data = pagination.items
output = {
"pagination": {
"pages_count": pagination.pages,
"itens_count": pagination.total,
"itens_per_page": rows_per_page,
"prev": pagination.prev_num,
"next": pagination.next_num,
"current": pagination.page,
},
"itens": [],
"error": False,
}
return data, output
def __init__(self, query: BaseQuery, page_param: str = 'page') -> None:
"""
Initialize the pagination object.
The current page will be determined from the page parameter in the request arguments. If the page parameter
is not included in the request arguments, the current page defaults to `1`.
:param query: The base query that will be paginated.
:param page_param: The name of the page parameter specifying the current page. Defaults to `page`.
"""
# Get the current page from the request arguments.
try:
self.current_page = request.args.get(page_param, 1, type=int)
except TypeError:
# In tests, the above call fails because get does not take keyword arguments - it does however work outside
# of requests. Thus, fall back to this manual conversion.
self.current_page = int(request.args.get(page_param, 1))
application = get_app()
self.rows_per_page = application.config['ITEMS_PER_PAGE']
self._rows = query.paginate(self.current_page, self.rows_per_page)
def __init__(self, query: BaseQuery, page_param: str = 'page') -> None:
"""
The current page will be determined from the page parameter in the request arguments. If the page parameter
is not included in the request arguments, the current page defaults to `1`.
:param query: The base query that will be paginated.
:param page_param: The name of the page parameter specifying the current page. Defaults to ``page``.
"""
self.current_page: int
self.rows_per_page: int
# Get the current page from the request arguments.
try:
self.current_page = request.args.get(page_param, 1, type=int)
except TypeError:
# In tests, the above call fails because get does not take keyword arguments - it does however work outside
# of requests. Thus, fall back to this manual conversion.
self.current_page = int(request.args.get(page_param, 1))
application = get_app()
self.rows_per_page = application.config['ITEMS_PER_PAGE']
self._rows = query.paginate(self.current_page, self.rows_per_page)
def paginate(query: BaseQuery, page_num: int = 1, page_size: int = 10):
query_slice = query.paginate(int(page_num), int(page_size))
result = dict()
result.update(data=query_slice.items, has_previous=query_slice.has_prev, has_next=query_slice.has_next)
return result
