def user_listing(self):
form = Form(self.request)
path = self.request.matchdict['prefix']
user = Users.get_by_path(path)
page = int(self.request.params.get("page", 1))
page_url = PageURL_WebOb(self.request)
active_listings = DBSession.query(Listings).filter(Listings.user == user).filter(Listings.approved==True).\
filter(Listings.declined==False).filter(Listings.status==True).all()
past_sales = DBSession.query(Listings).filter(
Listings.user == user).filter(Listings.status == False).all()
active_paginator = Page(active_listings,
page=int(self.request.params.get("page", 1)),
items_per_page=10,
url=page_url)
pastsales_paginator = Page(past_sales,
page=int(self.request.params.get("page",
1)),
items_per_page=10,
url=page_url)
title = user.fullname + "'s Listings"
return dict(user=user,
pastsales_paginator=pastsales_paginator,
lis="d",
form=FormRenderer(form),
active_paginator=active_paginator,
title=title)
def orders(request):
message = ''
units = ''
address = ''
if 'form.submitted' in request.params:
if 'id' in request.params:
order_id = int(request.params['id'])
state = int(request.params['state'])
message = order_service.update_order_state(order_id, state,
request)
else:
message = order_service.create_order(request)
if message != '':
units = request.params['units']
address = request.params['address']
is_admin = check_permission('admin', request)
if is_admin:
query1 = order_service.get_all_pending_orders()
pending_orders = Page(query1,
page=int(request.params.get('p1', 1)),
items_per_page=10,
url=Customizable_PageURL_WebOb(request,
get_param='p1'))
query2 = order_service.get_all_processed_orders()
processed_orders = Page(query2,
page=int(request.params.get('p2', 1)),
items_per_page=10,
url=Customizable_PageURL_WebOb(request,
get_param='p2'))
else:
query1 = order_service.get_all_pending_orders(get_user_email(request))
pending_orders = Page(query1,
page=int(request.params.get('p1', 1)),
items_per_page=10,
url=Customizable_PageURL_WebOb(request,
get_param='p1'))
query2 = order_service.get_all_processed_orders(
get_user_email(request))
processed_orders = Page(query2,
page=int(request.params.get('p2', 1)),
items_per_page=10,
url=Customizable_PageURL_WebOb(request,
get_param='p2'))
is_admin = check_permission('admin', request)
return dict(message=message,
units=units,
address=address,
pending_orders=pending_orders,
processed_orders=processed_orders,
is_admin=is_admin)
def _rank_index_data(request):
current_page = request.params.get("page", 1)
# game type whitelist
game_types_allowed = ["ca", "ctf", "dm", "duel", "ft", "ka", "tdm"]
game_type_cd = request.matchdict['game_type_cd']
if game_type_cd not in game_types_allowed:
raise httpexceptions.HTTPNotFound()
ranks_q = DBSession.query(PlayerRank).\
filter(PlayerRank.game_type_cd==game_type_cd).\
order_by(PlayerRank.rank)
game_type = DBSession.query(GameType).\
filter(GameType.game_type_cd == game_type_cd).one()
ranks = Page(ranks_q, current_page, url=page_url)
if len(ranks) == 0:
ranks = None
return {
'ranks': ranks,
'game_type_cd': game_type_cd,
'game_type': game_type,
}
def from_category(request):
c_id = request.matchdict['category_id']
category = PropertyCategory.get_by_id(c_id)
if category.parent:
title = "%s in Nigeria" % (category.name)
ptype = category.id
listings=DBSession.query(Listings).filter(Listings.approved==True).filter(Listings.declined==False).\
filter(Listings.category==category).order_by(Listings.modified.desc()).all()
else:
ptype = ''
title = "%s Properties in Nigeria" % (category.name)
category_children = [x.name for x in category.children]
listings = DBSession.query(Listings).join(PropertyCategory).filter(Listings.approved==True).\
filter(Listings.declined==False).filter(PropertyCategory.name.in_(category_children)).order_by(Listings.modified.desc()).all()
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(listings, page=page, items_per_page=10, url=page_url)
form = Form(request)
return dict(title=title,
paginator=paginator,
category=category,
form=FormRenderer(form),
type='',
min_price='',
max_price='',
state_id='',
lga_id='',
lgas=[],
ptype=ptype,
beds='',
baths='',
area_size='',
covered_area='',
transaction_type='')
def from_area(request):
area_id = request.matchdict['area_id']
district = District.get_by_id(area_id)
listings=DBSession.query(Listings).filter(Listings.approved==True).\
filter(Listings.declined==False).filter(Listings.district==district).order_by(Listings.modified.desc()).all()
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(listings, page=page, items_per_page=5, url=page_url)
form = Form(request)
title = "Properties in %s, %s,%s" % (district.name, district.lga.name,
district.lga.state.name)
return dict(title=title,
paginator=paginator,
district=district,
form=FormRenderer(form),
type='',
min_price='',
max_price='',
state_id=district.lga.state.id,
lga_id=district.lga.id,
lgas=[(a.id, a.name) for a in district.lga.state.lga.all()],
ptype='',
beds='',
baths='',
area_size='',
covered_area='',
transaction_type='')
def from_state(request):
state_name = request.matchdict['state_name']
state = State.get_by_name(state_name)
listings=DBSession.query(Listings).filter(Listings.approved==True).\
filter(Listings.declined==False).filter(Listings.state==state).order_by(Listings.modified.desc()).all()
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(listings, page=page, items_per_page=10, url=page_url)
title = "Properties in %s" % (state_name)
form = Form(request)
return dict(title=title,
form=FormRenderer(form),
paginator=paginator,
state=state,
type='',
min_price='',
max_price='',
state_id=state.id,
lga_id='',
lgas=[(a.id, a.name) for a in state.lga.all()],
ptype='',
beds='',
baths='',
area_size='',
covered_area='',
transaction_type='')
def buy(self):
form = Form(self.request)
usertypes = userTypes()
title = "Properties for sale in Nigeria"
listing = DBSession.query(Listings).filter(Listings.listing_type=='For sale').\
filter_by(approved = True).filter(Listings.declined==False).\
filter_by(status=True).order_by(Listings.modified.desc()).all()
page = int(self.request.params.get("page", 1))
page_url = PageURL_WebOb(self.request)
paginator = Page(listing,
page=page,
item_count=len(listing),
items_per_page=10,
url=page_url)
return dict(paginator=paginator,
title=title,
buy='buy',
form=FormRenderer(form),
usertypes=usertypes,
type='Buy',
min_price='',
max_price='',
state_id='',
lga_id='',
lgas=[],
ptype='',
beds='',
baths='',
area_size='',
covered_area='',
transaction_type='')
def all_listing(self):
form = Form(self.request)
usertypes = userTypes()
title = 'Properties for sale and rent in Nigeria'
page = int(self.request.params.get('page', 1))
paginator = Listings.get_paginator(self.request, page)
pastsales = DBSession.query(Listings).filter(Listings.approved==True).\
filter(Listings.declined==False).filter(Listings.status==False).all()
page_url = PageURL_WebOb(self.request)
pastsales_paginator = Page(pastsales,
page=int(self.request.params.get("page",
1)),
items_per_page=5,
url=page_url)
self.request.response.cache_control.prevent_auto = True
return dict(paginator=paginator,
find='all',
form=FormRenderer(form),
usertypes=usertypes,
title=title,
pastsales_paginator=pastsales_paginator,
type='',
min_price='',
max_price='',
state_id='',
lga_id='',
lgas=[],
ptype='',
beds='',
baths='',
area_size='',
covered_area='',
transaction_type='')
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 zone_view(self):
zonename = self.request.matchdict['zonename']
page = int(self.request.params['page']
) if 'page' in self.request.params else 0
search = self.request.params[
'search'] if 'search' in self.request.params else None
zonefile = settings.zones[zonename]
zone = Zone(zonename, zonefile)
if search:
records = zone.get_records(name=search)
else:
records = zone.get_records()
entries = []
for record in records:
protected = name_is_protected(zonename, record.name)
entries.append({'record': record, 'protected': protected})
page_url = PageURL_WebOb(self.request)
entries = Page(entries, page, url=page_url)
return {
"zonename": zonename,
"entries": entries,
"serial": zone.serial,
}
def tag(template, name, page=1):
"""
:param template:
模板文件，此参数自动传入
:param name:
Tag名称，若为非ASCII字符，一般是经过URL编码的
"""
# 若name为非ASCII字符，传入时一般是经过URL编码的
# 若name为URL编码，则需要解码为Unicode
# URL编码判断方法：若已为URL编码, 再次编码会在每个码之前出现`%25`
_name = to_bytes(name, 'utf-8')
if urllib.quote(_name).count('%25') > 0:
name = urllib.unquote(_name)
tag = Tag.query.filter_by(name=name).first_or_404()
_url = page_url
_query = Article.query.public().filter(Article.tags.any(id=tag.id))
pagination = Page(_query,
page=page,
items_per_page=Article.PER_PAGE,
url=_url)
articles = pagination.items
_template = template % (tag.template or 'tag.html')
return render_template(_template,
tag=tag,
pagination=pagination,
articles=articles)
def list_view(request):
query_args = {}
if "filter" in request.params:
keys = list(index(request.params["filter"]))
query_args.update({"search_terms": {"$in": keys}})
if "keyword" in request.params:
query_args.update({"keywords": {"$in": [request.params["keyword"]]}})
docs = request.db.docs.find(spec=query_args)
docs.sort("created", DESCENDING)
item_count = docs.count()
page = int(request.params.get("page", 1))
items_per_page = 10
url_maker = PageURL_WebOb(request)
docs = Page(
list(docs[(page - 1) * items_per_page:page * items_per_page]),
url=url_maker,
page=page,
items_per_page=items_per_page,
item_count=item_count,
presliced_list=True,
)
distinct_keywords = request.db.docs.distinct("keywords")
distinct_keywords.sort()
return {"docs": docs, "distinct_keywords": distinct_keywords}
def search(request):
"""This searches contents i.e Blogs, Questions"""
title = "Voices search"
search_term = request.params.get('search_term', '')
form = Form(request)
searchstring = u'%%%s%%' % search_term
# generic_filter can be applied to all Node (and subclassed) objects
generic_filter = or_(
Content.title.like(searchstring),
Content.body.like(searchstring),
)
results = DBSession.query(Content).filter(Content.type !='listing').filter(generic_filter).\
order_by(Content.title.asc()).all()
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(results, page=page, items_per_page=10, url=page_url)
return render_to_response("buddy:templates/home/searchresult.mako",
dict(paginator=paginator,
title=title,
form=FormRenderer(form)),
request=request)
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 index(self):
form = Form(self.request)
params = self.request.params
protype = params.get('type','')
location = params.get('cities_auto','')
name = params.get('name','')
users = DBSession.query(Users)
if protype:
users = users.join(User_types).filter(User_types.id==protype)
if location and name:
st = State.get_by_name(location)
name="%"+name+"%"
filters = or_(Users.fullname.like(name),Users.company_name.like(name))
users = users.filter(Users.state_id==st.id).filter(filters)
if location and not name:
st = State.get_by_name(location)
users = users.filter(Users.state==st)
if name and not location:
namelike="%"+name+"%"
filters = or_(Users.fullname.like(namelike),Users.company_name.like(namelike))
users = users.filter(filters)
users = users.filter(and_(Users.email!=u'*****@*****.**',Users.email!=u'*****@*****.**')).order_by((Users.photo!=None).desc()).all()
page_url = PageURL_WebOb(self.request)
paginator = Page(users,
page=int(self.request.params.get("page", 1)),
items_per_page=12,
url=page_url)
return dict(title="Nairabricks Real Estate Professionals",
name = name,
location = location,
protype= protype,
form = FormRenderer(form),paginator=paginator)
def index(self):
users_log = UserLog.query()\
.options(joinedload(UserLog.user))\
.options(joinedload(UserLog.repository))
#FILTERING
c.search_term = request.GET.get('filter')
try:
users_log = _journal_filter(users_log, c.search_term)
except Exception:
# we want this to crash for now
raise
users_log = users_log.order_by(UserLog.action_date.desc())
p = safe_int(request.GET.get('page', 1), 1)
def url_generator(**kw):
return url.current(filter=c.search_term, **kw)
c.users_log = Page(users_log, page=p, items_per_page=10, url=url_generator)
c.log_data = render('admin/admin_log.html')
if request.environ.get('HTTP_X_PARTIAL_XHR'):
return c.log_data
return render('admin/admin.html')
def user_list(request):
users_per_page = int(
request.registry.settings.get("votabo.users_per_page", 200))
page = int(request.GET.get("page", "1"))
url_for_page = PageURL(request.path, request.params)
sql = DBSession.query(User).order_by(desc(User.id))
if request.GET.get("id"):
sql = sql.filter(User.id == request.GET["id"])
if request.GET.get("username"):
sql = sql.filter(
User.username.ilike("%" + request.GET["username"] + "%"))
if request.GET.get(
"email"
): # FIXME: has_permission(edit-user) -- else info could leak by blind searching
sql = sql.filter(User.email.ilike("%" + request.GET["email"] + "%"))
if request.GET.get("posts"):
sql = sql.filter(
User.post_count >= int(request.GET["posts"].replace("on", "1")))
if request.GET.get("comments"):
sql = sql.filter(User.comment_count >= int(
request.GET["comments"].replace("on", "1")))
if request.GET.get("category"):
sql = sql.filter(User.category == request.GET["category"])
users = Page(sql,
page=page,
items_per_page=users_per_page,
url=url_for_page)
return {"users": users, "pager": users}
def list(self, modelname, format='html'):
"""List instances of a model type"""
S = self.Session()
grid = self._model_grids[modelname]
query = S.query(grid.model.__class__)
page = Page(query,
page=int(request.GET.get('page', '1')),
**self._paginate)
if format == 'json':
values = []
for item in page:
pk = _pk(item)
values.append((pk, url('view_model', pk)))
return self.render_json(records=dict(values),
page_count=page.page_count,
page=page.page)
grid = grid.bind(instances=page, session=None)
clsnames = [
f.relation_type().__name__ for f in grid._fields.itervalues()
if f.is_relation
]
return self._engine('admin_list',
c=c,
grid=grid,
page=page,
clsnames=clsnames,
modelname=modelname,
custom_css=self._custom_css,
custom_js=self._custom_js)
def userblogfilter(self):
path = self.request.matchdict['prefix']
form = Form(self.request)
#id = self.request.matchdict['id']
category = self.request.matchdict['category']
user = Users.get_by_path(path)
blogs = user.content.filter(Content.type == 'blog').filter(
Blogs.categories.any(name=category)).all()
bcategor = user.content.filter(Content.type == 'blog').filter(
Blogs.user_id == user.id).all()
bc = [s.categories for s in bcategor]
bc = histogram(bc)
title = user.fullname + "'s Blogs on " + category
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,
blog_nav_cat=get_navcategories(),
form=FormRenderer(form),
bl='bl',
category=category,
title=title,
bcategories=bc)
def index(self):
# Return a rendered template
p = int(request.params.get('page', 1))
c.user = User.get(self.rhodecode_user.user_id)
all_repos = self.sa.query(Repository)\
.filter(Repository.user_id == c.user.user_id)\
.order_by(func.lower(Repository.repo_name)).all()
c.user_repos = ScmModel().get_repos(all_repos)
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/journal.html')
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 user_search(request):
title = 'Professionals'
search_term = request.params.get('search_term', '')
form = Form(request)
searchstring = u'%%%s%%' % search_term
generic_filter = or_(Users.firstname.like(searchstring),
Users.surname.like(searchstring),
Users.company_name.like(searchstring))
results = DBSession.query(Users).filter(generic_filter).\
filter(and_(Users.email!=u'*****@*****.**',Users.email!=u'*****@*****.**'))\
.order_by((Users.photo!=None).desc()).all()
page_url = PageURL_WebOb(request)
page = int(request.params.get("page", 1))
paginator = Page(results, page=page, items_per_page=10, url=page_url)
return render_to_response("buddy:templates/search/index.mako",
dict(paginator=paginator,
title=title,
name=search_term,
location='',
protype='',
form=FormRenderer(form)),
request=request)
def get_page(self, **kwargs):
S = meta.Session
q = S.query(self.get_model())
# FIXME: SQL injection; regex whitelist *should* stop it
for name in [n for n in request.GET if "--" in n]:
col_name = name[name.find("--") + 2:]
value = request.GET[name]
if re.match("^[a-zA-Z0-9_]+$", col_name) and re.match(
"^[a-zA-Z0-9_]+$", value):
if name == "User--id": # FIXME: haaaaaaaaaack. id alone is ambiguous
q = q.filter("member.id = '%s'" % (str(value), ))
elif re.match("^[0-9]+$", value):
q = q.filter("%s = %s" % (col_name, str(value)))
elif col_name == "status":
q = q.filter("%s = '%s'" % (col_name, value))
else:
q = q.filter("%s ILIKE '%s'" %
(col_name, "%" + value + "%"))
options = dict(collection=q, 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 account_listing(self):
form = Form(self.request)
user = self.request.user
page = int(self.request.params.get("page", 1))
page_url = PageURL_WebOb(self.request)
active_listings = DBSession.query(Listings).filter(Listings.user == user).filter(Listings.approved == True). \
filter(Listings.declined == False).filter(Listings.status == True).all()
onreview_listings = DBSession.query(Listings).filter(Listings.user == user).filter(Listings.approved == False). \
filter(Listings.declined == False).filter(Listings.status == True).all()
declined_listings = DBSession.query(Listings).filter(Listings.user == user). \
filter(Listings.declined == True).filter(Listings.status == True).all()
past_sales = DBSession.query(Listings).filter(
Listings.user == user).filter(Listings.status == False).all()
favourites = user.favourites
active_paginator = Page(active_listings,
page=int(self.request.params.get("page", 1)),
items_per_page=10,
url=page_url)
declined_paginator = Page(declined_listings,
page=int(self.request.params.get("page", 1)),
items_per_page=10,
url=page_url)
pastsales_paginator = Page(past_sales,
page=int(self.request.params.get("page",
1)),
items_per_page=10,
url=page_url)
onreview_paginator = Page(onreview_listings,
page=int(self.request.params.get("page", 1)),
items_per_page=10,
url=page_url)
favourite_paginator = Page(favourites,
page=int(self.request.params.get("page",
1)),
items_per_page=10,
url=page_url)
title = user.fullname + "'s Listings"
if page > 1:
title = title + ' page ' + str(page)
return dict(user=user,
pastsales_paginator=pastsales_paginator,
onreview_paginator=onreview_paginator,
form=FormRenderer(form),
active_paginator=active_paginator,
declined_paginator=declined_paginator,
title=title,
favourites_paginator=favourite_paginator)
def index(self, format='html'):
"""GET /_admin/notifications: All items in the collection"""
# url('notifications')
c.user = self.rhodecode_user
notif = NotificationModel().get_for_user(self.rhodecode_user.user_id)
p = int(request.params.get('page', 1))
c.notifications = Page(notif, page=p, items_per_page=10)
return render('admin/notifications/notifications.html')
def list_clinic():
try:
page = request.values.get("page", 1)
except:
page = 1
cs = list(connection.Clinic.find({'active':0}).sort('name'))
paginate_clinics = Page(cs, page = page, items_per_page = 10, url = lambda page:"%s?page=%d" % (url_for("list_clinic"), page))
return {"clinics" :paginate_clinics}
def get_explore_ourpicks(cls, request, logged_in_alias, page=1):
page_url = PageURL_WebOb(request)
now = int(round(time.time() / 60 / 60)) + 1
gravity = 1.8
return Page(DBSession.query(Question, Qvote, Images).outerjoin(Images, Images.usralias == Question.askedbyalias).outerjoin\
(Qvote, and_(Question.questionasker==Qvote.questionasker,\
Qvote.userid == logged_in_alias)).filter(Question.askedby !="Sebastian").filter(Question.askedby !="sebastian").filter(Question.answered==True).order_by(func.random()).offset(20).limit(20), page,
url=page_url, items_per_page=20)
def index(self, id=1):
c.now = datetime.now()
query = model.meta.Session.query(model.Snippet)
c.lastsnippets = query.order_by(desc(model.Snippet.creation)).limit(5)
c.page = Page(query.order_by(desc(model.Snippet.creation)),
id or 1,
items_per_page=10)
return render('/archive.mako')
def top_servers_by_players(request):
current_page = request.params.get('page', 1)
cutoff_days = int(request.registry.settings.get('xonstat.leaderboard_lifetime', 30))
region = request.params.get("region") or request.cookies.get("region")
game_type_cd = request.params.get("gametype") or request.cookies.get("gametype")
top_servers_q = top_servers_by_players_q(cutoff_days, region, game_type_cd)
top_servers = Page(top_servers_q, current_page, items_per_page=25, url=page_url)
return {'top_servers':top_servers}
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}