# Defaults
LEADERBOARD_LIFETIME = 30
LEADERBOARD_COUNT = 10
+INDEX_COUNT = 20
RECENT_GAMES_COUNT = 20
"""Common parameter parsing."""
self.request = request
self.page = request.params.get("page", 1)
- self.servers = self.raw()
+ self.servers = self.server_index()
- def raw(self):
+ def server_index(self):
"""Returns the raw data shared by all renderers."""
try:
- server_q = DBSession.query(Server).order_by(Server.server_id.desc())
+ 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:
+ except Exception as e:
+ log.debug(e)
raise HTTPNotFound
return servers
class ServerTopMaps(ServerInfoBase):
"""Returns the top maps played on a given server."""
- def __init__(self, request, limit=LEADERBOARD_COUNT, last=None):
+ def __init__(self, request, limit=INDEX_COUNT, last=None):
"""Common parameter parsing."""
super(ServerTopMaps, self).__init__(request, limit, last)
- self.top_maps = self.raw()
+ self.top_maps = self.top_maps()
- def raw(self):
+ def top_maps(self):
"""Returns the raw data shared by all renderers."""
try:
top_maps_q = DBSession.query(
fg.row_number().over(order_by=expr.desc(func.count())).label("rank"),
Game.map_id, Map.name, func.count().label("times_played"))\
- .filter(Map.map_id==Game.map_id)\
- .filter(Game.server_id==self.server_id)\
+ .filter(Map.map_id == Game.map_id)\
+ .filter(Game.server_id == self.server_id)\
.filter(Game.create_dt > (self.now - timedelta(days=self.lifetime)))\
.group_by(Game.map_id)\
.group_by(Map.name) \
def html(self):
"""Returns the HTML-ready representation."""
- return self.top_maps
+
+ # build the query string
+ query = {}
+ if len(self.top_maps) > 1:
+ query['last'] = self.top_maps[-1].rank
+
+ return {
+ "server_id": self.server_id,
+ "top_maps": self.top_maps,
+ "lifetime": self.lifetime,
+ "query": query,
+ }
def json(self):
"""For rendering this data using JSON."""
"times_played": tm.times_played,
} for tm in self.top_maps]
- return top_maps
+ return {
+ "server_id": self.server_id,
+ "top_maps": top_maps,
+ }
class ServerTopScorers(ServerInfoBase):
"""Returns the top scorers on a given server."""
- def __init__(self, request, limit=LEADERBOARD_COUNT, last=None):
+ def __init__(self, request, limit=INDEX_COUNT, last=None):
"""Common parameter parsing."""
super(ServerTopScorers, self).__init__(request, limit, last)
- self.top_scorers = self.raw()
+ self.top_scorers = self.top_scorers()
- def raw(self):
+ def top_scorers(self):
"""Top scorers on this server by total score."""
try:
top_scorers_q = DBSession.query(
.filter(Game.server_id == self.server_id)\
.filter(Player.player_id > 2)\
.filter(PlayerGameStat.create_dt >
- (self.now - timedelta(days=LEADERBOARD_LIFETIME)))\
+ (self.now - timedelta(days=self.lifetime)))\
.order_by(expr.desc(func.sum(PlayerGameStat.score)))\
.group_by(Player.nick)\
.group_by(Player.player_id)
top_scorers = [TopScorer(ts.rank, ts.player_id, html_colors(ts.nick), ts.total_score)
for ts in self.top_scorers]
- return top_scorers
+
+ # build the query string
+ query = {}
+ if len(top_scorers) > 1:
+ query['last'] = top_scorers[-1].rank
+
+ return {
+ "server_id": self.server_id,
+ "top_scorers": top_scorers,
+ "lifetime": self.lifetime,
+ "query": query,
+ }
def json(self):
"""For rendering this data using JSON."""
"score": ts.total_score,
} for ts in self.top_scorers]
- return top_scorers
+ return {
+ "server_id": self.server_id,
+ "top_scorers": top_scorers,
+ }
class ServerTopPlayers(ServerInfoBase):
"""Returns the top players by playing time on a given server."""
- def __init__(self, request, limit=LEADERBOARD_COUNT, last=None):
+ def __init__(self, request, limit=INDEX_COUNT, last=None):
"""Common parameter parsing."""
super(ServerTopPlayers, self).__init__(request, limit, last)
- self.top_players = self.raw()
+ self.top_players = self.top_players()
- def raw(self):
+ def top_players(self):
"""Top players on this server by total playing time."""
try:
top_players_q = DBSession.query(
top_players = [TopPlayer(tp.rank, tp.player_id, html_colors(tp.nick), tp.alivetime)
for tp in self.top_players]
- return top_players
+ # build the query string
+ query = {}
+ if len(top_players) > 1:
+ query['last'] = top_players[-1].rank
+
+ return {
+ "server_id": self.server_id,
+ "top_players": top_players,
+ "lifetime": self.lifetime,
+ "query": query,
+ }
def json(self):
"""For rendering this data using JSON."""
"time": ts.alivetime.total_seconds(),
} for ts in self.top_players]
- return top_players
+ return {
+ "server_id": self.server_id,
+ "top_players": top_players,
+ }
class ServerInfo(ServerInfoBase):
# this view uses data from other views, so we'll save the data at that level
try:
- self.server = DBSession.query(Server).filter_by(server_id=self.server_id).one()
+ self.server = DBSession.query(Server)\
+ .filter(Server.active_ind)\
+ .filter(Server.server_id == self.server_id)\
+ .one()
+
self.top_maps_v = ServerTopMaps(self.request, limit=LEADERBOARD_COUNT)
self.top_scorers_v = ServerTopScorers(self.request, limit=LEADERBOARD_COUNT)
self.top_players_v = ServerTopPlayers(self.request, limit=LEADERBOARD_COUNT)
except:
raise HTTPNotFound
- def raw(self):
- """Returns the raw data shared by all renderers."""
- return {
- 'server': self.server,
- 'top_players': self.top_players_v.top_players,
- 'top_scorers': self.top_scorers_v.top_scorers,
- 'top_maps': self.top_maps_v.top_maps,
- 'recent_games': self.recent_games,
- }
-
def html(self):
"""For rendering this data using something HTML-based."""
return {
'server': self.server,
- 'top_players': self.top_players_v.html(),
- 'top_scorers': self.top_scorers_v.html(),
- 'top_maps': self.top_maps_v.html(),
+ 'top_players': self.top_players_v.html().get("top_players", None),
+ 'top_scorers': self.top_scorers_v.html().get("top_scorers", None),
+ 'top_maps': self.top_maps_v.html().get("top_maps", None),
'recent_games': self.recent_games,
'lifetime': self.lifetime,
}
projects / xonotic / xonstat.git / blobdiff