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')