def get_paginator_by_app_ids(cls, app_ids=None, page=1, item_count=None,
items_per_page=50, order_by=None,
filter_settings=None,
exclude_columns=None, db_session=None):
if not filter_settings:
filter_settings = {}
results, item_count = cls.get_search_iterator(app_ids, page,
items_per_page, order_by,
filter_settings)
paginator = paginate.Page([],
item_count=item_count,
items_per_page=items_per_page,
**filter_settings)
ordered_ids = tuple(item['_source']['pg_id']
for item in results.get('hits', []))
sorted_instance_list = []
if ordered_ids:
db_session = get_db_session(db_session)
query = db_session.query(Log)
query = query.filter(Log.log_id.in_(ordered_ids))
query = query.order_by(sa.desc('timestamp'))
sa_items = query.all()
# resort by score
for i_id in ordered_ids:
for item in sa_items:
if str(item.log_id) == str(i_id):
sorted_instance_list.append(item)
paginator.sa_items = sorted_instance_list
return paginator
def groups(fmt=None, page=1):
groups = (
g.db.query(GroupChat)
.order_by(GroupChat.id)
.options(joinedload(GroupChat.creator))
.offset((page - 1) * 50).limit(50).all()
)
if len(groups) == 0 and page != 1:
abort(404)
group_count = g.db.query(func.count('*')).select_from(GroupChat).scalar()
if fmt == "json":
group_dicts = []
for group in groups:
group_dict = group.to_dict()
group_dict["creator"] = group.creator.to_dict()
group_dicts.append(group_dict)
return jsonify({
"total": group_count,
"groups": group_dicts,
})
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=group_count,
url_maker=lambda page: url_for("admin_groups", page=page),
)
return render_template(
"admin/groups.html",
level_options=level_options,
groups=groups,
paginator=paginator,
)
def get(self):
current_page = request.args.get("page", 1, type=int)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
area = request.args.get("area", 'all')
if search_option and search_option in ['library_name', 'library_addr']:
search_column = getattr(Library, search_option)
page_url = url_for("admin.library_list")
if search_word:
page_url = url_for("admin.library_list", search_option=search_option, search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(Library)
if search_word:
records = records.filter(search_column.ilike('%{}%'.format(search_word)))
if area != "all":
records = records.filter(Library.area == area)
records = records.order_by(desc(Library.id))
total_cnt = records.count()
paginator = paginate.Page(records, current_page, page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("admin/library.html", paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url, items_per_page=items_per_page,
total_cnt=total_cnt, page=current_page)
def block_list(fmt=None, page=1):
blocks = g.db.query(Block).options(
joinedload(Block.blocking_user),
joinedload(Block.blocked_user),
joinedload(Block.chat),
).order_by(
Block.blocking_user_id,
Block.blocked_user_id,
).offset((page - 1) * 50).limit(50).all()
if len(blocks) == 0 and page != 1:
abort(404)
block_count = g.db.query(func.count('*')).select_from(Block).scalar()
if fmt == "json":
return jsonify({
"total": block_count,
"blocks": [_.to_dict(include_users=True) for _ in blocks],
})
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=block_count,
url_maker=lambda page: url_for("admin_block_list", page=page, **request.args),
)
return render_template(
"admin/block_list.html",
blocks=blocks,
paginator=paginator,
)
def test_url_generation():
def url_maker(page_number):
return str('x%s' % page_number)
page = paginate.Page(range(100), page=1, url_maker=url_maker)
assert page.pager(
) == '1 <a href="x2">2</a> <a href="x3">3</a> .. <a href="x5">5</a>'
def test_many_pages():
"""Test that fits 100 items on seven pages consisting of 15 items."""
items = range(100)
page = paginate.Page(items, page=0, items_per_page=15)
url = "http://example.org/foo/page=$page"
#eq_(page.collection_type, range) <-- py3 only
assert_in(page.collection_type, (range, list))
eq_(page.page, 1)
eq_(page.first_item, 1)
eq_(page.last_item, 15)
eq_(page.first_page, 1)
eq_(page.last_page, 7)
eq_(page.previous_page, None)
eq_(page.next_page, 2)
eq_(page.items_per_page, 15)
eq_(page.item_count, 100)
eq_(page.page_count, 7)
eq_(
page.pager(url=url),
'1 <a href="http://example.org/foo/page=2">2</a> <a href="http://example.org/foo/page=3">3</a> .. <a href="http://example.org/foo/page=7">7</a>'
)
eq_(
page.pager(url=url, separator='_'),
'1_<a href="http://example.org/foo/page=2">2</a>_<a href="http://example.org/foo/page=3">3</a>_.._<a href="http://example.org/foo/page=7">7</a>'
)
eq_(
page.pager(url=url,
link_attr={'style': 'linkstyle'},
curpage_attr={'style': 'curpagestyle'},
dotdot_attr={'style': 'dotdotstyle'}),
'<span style="curpagestyle">1</span> <a style="linkstyle" href="http://example.org/foo/page=2">2</a> <a style="linkstyle" href="http://example.org/foo/page=3">3</a> <span style="dotdotstyle">..</span> <a style="linkstyle" href="http://example.org/foo/page=7">7</a>'
)
def test_many_pages():
"""Test that fits 100 items on seven pages consisting of 15 items."""
items = range(100)
page = paginate.Page(items, page=0, items_per_page=15)
url = "http://example.org/foo/page=$page"
assert hasattr(page.collection_type, '__iter__') is True
assert page.page == 1
assert page.first_item == 1
assert page.last_item == 15
assert page.first_page == 1
assert page.last_page == 7
assert page.previous_page is None
assert page.next_page == 2
assert page.items_per_page == 15
assert page.item_count == 100
assert page.page_count == 7
assert page.pager(
url=url
) == '1 <a href="http://example.org/foo/page=2">2</a> <a href="http://example.org/foo/page=3">3</a> .. <a href="http://example.org/foo/page=7">7</a>'
assert page.pager(
url=url, separator='_'
) == '1_<a href="http://example.org/foo/page=2">2</a>_<a href="http://example.org/foo/page=3">3</a>_.._<a href="http://example.org/foo/page=7">7</a>'
assert page.pager(
url=url,
link_attr={'style': 'linkstyle'},
curpage_attr={'style': 'curpagestyle'},
dotdot_attr={'style': 'dotdotstyle'}
) == '<span style="curpagestyle">1</span> <a href="http://example.org/foo/page=2" style="linkstyle">2</a> <a href="http://example.org/foo/page=3" style="linkstyle">3</a> <span style="dotdotstyle">..</span> <a href="http://example.org/foo/page=7" style="linkstyle">7</a>'
def get(self):
current_page = request.args.get("page", 1, type=int)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
if search_option and search_option in ['press_date', 'category', 'news_title', 'news_press']:
search_column = getattr(News, search_option)
page_url = url_for("admin.news")
if search_word:
page_url = url_for("admin.news", search_option=search_option, search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(News)
if search_word:
records = records.filter(search_column.ilike('%{}%'.format(search_word)))
records = records.order_by(desc(News.id))
total_cnt = records.count()
paginator = paginate.Page(records, current_page, page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("admin/news.html", paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url, items_per_page=items_per_page,
total_cnt=total_cnt, page=current_page)
def get_country_play_count_table_data(
customer=None,
date_from=None,
date_to=None,
page=1,
items_per_page=10,
showing_on_graph=None,
):
plays = api\
.get_plays_by_geography(customer=customer, date_from=date_from, date_to=date_to)
grouped_plays = group_into_nested_location(plays)
grouped_plays = paginate.Page(grouped_plays,
page=page,
items_per_page=items_per_page)
columns = [
dict(id='country', name='Country'),
dict(id='pct_listen', name=f'% Listen'),
dict(id='total_plays', name=('Total Plays'))
]
rows = [
dict(country=g.country,
pct_listen=0,
total_plays=intcomma(g.total_plays)) for g in grouped_plays
]
return (rows, columns, grouped_plays)
def home(fmt=None, page=1):
flags = (
g.db.query(SpamFlag)
.order_by(SpamFlag.id.desc())
.options(
joinedload_all(SpamFlag.message, Message.chat),
joinedload_all(SpamFlag.message, Message.chat_user),
joinedload_all(SpamFlag.message, Message.user),
)
.offset((page - 1) * 50).limit(50).all()
)
if not flags and page != 1:
abort(404)
flag_count = g.db.query(func.count("*")).select_from(SpamFlag).scalar()
if fmt == "json":
return jsonify({
"flags": [_.to_dict() for _ in flags],
})
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=flag_count,
url_maker=lambda page: url_for("spamless2_home", page=page, **request.args),
)
return render_template(
"admin/spamless2/home.html",
flags=flags,
paginator=paginator,
)
def test_pager_without_radius_pattern():
def url_maker(page_number):
return str('x%s' % page_number)
page = paginate.Page(range(100), page=2, url_maker=url_maker)
assert page.pager(
'$link_first FOO $link_last') == '<a href="x1"><<</a> FOO <a href="x5">>></a>'
def test_url_assertion():
page = paginate.Page(range(100), page=0, items_per_page=10)
url = "http://example.org/"
@raises(Exception)
def pager():
page.pager(url=url)
def ca_view(catop):
current_page = request.args.get("page", 1, type=int)
filter_type = request.args.get('filter_type', 'CERTIFICATED')
logging.debug(filter_type)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
ca_record = CA.query.filter(CA.catop == catop).first()
if not ca_record:
flash('이러기야? 잘못된 CA를 조회하셨습니다')
left_ca_days = (ca_record.created_date +
timedelta(days=int(ca_record.cadays))) - datetime.now()
left_ca_days = "{days} 일 {times}".format(
days=left_ca_days.days,
times=time.strftime("%H시 %M분 %S초", time.gmtime(left_ca_days.seconds)))
search_column: Column = None
if search_option:
search_column: Column = getattr(Certficate, search_option)
page_url = url_for("ca_view",
catop=ca_record.catop,
filter_type=filter_type)
if search_word:
page_url = url_for("ca_view",
catop=ca_record.catop,
search_option=search_option,
search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(Certficate).filter(
Certficate.cert_status == filter_type)
if search_word:
records = records.filter(
search_column.ilike('%{}%'.format(search_word)))
records = records.order_by(desc(Certficate.id))
total_cnt = records.count()
paginator = paginate.Page(records,
current_page,
page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("ca_view.html",
paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url,
items_per_page=items_per_page,
total_cnt=total_cnt,
page=current_page,
ca_record=ca_record,
left_ca_days=left_ca_days)
def user_list(fmt=None):
try:
page = int(request.args.get("page", 1))
except ValueError:
abort(404)
users = g.db.query(User).options(joinedload(User.admin_tier))
users = _filter_users(users)
if request.args.get("order") in user_orders:
users = users.order_by(user_orders[request.args["order"]].column)
else:
users = users.order_by(user_orders["id"].column)
try:
users = users.offset((page - 1) * 50).limit(50).all()
except DataError:
abort(400)
if len(users) == 0 and page != 1:
abort(404)
user_count = g.db.query(func.count('*')).select_from(User)
user_count = _filter_users(user_count)
user_count = user_count.scalar()
if fmt == "json":
return jsonify({
"total": user_count,
"users": [_.to_dict() for _ in users],
})
paginator_args = {
k: v
for k, v in list(request.args.items()) if k != "page"
}
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=user_count,
url_maker=lambda page: url_for(
"admin_user_list", page=page, **paginator_args),
)
return render_template(
"admin/user_list.html",
User=User,
users=users,
paginator=paginator,
group_link_args={
k: v
for k, v in list(request.args.items())
if k not in ("page", "group")
},
user_orders=user_orders,
)
def get(self):
current_page = request.args.get("page", 1, type=int)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
if search_option and search_option in [
'lecture_name', 'session_time', 'lecture_title'
]:
search_column = getattr(Lecture, search_option)
if search_option == "roundtable_num" and search_word and not search_word.isdecimal(
):
flash('개최회차는 숫자만 입력하셔야 합니다.')
search_word = None
page_url = url_for("admin.lecturer")
if search_word:
page_url = url_for("admin.lecturer",
search_option=search_option,
search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(Lecture).outerjoin(Roundtable).outerjoin(
Library)
if search_word:
if search_option == 'roundtable_num':
records = records.filter(
Roundtable.roundtable_num == search_word)
elif search_option == 'library_name':
records = records.filter(
Library.library_name.ilike('%{}%'.format(search_word)))
elif search_option == 'session_time':
records = records.filter(search_column == int(search_word) - 1)
else:
records = records.filter(
search_column.ilike('%{}%'.format(search_word)))
records = records.order_by(desc(Lecture.roundtable_id))
total_cnt = records.count()
paginator = paginate.Page(records,
current_page,
page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("admin/lecturer.html",
paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url,
items_per_page=items_per_page,
total_cnt=total_cnt,
page=current_page)
def paginator(self, count, page, limit, zero_based_pages=True):
page_offset = 1 if zero_based_pages else 0
limit = 10 if limit is None else limit
def page_url(page):
params = request.GET.copy()
params['page'] = page - page_offset
return url(request.path, params)
return paginate.Page(list(range(count)), page + page_offset, int(limit),
url_maker=page_url,
)
def get_paginator_by_app_ids(
cls,
app_ids=None,
page=1,
item_count=None,
items_per_page=50,
order_by=None,
filter_settings=None,
exclude_columns=None,
db_session=None,
):
if not filter_settings:
filter_settings = {}
results = cls.get_search_iterator(
app_ids, page, items_per_page, order_by, filter_settings
)
ordered_ids = []
if results:
for item in results["top_groups"]["buckets"]:
pg_id = item["top_reports_hits"]["hits"]["hits"][0]["_source"][
"report_id"
]
ordered_ids.append(pg_id)
log.info(filter_settings)
paginator = paginate.Page(
ordered_ids, items_per_page=items_per_page, **filter_settings
)
sa_items = ()
if paginator.items:
db_session = get_db_session(db_session)
# latest report detail
query = db_session.query(Report)
query = query.options(sa.orm.joinedload(Report.report_group))
query = query.filter(Report.id.in_(paginator.items))
if filter_settings.get("order_col"):
order_col = filter_settings.get("order_col")
if filter_settings.get("order_dir") == "dsc":
sort_on = "desc"
else:
sort_on = "asc"
if order_col == "when":
order_col = "last_timestamp"
query = query.order_by(
getattr(sa, sort_on)(getattr(ReportGroup, order_col))
)
sa_items = query.all()
sorted_instance_list = []
for i_id in ordered_ids:
for report in sa_items:
if str(report.id) == i_id and report not in sorted_instance_list:
sorted_instance_list.append(report)
paginator.sa_items = sorted_instance_list
return paginator
def get(self):
current_page = request.args.get("page", 1, type=int)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
if search_option and search_option in ['name', 'email', 'phone']:
search_column = getattr(User, search_option)
page_url = url_for("admin.member_list")
if search_word:
page_url = url_for("admin.member_list",
search_option=search_option,
search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(User)
if search_word:
if search_option == "phone":
records = records.filter(
User.phone_search.ilike('%{}%'.format(
search_word.replace("-", ""))))
elif search_option == "username":
# 다른데서 먼저 찾아야 한다.
social_auth_records = db_session.query(
UserSocialAuth.user_id).filter(
UserSocialAuth.provider == 'username',
UserSocialAuth.uid.ilike('%{}%'.format(search_word)))
records = records.filter(User.id.in_(social_auth_records))
else:
records = records.filter(
search_column.ilike('%{}%'.format(search_word)))
records = records.order_by(desc(User.id))
total_cnt = records.count()
paginator = paginate.Page(records,
current_page,
page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("admin/member.html",
paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url,
items_per_page=items_per_page,
total_cnt=total_cnt,
page=current_page)
def invites(chat, pm_user, url, fmt=None, page=1):
if chat.type != "group" or chat.publicity != "private":
abort(404)
try:
own_chat_user = g.db.query(ChatUser).filter(
and_(
ChatUser.chat_id == chat.id,
ChatUser.user_id == g.user.id,
)).one()
except NoResultFound:
abort(404)
if not own_chat_user.can("invite"):
abort(403)
invite_count = g.db.query(func.count('*')).select_from(Invite).filter(
Invite.chat_id == chat.id, ).scalar()
invites = g.db.query(Invite, User).filter(
Invite.chat_id == chat.id, ).join(Invite.user).options(
joinedload(Invite.chat_user),
joinedload(Invite.creator_chat_user),
).order_by(User.username).limit(50).offset((page - 1) * 50).all()
if len(invites) == 0 and page != 1:
abort(404)
if fmt == "json":
return jsonify({
"total":
invite_count,
"invites": [invite.to_dict() for invite, user in invites],
})
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=invite_count,
url_maker=lambda page: url_for("rp_invites", url=url, page=page),
)
return render_template(
"chat/chat_invites.html",
chat=chat,
own_chat_user=own_chat_user,
invites=invites,
paginator=paginator,
)
def user_web_notes(username):
current_page = request.args.get("page", 1, type=int)
notebook = request.args.get('notebook', '')
search_word = request.args.get("search_word", '')
# if search_option and search_option in ['classify', 'subject']:
# search_column = getattr(FAQ, search_option)
page_param = {}
if notebook:
page_param["notebook"] = notebook
if search_word:
page_param["search_word"] = search_word
page_url = url_for("user_web_notes", username=username, **page_param)
if len(page_param.keys()) > 0:
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
notebooks = notebook_names(notebook)
notes = PeterboyNote.query.join(User).outerjoin(PeterboyNotebook).filter(
User.username == username)
if notebook:
notes = notes.filter(PeterboyNotebook.note_id.in_(notebooks))
# if search_word:
# records = records.filter(
# search_column.ilike('%{}%'.format(search_word)))
notes = notes.order_by(desc(PeterboyNote.id))
total_cnt = notes.count()
paginator = paginate.Page(notes,
current_page,
page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("web/user_space/notes.html",
paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url,
items_per_page=items_per_page,
total_cnt=total_cnt,
page=current_page)
def test_slice_page_5():
items = list(range(1, 1000))
page = paginate.Page(items, page=5, items_per_page=10)
assert page.page == 5
assert page.first_item == 41
assert page.last_item == 50
assert page.first_page == 1
assert page.last_page == 100
assert page.previous_page is 4
assert page.next_page == 6
assert page.items_per_page == 10
assert page.item_count == 999
assert page.page_count == 100
assert page.items == [41, 42, 43, 44, 45, 46, 47, 48, 49, 50]
def test_slice_page_0():
items = list(range(1, 1000))
page = paginate.Page(items, page=0, items_per_page=10)
assert page.page == 1
assert page.first_item == 1
assert page.last_item == 10
assert page.first_page == 1
assert page.last_page == 100
assert page.previous_page is None
assert page.next_page == 2
assert page.items_per_page == 10
assert page.item_count == 999
assert page.page_count == 100
assert page.items == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def get_paginator_by_app_ids(cls,
app_ids=None,
page=1,
item_count=None,
items_per_page=50,
order_by=None,
filter_settings=None,
exclude_columns=None,
db_session=None):
if not filter_settings:
filter_settings = {}
results = cls.get_search_iterator(app_ids, page, items_per_page,
order_by, filter_settings)
ordered_ids = []
if results:
for item in results['top_groups']['buckets']:
pg_id = item['top_reports_hits']['hits']['hits'][0]['_source'][
'pg_id']
ordered_ids.append(pg_id)
log.info(filter_settings)
paginator = paginate.Page(ordered_ids,
items_per_page=items_per_page,
**filter_settings)
sa_items = ()
if paginator.items:
db_session = get_db_session(db_session)
# latest report detail
query = db_session.query(Report)
query = query.options(sa.orm.joinedload(Report.report_group))
query = query.filter(Report.id.in_(paginator.items))
if filter_settings.get('order_col'):
order_col = filter_settings.get('order_col')
if filter_settings.get('order_dir') == 'dsc':
sort_on = 'desc'
else:
sort_on = 'asc'
if order_col == 'when':
order_col = 'last_timestamp'
query = query.order_by(
getattr(sa, sort_on)(getattr(ReportGroup, order_col)))
sa_items = query.all()
sorted_instance_list = []
for i_id in ordered_ids:
for report in sa_items:
if (str(report.id) == i_id
and report not in sorted_instance_list):
sorted_instance_list.append(report)
paginator.sa_items = sorted_instance_list
return paginator
def test_empty_link_map():
"""Test that fits 10 items on a single 10-item page."""
items = []
page = paginate.Page(items, page=0, items_per_page=15)
url = "http://example.org/foo/page=$page"
format = '$link_first $link_previous ~4~ $link_next $link_last (Page $page our of $page_count - total items $item_count)'
result = page.link_map(format, url=url)
assert result == {'current_page': None,
'first_page': None,
'last_page': None,
'next_page': None,
'previous_page': None,
'radius': 4,
'range_pages': []}
def get(self):
current_page = request.args.get("page", 1, type=int)
search_option = request.args.get("search_option", '')
search_word = request.args.get("search_word", '')
if search_option and search_option in ['donation_description']:
search_column = getattr(DonationGoods, search_option)
if search_option == "roundtable_num" and search_word and not search_word.isdecimal(
):
flash('개최회차는 숫자만 입력하셔야 합니다.')
search_word = None
page_url = url_for("admin.goods_donation")
if search_word:
page_url = url_for("admin.goods_donation",
search_option=search_option,
search_word=search_word)
page_url = str(page_url) + "&page=$page"
else:
page_url = str(page_url) + "?page=$page"
items_per_page = 10
records = db_session.query(DonationGoods).join(Roundtable)
if search_word:
if search_option == 'roundtable_num':
records = records.filter(
Roundtable.roundtable_num == search_word)
else:
records = records.filter(
search_column.ilike('%{}%'.format(search_word)))
records = records.order_by(desc(DonationGoods.id))
total_cnt = records.count()
paginator = paginate.Page(records,
current_page,
page_url=page_url,
items_per_page=items_per_page,
wrapper_class=SqlalchemyOrmWrapper)
return render_template("admin/goods_donation.html",
paginator=paginator,
paginate_link_tag=paginate_link_tag,
page_url=page_url,
items_per_page=items_per_page,
total_cnt=total_cnt,
page=current_page)
def index(self, page=0, limit=25, **kw):
c.page_list = W.page_list
c.page_size = W.page_size
limit, page = h.paging_sanitizer(limit, page)
query = M.notification.SiteNotification.query.find().sort('_id', -1)
count = query.count()
notifications = paginate.Page(query.all(), page + 1, limit)
return {
'notifications': notifications,
'count': count,
'page_url': page,
'limit': limit
}
def users(chat, pm_user, url, fmt=None, page=1):
if chat.type != "group":
abort(404)
try:
own_chat_user = g.db.query(ChatUser).filter(
and_(
ChatUser.chat_id == chat.id,
ChatUser.user_id == g.user.id,
)).one()
except:
own_chat_user = None
user_count = g.db.query(func.count('*')).select_from(ChatUser).filter(
ChatUser.chat_id == chat.id, ).scalar()
users = g.db.query(ChatUser).filter(ChatUser.chat_id == chat.id, ).options(
joinedload(ChatUser.user),
joinedload_all("invite.creator_chat_user"),
joinedload_all("ban.creator_chat_user"),
).order_by(ChatUser.number).limit(50).offset((page - 1) * 50).all()
if len(users) == 0:
abort(404)
if fmt == "json":
return jsonify({
"total": user_count,
"users": [_.to_dict() for _ in users]
})
paginator = paginate.Page(
[],
page=page,
items_per_page=50,
item_count=user_count,
url_maker=lambda page: url_for("rp_users", url=url, page=page),
)
return render_template(
"chat/chat_users.html",
chat=chat,
own_chat_user=own_chat_user,
users=users,
paginator=paginator,
)
def test_one_page():
"""Test that fits 10 items on a single 10-item page."""
items = range(10)
page = paginate.Page(items, page=0, items_per_page=10)
url = "http://example.org/foo/page=$page"
assert page.page == 1
assert page.first_item == 1
assert page.last_item == 10
assert page.first_page == 1
assert page.last_page == 1
assert page.previous_page is None
assert page.next_page is None
assert page.items_per_page == 10
assert page.item_count == 10
assert page.page_count == 1
assert page.pager(url=url) == ''
assert page.pager(url=url, show_if_single_page=True) == '1'
def test_empty_list():
"""Test whether an empty list is handled correctly."""
items = []
page = paginate.Page(items, page=0)
assert page.page == 1
assert page.first_item is None
assert page.last_item is None
assert page.first_page is None
assert page.last_page is None
assert page.previous_page is None
assert page.next_page is None
assert page.items_per_page == 20
assert page.item_count == 0
assert page.page_count == 0
assert page.pager(url="http://example.org/page=$page") == ''
assert page.pager(url="http://example.org/page=$page",
show_if_single_page=True) == ''
def test_one_page():
"""Test that fits 10 items on a single 10-item page."""
items = range(10)
page = paginate.Page(items, page=0, items_per_page=10)
url = "http://example.org/foo/page=$page"
eq_(page.page, 1)
eq_(page.first_item, 1)
eq_(page.last_item, 10)
eq_(page.first_page, 1)
eq_(page.last_page, 1)
eq_(page.previous_page, None)
eq_(page.next_page, None)
eq_(page.items_per_page, 10)
eq_(page.item_count, 10)
eq_(page.page_count, 1)
eq_(page.pager(url=url), '')
eq_(page.pager(url=url, show_if_single_page=True), '1')
