Refactor the map_index views.

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

diff --git a/xonstat/views/map.py b/xonstat/views/map.py
index a10073d58620d40b3e762f40d3ad7e959c25438e..f1daf4aabe7f57c385ce1a0a1511fa9fe8e22773 100644 (file)
--- a/xonstat/views/map.py
+++ b/xonstat/views/map.py
@@ -1,49 +1,56 @@
 import logging
-import sqlalchemy.sql.functions as func
-import sqlalchemy.sql.expression as expr
 from collections import namedtuple
 from datetime import datetime, timedelta
+
+import sqlalchemy.sql.expression as expr
+import sqlalchemy.sql.functions as func
+from pyramid.httpexceptions import HTTPNotFound
 from webhelpers.paginate import Page
-from xonstat.models import *
+from xonstat.models import DBSession, Server, Map, Game, PlayerGameStat, Player, PlayerCaptime
+from xonstat.models.map import MapCapTime
 from xonstat.util import page_url, html_colors
 from xonstat.views.helpers import RecentGame, recent_games_q
 
 log = logging.getLogger(__name__)
 
-def _map_index_data(request):
-    if request.params.has_key('page'):
-        current_page = request.params['page']
-    else:
-        current_page = 1
+# Defaults
+INDEX_COUNT = 20
 
-    try:
-        map_q = DBSession.query(Map).\
-                order_by(Map.map_id.desc())
 
-        maps = Page(map_q, current_page, items_per_page=25, url=page_url)
+class MapIndex(object):
+    """Returns a list of maps."""
 
-    except Exception as e:
-        maps = None
+    def __init__(self, request):
+        """Common parameter parsing."""
+        self.request = request
+        self.page = request.params.get("page", 1)
 
-    return {'maps':maps, }
+        # all views share this data, so we'll precalculate
+        self.maps = self.map_index()
 
+    def map_index(self):
+        """Returns the raw data shared by all renderers."""
+        try:
+            map_q = DBSession.query(Map).order_by(Map.map_id.desc())
+            maps = Page(map_q, self.page, items_per_page=INDEX_COUNT, url=page_url)
 
-def map_index(request):
-    """
-    Provides a list of all the current maps.
-    """
-    return _map_index_data(request)
+        except Exception as e:
+            log.debug(e)
+            raise HTTPNotFound
 
+        return maps
 
-def map_index_json(request):
-    """
-    Provides a JSON-serialized list of all the current maps.
-    """
-    view_data = _map_index_data(request)
-
-    maps = [m.to_dict() for m in view_data['maps']]
+    def html(self):
+        """For rendering this data using something HTML-based."""
+        return {
+            'maps': self.maps,
+        }
 
-    return maps
+    def json(self):
+        """For rendering this data using JSON."""
+        return {
+            'maps': [m.to_dict() for m in self.maps],
+        }
 
 
 def _map_info_data(request):
@@ -112,13 +119,14 @@ def _map_info_data(request):
                 group_by(Server.name).\
                 group_by(Server.server_id).all()[0:leaderboard_count]
 
+        # TODO make this a configuration parameter to be set in the settings
         # top captimes
         captimes_raw = DBSession.query(Player.player_id, Player.nick,
             PlayerCaptime.fastest_cap, PlayerCaptime.game_id).\
                 filter(PlayerCaptime.map_id == map_id).\
                 filter(Player.player_id == PlayerCaptime.player_id).\
                 order_by(PlayerCaptime.fastest_cap).\
-                limit(25).\
+                limit(10).\
                 all()
 
         captimes = [Captime(c.player_id, html_colors(c.nick),
@@ -164,33 +172,6 @@ def map_info_json(request):
     return [{'status':'not implemented'}]
 
 
-class MapCapTime(object):
-    def __init__(self, row):
-        self.fastest_cap          = row.fastest_cap
-        self.create_dt            = row.create_dt
-        self.create_dt_epoch      = timegm(row.create_dt.timetuple())
-        self.create_dt_fuzzy      = pretty_date(row.create_dt)
-        self.player_id            = row.player_id
-        self.player_nick          = row.player_nick
-        self.player_nick_stripped = strip_colors(row.player_nick)
-        self.player_nick_html     = html_colors(row.player_nick)
-        self.game_id              = row.game_id
-        self.server_id            = row.server_id
-        self.server_name          = row.server_name
-
-    def to_dict(self):
-        return {
-            "fastest_cap"          : self.fastest_cap.total_seconds(),
-            "create_dt_epoch"      : self.create_dt_epoch,
-            "create_dt_fuzzy"      : self.create_dt_fuzzy,
-            "player_id"            : self.player_id,
-            "player_nick"          : self.player_nick,
-            "player_nick_stripped" : self.player_nick_stripped,
-            "game_id"              : self.game_id,
-            "server_id"            : self.server_id,
-            "server_name"          : self.server_name,
-            }
-
 def map_captimes_data(request):
     map_id = int(request.matchdict['id'])
 
@@ -212,7 +193,7 @@ def map_captimes_data(request):
                 order_by(expr.asc(PlayerCaptime.fastest_cap))
 
     except Exception as e:
-        raise pyramid.httpexceptions.HTTPNotFound
+        raise httpexceptions.HTTPNotFound
 
     map_captimes = Page(mct_q, current_page, items_per_page=20, url=page_url)