Show latency in game_info if at least one player has a value.

[xonotic/xonstat.git] / xonstat / views / game.py

diff --git a/xonstat/views/game.py b/xonstat/views/game.py
index 3d3d44b0fcc8a1743e81bae39662cf001d8f8752..0d7a9df80a01bcfe8122dad6099c73b6570fd80f 100644 (file)
--- a/xonstat/views/game.py
+++ b/xonstat/views/game.py
@@ -2,6 +2,7 @@ import datetime
 import logging
 import re
 import time
 import logging
 import re
 import time

+from collections import OrderedDict

 from pyramid.response import Response
 from sqlalchemy import desc, func, over
 from webhelpers.paginate import Page, PageURL
 from pyramid.response import Response
 from sqlalchemy import desc, func, over
 from webhelpers.paginate import Page, PageURL


@@ -12,34 +13,51 @@ from xonstat.views.helpers import RecentGame, recent_games_q
 log = logging.getLogger(__name__)
 
 
 log = logging.getLogger(__name__)
 
 

+# DEPRECATED

 def _game_index_data(request):
 def _game_index_data(request):

-    if request.matchdict.has_key('game_type_cd'):
-        game_type_cd  = request.matchdict['game_type_cd']
-    else:
-        game_type_cd  = None
+    game_type_cd = None
+    game_type_descr = None
+
+    if request.params.has_key('game_type_cd'):
+        game_type_cd = request.params['game_type_cd']
+        try:
+            game_type_descr = DBSession.query(GameType.descr).\
+                filter(GameType.game_type_cd == game_type_cd).\
+                one()[0]
+        except Exception as e:
+            game_type_cd = None

 
     if request.params.has_key('page'):
         current_page = request.params['page']
     else:
         current_page = 1
 
     if request.params.has_key('page'):
         current_page = request.params['page']
     else:
         current_page = 1

-            
-    rgs_q = recent_games_q(game_type_cd=game_type_cd)
-
-    games = Page(rgs_q, current_page, items_per_page=10, url=page_url)
-
-    # replace the items in the canned pagination class with more rich ones
-    games.items = [RecentGame(row) for row in games.items]
-        
-    pgstats = {}
-    for game in games.items:
-        pgstats[game.game_id] = DBSession.query(PlayerGameStat).\
-                filter(PlayerGameStat.game_id == game.game_id).\
-                order_by(PlayerGameStat.scoreboardpos).\
-                order_by(PlayerGameStat.score).all()
+
+    try:
+        rgs_q = recent_games_q(game_type_cd=game_type_cd)
+
+        games = Page(rgs_q, current_page, items_per_page=10, url=page_url)
+
+        # replace the items in the canned pagination class with more rich ones
+        games.items = [RecentGame(row) for row in games.items]
+
+        pgstats = {}
+        for game in games.items:
+            pgstats[game.game_id] = DBSession.query(PlayerGameStat).\
+                    filter(PlayerGameStat.game_id == game.game_id).\
+                    order_by(PlayerGameStat.scoreboardpos).\
+                    order_by(PlayerGameStat.score).all()
+
+    except Exception as e:
+        games           = None
+        pgstats         = None
+        game_type_cd    = None
+        game_type_descr = None

 
     return {'games':games,
             'pgstats':pgstats,
 
     return {'games':games,
             'pgstats':pgstats,

-            'game_type_cd':game_type_cd}
+            'game_type_cd':game_type_cd,
+            'game_type_descr':game_type_descr,
+            }

 
 
 def game_index(request):
 
 
 def game_index(request):


@@ -68,10 +86,7 @@ def _game_info_data(request):
     else:
         show_elo = False
 
     else:
         show_elo = False
 

-    if request.params.has_key('show_latency'):
-        show_latency = True
-    else:
-        show_latency = False
+    show_latency = False

 
     try:
         notfound = False
 
     try:
         notfound = False


@@ -88,12 +103,33 @@ def _game_info_data(request):
                 order_by(PlayerGameStat.score).\
                 all()
 
                 order_by(PlayerGameStat.score).\
                 all()
 

+        # if at least one player has a valid latency, we'll show the column
+        for pgstat in pgstats:
+            if pgstat.avg_latency is not None:
+                show_latency = True
+
+        q = DBSession.query(TeamGameStat).\
+                filter(TeamGameStat.game_id == game_id)
+        if game.game_type_cd == 'ctf':
+            q = q.order_by(TeamGameStat.caps.desc())
+        elif game.game_type_cd in 'ca' 'lms' 'ka':
+            q = q.order_by(TeamGameStat.rounds.desc())
+
+        q = q.order_by(TeamGameStat.score.desc())
+
+        tgstats = q.all()
+
+        stats_by_team = OrderedDict()
+        for pgstat in pgstats:
+            if pgstat.team not in stats_by_team.keys():
+                stats_by_team[pgstat.team] = []
+            stats_by_team[pgstat.team].append(pgstat)
+

         captimes = []
         if game.game_type_cd == 'ctf':
             for pgstat in pgstats:
                 if pgstat.fastest is not None:
                     captimes.append(pgstat)
         captimes = []
         if game.game_type_cd == 'ctf':
             for pgstat in pgstats:
                 if pgstat.fastest is not None:
                     captimes.append(pgstat)

-

             captimes = sorted(captimes, key=lambda x:x.fastest)
 
         pwstats = {}
             captimes = sorted(captimes, key=lambda x:x.fastest)
 
         pwstats = {}


@@ -110,10 +146,10 @@ def _game_info_data(request):
                         pwstats[pgstat.player_game_stat_id] = []
 
                     # NOTE adding pgstat to position 6 in order to display nick.
                         pwstats[pgstat.player_game_stat_id] = []
 
                     # NOTE adding pgstat to position 6 in order to display nick.

-                    # You have to use a slice [0:5] to pass to the accuracy 
+                    # You have to use a slice [0:5] to pass to the accuracy

                     # template
                     # template

-                    pwstats[pgstat.player_game_stat_id].append((weapon.descr, 
-                        weapon.weapon_cd, pwstat.actual, pwstat.max, 
+                    pwstats[pgstat.player_game_stat_id].append((weapon.descr,
+                        weapon.weapon_cd, pwstat.actual, pwstat.max,

                         pwstat.hit, pwstat.fired, pgstat))
 
     except Exception as inst:
                         pwstat.hit, pwstat.fired, pgstat))
 
     except Exception as inst:


@@ -122,10 +158,12 @@ def _game_info_data(request):
         map = None
         gametype = None
         pgstats = None
         map = None
         gametype = None
         pgstats = None

+        tgstats = None

         pwstats = None
         captimes = None
         show_elo = False
         show_latency = False
         pwstats = None
         captimes = None
         show_elo = False
         show_latency = False

+        stats_by_team = None

         raise inst
 
     return {'game':game,
         raise inst
 
     return {'game':game,


@@ -133,10 +171,12 @@ def _game_info_data(request):
             'map':map,
             'gametype':gametype,
             'pgstats':pgstats,
             'map':map,
             'gametype':gametype,
             'pgstats':pgstats,

+            'tgstats':tgstats,

             'pwstats':pwstats,
             'captimes':captimes,
             'show_elo':show_elo,
             'show_latency':show_latency,
             'pwstats':pwstats,
             'captimes':captimes,
             'show_elo':show_elo,
             'show_latency':show_latency,

+            'stats_by_team':stats_by_team,

             }
 
 
             }
 
 


@@ -200,7 +240,9 @@ def game_finder_data(request):
     query = {}
 
     server_id, map_id, player_id = None, None, None
     query = {}
 
     server_id, map_id, player_id = None, None, None

-    range_start, range_end = None, None
+    range_start, range_end, game_type_cd = None, None, None
+    game_type_descr = None
+

     # these become WHERE clauses when present
     if request.params.has_key('server_id'):
         server_id = request.params['server_id']
     # these become WHERE clauses when present
     if request.params.has_key('server_id'):
         server_id = request.params['server_id']


@@ -222,8 +264,18 @@ def game_finder_data(request):
         range_end = request.params['range_end']
         query['range_end'] = range_end
 
         range_end = request.params['range_end']
         query['range_end'] = range_end
 

+    if request.params.has_key('type'):
+        game_type_cd = request.params['type']
+        query['type'] = game_type_cd
+        try:
+            game_type_descr = DBSession.query(GameType.descr).\
+                filter(GameType.game_type_cd == game_type_cd).\
+                one()[0]
+        except Exception as e:
+            game_type_cd = None
+

     rgs_q = recent_games_q(server_id=server_id, map_id=map_id,
     rgs_q = recent_games_q(server_id=server_id, map_id=map_id,

-            player_id=player_id)
+            player_id=player_id, game_type_cd=game_type_cd)

 
     recent_games = Page(rgs_q, current_page, url=page_url)
 
 
     recent_games = Page(rgs_q, current_page, url=page_url)
 


@@ -232,6 +284,7 @@ def game_finder_data(request):
     return {
             'recent_games':recent_games,
             'query':query,
     return {
             'recent_games':recent_games,
             'query':query,

+            'game_type_cd':game_type_cd,

            }
 
 def game_finder(request):
            }
 
 def game_finder(request):