xonstat/views/server.py

   1 import logging
   2 import sqlalchemy.sql.functions as func
   3 import sqlalchemy.sql.expression as expr
   4 from datetime import datetime, timedelta
   5 from webhelpers.paginate import Page
   6 from xonstat.models import *
   7 from xonstat.util import page_url, html_colors
   8 from xonstat.views.helpers import RecentGame, recent_games_q
   9
  10 log = logging.getLogger(__name__)
  11
  12 def _server_index_data(request):
  13     if request.params.has_key('page'):
  14         current_page = request.params['page']
  15     else:
  16         current_page = 1
  17
  18     try:
  19         server_q = DBSession.query(Server).\
  20                 order_by(Server.server_id.desc())
  21
  22         servers = Page(server_q, current_page, items_per_page=25, url=page_url)
  23
  24
  25     except Exception as e:
  26         servers = None
  27
  28     return {'servers':servers, }
  29
  30
  31 def server_index(request):
  32     """
  33     Provides a list of all the current servers.
  34     """
  35     return _server_index_data(request)
  36
  37
  38 def server_index_json(request):
  39     """
  40     Provides a list of all the current servers. JSON.
  41     """
  42     return [{'status':'not implemented'}]
  43
  44
  45 def _server_info_data(request):
  46     server_id = request.matchdict['id']
  47
  48     try:
  49         leaderboard_lifetime = int(
  50                 request.registry.settings['xonstat.leaderboard_lifetime'])
  51     except:
  52         leaderboard_lifetime = 30
  53
  54     leaderboard_count = 10
  55     recent_games_count = 20
  56
  57     try:
  58         server = DBSession.query(Server).filter_by(server_id=server_id).one()
  59
  60         # top maps by total times played
  61         top_maps = DBSession.query(Game.map_id, Map.name,
  62                 func.count()).\
  63                 filter(Map.map_id==Game.map_id).\
  64                 filter(Game.server_id==server.server_id).\
  65                 filter(Game.create_dt >
  66                     (datetime.utcnow() - timedelta(days=leaderboard_lifetime))).\
  67                 order_by(expr.desc(func.count())).\
  68                 group_by(Game.map_id).\
  69                 group_by(Map.name).all()[0:leaderboard_count]
  70
  71         # top players by score
  72         top_scorers = DBSession.query(Player.player_id, Player.nick,
  73                 func.sum(PlayerGameStat.score)).\
  74                 filter(Player.player_id == PlayerGameStat.player_id).\
  75                 filter(Game.game_id == PlayerGameStat.game_id).\
  76                 filter(Game.server_id == server.server_id).\
  77                 filter(Player.player_id > 2).\
  78                 filter(PlayerGameStat.create_dt >
  79                         (datetime.utcnow() - timedelta(days=leaderboard_lifetime))).\
  80                 order_by(expr.desc(func.sum(PlayerGameStat.score))).\
  81                 group_by(Player.nick).\
  82                 group_by(Player.player_id).all()[0:leaderboard_count]
  83
  84         top_scorers = [(player_id, html_colors(nick), score) \
  85                 for (player_id, nick, score) in top_scorers]
  86
  87         # top players by playing time
  88         top_players = DBSession.query(Player.player_id, Player.nick,
  89                 func.sum(PlayerGameStat.alivetime)).\
  90                 filter(Player.player_id == PlayerGameStat.player_id).\
  91                 filter(Game.game_id == PlayerGameStat.game_id).\
  92                 filter(Game.server_id == server.server_id).\
  93                 filter(Player.player_id > 2).\
  94                 filter(PlayerGameStat.create_dt >
  95                         (datetime.utcnow() - timedelta(days=leaderboard_lifetime))).\
  96                 order_by(expr.desc(func.sum(PlayerGameStat.alivetime))).\
  97                 group_by(Player.nick).\
  98                 group_by(Player.player_id).all()[0:leaderboard_count]
  99
 100         top_players = [(player_id, html_colors(nick), score) \
 101                 for (player_id, nick, score) in top_players]
 102
 103         # recent games played in descending order
 104         rgs = recent_games_q(server_id=server_id).limit(recent_games_count).all()
 105         recent_games = [RecentGame(row) for row in rgs]
 106
 107     except Exception as e:
 108         server = None
 109         recent_games = None
 110         top_players = None
 111         raise e
 112     return {'server':server,
 113             'recent_games':recent_games,
 114             'top_players': top_players,
 115             'top_scorers': top_scorers,
 116             'top_maps': top_maps,
 117             }
 118
 119
 120 def server_info(request):
 121     """
 122     List the stored information about a given server.
 123     """
 124     serverinfo_data =  _server_info_data(request)
 125
 126     # FIXME: code clone, should get these from _server_info_data
 127     leaderboard_count = 10
 128     recent_games_count = 20
 129
 130     for i in range(leaderboard_count-len(serverinfo_data['top_maps'])):
 131         serverinfo_data['top_maps'].append(('-', '-', '-'))
 132
 133     for i in range(leaderboard_count-len(serverinfo_data['top_scorers'])):
 134         serverinfo_data['top_scorers'].append(('-', '-', '-'))
 135
 136     for i in range(leaderboard_count-len(serverinfo_data['top_players'])):
 137         serverinfo_data['top_players'].append(('-', '-', '-'))
 138
 139     return serverinfo_data
 140
 141
 142 def server_info_json(request):
 143     """
 144     List the stored information about a given server. JSON.
 145     """
 146     return [{'status':'not implemented'}]
 147
 148
 149 def _server_game_index_data(request):
 150     server_id = request.matchdict['server_id']
 151     current_page = request.matchdict['page']
 152
 153     try:
 154         server = DBSession.query(Server).filter_by(server_id=server_id).one()
 155
 156         games_q = DBSession.query(Game, Server, Map).\
 157                 filter(Game.server_id == server_id).\
 158                 filter(Game.server_id == Server.server_id).\
 159                 filter(Game.map_id == Map.map_id).\
 160                 order_by(Game.game_id.desc())
 161
 162         games = Page(games_q, current_page, url=page_url)
 163     except Exception as e:
 164         server = None
 165         games = None
 166         raise e
 167
 168     return {'games':games,
 169             'server':server}
 170
 171
 172 def server_game_index(request):
 173     """
 174     List the games played on a given server. Paginated.
 175     """
 176     return _server_game_index_data(request)
 177
 178
 179 def server_game_index_json(request):
 180     """
 181     List the games played on a given server. Paginated. JSON.
 182     """
 183     return [{'status':'not implemented'}]