]> de.git.xonotic.org Git - xonotic/xonstat.git/blobdiff - xonstat/views/player.py
The player JSON view should use to_dict() instead.
[xonotic/xonstat.git] / xonstat / views / player.py
index b1fbd5d8ca643ef2f84613fc345dbace2126000f..26da28f9deb3d29732a40ef063a728aeb6c4314d 100644 (file)
@@ -1,16 +1,17 @@
 import datetime
-import json
 import logging
-import re
+import pyramid.httpexceptions
 import sqlalchemy as sa
 import sqlalchemy.sql.functions as func
-import time
-from pyramid.response import Response
-from pyramid.url import current_route_url
-from sqlalchemy import desc, distinct
-from webhelpers.paginate import Page, PageURL
+import sqlalchemy.sql.expression as expr
+from calendar import timegm
+from collections import namedtuple
+from webhelpers.paginate import Page
 from xonstat.models import *
-from xonstat.util import page_url
+from xonstat.util import page_url, to_json, pretty_date, datetime_seconds
+from xonstat.util import is_cake_day, verify_request
+from xonstat.views.helpers import RecentGame, recent_games_q
+from urllib import unquote
 
 log = logging.getLogger(__name__)
 
@@ -28,7 +29,7 @@ def player_index_data(request):
                 filter(sa.not_(Player.nick.like('Anonymous Player%'))).\
                 order_by(Player.player_id.desc())
 
-        players = Page(player_q, current_page, items_per_page=10, url=page_url)
+        players = Page(player_q, current_page, items_per_page=25, url=page_url)
 
     except Exception as e:
         players = None
@@ -52,101 +53,294 @@ def player_index_json(request):
     return [{'status':'not implemented'}]
 
 
-def _get_games_played(player_id):
+def get_games_played(player_id):
     """
     Provides a breakdown by gametype of the games played by player_id.
 
-    Returns a tuple containing (total_games, games_breakdown), where
-    total_games is the absolute number of games played by player_id
-    and games_breakdown is an array containing (game_type_cd, # games)
-    """
-    games_played = DBSession.query(Game.game_type_cd, func.count()).\
-            filter(Game.game_id == PlayerGameStat.game_id).\
-            filter(PlayerGameStat.player_id == player_id).\
-            group_by(Game.game_type_cd).\
-            order_by(func.count().desc()).all()
+    Returns a list of namedtuples with the following members:
+        - game_type_cd
+        - games
+        - wins
+        - losses
+        - win_pct
 
-    total = 0
-    for (game_type_cd, games) in games_played:
-        total += games
+    The list itself is ordered by the number of games played
+    """
+    GamesPlayed = namedtuple('GamesPlayed', ['game_type_cd', 'games', 'wins',
+        'losses', 'win_pct'])
 
-    return (total, games_played)
+    raw_games_played = DBSession.query('game_type_cd', 'wins', 'losses').\
+            from_statement(
+                "SELECT game_type_cd, "
+                       "SUM(win) wins, "
+                       "SUM(loss) losses "
+                "FROM   (SELECT g.game_id, "
+                               "g.game_type_cd, "
+                               "CASE "
+                                 "WHEN g.winner = pgs.team THEN 1 "
+                                 "WHEN pgs.scoreboardpos = 1 THEN 1 "
+                                 "ELSE 0 "
+                               "END win, "
+                               "CASE "
+                                 "WHEN g.winner = pgs.team THEN 0 "
+                                 "WHEN pgs.scoreboardpos = 1 THEN 0 "
+                                 "ELSE 1 "
+                               "END loss "
+                        "FROM   games g, "
+                               "player_game_stats pgs "
+                        "WHERE  g.game_id = pgs.game_id "
+                        "AND pgs.player_id = :player_id "
+                        "AND g.players @> ARRAY[:player_id]) win_loss "
+                "GROUP  BY game_type_cd "
+            ).params(player_id=player_id).all()
+
+    games_played = []
+    overall_games = 0
+    overall_wins = 0
+    overall_losses = 0
+    for row in raw_games_played:
+        games = row.wins + row.losses
+        overall_games += games
+        overall_wins += row.wins
+        overall_losses += row.losses
+        win_pct = float(row.wins)/games * 100
+
+        games_played.append(GamesPlayed(row.game_type_cd, games, row.wins,
+            row.losses, win_pct))
 
+    try:
+        overall_win_pct = float(overall_wins)/overall_games * 100
+    except:
+        overall_win_pct = 0.0
 
-# TODO: should probably factor the above function into this one such that
-# total_stats['ctf_games'] is the count of CTF games and so on...
-def _get_total_stats(player_id):
-    """
-    Provides aggregated stats by player_id.
+    games_played.append(GamesPlayed('overall', overall_games, overall_wins,
+        overall_losses, overall_win_pct))
 
-    Returns a dict with the keys 'kills', 'deaths', 'alivetime'.
+    # sort the resulting list by # of games played
+    games_played = sorted(games_played, key=lambda x:x.games)
+    games_played.reverse()
+    return games_played
 
-    kills = how many kills a player has over all games
-    deaths = how many deaths a player has over all games
-    alivetime = how long a player has played over all games
 
-    If any of the above are None, they are set to 0.
+def get_overall_stats(player_id):
     """
-    total_stats = {}
-    (total_stats['kills'], total_stats['deaths'], total_stats['alivetime']) = DBSession.\
-            query("total_kills", "total_deaths", "total_alivetime").\
-            from_statement(
-                "select sum(kills) total_kills, "
-                "sum(deaths) total_deaths, "
-                "sum(alivetime) total_alivetime "
-                "from player_game_stats "
-                "where player_id=:player_id"
-            ).params(player_id=player_id).one()
-
-    (total_stats['wins'],) = DBSession.\
-            query("total_wins").\
+    Provides a breakdown of stats by gametype played by player_id.
+
+    Returns a dictionary of namedtuples with the following members:
+        - total_kills
+        - total_deaths
+        - k_d_ratio
+        - last_played (last time the player played the game type)
+        - last_played_epoch (same as above, but in seconds since epoch)
+        - last_played_fuzzy (same as above, but in relative date)
+        - total_playing_time (total amount of time played the game type)
+        - total_playing_time_secs (same as the above, but in seconds)
+        - total_pickups (ctf only)
+        - total_captures (ctf only)
+        - cap_ratio (ctf only)
+        - total_carrier_frags (ctf only)
+        - game_type_cd
+        - game_type_descr
+
+    The key to the dictionary is the game type code. There is also an
+    "overall" game_type_cd which sums the totals and computes the total ratios.
+    """
+    OverallStats = namedtuple('OverallStats', ['total_kills', 'total_deaths',
+        'k_d_ratio', 'last_played', 'last_played_epoch', 'last_played_fuzzy',
+        'total_playing_time', 'total_playing_time_secs', 'total_pickups', 'total_captures', 'cap_ratio',
+        'total_carrier_frags', 'game_type_cd', 'game_type_descr'])
+
+    raw_stats = DBSession.query('game_type_cd', 'game_type_descr',
+            'total_kills', 'total_deaths', 'last_played', 'total_playing_time',
+            'total_pickups', 'total_captures', 'total_carrier_frags').\
             from_statement(
-                "select count(*) total_wins "
-                "from games g, player_game_stats pgs "
-                "where g.game_id = pgs.game_id "
-                "and player_id=:player_id "
-                "and (g.winner = pgs.team or pgs.rank = 1)"
-            ).params(player_id=player_id).one()
+                "SELECT g.game_type_cd, "
+                       "gt.descr game_type_descr, "
+                       "Sum(pgs.kills)         total_kills, "
+                       "Sum(pgs.deaths)        total_deaths, "
+                       "Max(pgs.create_dt)     last_played, "
+                       "Sum(pgs.alivetime)     total_playing_time, "
+                       "Sum(pgs.pickups)       total_pickups, "
+                       "Sum(pgs.captures)      total_captures, "
+                       "Sum(pgs.carrier_frags) total_carrier_frags "
+                "FROM   games g, "
+                       "cd_game_type gt, "
+                       "player_game_stats pgs "
+                "WHERE  g.game_id = pgs.game_id "
+                  "AND  g.game_type_cd = gt.game_type_cd "
+                  "AND  g.players @> ARRAY[:player_id] "
+                  "AND  pgs.player_id = :player_id "
+                "GROUP  BY g.game_type_cd, game_type_descr "
+                "UNION "
+                "SELECT 'overall'              game_type_cd, "
+                       "'Overall'              game_type_descr, "
+                       "Sum(pgs.kills)         total_kills, "
+                       "Sum(pgs.deaths)        total_deaths, "
+                       "Max(pgs.create_dt)     last_played, "
+                       "Sum(pgs.alivetime)     total_playing_time, "
+                       "Sum(pgs.pickups)       total_pickups, "
+                       "Sum(pgs.captures)      total_captures, "
+                       "Sum(pgs.carrier_frags) total_carrier_frags "
+                "FROM   player_game_stats pgs "
+                "WHERE  pgs.player_id = :player_id "
+            ).params(player_id=player_id).all()
+
+    # to be indexed by game_type_cd
+    overall_stats = {}
+
+    for row in raw_stats:
+        # individual gametype ratio calculations
+        try:
+            k_d_ratio = float(row.total_kills)/row.total_deaths
+        except:
+            k_d_ratio = None
 
-    for (key,value) in total_stats.items():
-        if value == None:
-            total_stats[key] = 0
+        try:
+            cap_ratio = float(row.total_captures)/row.total_pickups
+        except:
+            cap_ratio = None
+
+        # everything else is untouched or "raw"
+        os = OverallStats(total_kills=row.total_kills,
+                total_deaths=row.total_deaths,
+                k_d_ratio=k_d_ratio,
+                last_played=row.last_played,
+                last_played_epoch=timegm(row.last_played.timetuple()),
+                last_played_fuzzy=pretty_date(row.last_played),
+                total_playing_time=row.total_playing_time,
+                total_playing_time_secs=int(datetime_seconds(row.total_playing_time)),
+                total_pickups=row.total_pickups,
+                total_captures=row.total_captures,
+                cap_ratio=cap_ratio,
+                total_carrier_frags=row.total_carrier_frags,
+                game_type_cd=row.game_type_cd,
+                game_type_descr=row.game_type_descr)
+
+        overall_stats[row.game_type_cd] = os
+
+    # We have to edit "overall" stats to exclude deaths in CTS.
+    # Although we still want to record deaths, they shouldn't
+    # count towards the overall K:D ratio.
+    if 'cts' in overall_stats:
+        os = overall_stats['overall']
 
-    return total_stats
+        try:
+            k_d_ratio = float(os.total_kills)/(os.total_deaths - overall_stats['cts'].total_deaths)
+        except:
+            k_d_ratio = None
 
+        non_cts_deaths = os.total_deaths - overall_stats['cts'].total_deaths
 
-def _get_fav_map(player_id):
-    """
-    Get the player's favorite map. The favorite map is defined
-    as the map that he or she has played the most in the past 
-    90 days.
 
-    Returns a dictionary with keys for the map's name and id.
-    """
-    # 90 day window
-    back_then = datetime.datetime.utcnow() - datetime.timedelta(days=90)
+        overall_stats['overall'] = OverallStats(
+                total_kills             = os.total_kills,
+                total_deaths            = non_cts_deaths,
+                k_d_ratio               = k_d_ratio,
+                last_played             = os.last_played,
+                last_played_epoch       = os.last_played_epoch,
+                last_played_fuzzy       = os.last_played_fuzzy,
+                total_playing_time      = os.total_playing_time,
+                total_playing_time_secs = os.total_playing_time_secs,
+                total_pickups           = os.total_pickups,
+                total_captures          = os.total_captures,
+                cap_ratio               = os.cap_ratio,
+                total_carrier_frags     = os.total_carrier_frags,
+                game_type_cd            = os.game_type_cd,
+                game_type_descr         = os.game_type_descr)
+
+    return overall_stats
 
-    raw_fav_map = DBSession.query(Map.name, Map.map_id).\
-            filter(Game.game_id == PlayerGameStat.game_id).\
-            filter(Game.map_id == Map.map_id).\
-            filter(PlayerGameStat.player_id == player_id).\
-            filter(PlayerGameStat.create_dt > back_then).\
-            group_by(Map.name, Map.map_id).\
-            order_by(func.count().desc()).\
-            limit(1).one()
 
-    fav_map = {}
-    fav_map['name'] = raw_fav_map[0]
-    fav_map['id'] = raw_fav_map[1]
+def get_fav_maps(player_id, game_type_cd=None):
+    """
+    Provides a breakdown of favorite maps by gametype.
 
-    return fav_map
+    Returns a dictionary of namedtuples with the following members:
+        - game_type_cd
+        - map_name (map name)
+        - map_id
+        - times_played
 
+    The favorite map is defined as the map you've played the most
+    for the given game_type_cd.
 
-def _get_rank(player_id):
+    The key to the dictionary is the game type code. There is also an
+    "overall" game_type_cd which is the overall favorite map. This is
+    defined as the favorite map of the game type you've played the
+    most. The input parameter game_type_cd is for this.
     """
-    Get the player's rank as well as the total number of ranks.
+    FavMap = namedtuple('FavMap', ['map_name', 'map_id', 'times_played', 'game_type_cd'])
+
+    raw_favs = DBSession.query('game_type_cd', 'map_name',
+            'map_id', 'times_played').\
+            from_statement(
+                "SELECT game_type_cd, "
+                       "name map_name, "
+                       "map_id, "
+                       "times_played "
+                "FROM   (SELECT g.game_type_cd, "
+                               "m.name, "
+                               "m.map_id, "
+                               "Count(*) times_played, "
+                               "Row_number() "
+                                 "OVER ( "
+                                   "partition BY g.game_type_cd "
+                                   "ORDER BY Count(*) DESC, m.map_id ASC) rank "
+                        "FROM   games g, "
+                               "player_game_stats pgs, "
+                               "maps m "
+                        "WHERE  g.game_id = pgs.game_id "
+                               "AND g.map_id = m.map_id "
+                               "AND g.players @> ARRAY[:player_id]"
+                               "AND pgs.player_id = :player_id "
+                        "GROUP  BY g.game_type_cd, "
+                                  "m.map_id, "
+                                  "m.name) most_played "
+                "WHERE  rank = 1 "
+                "ORDER BY  times_played desc "
+            ).params(player_id=player_id).all()
+
+    fav_maps = {}
+    overall_fav = None
+    for row in raw_favs:
+        fv = FavMap(map_name=row.map_name,
+            map_id=row.map_id,
+            times_played=row.times_played,
+            game_type_cd=row.game_type_cd)
+
+        # if we aren't given a favorite game_type_cd
+        # then the overall favorite is the one we've
+        # played the most
+        if overall_fav is None:
+            fav_maps['overall'] = fv
+            overall_fav = fv.game_type_cd
+
+        # otherwise it is the favorite map from the
+        # favorite game_type_cd (provided as a param)
+        # and we'll overwrite the first dict entry
+        if game_type_cd == fv.game_type_cd:
+            fav_maps['overall'] = fv
+
+        fav_maps[row.game_type_cd] = fv
+
+    return fav_maps
+
+
+def get_ranks(player_id):
+    """
+    Provides a breakdown of the player's ranks by game type.
+
+    Returns a dictionary of namedtuples with the following members:
+        - game_type_cd
+        - rank
+        - max_rank
+
+    The key to the dictionary is the game type code. There is also an
+    "overall" game_type_cd which is the overall best rank.
     """
-    rank = DBSession.query("game_type_cd", "rank", "max_rank").\
+    Rank = namedtuple('Rank', ['rank', 'max_rank', 'percentile', 'game_type_cd'])
+
+    raw_ranks = DBSession.query("game_type_cd", "rank", "max_rank").\
             from_statement(
                 "select pr.game_type_cd, pr.rank, overall.max_rank "
                 "from player_ranks pr,  "
@@ -154,11 +348,68 @@ def _get_rank(player_id):
                     "from player_ranks  "
                     "group by game_type_cd) overall "
                 "where pr.game_type_cd = overall.game_type_cd  "
+                "and max_rank > 1 "
                 "and player_id = :player_id "
                 "order by rank").\
             params(player_id=player_id).all()
 
-    return rank;
+    ranks = {}
+    found_top_rank = False
+    for row in raw_ranks:
+        rank = Rank(rank=row.rank,
+            max_rank=row.max_rank,
+            percentile=100 - 100*float(row.rank-1)/(row.max_rank-1),
+            game_type_cd=row.game_type_cd)
+
+
+        if not found_top_rank:
+            ranks['overall'] = rank
+            found_top_rank = True
+        elif rank.percentile > ranks['overall'].percentile:
+            ranks['overall'] = rank
+
+        ranks[row.game_type_cd] = rank
+
+    return ranks;
+
+
+def get_elos(player_id):
+    """
+    Provides a breakdown of the player's elos by game type.
+
+    Returns a dictionary of namedtuples with the following members:
+        - player_id
+        - game_type_cd
+        - games
+        - elo
+
+    The key to the dictionary is the game type code. There is also an
+    "overall" game_type_cd which is the overall best rank.
+    """
+    raw_elos = DBSession.query(PlayerElo).filter_by(player_id=player_id).\
+            order_by(PlayerElo.elo.desc()).all()
+
+    elos = {}
+    found_max_elo = False
+    for row in raw_elos:
+        if not found_max_elo:
+            elos['overall'] = row
+            found_max_elo = True
+
+        elos[row.game_type_cd] = row
+
+    return elos
+
+
+def get_recent_games(player_id, limit=10):
+    """
+    Provides a list of recent games for a player. Uses the recent_games_q helper.
+    """
+    # recent games played in descending order
+    rgs = recent_games_q(player_id=player_id, force_player_id=True).limit(limit).all()
+    recent_games = [RecentGame(row) for row in rgs]
+
+    return recent_games
 
 
 def get_accuracy_stats(player_id, weapon_cd, games):
@@ -179,7 +430,7 @@ def get_accuracy_stats(player_id, weapon_cd, games):
 
         # Determine the raw accuracy (hit, fired) numbers for $games games
         # This is then enumerated to create parameters for a flot graph
-        raw_accs = DBSession.query(PlayerWeaponStat.game_id, 
+        raw_accs = DBSession.query(PlayerWeaponStat.game_id,
             PlayerWeaponStat.hit, PlayerWeaponStat.fired).\
                 filter(PlayerWeaponStat.player_id == player_id).\
                 filter(PlayerWeaponStat.weapon_cd == weapon_cd).\
@@ -215,7 +466,7 @@ def get_damage_stats(player_id, weapon_cd, games):
 
         # Determine the damage efficiency (hit, fired) numbers for $games games
         # This is then enumerated to create parameters for a flot graph
-        raw_dmgs = DBSession.query(PlayerWeaponStat.game_id, 
+        raw_dmgs = DBSession.query(PlayerWeaponStat.game_id,
             PlayerWeaponStat.actual, PlayerWeaponStat.hit).\
                 filter(PlayerWeaponStat.player_id == player_id).\
                 filter(PlayerWeaponStat.weapon_cd == weapon_cd).\
@@ -251,79 +502,28 @@ def player_info_data(request):
         player = DBSession.query(Player).filter_by(player_id=player_id).\
                 filter(Player.active_ind == True).one()
 
-        # games played, alivetime, wins, kills, deaths
-        total_stats = _get_total_stats(player.player_id)
-
-        # games breakdown - N games played (X ctf, Y dm) etc
-        (total_games, games_breakdown) = _get_games_played(player.player_id)
-
-        # favorite map from the past 90 days
-        try:
-            fav_map = _get_fav_map(player.player_id)
-        except:
-            fav_map = None
-
-        # friendly display of elo information and preliminary status
-        elos = DBSession.query(PlayerElo).filter_by(player_id=player_id).\
-                filter(PlayerElo.game_type_cd.in_(['ctf','duel','dm'])).\
-                order_by(PlayerElo.elo.desc()).all()
-
-        elos_display = []
-        for elo in elos:
-            if elo.games > 32:
-                str = "{0} ({1})"
-            else:
-                str = "{0}* ({1})"
-
-            elos_display.append(str.format(round(elo.elo, 3),
-                elo.game_type_cd))
-
-        # get current rank information
-        ranks = _get_rank(player_id)
-        ranks_display = ', '.join(["{1} of {2} ({0})".format(gtc, rank,
-            max_rank) for gtc, rank, max_rank in ranks])
-
-
-        # which weapons have been used in the past 90 days
-        # and also, used in 5 games or more?
-        back_then = datetime.datetime.utcnow() - datetime.timedelta(days=90)
-        recent_weapons = []
-        for weapon in DBSession.query(PlayerWeaponStat.weapon_cd, func.count()).\
-                filter(PlayerWeaponStat.player_id == player_id).\
-                filter(PlayerWeaponStat.create_dt > back_then).\
-                group_by(PlayerWeaponStat.weapon_cd).\
-                having(func.count() > 4).\
-                all():
-                    recent_weapons.append(weapon[0])
-
-        # recent games table, all data
-        recent_games = DBSession.query(PlayerGameStat, Game, Server, Map).\
-                filter(PlayerGameStat.player_id == player_id).\
-                filter(PlayerGameStat.game_id == Game.game_id).\
-                filter(Game.server_id == Server.server_id).\
-                filter(Game.map_id == Map.map_id).\
-                order_by(Game.game_id.desc())[0:10]
+        games_played   = get_games_played(player_id)
+        overall_stats  = get_overall_stats(player_id)
+        fav_maps       = get_fav_maps(player_id)
+        elos           = get_elos(player_id)
+        ranks          = get_ranks(player_id)
+        recent_games   = get_recent_games(player_id)
+        cake_day       = is_cake_day(player.create_dt)
 
     except Exception as e:
-        player = None
-        elos_display = None
-        total_stats = None
-        recent_games = None
-        total_games = None
-        games_breakdown = None
-        recent_weapons = []
-        fav_map = None
-        ranks_display = None;
+        raise pyramid.httpexceptions.HTTPNotFound
+
+        ## do not raise application exceptions here (only for debugging)
+        # raise e
 
     return {'player':player,
-            'elos_display':elos_display,
+            'games_played':games_played,
+            'overall_stats':overall_stats,
+            'fav_maps':fav_maps,
+            'elos':elos,
+            'ranks':ranks,
             'recent_games':recent_games,
-            'total_stats':total_stats,
-            'total_games':total_games,
-            'games_breakdown':games_breakdown,
-            'recent_weapons':recent_weapons,
-            'fav_map':fav_map,
-            'ranks_display':ranks_display,
+            'cake_day':cake_day,
             }
 
 
@@ -338,11 +538,66 @@ def player_info_json(request):
     """
     Provides detailed information on a specific player. JSON.
     """
-    return [{'status':'not implemented'}]
+
+    # All player_info fields are converted into JSON-formattable dictionaries
+    player_info = player_info_data(request)
+
+    player = player_info['player'].to_dict()
+
+    games_played = {}
+    for game in player_info['games_played']:
+        games_played[game.game_type_cd] = to_json(game)
+
+    overall_stats = {}
+    for gt,stats in player_info['overall_stats'].items():
+        overall_stats[gt] = to_json(stats)
+
+    elos = {}
+    for gt,elo in player_info['elos'].items():
+        elos[gt] = to_json(elo.to_dict())
+
+    ranks = {}
+    for gt,rank in player_info['ranks'].items():
+        ranks[gt] = to_json(rank)
+
+    fav_maps = {}
+    for gt,mapinfo in player_info['fav_maps'].items():
+        fav_maps[gt] = to_json(mapinfo)
+
+    recent_games = [g.to_dict() for g in player_info['recent_games']]
+
+    return [{
+        'player':           player,
+        'games_played':     games_played,
+        'overall_stats':    overall_stats,
+        'fav_maps':         fav_maps,
+        'elos':             elos,
+        'ranks':            ranks,
+        'recent_games':     recent_games,
+    }]
 
 
 def player_game_index_data(request):
-    player_id = request.matchdict['player_id']
+    try:
+        player_id = int(request.matchdict['player_id'])
+    except:
+        player_id = -1
+
+    game_type_cd = None
+    game_type_descr = None
+
+    if request.params.has_key('type'):
+        game_type_cd = request.params['type']
+        try:
+            game_type_descr = DBSession.query(GameType.descr).\
+                filter(GameType.game_type_cd == game_type_cd).\
+                one()[0]
+        except Exception as e:
+            pass
+
+    else:
+        game_type_cd = None
+        game_type_descr = None
 
     if request.params.has_key('page'):
         current_page = request.params['page']
@@ -350,29 +605,37 @@ def player_game_index_data(request):
         current_page = 1
 
     try:
-        games_q = DBSession.query(Game, Server, Map).\
-            filter(PlayerGameStat.game_id == Game.game_id).\
-            filter(PlayerGameStat.player_id == player_id).\
-            filter(Game.server_id == Server.server_id).\
-            filter(Game.map_id == Map.map_id).\
-            order_by(Game.game_id.desc())
-
-        games = Page(games_q, current_page, items_per_page=10, url=page_url)
-
-        pgstats = {}
-        for (game, server, map) in games:
-            pgstats[game.game_id] = DBSession.query(PlayerGameStat).\
-                    filter(PlayerGameStat.game_id == game.game_id).\
-                    order_by(PlayerGameStat.rank).\
-                    order_by(PlayerGameStat.score).all()
+        player = DBSession.query(Player).\
+                filter_by(player_id=player_id).\
+                filter(Player.active_ind == True).\
+                one()
+
+        rgs_q = recent_games_q(player_id=player.player_id,
+            force_player_id=True, game_type_cd=game_type_cd)
+
+        games = Page(rgs_q, current_page, items_per_page=20, url=page_url)
+
+        # replace the items in the canned pagination class with more rich ones
+        games.items = [RecentGame(row) for row in games.items]
+
+        games_played = get_games_played(player_id)
 
     except Exception as e:
+        raise e
         player = None
         games = None
+        game_type_cd = None
+        game_type_descr = None
+        games_played = None
 
-    return {'player_id':player_id,
+    return {
+            'player_id':player.player_id,
+            'player':player,
             'games':games,
-            'pgstats':pgstats}
+            'game_type_cd':game_type_cd,
+            'game_type_descr':game_type_descr,
+            'games_played':games_played,
+           }
 
 
 def player_game_index(request):
@@ -421,11 +684,11 @@ def player_accuracy_data(request):
         games = len(accs)
 
     return {
-            'player_id':player_id, 
-            'player_url':request.route_url('player_info', id=player_id), 
-            'weapon':weapon_cd, 
-            'games':games, 
-            'avg':avg, 
+            'player_id':player_id,
+            'player_url':request.route_url('player_info', id=player_id),
+            'weapon':weapon_cd,
+            'games':games,
+            'avg':avg,
             'accs':accs
             }
 
@@ -478,11 +741,11 @@ def player_damage_data(request):
         games = len(dmgs)
 
     return {
-            'player_id':player_id, 
-            'player_url':request.route_url('player_info', id=player_id), 
-            'weapon':weapon_cd, 
-            'games':games, 
-            'avg':avg, 
+            'player_id':player_id,
+            'player_url':request.route_url('player_info', id=player_id),
+            'weapon':weapon_cd,
+            'games':games,
+            'avg':avg,
             'dmgs':dmgs
             }
 
@@ -498,3 +761,336 @@ def player_damage_json(request):
        games = over how many games to display damage. Can be up to 50.
     """
     return player_damage_data(request)
+
+
+def player_hashkey_info_data(request):
+    # hashkey = request.matchdict['hashkey']
+
+    # the incoming hashkey is double quoted, and WSGI unquotes once...
+    # hashkey = unquote(hashkey)
+
+    # if using request verification to obtain the hashkey
+    (idfp, status) = verify_request(request)
+    log.debug("d0_blind_id verification: idfp={0} status={1}\n".format(idfp, status))
+
+    log.debug("\n----- BEGIN REQUEST BODY -----\n" + request.body +
+            "----- END REQUEST BODY -----\n\n")
+
+    # if config is to *not* verify requests and we get nothing back, this
+    # query will return nothing and we'll 404.
+    try:
+        player = DBSession.query(Player).\
+                filter(Player.player_id == Hashkey.player_id).\
+                filter(Player.active_ind == True).\
+                filter(Hashkey.hashkey == idfp).one()
+
+        games_played      = get_games_played(player.player_id)
+        overall_stats     = get_overall_stats(player.player_id)
+        fav_maps          = get_fav_maps(player.player_id)
+        elos              = get_elos(player.player_id)
+        ranks             = get_ranks(player.player_id)
+        most_recent_game  = get_recent_games(player.player_id, 1)[0]
+
+    except Exception as e:
+        raise pyramid.httpexceptions.HTTPNotFound
+
+    return {'player':player,
+            'hashkey':idfp,
+            'games_played':games_played,
+            'overall_stats':overall_stats,
+            'fav_maps':fav_maps,
+            'elos':elos,
+            'ranks':ranks,
+            'most_recent_game':most_recent_game,
+            }
+
+
+def player_hashkey_info_json(request):
+    """
+    Provides detailed information on a specific player. JSON.
+    """
+
+    # All player_info fields are converted into JSON-formattable dictionaries
+    player_info = player_hashkey_info_data(request)
+
+    player = player_info['player'].to_dict()
+
+    games_played = {}
+    for game in player_info['games_played']:
+        games_played[game.game_type_cd] = to_json(game)
+
+    overall_stats = {}
+    for gt,stats in player_info['overall_stats'].items():
+        overall_stats[gt] = to_json(stats)
+
+    elos = {}
+    for gt,elo in player_info['elos'].items():
+        elos[gt] = to_json(elo.to_dict())
+
+    ranks = {}
+    for gt,rank in player_info['ranks'].items():
+        ranks[gt] = to_json(rank)
+
+    fav_maps = {}
+    for gt,mapinfo in player_info['fav_maps'].items():
+        fav_maps[gt] = to_json(mapinfo)
+
+    most_recent_game = to_json(player_info['most_recent_game'])
+
+    return [{
+        'version':          1,
+        'player':           player,
+        'games_played':     games_played,
+        'overall_stats':    overall_stats,
+        'fav_maps':         fav_maps,
+        'elos':             elos,
+        'ranks':            ranks,
+        'most_recent_game': most_recent_game,
+    }]
+
+
+def player_hashkey_info_text(request):
+    """
+    Provides detailed information on a specific player. Plain text.
+    """
+    # UTC epoch
+    now = timegm(datetime.datetime.utcnow().timetuple())
+
+    # All player_info fields are converted into JSON-formattable dictionaries
+    player_info = player_hashkey_info_data(request)
+
+    # gather all of the data up into aggregate structures
+    player = player_info['player']
+    games_played = player_info['games_played']
+    overall_stats = player_info['overall_stats']
+    elos = player_info['elos']
+    ranks = player_info['ranks']
+    fav_maps = player_info['fav_maps']
+    most_recent_game = player_info['most_recent_game']
+
+    # one-offs for things needing conversion for text/plain
+    player_joined = timegm(player.create_dt.timetuple())
+    player_joined_dt = player.create_dt
+    alivetime = int(datetime_seconds(overall_stats['overall'].total_playing_time))
+
+    # this is a plain text response, if we don't do this here then
+    # Pyramid will assume html
+    request.response.content_type = 'text/plain'
+
+    return {
+        'version':          1,
+        'now':              now,
+        'player':           player,
+        'hashkey':          player_info['hashkey'],
+        'player_joined':    player_joined,
+        'player_joined_dt': player_joined_dt,
+        'games_played':     games_played,
+        'overall_stats':    overall_stats,
+        'alivetime':        alivetime,
+        'fav_maps':         fav_maps,
+        'elos':             elos,
+        'ranks':            ranks,
+        'most_recent_game': most_recent_game,
+    }
+
+
+def player_elo_info_data(request):
+    """
+    Provides elo information on a specific player. Raw data is returned.
+    """
+    (idfp, status) = verify_request(request)
+    log.debug("d0_blind_id verification: idfp={0} status={1}\n".format(idfp, status))
+
+    log.debug("\n----- BEGIN REQUEST BODY -----\n" + request.body +
+            "----- END REQUEST BODY -----\n\n")
+
+    hashkey = request.matchdict['hashkey']
+
+    # the incoming hashkey is double quoted, and WSGI unquotes once...
+    hashkey = unquote(hashkey)
+
+    try:
+        player = DBSession.query(Player).\
+                filter(Player.player_id == Hashkey.player_id).\
+                filter(Player.active_ind == True).\
+                filter(Hashkey.hashkey == hashkey).one()
+
+        elos = get_elos(player.player_id)
+
+    except Exception as e:
+        log.debug(e)
+        raise pyramid.httpexceptions.HTTPNotFound
+
+    return {
+        'hashkey':hashkey,
+        'player':player,
+        'elos':elos,
+    }
+
+
+def player_elo_info_json(request):
+    """
+    Provides elo information on a specific player. JSON.
+    """
+    elo_info = player_elo_info_data(request)
+
+    player = player_info['player'].to_dict()
+
+    elos = {}
+    for gt, elo in elo_info['elos'].items():
+        elos[gt] = to_json(elo.to_dict())
+
+    return [{
+        'version':          1,
+        'player':           player,
+        'elos':             elos,
+    }]
+
+
+def player_elo_info_text(request):
+    """
+    Provides elo information on a specific player. Plain text.
+    """
+    # UTC epoch
+    now = timegm(datetime.datetime.utcnow().timetuple())
+
+    # All player_info fields are converted into JSON-formattable dictionaries
+    elo_info = player_elo_info_data(request)
+
+    # this is a plain text response, if we don't do this here then
+    # Pyramid will assume html
+    request.response.content_type = 'text/plain'
+
+    return {
+        'version':          1,
+        'now':              now,
+        'hashkey':          elo_info['hashkey'],
+        'player':           elo_info['player'],
+        'elos':             elo_info['elos'],
+    }
+
+
+def player_captimes_data(request):
+    player_id = int(request.matchdict['player_id'])
+    if player_id <= 2:
+        player_id = -1;
+
+    current_page = request.params.get("page", 1)
+
+    try:
+        player = DBSession.query(Player).filter_by(player_id=player_id).one()
+
+        pct_q = DBSession.query(PlayerCaptime.fastest_cap, PlayerCaptime.create_dt,
+                PlayerCaptime.player_id, PlayerCaptime.game_id, PlayerCaptime.map_id,
+                Map.name.label('map_name'), Game.server_id, Server.name.label('server_name')).\
+                filter(PlayerCaptime.player_id==player_id).\
+                filter(PlayerCaptime.game_id==Game.game_id).\
+                filter(PlayerCaptime.map_id==Map.map_id).\
+                filter(Game.server_id==Server.server_id).\
+                order_by(expr.desc(PlayerCaptime.create_dt))
+
+    except Exception as e:
+        raise pyramid.httpexceptions.HTTPNotFound
+
+    captimes = Page(pct_q, current_page, items_per_page=20, url=page_url)
+
+    # replace the items in the canned pagination class with more rich ones
+    captimes.items = [PlayerCapTime(row) for row in captimes.items]
+
+    return {
+            "player_id" : player_id,
+            "player"    : player,
+            "captimes"  : captimes,
+        }
+
+
+def player_captimes(request):
+    return player_captimes_data(request)
+
+
+def player_captimes_json(request):
+    data = player_captimes_data(request)
+    page = request.params.get("page", 1)
+
+    # perform any necessary JSON conversions
+    player_id = data["player_id"]
+    player = data["player"].to_dict()
+    captimes = [ct.to_dict() for ct in data["captimes"].items]
+
+    return {
+            "player"    : player,
+            "captimes"  : captimes,
+            "page"      : page,
+            }
+
+
+def player_weaponstats_data_json(request):
+    player_id = int(request.matchdict["id"])
+    if player_id <= 2:
+        player_id = -1;
+
+    game_type_cd = request.params.get("game_type", None)
+    if game_type_cd == "overall":
+        game_type_cd = None
+
+    limit = 20
+    if request.params.has_key("limit"):
+        limit = int(request.params["limit"])
+
+        if limit < 0:
+            limit = 20
+        if limit > 50:
+            limit = 50
+
+
+    # the game_ids of the most recently played ones 
+    # of the given game type is used for a subquery
+    games_list = DBSession.query(Game.game_id).\
+            filter(Game.players.contains([player_id]))
+
+    if game_type_cd is not None:
+        games_list = games_list.filter(Game.game_type_cd == game_type_cd)
+
+    games_list = games_list.order_by(Game.game_id.desc()).limit(limit)
+
+    weapon_stats_raw = DBSession.query(PlayerWeaponStat).\
+        filter(PlayerWeaponStat.player_id == player_id).\
+        filter(PlayerWeaponStat.game_id.in_(games_list)).\
+        all()
+
+    games_to_weapons = {}
+    weapons_used = {}
+    sum_avgs = {}
+    for ws in weapon_stats_raw:
+        if ws.game_id not in games_to_weapons:
+            games_to_weapons[ws.game_id] = [ws.weapon_cd]
+        else:
+            games_to_weapons[ws.game_id].append(ws.weapon_cd)
+
+        weapons_used[ws.weapon_cd] = weapons_used.get(ws.weapon_cd, 0) + 1
+        sum_avgs[ws.weapon_cd] = sum_avgs.get(ws.weapon_cd, 0) + float(ws.hit)/float(ws.fired)
+
+    # Creating zero-valued weapon stat entries for games where a weapon was not
+    # used in that game, but was used in another game for the set. This makes 
+    # the charts look smoother
+    for game_id in games_to_weapons.keys():
+        for weapon_cd in set(weapons_used.keys()) - set(games_to_weapons[game_id]):
+            weapon_stats_raw.append(PlayerWeaponStat(player_id=player_id,
+                game_id=game_id, weapon_cd=weapon_cd))
+
+    # averages for the weapons used in the range
+    avgs = {}
+    for w in weapons_used.keys():
+        avgs[w] = round(sum_avgs[w]/float(weapons_used[w])*100, 2)
+
+    weapon_stats_raw = sorted(weapon_stats_raw, key = lambda x: x.game_id)
+    games            = sorted(games_to_weapons.keys())
+    weapon_stats     = [ws.to_dict() for ws in weapon_stats_raw]
+
+    return {
+        "weapon_stats": weapon_stats,
+        "weapons_used": weapons_used.keys(),
+        "games": games,
+        "averages": avgs,
+    }
+