def index(path='/'):
if path=='favicon.ico':
return redirect('https://www.baidu.com/favicon.ico')
code=request.args.get('code')
page=request.args.get('page',1,type=int)
password=has_password(path)
md5_p=md5(path)
if request.method=="POST":
password1=request.form.get('password')
if password1==password:
resp=make_response(redirect(url_for('.index',path=path)))
resp.delete_cookie(md5_p)
resp.set_cookie(md5_p,password)
return resp
if password!=False:
if not request.cookies.get(md5_p) or request.cookies.get(md5_p)!=password:
return render_template('password.html',path=path)
if code is not None:
Atoken=OAuth(code)
if Atoken.get('access_token'):
with open('data/Atoken.json','w') as f:
json.dump(Atoken,f,ensure_ascii=False)
app_url=GetAppUrl()
refresh_token=Atoken.get('refresh_token')
with open('data/AppUrl','w') as f:
f.write(app_url)
token=ReFreshToken(refresh_token)
with open('data/token.json','w') as f:
json.dump(token,f,ensure_ascii=False)
return make_response('<h1>授权成功!<a href="/">点击进入首页</a></h1>')
else:
return jsonify(Atoken)
else:
if items.count()==0:
if not os.path.exists('data/token.json'):
return make_response('<h1><a href="{}">点击授权账号</a></h1>'.format(LoginUrl))
else:
subprocess.Popen('python function.py UpdateFile',shell=True)
return make_response('<h1>正在更新数据!</h1>')
if request.args.get('image_mode'):
image_mode=request.args.get('image_mode',type=int)
resp,total = FetchData(path,page)
pagination=Pagination(query=None,page=page, per_page=50, total=total, items=None)
resp=make_response(render_template('index.html',pagination=pagination,items=resp,path=path,image_mode=image_mode,endpoint='.index'))
resp.set_cookie('image_mode',str(image_mode))
else:
image_mode=request.cookies.get('image_mode') if request.cookies.get('image_mode') is not None else 0
image_mode=int(image_mode)
resp,total = FetchData(path,page)
pagination=Pagination(query=None,page=page, per_page=50, total=total, items=None)
resp=make_response(render_template('index.html',pagination=pagination,items=resp,path=path,image_mode=image_mode,endpoint='.index'))
resp.set_cookie('image_mode',str(image_mode))
return resp
def users_search_with_pagination(self,
username_hint,
fav_only,
hidden,
current_page=1,
per_page=20,
sort_type='alphabetical'):
"""
Search users with defined parameters and return them as a SearchResults object which contains a Pagination object.
:param current_user The user who made the research
:param username_hint: A hint gave by the user to search similar usernames
:param fav_only: containing "True" to show only bookmarked users else None
:param hidden: containing "True" to show hidden users else None
:param current_page: The current page number
:param per_page: The number of users shown on a search results page
:param sort_type: The sort type to use, using the ResultsSortType class constants
:return: A SearchResults with a Pagination object.
"""
results = self.users_search(username_hint, fav_only, hidden, sort_type)
page_elements = results.items.slice(
(current_page - 1) * per_page, current_page *
per_page) # the users that will be displayed on the page
results.pagination = Pagination(None, current_page, per_page,
results.items.count(), page_elements)
results.items = None
return results
def render_question_answer():
Question = models.Question
try:
number = int(request.args.get('page') or 1)
except ValueError:
number = 1
if number < 1:
abort(404)
try:
page = models.Page.get_by_label('question-answer')
except NoResultFound:
abort(404)
total = db.session.query(Question.id).count()
questions = (
db.session.query(Question)
.order_by(Question.id.desc())
.limit(QUESTIONS_PER_PAGE)
.offset(QUESTIONS_PER_PAGE * (number - 1)).all()
)
if not questions and number != 1:
abort(404)
pagination = Pagination(None, number, QUESTIONS_PER_PAGE, total, items=questions)
modified = (
db.session.query(Question.date_modified)
.order_by(Question.date_modified.desc()).limit(1).scalar()
)
if modified and modified > page.date_modified:
page.date_modified = modified
return _generate_response('company/question-answer.html', page=page,
pagination=pagination)
def paginate(query: Query,
page: int,
per_page: int,
*,
item_mapper: Mapper = None) -> Pagination:
"""Return `per_page` items from page `page`."""
if page < 1:
page = 1
if per_page < 1:
raise ValueError('The number of items per page must be positive.')
offset = (page - 1) * per_page
items = query \
.limit(per_page) \
.offset(offset) \
.all()
item_count = len(items)
if page == 1 and item_count < per_page:
total = item_count
else:
total = query.order_by(None).count()
if item_mapper is not None:
items = [item_mapper(item) for item in items]
# Intentionally pass no query object.
return Pagination(None, page, per_page, total, items)
def read_all_formats(self, identity):
"""Read available metadata formats."""
self.require_permission(identity, 'read_format')
formats = [{
"id": k,
"schema": v.get("schema", None),
"namespace": v.get("namespace", None),
} for k, v in current_app.config.get(
'OAISERVER_METADATA_FORMATS').items()]
results = Pagination(
query=None,
page=1,
per_page=None,
total=len(formats),
items=formats,
)
return self.config.metadata_format_result_list_cls(
self,
identity,
results,
schema=ServiceSchemaWrapper(
self, schema=self.config.metadata_format_schema),
)
def manage():
if request.method=='POST':
pass
path=urllib.unquote(request.args.get('path','A:/'))
user,n_path=path.split(':')
if n_path=='':
path=':'.join([user,'/'])
page=request.args.get('page',1,type=int)
image_mode=request.args.get('image_mode')
sortby=request.args.get('sortby')
order=request.args.get('order')
if sortby:
sortby=request.args.get('sortby')
else:
sortby=request.cookies.get('admin_sortby') if request.cookies.get('admin_sortby') is not None else 'lastModtime'
sortby=sortby
if order:
order=request.args.get('order')
else:
order=request.cookies.get('admin_order') if request.cookies.get('admin_order') is not None else 'desc'
order=order
resp,total = FetchData(path=path,page=page,per_page=50,sortby=sortby,order=order)
pagination=Pagination(query=None,page=page, per_page=50, total=total, items=None)
if path.split(':',1)[-1]=='/':
path=':'.join([path.split(':',1)[0],''])
resp=make_response(render_template('admin/manage.html',pagination=pagination,items=resp,path=path,sortby=sortby,order=order,cur_user=user,endpoint='admin.manage'))
resp.set_cookie('admin_sortby',str(sortby))
resp.set_cookie('admin_order',str(order))
return resp
def test_jsonify_paginate(self):
"""Testing the jsonify_paginate method"""
with app.app_context():
items = []
for index in range(12):
item = Category(name=str(index))
items.append(item)
page = Pagination(query=None,
page=1,
per_page=12,
total=30,
items=items)
resp = jsonify_paginate(page)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.is_json, True)
data = resp.get_json()
self.assertEqual(data["page"], 1)
self.assertEqual(data["pages"], 3)
self.assertEqual(data["per_page"], 12)
self.assertEqual(data["total"], 30)
self.assertEqual(len(data["items"]), 12)
def index(page=1, page_size=20):
"""评论列表"""
g.page_title = _(u'商品评价')
args = request.args
goods_id = toint(args.get('goods_id', '0'))
add_time_daterange = args.get('add_time_daterange', '').strip()
q = db.session.query(Comment.comment_id, Comment.uid, Comment.nickname, Comment.avatar,
Comment.rating, Comment.content, Comment.img_data, Comment.add_time,
Goods.goods_id, Goods.goods_name, Goods.goods_img).\
filter(Comment.tid == Goods.goods_id).\
filter(Comment.ttype == 1).\
filter(Comment.is_show == 1)
if goods_id > 0:
q = q.filter(Comment.tid == goods_id)
if add_time_daterange:
start, end = date_range(add_time_daterange)
q = q.filter(Comment.add_time >= start).filter(Comment.add_time < end)
comments = q.order_by(Comment.comment_id.desc()).offset(
(page - 1) * page_size).limit(page_size).all()
pagination = Pagination(None, page, page_size, q.count(), None)
return render_template('admin/comment/index.html.j2',
pagination=pagination,
comments=comments)
def admin_users(page):
if request.method == 'POST':
if 'submit' in request.form:
command = request.form['submit'].split('-')[0]
email = request.form['submit'].split('-')[1]
if command == 'disable':
User.query.filter_by(email=email).first().is_live = False
db.session.commit()
elif command == 'enable':
User.query.filter_by(email=email).first().is_live = True
db.session.commit()
query = User.query.all
count = len(query())
users = utilities.get_items_for_page(query, page)
table_header = [
'ID', 'Name', 'Email Address', 'Role', 'Is Live?', 'Enable/Disable'
]
table_data = [[
str(user.id), user.name, user.email, user.role.name, user.is_live
] for user in users]
if not users and page != 1:
abort(404)
pagination = Pagination(query(), page, app.config['PER_PAGE'], count,
users)
return render_template('admin_users.html',
user=current_user.name,
user_role=current_user.role.name,
all_users_header=table_header,
all_users_list=table_data,
pagination=pagination)
def get(self, time_range):
if time_range not in ["week", "month"]:
return error(ErrorCode.INVALID_PARAMS, 400)
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if time_range == "week":
days = 7
else:
days = 30
movie_ids, total = get_rank_movie_ids_with_range(
days, args.page, args.per_page)
movies = MovieModel.query.filter(MovieModel.id.in_(movie_ids)).all()
pagination = Pagination("", args.page, args.per_page, total, movies)
p = get_item_pagination(pagination,
"api.LeaderBoard",
time_range=time_range)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def index(page=1, page_size=20):
"""优惠券列表"""
g.page_title = _(u'优惠券')
args = request.args
tab_status = toint(args.get('tab_status', '0'))
cb_name = args.get('cb_name', '').strip()
current_time = current_timestamp()
q = CouponBatch.query
if tab_status == 1:
q = q.filter(CouponBatch.is_valid == 1).\
filter(or_(CouponBatch.begin_time == 0, CouponBatch.begin_time <= current_time)).\
filter(or_(CouponBatch.end_time == 0, CouponBatch.end_time >= current_time))
elif tab_status == 2:
q = q.filter(
and_(CouponBatch.end_time > 0,
CouponBatch.end_time < current_time))
if cb_name:
q = q.filter(CouponBatch.cb_name.like('%%%s%%' % cb_name))
batches = q.order_by(CouponBatch.cb_id.desc()).offset(
(page - 1) * page_size).limit(page_size).all()
pagination = Pagination(None, page, page_size, q.count(), None)
return render_template('admin/coupon/index.html.j2',
pagination=pagination,
batches=batches)
def statistics_event():
position = request.args.get('position')
page = int(request.args.get('page', 1))
size = int(request.args.get('size', 20))
unique = int(request.args.get('unique', 0))
start_time, end_time = _parse_start_end_time()
query = Event.query.filter(Event.company_id == g.user.company_id,
Event.timestamp > start_time,
Event.timestamp <= end_time)
if position:
screen = Screen.query.filter_by(camera_position=position).first()
if screen is None:
return error_result(ErrorCode.ERROR_SCREEN_NOT_EXIST)
query = query.filter(Event.screen_id == screen.id)
events = query.order_by(Event.timestamp.desc()).all()
result = [
event.get_json()
for event in _filter_events(events, unique=bool(unique))
]
page_info = page_format(Pagination(None, page, size, len(result), None))
result = result[(page - 1) * size:page * size]
return success_result(result, page_info)
def new_search(cls, query, page, order_by=None, per_page=PER_PAGE):
"""用于在搜索栏搜搜, query是输入的搜索内容, 字符串"""
s = cls.search()
# multi_match: 多个字段匹配, SEARCH_FIELDS设置了字段权重
s = s.query('multi_match', query=query, fields=SEARCH_FIELDS)
if page < 1:
page = 1
start = (page - 1) * PER_PAGE
s = s.extra(**{'from': start, 'size': per_page})
if order_by is not None:
s = s.sort(order_by)
rs = s.execute()
dct = defaultdict(list)
# 这里考虑了多种kind的情况, 不过我们目前只会用到Post
for i in rs:
dct[i.kind].append(i.id)
items = []
for kind, ids in dct.items():
target_cls = TARGET_MAPPER.get(kind)
# 最终还是依靠orm来获取数据
if target_cls:
items_ = target_cls.get_multi(ids)
items.extend(items_)
return Pagination(query, page, per_page, rs.hits.total, items)
def paginate_faste(self,
page=1,
per_page=50,
max_page=None,
step=5,
count_query=None):
if page < 1:
abort(404)
if max_page and page > max_page:
abort(404)
# Count all items
if count_query is not None:
total_query_count = count_query.scalar()
else:
total_query_count = self.count()
# Grab items on current page
items = self.limit(per_page).offset((page - 1) * per_page).all()
if not items and page != 1:
abort(404)
return Pagination(self, page, per_page, total_query_count, items)
def sessions_search_with_pagination(self,
sessions_hint,
typ,
search_parameter,
page=1,
per_page=20,
sort_type='mostRecent'):
"""
Search sessions with defined parameters and return them as a SearchResults object which contains a Pagination object.
:param current_user The user who made the research
:param sessions_hint: A hint gave by the user to search various sessions
:param typ: str containing the type of sessions_hint (search filter)
:param search_parameter: str containing the name of the search container
:param current_page: The current page number
:param per_page: The number of users shown on a search results page
:return: A SearchResults with a Pagination object.
"""
results = self.sessions_search(sessions_hint, typ, search_parameter,
sort_type)
page_elements = results.items.slice(
(page - 1) * per_page,
page * per_page) # the sessions that will be displayed on the page
results.pagination = Pagination(None, page, per_page,
results.items.count(), page_elements)
results.items = None
return results
def find(key_word):
page = request.args.get('page', 1, type=int)
image_mode = request.args.get('image_mode')
sortby = request.args.get('sortby')
order = request.args.get('order')
action = request.args.get('action', 'download')
resp, total = FetchData(path=key_word,
page=page,
per_page=50,
sortby=sortby,
order=order,
dismiss=True,
search_mode=True)
pagination = Pagination(query=None,
page=page,
per_page=50,
total=total,
items=None)
resp = make_response(
render_template('theme/{}/find.html'.format(GetConfig('theme')),
pagination=pagination,
items=resp,
path='/',
sortby=sortby,
order=order,
key_word=key_word,
cur_user='******'.format(key_word),
endpoint='.find'))
resp.set_cookie('image_mode', str(image_mode))
resp.set_cookie('sortby', str(sortby))
resp.set_cookie('order', str(order))
return resp
def optimised_pagination(query, per_page, page):
""" A more efficient pagination for SQLAlchemy
Fetch one item before offset (to know if there's a previous page)
Fetch one item after limit (to know if there's a next page)
The trade-off is that the total items are not available, but if you don't need them
there's no need for an extra COUNT query
"""
offset_start = (page - 1) * per_page
query_offset = max(offset_start - 1, 0)
optimistic_items = query.limit(per_page + 1).offset(query_offset).all()
if page == 1:
if len(optimistic_items) == per_page + 1:
# On first page, there's no optimistic item for previous page
items = optimistic_items[:-1]
else:
# The number of items on the first page is fewer than per_page
items = optimistic_items
elif len(optimistic_items) == per_page + 2:
# We fetched an extra item on both ends
items = optimistic_items[1:-1]
else:
# An extra item only on the head
# This is the last page
items = optimistic_items[1:]
# This total is at least the number of items for the query, could be more
total = offset_start + len(optimistic_items)
return Pagination(query, page, per_page, total, items)
def UploadRPCserver():
action = request.form.get('action')
page = request.form.get('page', 1, type=int)
if action == 'pagination':
data = {'code': 1}
total = get_upload_tasks_no()
pagination = Pagination(query=None,
page=page,
per_page=50,
total=total,
items=None)
data['page'] = page
data['pages'] = pagination.pages
page_lists = []
for p in pagination.iter_pages():
page_lists.append(p)
data['page_lists'] = page_lists[::-1]
data['has_prev'] = pagination.has_prev
data['has_next'] = pagination.has_next
return jsonify(data)
elif action == 'ClearHist':
mon_db.upload_queue.delete_many({})
ret = {'msg': '清除成功！'}
return jsonify(ret)
elif action == 'Restart':
cmd = 'python {}/function.py StartUploadQueue'.format(config_dir)
subprocess.Popen(cmd, shell=True)
ret = {'msg': '重启成功！'}
return jsonify(ret)
ret = get_upload_tasks(page)
data = {'code': 1, 'result': ret}
return jsonify(data)
def search_movie(search_text, page, per_page):
sql = text('''
WITH similar_words AS (
SELECT string_agg(word, ' | ') AS words
FROM (
SELECT word
FROM unique_lexeme
WHERE word % '':keywords''
ORDER BY word <-> '':keywords''
LIMIT 2
) AS tab
)
SELECT id, count(*) OVER() AS full_count
FROM search_view
WHERE document @@ to_tsquery('english', (SELECT words FROM similar_words))
ORDER BY ts_rank(document, to_tsquery('english', (SELECT words FROM similar_words))) DESC
LIMIT :per_page
OFFSET :offset_page
''') # TODO consider in conditionally recounting because should get few items every time
# TODO if there are only stop words, search them only in title (disable warnings)
# TODO for each element of tsvector, we could get the similar word
# (e.g. "the prestige" query cannot find "Prestige, the")
sql = sql.bindparams(keywords=search_text, per_page=per_page, offset_page=((page-1) * per_page))
result = db.engine.execute(sql).fetchall()
total_count = result[0][1] if len(result) > 0 else 0
movies = [Movie.query.get(row[0]) for row in result]
return Pagination(None, page, per_page, total_count, movies)
def qualifications(page):
if request.method == 'POST':
if 'submit' in request.form:
command = request.form['submit'].split('-')[0]
id = request.form['submit'].split('-')[1]
if command == 'edit':
redirect(url_for('qualifications'))
elif command == 'delete':
item = Qualification.query.filter_by(id=id).first()
db.session.delete(item)
db.session.commit()
query = Qualification.query.order_by(Qualification.name,
Qualification.year).all
count = len(query())
qualifications = utilities.get_items_for_page(query, page)
table_header = [
'ID', 'Name', 'Locale', 'Year', 'Number of Students', 'Actions'
]
table_data = [[str(q.id), q.name, q.locale, q.year, q.num_students]
for q in qualifications]
if not qualifications and page != 1:
abort(404)
pagination = Pagination(query(), page, app.config['PER_PAGE'], count,
qualifications)
return render_template('data_display.html',
user=current_user.name,
user_role=current_user.role.name,
table_header=table_header,
table_data=table_data,
pagination=pagination)
def show_categories(page=1):
per_page = request.args.get('per_page', 10, type=int)
# 获取当前官网
current_site = Site.current_site(master_uid=Master.master_uid())
builder = Category.query.filter_by(site_id=current_site.id)
total_count = builder.count()
categories = Category.always_category(
site_id=current_site.id,
language_id=current_site.default_language,
path=0,
page=1,
per_page=per_page)
paginated_categories = []
for cate in categories:
category = {
'id': cate.id,
'name': cate.name,
'icon': Asset.query.get(cate.icon_id) if cate.icon_id else None,
'sort_order': cate.sort_order,
'status': cate.status
}
paginated_categories.append(category)
pagination = Pagination(query=None,
page=1,
per_page=per_page,
total=total_count,
items=None)
return render_template('admin/categories/show_list.html',
paginated_categories=paginated_categories,
pagination=pagination)
def new_search(cls, query, page, order_by=None, per_page=PER_PAGE):
"""
创建一个查询实例，查询结果并分页返回，这里的query就是查询参数
"""
s = cls.search()
s = s.query('multi_match', query=query,
fields=SEARCH_FIELDS) # 设置搜索规则，SEARCH_FIELDS为匹配的权重
if page < 1:
page = 1
start = (page - 1) * PER_PAGE
s = s.extra(**{'from': start, 'size': per_page})
if order_by is not None:
s = s.sort(order_by)
# 这里是rs是搜索的Response对象，结果存在hits中，可以迭代对象
rs = s.execute()
dct = defaultdict(list) # 使用标准库来创建字典，可以实现get不存在的key的时候，返回空list
for i in rs:
dct[i.kind].append(i.id) # 分类数据，(由于当前只有一种类型数据，即post，不是很明显)
items = []
for kind, ids in dct.items():
target_cls = TARGET_MAPPER.get(kind) # 通过TARGET_MAPPER决定要操作的模型对象，上面已经通过kind进行分类了
if target_cls:
items_ = target_cls.get_multi(ids)
items.extend(items_)
return Pagination(query, page, per_page, rs.hits.total, items)
def new_search(cls, query, page, order_by=None, per_page=PER_PAGE):
""" 根据关键字搜索结果，title权重最大, tag次之, content最小 """
s = cls.search()
s = s.query('multi_match', query=query, fields=SEARCH_FIELDS) # 多行匹配
if page < 1:
page = 1
start = (page - 1) * PER_PAGE
s = s.extra(**{'from': start, 'size': per_page})
if order_by is not None:
s = s.sort(order_by)
rs = s.execute()
dct = defaultdict(list)
for i in rs:
dct[i.kind].append(i.id)
items = []
for kind, ids in dct.items():
target_cls = TARGET_MAPPER.get(kind)
if target_cls:
items_ = target_cls.get_multi(ids)
items.extend(items_)
# Fix elasticsearch-dsl for 7.x
total = rs.hits.total.value if __version__[0] >= 7 else rs.hits.total
return Pagination(query, page, per_page, total, items)
def new_search(cls, query, page, order_by=None, per_page=PER_PAGE):
s = cls.search()
s = s.query('multi_match', query=query, fields=SEARCH_FIELDS)
if page < 1:
page = 1
start = (page - 1) * per_page
s = s.extra(**{'from': start, 'size': per_page})
if order_by is not None:
s = s.sort(order_by)
rs = s.execute()
dct = defaultdict(list)
for i in rs:
dct[i.kind].append(
i.id
) # `Response` object allows you access to any key from the response dict via attribute access.
items = []
for kind, ids in dct.items():
target_cls = TARGET_MAPPER.get(kind)
if target_cls:
items_ = target_cls.get_multi(ids)
items.extend(items_)
return Pagination(query, page, per_page, rs.hits.total, items)
def paginate_limit(self,
page=None,
per_page=None,
limit=None) -> Pagination:
"""Return paginate object
Args:
page: number of page
per_page: item per page
limit: limit item per page
Returns:
Pagination object
"""
page = page or 1
per_page = per_page or 12
limit = limit if limit else per_page
items = self.limit(limit).offset((page - 1) * per_page).all()
# No need to count if we're on the first page and there are fewer
# items than we expected
if page == 1 and len(items) < per_page:
total = len(items)
else:
total = self.order_by(None).count()
return Pagination(self, page, per_page, total, items)
def paginate(self, *args, **kwargs):
pagination = super(QueryBooster, self).paginate(*args, **kwargs)
distinct_total = self.order_by(None).distinct().count()
items = self.distinct().limit(pagination.per_page).offset(
(pagination.page - 1) * pagination.per_page).all()
return Pagination(self, pagination.page, pagination.per_page,
distinct_total, items)
def manage():
if request.method=='POST':
pass
path=urllib.unquote(request.args.get('path','/'))
if path=='':
path='/'
if path!='/' and path.startswith('/'):
path=re.sub('^/+','',path)
page=request.args.get('page',1,type=int)
image_mode=request.args.get('image_mode')
sortby=request.args.get('sortby')
order=request.args.get('order')
if sortby:
sortby=request.args.get('sortby')
else:
sortby=request.cookies.get('admin_sortby') if request.cookies.get('admin_sortby') is not None else 'lastModtime'
sortby=sortby
if order:
order=request.args.get('order')
else:
order=request.cookies.get('admin_order') if request.cookies.get('admin_order') is not None else 'desc'
order=order
resp,total = FetchData(path=path,page=page,per_page=50,sortby=sortby,order=order)
pagination=Pagination(query=None,page=page, per_page=50, total=total, items=None)
resp=make_response(render_template('admin/manage.html',pagination=pagination,items=resp,path=path,sortby=sortby,order=order,endpoint='admin.manage'))
resp.set_cookie('admin_sortby',str(sortby))
resp.set_cookie('admin_order',str(order))
return resp
def get_course_learners_with_results(self,
course_id,
instrument_ids=None,
page=1,
max_per_page=20):
results = []
try:
related_courses_ids = self._get_contained_course_ids(course_id)
query = self.db.session.query(Request.tesla_id).filter(
CourseActivity.course_id.in_(related_courses_ids),
Request.activity_id == CourseActivity.activity_id,
RequestResult.request_id == Request.id).group_by(
Request.tesla_id)
if instrument_ids is not None:
query.filter(RequestResult.instrument_id.in_(instrument_ids))
results = query.group_by(Request.tesla_id).order_by(
Request.tesla_id).paginate(page=page,
max_per_page=max_per_page)
except Exception:
self.logger.exception(
"Error getting list of learners with requests for a certain course"
)
results = Pagination(None, page, max_per_page, 0, [])
return results
def paginate(self, page=1, per_page=25, show_all=False):
"""Paginate a query object.
This behaves almost like the default `paginate` method from
Flask-SQLAlchemy but allows showing all results on a single page.
:param page: Number of the page to return.
:param per_page: Number of items per page.
:param show_all: Whether to show all the elements on one page.
:return: a :class:`Pagination` object
"""
if page < 1 or show_all:
page = 1
if show_all:
items = self.all()
per_page = total = len(items)
else:
items = self.limit(per_page).offset((page - 1) * per_page).all()
if page == 1 and len(items) < per_page:
total = len(items)
else:
total = self.order_by(None).count()
return Pagination(self, page, per_page, total, items)
def games_search_with_pagination(self,
games_hint,
typ,
search_parameter,
page=1,
per_page=20,
sort_type='alphabetical'):
"""
Search games with defined parameters and return them as a SearchResults object which contains a Pagination object.
:param current_user The user who made the research
:param games_hint: A hint gave by the user to search various games
:param typ: str containing the type of games_hint (search filter)
:param search_parameter: str containing the name of the search container
:param current_page: The current page number
:param per_page: The number of users shown on a search results page
:return: A SearchResults with a Pagination object.
"""
results = self.games_search(games_hint, typ, search_parameter,
sort_type)
# We want to remove already owned and wished games from the page
if search_parameter is None or search_parameter == "None":
results.items = results.items.filter(
Game.id.notin_(self.get_wished_games(True)))
results.items = results.items.filter(
Game.id.notin_(self.get_owned_games(True)))
page_elements = results.items.slice(
(page - 1) * per_page,
page * per_page) # the games that will be displayed on the page
results.pagination = Pagination(None, page, per_page,
results.items.count(), page_elements)
results.items = None
return results
