xonstat/views/game.py

   1 import datetime
   2 import logging
   3 import re
   4 import time
   5 from collections import OrderedDict
   6 from pyramid.response import Response
   7 from sqlalchemy import desc, func, over
   8 from webhelpers.paginate import Page, PageURL
   9 from xonstat.models import *
  10 from xonstat.util import page_url
  11 from xonstat.views.helpers import RecentGame, recent_games_q
  12
  13 log = logging.getLogger(__name__)
  14
  15
  16 # DEPRECATED
  17 def _game_index_data(request):
  18     game_type_cd = None
  19     game_type_descr = None
  20
  21     if request.params.has_key('game_type_cd'):
  22         game_type_cd = request.params['game_type_cd']
  23         try:
  24             game_type_descr = DBSession.query(GameType.descr).\
  25                 filter(GameType.game_type_cd == game_type_cd).\
  26                 one()[0]
  27         except Exception as e:
  28             game_type_cd = None
  29
  30     if request.params.has_key('page'):
  31         current_page = request.params['page']
  32     else:
  33         current_page = 1
  34
  35     try:
  36         rgs_q = recent_games_q(game_type_cd=game_type_cd)
  37
  38         games = Page(rgs_q, current_page, items_per_page=10, url=page_url)
  39
  40         # replace the items in the canned pagination class with more rich ones
  41         games.items = [RecentGame(row) for row in games.items]
  42
  43         pgstats = {}
  44         for game in games.items:
  45             pgstats[game.game_id] = DBSession.query(PlayerGameStat).\
  46                     filter(PlayerGameStat.game_id == game.game_id).\
  47                     order_by(PlayerGameStat.scoreboardpos).\
  48                     order_by(PlayerGameStat.score).all()
  49
  50     except Exception as e:
  51         games           = None
  52         pgstats         = None
  53         game_type_cd    = None
  54         game_type_descr = None
  55
  56     return {'games':games,
  57             'pgstats':pgstats,
  58             'game_type_cd':game_type_cd,
  59             'game_type_descr':game_type_descr,
  60             }
  61
  62
  63 def game_index(request):
  64     """
  65     Provides a list of current games, with the associated game stats.
  66     These games are ordered by game_id, with the most current ones first.
  67     Paginated.
  68     """
  69     return _game_index_data(request)
  70
  71
  72 def game_index_json(request):
  73     """
  74     Provides a list of current games, with the associated game stats.
  75     These games are ordered by game_id, with the most current ones first.
  76     Paginated. JSON.
  77     """
  78     return [{'status':'not implemented'}]
  79
  80
  81 def _game_info_data(request):
  82     game_id = request.matchdict['id']
  83
  84     if request.params.has_key('show_elo'):
  85         show_elo = True
  86     else:
  87         show_elo = False
  88
  89     if request.params.has_key('show_latency'):
  90         show_latency = True
  91     else:
  92         show_latency = False
  93
  94     try:
  95         notfound = False
  96
  97         (game, server, map, gametype) = DBSession.query(Game, Server, Map, GameType).\
  98                 filter(Game.game_id == game_id).\
  99                 filter(Game.server_id == Server.server_id).\
 100                 filter(Game.map_id == Map.map_id).\
 101                 filter(Game.game_type_cd == GameType.game_type_cd).one()
 102
 103         pgstats = DBSession.query(PlayerGameStat).\
 104                 filter(PlayerGameStat.game_id == game_id).\
 105                 order_by(PlayerGameStat.scoreboardpos).\
 106                 order_by(PlayerGameStat.score).\
 107                 all()
 108
 109         tgstats = DBSession.query(TeamGameStat).\
 110                 filter(TeamGameStat.game_id == game_id).\
 111                 order_by(TeamGameStat.score).\
 112                 all()
 113
 114         stats_by_team = OrderedDict()
 115         for pgstat in pgstats:
 116             if pgstat.team not in stats_by_team.keys():
 117                 stats_by_team[pgstat.team] = []
 118             stats_by_team[pgstat.team].append(pgstat)
 119         log.debug(stats_by_team)
 120
 121         captimes = []
 122         if game.game_type_cd == 'ctf':
 123             for pgstat in pgstats:
 124                 if pgstat.fastest is not None:
 125                     captimes.append(pgstat)
 126             captimes = sorted(captimes, key=lambda x:x.fastest)
 127
 128         pwstats = {}
 129         for (pwstat, pgstat, weapon) in DBSession.query(PlayerWeaponStat, PlayerGameStat, Weapon).\
 130                 filter(PlayerWeaponStat.game_id == game_id).\
 131                 filter(PlayerWeaponStat.weapon_cd == Weapon.weapon_cd).\
 132                 filter(PlayerWeaponStat.player_game_stat_id == \
 133                     PlayerGameStat.player_game_stat_id).\
 134                 order_by(PlayerGameStat.scoreboardpos).\
 135                 order_by(PlayerGameStat.score).\
 136                 order_by(Weapon.descr).\
 137                 all():
 138                     if pgstat.player_game_stat_id not in pwstats:
 139                         pwstats[pgstat.player_game_stat_id] = []
 140
 141                     # NOTE adding pgstat to position 6 in order to display nick.
 142                     # You have to use a slice [0:5] to pass to the accuracy
 143                     # template
 144                     pwstats[pgstat.player_game_stat_id].append((weapon.descr,
 145                         weapon.weapon_cd, pwstat.actual, pwstat.max,
 146                         pwstat.hit, pwstat.fired, pgstat))
 147
 148     except Exception as inst:
 149         game = None
 150         server = None
 151         map = None
 152         gametype = None
 153         pgstats = None
 154         tgstats = None
 155         pwstats = None
 156         captimes = None
 157         show_elo = False
 158         show_latency = False
 159         stats_by_team = None
 160         raise inst
 161
 162     return {'game':game,
 163             'server':server,
 164             'map':map,
 165             'gametype':gametype,
 166             'pgstats':pgstats,
 167             'tgstats':tgstats,
 168             'pwstats':pwstats,
 169             'captimes':captimes,
 170             'show_elo':show_elo,
 171             'show_latency':show_latency,
 172             'stats_by_team':stats_by_team,
 173             }
 174
 175
 176 def game_info(request):
 177     """
 178     List the game stats (scoreboard) for a particular game. Paginated.
 179     """
 180     return _game_info_data(request)
 181
 182
 183 def game_info_json(request):
 184     """
 185     List the game stats (scoreboard) for a particular game. Paginated. JSON.
 186     """
 187     return [{'status':'not implemented'}]
 188
 189
 190 def _rank_index_data(request):
 191     if request.params.has_key('page'):
 192         current_page = request.params['page']
 193     else:
 194         current_page = 1
 195
 196     game_type_cd = request.matchdict['game_type_cd']
 197
 198     ranks_q = DBSession.query(PlayerRank).\
 199             filter(PlayerRank.game_type_cd==game_type_cd).\
 200             order_by(PlayerRank.rank)
 201
 202     ranks = Page(ranks_q, current_page, url=page_url)
 203
 204     if len(ranks) == 0:
 205         ranks = None
 206
 207     return {
 208             'ranks':ranks,
 209             'game_type_cd':game_type_cd,
 210            }
 211
 212
 213 def rank_index(request):
 214     """
 215     Provide a list of gametype ranks, paginated.
 216     """
 217     return _rank_index_data(request)
 218
 219
 220 def rank_index_json(request):
 221     """
 222     Provide a list of gametype ranks, paginated. JSON.
 223     """
 224     return [{'status':'not implemented'}]
 225
 226
 227 def game_finder_data(request):
 228     if request.params.has_key('page'):
 229         current_page = request.params['page']
 230     else:
 231         current_page = 1
 232
 233     query = {}
 234
 235     server_id, map_id, player_id = None, None, None
 236     range_start, range_end, game_type_cd = None, None, None
 237     game_type_descr = None
 238
 239     # these become WHERE clauses when present
 240     if request.params.has_key('server_id'):
 241         server_id = request.params['server_id']
 242         query['server_id'] = server_id
 243
 244     if request.params.has_key('map_id'):
 245         map_id = request.params['map_id']
 246         query['map_id'] = map_id
 247
 248     if request.params.has_key('player_id'):
 249         player_id = request.params['player_id']
 250         query['player_id'] = player_id
 251
 252     if request.params.has_key('range_start'):
 253         range_start = request.params['range_start']
 254         query['range_start'] = range_start
 255
 256     if request.params.has_key('range_end'):
 257         range_end = request.params['range_end']
 258         query['range_end'] = range_end
 259
 260     if request.params.has_key('type'):
 261         game_type_cd = request.params['type']
 262         query['type'] = game_type_cd
 263         try:
 264             game_type_descr = DBSession.query(GameType.descr).\
 265                 filter(GameType.game_type_cd == game_type_cd).\
 266                 one()[0]
 267         except Exception as e:
 268             game_type_cd = None
 269
 270     rgs_q = recent_games_q(server_id=server_id, map_id=map_id,
 271             player_id=player_id, game_type_cd=game_type_cd)
 272
 273     recent_games = Page(rgs_q, current_page, url=page_url)
 274
 275     recent_games.items = [RecentGame(row) for row in recent_games.items]
 276
 277     return {
 278             'recent_games':recent_games,
 279             'query':query,
 280             'game_type_cd':game_type_cd,
 281            }
 282
 283 def game_finder(request):
 284     """
 285     Provide a list of recent games with an advanced filter.
 286     """
 287     return game_finder_data(request)