xonstat/views/player.py

   1 import datetime
   2 import json
   3 import logging
   4 import re
   5 import sqlalchemy as sa
   6 import sqlalchemy.sql.functions as func
   7 import time
   8 from pyramid.response import Response
   9 from pyramid.url import current_route_url
  10 from sqlalchemy import desc, distinct
  11 from webhelpers.paginate import Page, PageURL
  12 from xonstat.models import *
  13 from xonstat.util import page_url
  14
  15 log = logging.getLogger(__name__)
  16
  17
  18 def _player_index_data(request):
  19     if request.params.has_key('page'):
  20         current_page = request.params['page']
  21     else:
  22         current_page = 1
  23
  24     try:
  25         player_q = DBSession.query(Player).\
  26                 filter(Player.player_id > 2).\
  27                 filter(Player.active_ind == True).\
  28                 filter(sa.not_(Player.nick.like('Anonymous Player%'))).\
  29                 order_by(Player.player_id.desc())
  30
  31         players = Page(player_q, current_page, items_per_page=10, url=page_url)
  32
  33     except Exception as e:
  34         players = None
  35         raise e
  36
  37     return {'players':players
  38            }
  39
  40
  41 def player_index(request):
  42     """
  43     Provides a list of all the current players.
  44     """
  45     return _player_index_data(request)
  46
  47
  48 def _get_games_played(player_id):
  49     """
  50     Provides a breakdown by gametype of the games played by player_id.
  51
  52     Returns a tuple containing (total_games, games_breakdown), where
  53     total_games is the absolute number of games played by player_id
  54     and games_breakdown is an array containing (game_type_cd, # games)
  55     """
  56     games_played = DBSession.query(Game.game_type_cd, func.count()).\
  57             filter(Game.game_id == PlayerGameStat.game_id).\
  58             filter(PlayerGameStat.player_id == player_id).\
  59             group_by(Game.game_type_cd).\
  60             order_by(func.count().desc()).all()
  61
  62     total = 0
  63     for (game_type_cd, games) in games_played:
  64         total += games
  65
  66     return (total, games_played)
  67
  68
  69 # TODO: should probably factor the above function into this one such that
  70 # total_stats['ctf_games'] is the count of CTF games and so on...
  71 def _get_total_stats(player_id):
  72     """
  73     Provides aggregated stats by player_id.
  74
  75     Returns a dict with the keys 'kills', 'deaths', 'alivetime'.
  76
  77     kills = how many kills a player has over all games
  78     deaths = how many deaths a player has over all games
  79     alivetime = how long a player has played over all games
  80
  81     If any of the above are None, they are set to 0.
  82     """
  83     total_stats = {}
  84     (total_stats['kills'], total_stats['deaths'], total_stats['alivetime']) = DBSession.\
  85             query("total_kills", "total_deaths", "total_alivetime").\
  86             from_statement(
  87                 "select sum(kills) total_kills, "
  88                 "sum(deaths) total_deaths, "
  89                 "sum(alivetime) total_alivetime "
  90                 "from player_game_stats "
  91                 "where player_id=:player_id"
  92             ).params(player_id=player_id).one()
  93
  94     (total_stats['wins'],) = DBSession.\
  95             query("total_wins").\
  96             from_statement(
  97                 "select count(*) total_wins "
  98                 "from games g, player_game_stats pgs "
  99                 "where g.game_id = pgs.game_id "
 100                 "and player_id=:player_id "
 101                 "and (g.winner = pgs.team or pgs.rank = 1)"
 102             ).params(player_id=player_id).one()
 103
 104     for (key,value) in total_stats.items():
 105         if value == None:
 106             total_stats[key] = 0
 107
 108     return total_stats
 109
 110
 111 def get_accuracy_stats(player_id, weapon_cd, games):
 112     """
 113     Provides accuracy for weapon_cd by player_id for the past N games.
 114     """
 115     # Reaching back 90 days should give us an accurate enough average
 116     # We then multiply this out for the number of data points (games) to
 117     # create parameters for a flot graph
 118     try:
 119         raw_avg = DBSession.query(func.sum(PlayerWeaponStat.hit),
 120                 func.sum(PlayerWeaponStat.fired)).\
 121                 filter(PlayerWeaponStat.player_id == player_id).\
 122                 filter(PlayerWeaponStat.weapon_cd == weapon_cd).\
 123                 one()
 124
 125         avg = round(float(raw_avg[0])/raw_avg[1]*100, 2)
 126
 127         # Determine the raw accuracy (hit, fired) numbers for $games games
 128         # This is then enumerated to create parameters for a flot graph
 129         raw_accs = DBSession.query(PlayerWeaponStat.game_id,
 130             PlayerWeaponStat.hit, PlayerWeaponStat.fired).\
 131                 filter(PlayerWeaponStat.player_id == player_id).\
 132                 filter(PlayerWeaponStat.weapon_cd == weapon_cd).\
 133                 order_by(PlayerWeaponStat.game_id.desc()).\
 134                 limit(games).\
 135                 all()
 136
 137         # they come out in opposite order, so flip them in the right direction
 138         raw_accs.reverse()
 139
 140         accs = []
 141         for i in range(len(raw_accs)):
 142             accs.append((raw_accs[i][0], round(float(raw_accs[i][1])/raw_accs[i][2]*100, 2)))
 143     except:
 144         accs = []
 145         avg = 0.0
 146
 147     return (avg, accs)
 148
 149
 150 def _player_info_data(request):
 151     player_id = int(request.matchdict['id'])
 152     if player_id <= 2:
 153         player_id = -1;
 154
 155     try:
 156         player = DBSession.query(Player).filter_by(player_id=player_id).\
 157                 filter(Player.active_ind == True).one()
 158
 159         # games played, alivetime, wins, kills, deaths
 160         total_stats = _get_total_stats(player.player_id)
 161
 162         # games breakdown - N games played (X ctf, Y dm) etc
 163         (total_games, games_breakdown) = _get_games_played(player.player_id)
 164
 165
 166         # friendly display of elo information and preliminary status
 167         elos = DBSession.query(PlayerElo).filter_by(player_id=player_id).\
 168                 filter(PlayerElo.game_type_cd.in_(['ctf','duel','dm'])).\
 169                 order_by(PlayerElo.elo.desc()).all()
 170
 171         elos_display = []
 172         for elo in elos:
 173             if elo.games > 32:
 174                 str = "{0} ({1})"
 175             else:
 176                 str = "{0}* ({1})"
 177
 178             elos_display.append(str.format(round(elo.elo, 3),
 179                 elo.game_type_cd))
 180
 181         # which weapons have been used in the past 90 days
 182         # and also, used in 5 games or more?
 183         back_then = datetime.datetime.utcnow() - datetime.timedelta(days=90)
 184         recent_weapons = []
 185         for weapon in DBSession.query(PlayerWeaponStat.weapon_cd, func.count()).\
 186                 filter(PlayerWeaponStat.player_id == player_id).\
 187                 filter(PlayerWeaponStat.create_dt > back_then).\
 188                 group_by(PlayerWeaponStat.weapon_cd).\
 189                 having(func.count() > 4).\
 190                 all():
 191                     recent_weapons.append(weapon[0])
 192
 193         # recent games table, all data
 194         recent_games = DBSession.query(PlayerGameStat, Game, Server, Map).\
 195                 filter(PlayerGameStat.player_id == player_id).\
 196                 filter(PlayerGameStat.game_id == Game.game_id).\
 197                 filter(Game.server_id == Server.server_id).\
 198                 filter(Game.map_id == Map.map_id).\
 199                 order_by(Game.game_id.desc())[0:10]
 200
 201     except Exception as e:
 202         player = None
 203         elos_display = None
 204         total_stats = None
 205         recent_games = None
 206         total_games = None
 207         games_breakdown = None
 208         recent_weapons = []
 209
 210     return {'player':player,
 211             'elos_display':elos_display,
 212             'recent_games':recent_games,
 213             'total_stats':total_stats,
 214             'total_games':total_games,
 215             'games_breakdown':games_breakdown,
 216             'recent_weapons':recent_weapons,
 217             }
 218
 219
 220 def player_info(request):
 221     """
 222     Provides detailed information on a specific player
 223     """
 224     return _player_info_data(request)
 225
 226
 227 def _player_game_index_data(request):
 228     player_id = request.matchdict['player_id']
 229
 230     if request.params.has_key('page'):
 231         current_page = request.params['page']
 232     else:
 233         current_page = 1
 234
 235     try:
 236         games_q = DBSession.query(Game, Server, Map).\
 237             filter(PlayerGameStat.game_id == Game.game_id).\
 238             filter(PlayerGameStat.player_id == player_id).\
 239             filter(Game.server_id == Server.server_id).\
 240             filter(Game.map_id == Map.map_id).\
 241             order_by(Game.game_id.desc())
 242
 243         games = Page(games_q, current_page, items_per_page=10, url=page_url)
 244
 245         pgstats = {}
 246         for (game, server, map) in games:
 247             pgstats[game.game_id] = DBSession.query(PlayerGameStat).\
 248                     filter(PlayerGameStat.game_id == game.game_id).\
 249                     order_by(PlayerGameStat.rank).\
 250                     order_by(PlayerGameStat.score).all()
 251
 252     except Exception as e:
 253         player = None
 254         games = None
 255
 256     return {'player_id':player_id,
 257             'games':games,
 258             'pgstats':pgstats}
 259
 260
 261 def player_game_index(request):
 262     """
 263     Provides an index of the games in which a particular
 264     player was involved. This is ordered by game_id, with
 265     the most recent game_ids first. Paginated.
 266     """
 267     return _player_game_index_data(request)
 268
 269
 270 def _player_accuracy_data(request):
 271     player_id = request.matchdict['id']
 272     allowed_weapons = ['nex', 'rifle', 'shotgun', 'uzi', 'minstanex']
 273     weapon_cd = 'nex'
 274     games = 20
 275
 276     if request.params.has_key('weapon'):
 277         if request.params['weapon'] in allowed_weapons:
 278             weapon_cd = request.params['weapon']
 279
 280     if request.params.has_key('games'):
 281         try:
 282             games = request.params['games']
 283
 284             if games < 0:
 285                 games = 20
 286             if games > 50:
 287                 games = 50
 288         except:
 289             games = 20
 290
 291     (avg, accs) = get_accuracy_stats(player_id, weapon_cd, games)
 292
 293     # if we don't have enough data for the given weapon
 294     if len(accs) < games:
 295         games = len(accs)
 296
 297     return {
 298             'player_id':player_id,
 299             'player_url':request.route_url('player_info', id=player_id),
 300             'weapon':weapon_cd,
 301             'games':games,
 302             'avg':avg,
 303             'accs':accs
 304             }
 305
 306
 307 def player_accuracy_json(request):
 308     """
 309     Provides a JSON response representing the accuracy for the given weapon.
 310
 311     Parameters:
 312        weapon = which weapon to display accuracy for. Valid values are 'nex',
 313                 'shotgun', 'uzi', and 'minstanex'.
 314        games = over how many games to display accuracy. Can be up to 50.
 315     """
 316     return _player_accuracy_data(request)