move Server code into more services and use them into blueprints or server

server/services/dashboard_query.py

@@ -0,0 +1,144 @@
+from quart_common.web.logger import await_log, logging
+
+from typing import Awaitable, Callable
+import json
+
+from .dashboard_ws_hub import DashboardWebSocketHub
+from server.database import GameplayDatabase
+
+class DashboardQueryService:
+  def __init__(self, gameplay_database:GameplayDatabase, ws_hub:DashboardWebSocketHub, logger:logging, dashboard_running_game_stale_sec:int):
+    self.gameplay_database = gameplay_database
+    self.ws_hub = ws_hub
+    self.logger = logger
+    self.dashboard_running_game_stale_sec = dashboard_running_game_stale_sec
+    self.publish_notice:Callable[[str], Awaitable[None]] | None = None
+
+  def set_publish_notice(self, publish_notice:Callable[[str], Awaitable[None]]) -> None:
+    self.publish_notice = publish_notice
+
+  async def on_dashboard_games_update_notice(self, trigger:str) -> None:
+    await self.push_dashboard_games_update(
+      game_state=None,
+      publish_cluster=False,
+      trigger=trigger,
+    )
+
+  async def build_dashboard_games_event(self, game_state:dict|None=None, trigger_override:str|None=None) -> dict:
+    games_payload = await self.get_dashboard_games(limit=100)
+    summary_payload = await self.get_dashboard_summary()
+    game_id = None
+    if game_state is not None:
+      game_id = game_state.get('game', {}).get('id')
+    trigger = trigger_override or ('game_saved' if game_id else 'snapshot')
+
+    return {
+      'type': 'dashboard_games_update',
+      'trigger': trigger,
+      'games': games_payload,
+      'summary': summary_payload,
+    }
+
+  async def build_dashboard_game_replay_event(self, game_id:str, request_id:str|None=None) -> dict:
+    replay_payload = await self.get_dashboard_game_replay(game_id)
+    if replay_payload is None:
+      return {
+        'type': 'dashboard_game_replay',
+        'request_id': request_id,
+        'game_id': game_id,
+        'error': 'game_not_found',
+      }
+
+    return {
+      'type': 'dashboard_game_replay',
+      'request_id': request_id,
+      'game_id': game_id,
+      'replay': replay_payload,
+    }
+
+  async def handle_dashboard_ws_request(self, payload_raw:object) -> dict|None:
+    if not isinstance(payload_raw, str):
+      return None
+
+    try:
+      payload = json.loads(payload_raw)
+    except json.JSONDecodeError:
+      return None
+
+    if not isinstance(payload, dict):
+      return None
+
+    if payload.get('type') != 'dashboard_game_replay_request':
+      return None
+
+    game_id = str(payload.get('game_id') or '').strip()
+    request_id_raw = payload.get('request_id')
+    request_id = None if request_id_raw is None else str(request_id_raw)
+    if game_id == '':
+      return {
+        'type': 'dashboard_game_replay',
+        'request_id': request_id,
+        'error': 'missing_game_id',
+      }
+
+    return await self.build_dashboard_game_replay_event(
+      game_id=game_id,
+      request_id=request_id,
+    )
+
+  async def push_dashboard_games_update(self, game_state:dict|None=None, publish_cluster:bool=True, trigger:str|None=None) -> None:
+    if self.gameplay_database is None:
+      return
+    event_payload = await self.build_dashboard_games_event(
+      game_state,
+      trigger_override=trigger,
+    )
+    await self.ws_hub.broadcast_payload(event_payload)
+    if publish_cluster and self.publish_notice is not None:
+      await self.publish_notice(str(event_payload.get('trigger') or ''))
+
+  async def get_dashboard_summary(self) -> dict:
+    if self.gameplay_database is None:
+      return {'enabled': False}
+    try:
+      await self._finalize_stale_dashboard_games()
+      summary = await self.gameplay_database.get_summary()
+      summary['enabled'] = True
+      return summary
+    except Exception as error:
+      await await_log(self.logger.warning(f'Gameplay DB summary failed:{error}'))
+      return {'enabled': True, 'error': ' summary_unavailable'}
+
+  async def get_dashboard_games(self, limit:int=50) -> dict:
+    if self.gameplay_database is None:
+      return {'enabled': False, 'games': []}
+    try:
+      await self._finalize_stale_dashboard_games()
+      games = await self.gameplay_database.list_games(limit=limit)
+      return {'enabled': True, 'games': games}
+    except Exception as error:
+      await await_log(
+        self.logger.warning(f'Gameplay DB game list failed:{error}')
+      )
+      return {'enabled': True, 'error': 'games_unavailable', 'games': []}
+
+  async def get_dashboard_game_replay(self, game_id:str) -> dict|None:
+    if self.gameplay_database is None:
+      return {'enabled': False, 'error': 'database_disabled', 'game_id': game_id}
+    try:
+      replay = await self.gameplay_database.get_game_replay(game_id)
+      if replay is None:
+        return None
+      replay['enabled'] = True
+      return replay
+    except Exception as error:
+      await await_log(self.logger.warning(f'Gameplay DB replay failed:{error}'))
+      return {'enabled': True, 'error': 'replay_unavailable', 'game_id': game_id}
+
+  async def _finalize_stale_dashboard_games(self) -> None:
+    if self.gameplay_database is None:
+      return
+    try:
+      await self.gameplay_database.finalize_stale_running_games(stale_after_seconds=self.dashboard_running_game_stale_sec)
+    except Exception as error:
+      await await_log(self.logger.warning(f'Gameplay DB stale running game finalize failed:{error}'))