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,
}
