def get_pagination(self, count_query, query, page, page_size=options.page_size, *args): try: try: page = int(page) page_size = int(page_size) except ValueError: page = 1 page_size = 20 if page < 1: page = 1 start = (page - 1) * page_size if getattr(self, "db", None) is None: # UI Module self.db = self.handler.db # should add a c(count) alias in the count query count = self.db.get(count_query) count = int(count.c) if count else 0 if start > count: page = (count % page_size) start = (page - 1) * page_size start = max(0, start) pagination = Page(None, page=page, items_per_page=page_size, item_count=count, url=self.get_page_url) pages = pagination.pager('$link_previous ~3~ $link_next (Page $page of $page_count)') rows = self.db.query(query + str(" limit %s, %s" % (start, page_size)), *args) return {"pages":pages, "rows":rows} except TypeError: raise HTTPError(404)
def map_captimes_data(request): map_id = int(request.matchdict['id']) current_page = request.params.get('page', 1) try: mmap = DBSession.query(Map).filter_by(map_id=map_id).one() mct_q = DBSession.query(PlayerCaptime.fastest_cap, PlayerCaptime.create_dt, PlayerCaptime.player_id, PlayerCaptime.game_id, Game.server_id, Server.name.label('server_name'), PlayerGameStat.nick.label('player_nick')).\ filter(PlayerCaptime.map_id==map_id).\ filter(PlayerCaptime.game_id==Game.game_id).\ filter(PlayerCaptime.map_id==Map.map_id).\ filter(Game.server_id==Server.server_id).\ filter(PlayerCaptime.player_id==PlayerGameStat.player_id).\ filter(PlayerCaptime.game_id==PlayerGameStat.game_id).\ order_by(expr.asc(PlayerCaptime.fastest_cap)) except Exception as e: raise HTTPNotFound map_captimes = Page(mct_q, current_page, items_per_page=20, url=page_url) map_captimes.items = [MapCapTime(row) for row in map_captimes.items] return { 'map_id':map_id, 'map':mmap, 'captimes':map_captimes, }
def player_game_index_data(request): try: player_id = int(request.matchdict['player_id']) except: player_id = -1 game_type_cd = None game_type_descr = None if request.params.has_key('type'): game_type_cd = request.params['type'] try: game_type_descr = DBSession.query(GameType.descr).\ filter(GameType.game_type_cd == game_type_cd).\ one()[0] except Exception as e: pass else: game_type_cd = None game_type_descr = None if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 try: player = DBSession.query(Player).\ filter_by(player_id=player_id).\ filter(Player.active_ind == True).\ one() rgs_q = recent_games_q(player_id=player.player_id, force_player_id=True, game_type_cd=game_type_cd) games = Page(rgs_q, current_page, items_per_page=20, url=page_url) # replace the items in the canned pagination class with more rich ones games.items = [RecentGame(row) for row in games.items] games_played = get_games_played(player_id) except Exception as e: raise e player = None games = None game_type_cd = None game_type_descr = None games_played = None return { 'player_id':player.player_id, 'player':player, 'games':games, 'game_type_cd':game_type_cd, 'game_type_descr':game_type_descr, 'games_played':games_played, }
def top_players_by_time(request): return {'top_players': []} current_page = request.params.get('page', 1) cutoff_days = int(request.registry.settings.get('xonstat.leaderboard_lifetime', 30)) top_players_q = top_players_by_time_q(cutoff_days) top_players = Page(top_players_q, current_page, items_per_page=25, url=page_url) top_players.items = [(player_id, html_colors(nick), score) for (player_id, nick, score) in top_players.items] return {'top_players':top_players}
def player_game_index_data(request): RecentGame = namedtuple('RecentGame', ['game_id', 'game_type_cd', 'winner', 'game_create_dt', 'game_epoch', 'game_fuzzy', 'server_id', 'server_name', 'map_id', 'map_name', 'team', 'rank', 'elo_delta']) player_id = request.matchdict['player_id'] if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 try: player = DBSession.query(Player).filter_by(player_id=player_id).\ filter(Player.active_ind == True).one() games_q = DBSession.query(Game.game_id, Game.game_type_cd, Game.winner, Game.create_dt, Server.server_id, Server.name.label('server_name'), Map.map_id, Map.name.label('map_name'), PlayerGameStat.team, PlayerGameStat.rank, PlayerGameStat.elo_delta).\ filter(PlayerGameStat.game_id == Game.game_id).\ filter(PlayerGameStat.player_id == player_id).\ filter(Game.server_id == Server.server_id).\ filter(Game.map_id == Map.map_id).\ order_by(Game.game_id.desc()) games = Page(games_q, current_page, items_per_page=10, url=page_url) # replace the items in the canned pagination class with more rich ones games.items = [RecentGame( game_id = row.game_id, game_type_cd = row.game_type_cd, winner = row.winner, game_create_dt = row.create_dt, game_epoch = timegm(row.create_dt.timetuple()), game_fuzzy = pretty_date(row.create_dt), server_id = row.server_id, server_name = row.server_name, map_id = row.map_id, map_name = row.map_name, team = row.team, rank = row.rank, elo_delta = row.elo_delta ) for row in games.items] except Exception as e: player = None games = None return { 'player_id':player.player_id, 'player':player, 'games':games, }
def game_finder_data(request): if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 query = {} server_id, map_id, player_id = None, None, None range_start, range_end, game_type_cd = None, None, None game_type_descr = None # these become WHERE clauses when present if request.params.has_key('server_id'): server_id = request.params['server_id'] query['server_id'] = server_id if request.params.has_key('map_id'): map_id = request.params['map_id'] query['map_id'] = map_id if request.params.has_key('player_id'): player_id = request.params['player_id'] query['player_id'] = player_id if request.params.has_key('range_start'): range_start = request.params['range_start'] query['range_start'] = range_start if request.params.has_key('range_end'): range_end = request.params['range_end'] query['range_end'] = range_end if request.params.has_key('type'): game_type_cd = request.params['type'] query['type'] = game_type_cd try: game_type_descr = DBSession.query(GameType.descr).\ filter(GameType.game_type_cd == game_type_cd).\ one()[0] except Exception as e: game_type_cd = None rgs_q = recent_games_q(server_id=server_id, map_id=map_id, player_id=player_id, game_type_cd=game_type_cd) recent_games = Page(rgs_q, current_page, url=page_url) recent_games.items = [RecentGame(row) for row in recent_games.items] return { 'recent_games':recent_games, 'query':query, 'game_type_cd':game_type_cd, }
def _list(self): items = DBSession.query(self.dbObj).filter(self.dbObj.active == 0).all() try: page = int(self.get_argument("page", 1)) except: page = 1 my_page = Page(items, page = page, items_per_page = self.items_per_page, url = lambda page:"%s?action=list&page=%d" % (self.request.path, page)) pager = my_page.pager(symbol_first = "<<", show_if_single_page = True) self.render(self.template_prefix + "_list.html", my_page = my_page, pager = pager)
def _f(): output = fun() if not isinstance(output, dict) or not self.name in output: pass collection = output[self.name] request = fun.im_self.request page = Page(collection, request.paginate_page, request.paginate_items_per_page, controller = '/') page.kwargs = request.paginate_params if self.page_param != 'name': page.pager = partial(page.pager, page_param = self.page_param) if not getattr(request, 'paginators', None): request.paginators = Bunch() request.paginators[self.name] = output[self.name] = page
def test_one_page(): """Test that we fit 10 items on a single 10-item page.""" items = range(10) page = 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 == 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() == '' assert page.pager(show_if_single_page=True) == '<span class="pager_curpage">1</span>'
def test_empty_list(): """Test whether an empty list is handled correctly.""" items = [] page = Page(items, page=0) assert page.page == 0 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() == '' assert page.pager(show_if_single_page=True) == ''
def player_captimes_data(request): player_id = int(request.matchdict['player_id']) if player_id <= 2: player_id = -1; page = request.params.get("page", 1) sort = request.params.get("sort", "create_dt") try: player = DBSession.query(Player).filter_by(player_id=player_id).one() pct_q = DBSession.query(PlayerCaptime.fastest_cap, PlayerCaptime.create_dt, PlayerCaptime.player_id, PlayerCaptime.game_id, PlayerCaptime.map_id, Map.name.label('map_name'), Game.server_id, Server.name.label('server_name')).\ filter(PlayerCaptime.player_id==player_id).\ filter(PlayerCaptime.game_id==Game.game_id).\ filter(PlayerCaptime.map_id==Map.map_id).\ filter(Game.server_id==Server.server_id) if sort == "fastest": pct_q = pct_q.order_by(PlayerCaptime.fastest_cap) else: sort = "create_dt" pct_q = pct_q.order_by(expr.desc(PlayerCaptime.create_dt)) except Exception as e: raise pyramid.httpexceptions.HTTPNotFound captimes = Page(pct_q, page, items_per_page=20, url=page_url) # replace the items in the canned pagination class with more rich ones captimes.items = [PlayerCapTime(row) for row in captimes.items] return { "player_id" : player_id, "player" : player, "captimes" : captimes, "page" : page, "sort" : sort, }
def user_favourites(self): path = self.request.matchdict['prefix'] user = Users.get_by_path(path) form = Form(self.request) listings = user.favourites title = "%s Saved Properties" % user.fullname page_url = PageURL_WebOb(self.request) page = int(self.request.params.get("page", 1)) paginator = Page(listings, page=page, items_per_page=10, url=page_url) return dict(user=user, paginator=paginator, form=FormRenderer(form), saved='saved', title=title)
def m_events_list(): try: page = _g("page", 1) except: page = 1 es = list( connection.Events.find({ "active": 0 }).sort("date", pymongo.DESCENDING)) paginate_events = Page(es, page=page, items_per_page=ITEM_PER_PAGE, url=lambda page: "%s?page=%d" % (url_for("m_events_list"), page)) return {"paginate_events": paginate_events}
def m_doctor_list(): ds = connection.DoctorProfile.find({'active': 0}) try: page = request.values.get("page", 1) except: page = 1 ds = list(connection.DoctorProfile.find({'active': 0})) paginate_docotrs = Page(ds, page=page, items_per_page=ITEM_PER_PAGE, url=lambda page: "%s?page=%d" % (url_for("m_doctor_list"), page)) return render_template("m_doctor_list.html", paginate_docotrs=paginate_docotrs)
def server_index(self): """Returns the raw data shared by all renderers.""" try: server_q = DBSession.query(Server)\ .filter(Server.active_ind)\ .order_by(Server.server_id.desc()) servers = Page(server_q, self.page, items_per_page=25, url=page_url) except Exception as e: log.debug(e) raise HTTPNotFound return servers
def get_page(self, **kwargs): """return a ``webhelpers.paginate.Page`` used to display ``Grid``. Default is:: S = self.Session() query = S.query(self.get_model()) kwargs = request.environ.get('pylons.routes_dict', {}) return Page(query, page=int(request.GET.get('page', '1')), **kwargs) """ S = self.Session() options = dict(collection=S.query(self.get_model()), page=int(request.GET.get('page', '1'))) options.update(request.environ.get('pylons.routes_dict', {})) options.update(kwargs) collection = options.pop('collection') return Page(collection, **options)
def post_list(request): query = PostSearch(request.GET.get("q", "")) sort = request.GET.get("sort", "posted") posts_per_page = int( request.registry.settings.get("votabo.posts_per_page", 24)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(Post) sql = query.filter(sql) posts = Page(sql, page=page, items_per_page=posts_per_page, url=url_for_page, item_count=_count_posts()) return {"query": request.GET.get("q"), "posts": posts, "pager": posts}
def archives(template, year, month, page=1): _url = page_url _query = Article.query.archives(year, month) pagination = Page(_query, page=page, items_per_page=Article.PER_PAGE, url=_url) articles = pagination.items _template = template % 'archives.html' return render_template(_template, pagination=pagination, articles=articles, year=year, month=month)
def _map_index_data(request): if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 try: map_q = DBSession.query(Map).\ order_by(Map.map_id.desc()) maps = Page(map_q, current_page, items_per_page=25, url=page_url) except Exception as e: maps = None return {'maps':maps, }
def untag_list(request): untags_per_page = int( request.registry.settings.get("votabo.untags_per_page", 200)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(UnTag).order_by(desc(UnTag.tag)) if request.GET.get("tag"): sql = sql.filter(UnTag.tag.ilike("%" + request.GET["tag"] + "%")) if request.GET.get("redirect"): sql = sql.filter( UnTag.redirect.ilike("%" + request.GET["redirect"] + "%")) untags = Page(sql, page=page, items_per_page=untags_per_page, url=url_for_page) return {"untags": untags, "pager": untags}
def m_user_list(): # users = connection.User.find({"id":{"$in":r.users}}) # return {"users" : users} try: page = request.values.get("page", 1) except: page = 1 r = connection.Role.one({"name": "NORMALUSER"}) users = list(connection.User.find({"id": {"$in": r.users}})) paginate_users = Page(users, page=page, items_per_page=ITEM_PER_PAGE, url=lambda page: "%s?page=%d" % (url_for("m_user_list"), page)) return {"paginate_users": paginate_users}
def postban_list(request): postbans_per_page = int( request.registry.settings.get("votabo.postbans_per_page", 200)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(PostBan).order_by(desc(PostBan.id)) if request.GET.get("fingerprint"): sql = sql.filter(PostBan.fingerprint.ilike(request.GET["fingerprint"])) if request.GET.get("reason"): sql = sql.filter( PostBan.reason.ilike("%" + request.GET["reason"] + "%")) postbans = Page(sql, page=page, items_per_page=postbans_per_page, url=url_for_page) return {"postbans": postbans, "pager": postbans}
def topic(template, slug, page=1): topic = Topic.query.filter_by(slug=slug).first_or_404() _url = page_url _query = Article.query.public().filter(Article.topic_id == topic.id) pagination = Page(_query, page=page, items_per_page=Article.PER_PAGE, url=_url) articles = pagination.items _template = template % (topic.template or 'topic.html') return render_template(_template, topic=topic, pagination=pagination, articles=articles)
def index(template, page=1): _template = template % 'index.html' blog_mode = current_app.config.get("BLOG_MODE") if blog_mode: _url = page_url _query = Article.query.public() pagination = Page(_query, page=page, items_per_page=Article.PER_PAGE, url=_url) articles = pagination.items return render_template(_template, articles=articles, pagination=pagination) else: return render_template(_template)
def ratingsandreview(self): prefix = self.request.matchdict['prefix'] form = Form(self.request) user = Users.get_by_path(prefix) title = user.fullname + "'s" + " Ratings and Reviews" ratings = user.rating page_url = PageURL_WebOb(self.request) paginator = Page(ratings, page=int(self.request.params.get("page", 1)), items_per_page=5, url=page_url) return dict(paginator=paginator, user=user, rv='rv', title=title, form=FormRenderer(form), rating_page="rating_page")
def inbox(self): id = self.request.matchdict['id'] user = Users.get_by_id(id) if not user: self.session.flash('info; No such user') return HTTPFound(location=self.request.route_url('home')) messages = DBSession.query(Messages).filter( Messages.user_id == user.id).order_by( Messages.created.desc()).all() page_url = PageURL_WebOb(self.request) paginator = Page(messages, page=int(self.request.params.get("page", 1)), url=page_url) for message in messages: message.is_seen = True DBSession.flush() return dict(user=user, paginator=paginator, mess='mess')
def alias_list(request): aliases_per_page = int( request.registry.settings.get("votabo.aliases_per_page", 50)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(Alias).order_by(Alias.newtag) if request.GET.get("oldtag"): sql = sql.filter(Alias.oldtag.ilike("%" + request.GET["oldtag"] + "%")) if request.GET.get("newtag"): sql = sql.filter(Alias.newtag.ilike("%" + request.GET["newtag"] + "%")) aliases = Page(sql, page=page, items_per_page=aliases_per_page, url=url_for_page) return {"aliases": aliases, "pager": aliases}
def search(template): page = int(request.args.get('page', 1)) keyword = request.args.get('keyword', None) pagination = None articles = None if keyword: _url = PageURL(url_for('main.search'), {"page": page, "keyword": keyword.encode('utf-8')}) _query = Article.query.search(keyword) pagination = Page(_query, page=page, items_per_page=Article.PER_PAGE, url=_url) articles = pagination.items _template = template % 'search.html' return render_template(_template, articles=articles, keyword=keyword, pagination=pagination)
def _server_index_data(request): if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 try: server_q = DBSession.query(Server).\ order_by(Server.server_id.desc()) servers = Page(server_q, current_page, items_per_page=25, url=page_url) except Exception as e: servers = None return { 'servers': servers, }
def category(template, longslug, page=1): category = Category.query.filter_by(longslug=longslug).first_or_404() cate_ids = get_category_ids(longslug) _url = page_url _query = Article.query.public().filter(Article.category_id.in_(cate_ids)) pagination = Page(_query, page=page, items_per_page=Article.PER_PAGE, url=_url) articles = pagination.items _template = template % (category.template or 'category.html') return render_template(_template, category=category, pagination=pagination, articles=articles)
def device_configuration_history(request): animal_id = request.matchdict['animal_id'] is_admin = check_permission('admin', request) email = get_user_email(request) animal = None if animal_id != None: try: animal = animal_service.get_animal_by_id(int(animal_id)) except ValueError: pass if (animal == None) or (not is_admin and animal.user.email != email): return HTTPFound(request.route_url("animals_list")) configurations = Page(animal.get_all_configurations(), page=int(request.params.get('p', 1)), items_per_page=20, url=Customizable_PageURL_WebOb(request, get_param='p')) return dict(is_admin=check_permission('admin', request), configurations=configurations)
def get_page(self, **kwargs): """return a ``webhelpers.paginate.Page`` used to display ``Grid``. """ request = self.request def get_page_url(page, partial=None): url = "%s?page=%s" % (self.request.path, page) if partial: url += "&partial=1" return url options = dict(page=int(request.GET.get('page', '1')), url=get_page_url) options.update(kwargs) if 'collection' not in options: query = self.session.query(request.model_class) options['collection'] = request.query_factory(request, query) collection = options.pop('collection') return Page(collection, **options)
def public_journal(self): # Return a rendered template p = int(request.params.get('page', 1)) c.following = self.sa.query(UserFollowing)\ .filter(UserFollowing.user_id == self.rhodecode_user.user_id)\ .options(joinedload(UserFollowing.follows_repository))\ .all() journal = self._get_journal_data(c.following) c.journal_pager = Page(journal, page=p, items_per_page=20) c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager) c.journal_data = render('journal/journal_data.html') if request.environ.get('HTTP_X_PARTIAL_XHR'): return c.journal_data return render('journal/public_journal.html')
def search_users(request): dbsession = DBSession() search_term = request.params.get('search', '') searchstring = u'%%%s%%' % search_term title = "Real Estate Professionals" search = dbsession.query(Users).filter( or_(Users.firstname.like(searchstring), Users.surname.like(searchstring), Users.company_name.like(searchstring))).order_by( Users.join_date.desc()).all() page_url = PageURL_WebOb(request) page = int(request.params.get("page", 1)) paginator = Page(search, page=page, items_per_page=12, url=page_url) if page > 1: title = title + ' page ' + str(page) return render_to_response('buddy:templates/user/userlist.mako', dict(paginator=paginator, title=title), request=request)
def batch(control, filenames, path_info='/browser'): i = 1 if player.params.latest in filenames: i = filenames.index(player.params.latest) i = (i / 20) + 1 def url(page=1): return '%s?page=%s' % (request.environ['PATH_INFO'], page) page = Page(filenames, page=int(request.GET.get('page', i)), url=url) control.left = '%s?page=%s' % ( path_info, page.page - 1 or 1, ) control.right = '%s?page=%s' % ( path_info, page.page + 1, ) return page
def _server_game_index_data(request): server_id = request.matchdict['server_id'] current_page = request.matchdict['page'] try: server = DBSession.query(Server).filter_by(server_id=server_id).one() games_q = DBSession.query(Game, Server, Map).\ filter(Game.server_id == server_id).\ filter(Game.server_id == Server.server_id).\ filter(Game.map_id == Map.map_id).\ order_by(Game.create_dt.desc()) games = Page(games_q, current_page, url=page_url) except Exception as e: server = None games = None raise e return {'games': games, 'server': server}
def userdraft(self): path = self.request.matchdict['prefix'] user = Users.get_by_path(path) blogs = DBSession.query(Blogs).filter(Blogs.user == user).filter( Blogs.status == False).all() bc = [s.categories for s in blogs if s.status == 0] bc = histogram(bc) form = Form(self.request) title = 'Drafts' page_url = PageURL_WebOb(self.request) page = int(self.request.params.get('page', 1)) paginator = Page(blogs, page=page, url=page_url) if page > 1: title = title + ' page ' + str(page) return dict(user=user, paginator=paginator, bl='bl', form=FormRenderer(form), title=title, bcategories=bc)
def player_index_data(request): if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 try: player_q = DBSession.query(Player).\ filter(Player.player_id > 2).\ filter(Player.active_ind == True).\ filter(sa.not_(Player.nick.like('Anonymous Player%'))).\ order_by(Player.player_id.desc()) players = Page(player_q, current_page, items_per_page=25, url=page_url) except Exception as e: players = None raise e return {'players': players}
def filterd(self): categories = get_navcategories() id = self.request.matchdict['id'] cate = BlogCategory.get_by_id(id) title = cate.name query = DBSession.query(Blogs). \ filter(Blogs.categories.any(name=cate.name)).all() page_url = PageURL_WebOb(self.request) page = int(self.request.params.get('page', 1)) paginator = Page(query, page=page, url=page_url) if page > 1: title = title + ' page ' + str(page) return { 'paginator': paginator, 'title': title, 'blog_nav_cat': categories, "page_description": desc, 'bcategory': cate }
def log_list(request): logs_per_page = int( request.registry.settings.get("votabo.logs_per_page", 200)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(LogEvent).order_by(desc(LogEvent.id)) if request.GET.get("module"): sql = sql.filter(LogEvent.section.ilike(request.GET["module"])) if request.GET.get("username"): sql = sql.filter(LogEvent.username.ilike(request.GET["username"])) if request.GET.get("message"): sql = sql.filter(LogEvent.message.ilike(request.GET["message"] + "%")) if request.GET.get("address"): sql = sql.filter(LogEvent.address.op("<<=")(request.GET["address"])) logs = Page(sql, page=page, items_per_page=logs_per_page, url=url_for_page, item_count=_count_events()) return {"logs": logs, "pager": logs}
def ipban_list(request): ipbans_per_page = int( request.registry.settings.get("votabo.ipbans_per_page", 200)) page = int(request.GET.get("page", "1")) url_for_page = PageURL(request.path, request.params) sql = DBSession.query(IPBan).order_by(desc(IPBan.id)) if request.GET.get("ip"): if "/" not in request.GET["ip"]: sql = sql.filter(IPBan.ip == request.GET["ip"]) else: # pragma: no cover -- requires postgres sql = sql.filter(IPBan.ip.op(">>=")(request.GET["ip"])) if request.GET.get("reason"): sql = sql.filter(IPBan.reason.ilike("%" + request.GET["reason"] + "%")) if request.GET.get("banner"): sql = sql.join(User).filter(User.username.ilike(request.GET["banner"])) ipbans = Page(sql, page=page, items_per_page=ipbans_per_page, url=url_for_page) return {"ipbans": ipbans, "pager": ipbans}
def test_many_pages(): """Test that 100 items fit on seven 15-item pages.""" # Create routes mapper so that webhelper can create URLs # using webhelpers.url_for() mapper = Mapper() mapper.connect(':controller') items = range(100) page = Page(items, page=0, items_per_page=15) 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 print page.pager() assert page.pager() == '<span class="pager_curpage">1</span> <a class="pager_link" href="/content?page=2">2</a> <a class="pager_link" href="/content?page=3">3</a> <span class="pager_dotdot">..</span> <a class="pager_link" href="/content?page=7">7</a>' assert page.pager(separator='_') == '<span class="pager_curpage">1</span>_<a class="pager_link" href="/content?page=2">2</a>_<a class="pager_link" href="/content?page=3">3</a>_<span class="pager_dotdot">..</span>_<a class="pager_link" href="/content?page=7">7</a>' assert page.pager(page_param='xy') == '<span class="pager_curpage">1</span> <a class="pager_link" href="/content?xy=2">2</a> <a class="pager_link" href="/content?xy=3">3</a> <span class="pager_dotdot">..</span> <a class="pager_link" href="/content?xy=7">7</a>' assert page.pager(link_attr={'style':'s1'}, curpage_attr={'style':'s2'}, dotdot_attr={'style':'s3'}) == '<span style="s2">1</span> <a href="/content?page=2" style="s1">2</a> <a href="/content?page=3" style="s1">3</a> <span style="s3">..</span> <a href="/content?page=7" style="s1">7</a>'
def player_captimes_data(request): player_id = int(request.matchdict['player_id']) if player_id <= 2: player_id = -1; if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 PlayerCaptimes = namedtuple('PlayerCaptimes', ['fastest_cap', 'create_dt', 'create_dt_epoch', 'create_dt_fuzzy', 'player_id', 'game_id', 'map_id', 'map_name', 'server_id', 'server_name']) player = DBSession.query(Player).filter_by(player_id=player_id).one() #pct_q = DBSession.query('fastest_cap', 'create_dt', 'player_id', 'game_id', 'map_id', # 'map_name', 'server_id', 'server_name').\ # from_statement( # "SELECT ct.fastest_cap, " # "ct.create_dt, " # "ct.player_id, " # "ct.game_id, " # "ct.map_id, " # "m.name map_name, " # "g.server_id, " # "s.name server_name " # "FROM player_map_captimes ct, " # "games g, " # "maps m, " # "servers s " # "WHERE ct.player_id = :player_id " # "AND g.game_id = ct.game_id " # "AND g.server_id = s.server_id " # "AND m.map_id = ct.map_id " # #"ORDER BY ct.fastest_cap " # "ORDER BY ct.create_dt desc" # ).params(player_id=player_id) try: pct_q = DBSession.query(PlayerCaptime.fastest_cap, PlayerCaptime.create_dt, PlayerCaptime.player_id, PlayerCaptime.game_id, PlayerCaptime.map_id, Map.name.label('map_name'), Game.server_id, Server.name.label('server_name')).\ filter(PlayerCaptime.player_id==player_id).\ filter(PlayerCaptime.game_id==Game.game_id).\ filter(PlayerCaptime.map_id==Map.map_id).\ filter(Game.server_id==Server.server_id).\ order_by(expr.desc(PlayerCaptime.create_dt)) player_captimes = Page(pct_q, current_page, items_per_page=20, url=page_url) # replace the items in the canned pagination class with more rich ones player_captimes.items = [PlayerCaptimes( fastest_cap=row.fastest_cap, create_dt=row.create_dt, create_dt_epoch=timegm(row.create_dt.timetuple()), create_dt_fuzzy=pretty_date(row.create_dt), player_id=row.player_id, game_id=row.game_id, map_id=row.map_id, map_name=row.map_name, server_id=row.server_id, server_name=row.server_name ) for row in player_captimes.items] except Exception as e: player = None player_captimes = None return { 'player_id':player_id, 'player':player, 'captimes':player_captimes, #'player_url':request.route_path('player_info', id=player_id), }
def __init__(self, *args, **kwargs): kwargs.setdefault('url', url.current) _Page.__init__(self, *args, **kwargs)
def map_captimes_data(request): map_id = int(request.matchdict['id']) if request.params.has_key('page'): current_page = request.params['page'] else: current_page = 1 MapCaptimes = namedtuple('PlayerCaptimes', ['fastest_cap', 'create_dt', 'create_dt_epoch', 'create_dt_fuzzy', 'player_id', 'player_nick', 'player_nick_stripped', 'player_nick_html', 'game_id', 'server_id', 'server_name']) mmap = DBSession.query(Map).filter_by(map_id=map_id).one() #mct_q = DBSession.query('fastest_cap', 'create_dt', 'player_id', 'game_id', # 'server_id', 'server_name', 'player_nick').\ # from_statement( # "SELECT ct.fastest_cap, " # "ct.create_dt, " # "ct.player_id, " # "ct.game_id, " # "g.server_id, " # "s.name server_name, " # "pgs.nick player_nick " # "FROM player_map_captimes ct, " # "games g, " # "maps m, " # "servers s, " # "player_game_stats pgs " # "WHERE ct.map_id = :map_id " # "AND g.game_id = ct.game_id " # "AND g.server_id = s.server_id " # "AND m.map_id = ct.map_id " # "AND pgs.player_id = ct.player_id " # "AND pgs.game_id = ct.game_id " # "ORDER BY ct.fastest_cap " # "LIMIT 25" # ).params(map_id=map_id) #try: if True: mct_q = DBSession.query(PlayerCaptime.fastest_cap, PlayerCaptime.create_dt, PlayerCaptime.player_id, PlayerCaptime.game_id, Game.server_id, Server.name.label('server_name'), PlayerGameStat.nick.label('player_nick')).\ filter(PlayerCaptime.map_id==map_id).\ filter(PlayerCaptime.game_id==Game.game_id).\ filter(PlayerCaptime.map_id==Map.map_id).\ filter(Game.server_id==Server.server_id).\ filter(PlayerCaptime.player_id==PlayerGameStat.player_id).\ filter(PlayerCaptime.game_id==PlayerGameStat.game_id).\ order_by(expr.asc(PlayerCaptime.fastest_cap)) map_captimes = Page(mct_q, current_page, items_per_page=20, url=page_url) map_captimes.items = [MapCaptimes( fastest_cap=row.fastest_cap, create_dt=row.create_dt, create_dt_epoch=timegm(row.create_dt.timetuple()), create_dt_fuzzy=pretty_date(row.create_dt), player_id=row.player_id, player_nick=row.player_nick, player_nick_stripped=strip_colors(row.player_nick), player_nick_html=html_colors(row.player_nick), game_id=row.game_id, server_id=row.server_id, server_name=row.server_name, ) for row in map_captimes.items] #except Exception as e: else: map = None map_captimes = None return { 'map_id':map_id, 'map':mmap, 'captimes':map_captimes, }