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