rework that the sqlite and postgresql backend uses the same code to build the data for the dashboard

server/database/backend/SqliteGameplayBackend.py

@@ -285,19 +285,9 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
         }
 
       you_id = you.get("id")
-      for snake in snakes:
-        snake_id = snake.get("id")
-        head = snake.get("head", {})
-        head_x = head.get("x")
-        head_y = head.get("y")
-        if snake_id is None:
-          continue
-        new_head = (
-          (int(head_x), int(head_y))
-          if head_x is not None and head_y is not None
-          else None
-        )
-        inferred = self._infer_direction(previous_positions.get(snake_id), new_head)
+      for params in self._build_snake_turn_params(snakes, you_id, game_id, turn, previous_positions):
+        (p_game_id, p_turn, p_snake_id, p_name, p_health, p_length,
+         p_head_x, p_head_y, p_body, p_is_you, p_inferred, p_latency) = params
         connection.execute("""
           INSERT INTO snake_turns (
             game_id, turn, snake_id, snake_name, health, length,
@@ -315,18 +305,10 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
             latency = excluded.latency
           """,
           (
-            game_id,
-            turn,
-            snake_id,
-            snake.get("name"),
-            snake.get("health"),
-            snake.get("length"),
-            head_x,
-            head_y,
-            self._to_json(snake.get("body", [])),
-            1 if snake_id == you_id else 0,
-            inferred,
-            snake.get("latency"),
+            p_game_id, p_turn, p_snake_id, p_name, p_health, p_length,
+            p_head_x, p_head_y, self._to_json(p_body),
+            1 if p_is_you else 0,
+            p_inferred, p_latency,
           ),
         )
 
@@ -339,14 +321,7 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
       )
 
   def _record_game_end_sync(self, game_state:dict) -> None:
-    game = game_state.get("game", {})
-    game_id = game.get("id")
-    board = game_state.get("board", {})
-    snakes = list(board.get("snakes", []))
-    you = self._extract_you(game_state)
-    winner_name = next((snake.get("name") for snake in snakes if snake.get("name")), None)
-    you_id = you.get("id")
-    winner_you = any(snake.get("id") == you_id for snake in snakes)
+    game_id, winner_name, winner_you, turn = self._extract_game_end_params(game_state)
 
     with self._connect() as connection:
       connection.execute("""
@@ -362,8 +337,8 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
           self._utc_now(),
           winner_name,
           1 if winner_you else 0,
-          int(game_state.get("turn", 0)),
-          int(game_state.get("turn", 0)),
+          turn,
+          turn,
           game_id,
         ),
       )
@@ -417,13 +392,7 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
               (game_id, final_turn),
             ).fetchall()
 
-        survivor_ids = [s["snake_id"] for s in snake_rows if s["snake_id"]]
-        winner_you = bool(
-          your_snake_id
-          and your_snake_id in survivor_ids
-          and len(survivor_ids) == 1
-        )
-        survivor_name = next((s["snake_name"] for s in snake_rows if s["snake_name"]), None)
+        winner_you, survivor_name = self._calculate_survivor(snake_rows, your_snake_id)
 
         result = connection.execute("""
           UPDATE games
@@ -485,34 +454,7 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
         (max(1, int(recent_limit)),),
       ).fetchall()
 
-    return {
-      "total_games": int(totals["total_games"] or 0),
-      "running_games": int(totals["running_games"] or 0),
-      "finished_games": int(totals["finished_games"] or 0),
-      "wins": int(totals["wins"] or 0),
-      "losses": int(totals["losses"] or 0),
-      "avg_turns_finished": round(float(totals["avg_turns"] or 0.0), 2),
-      "by_game_type": [{
-        "game_type": row["type_label"],
-        "total": int(row["total"]),
-        "wins": int(row["wins"]),
-        "losses": int(row["losses"]),
-      } for row in by_type],
-      "recent_games": [{
-        "game_id": row["game_id"],
-        "started_at": row["started_at"],
-        "ended_at": row["ended_at"],
-        "map": row["map_name"],
-        "ruleset": row["ruleset_name"],
-        "game_type": row["game_type"],
-        "snake": row["your_snake_name"],
-        "snake_type": row["your_snake_type"],
-        "snake_version": row["your_snake_version"],
-        "winner_you": bool(row["winner_you"]),
-        "final_turn": int(row["final_turn"] or 0),
-        "status": row["status"],
-      } for row in recent],
-    }
+    return self._build_summary_output(totals, by_type, recent)
 
   def _list_games_sync(self, limit:int=50) -> list[dict]:
     with self._connect() as connection:
@@ -527,22 +469,7 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
         (max(1, int(limit)),),
       ).fetchall()
 
-    return [{
-      "game_id": row["game_id"],
-      "started_at": row["started_at"],
-      "ended_at": row["ended_at"],
-      "map": row["map_name"],
-      "source": row["source"],
-      "ruleset": row["ruleset_name"],
-      "game_type": row["game_type"],
-      "snake": row["your_snake_name"],
-      "snake_type": row["your_snake_type"],
-      "snake_version": row["your_snake_version"],
-      "winner_you": bool(row["winner_you"]),
-      "winner_name": row["winner_name"],
-      "final_turn": int(row["final_turn"] or 0),
-      "status": row["status"],
-    } for row in rows]
+    return self._build_game_list_output(rows)
 
   def _get_game_replay_sync(self, game_id:str) -> dict|None:
     with self._connect() as connection:
@@ -580,56 +507,7 @@ class SqliteGameplayBackend(GameplayBackendTemplate):
         (game_id,),
       ).fetchall()
 
-    snakes_by_turn: dict[int, list[dict]] = {}
-    for row in snake_rows:
-      snakes_by_turn.setdefault(int(row["turn"]), []).append({
-        "snake_id": row["snake_id"],
-        "snake_name": row["snake_name"],
-        "health": row["health"],
-        "length": row["length"],
-        "head": {"x": row["head_x"], "y": row["head_y"]},
-        "body": self._from_json(row["body_json"]) or [],
-        "is_you": bool(row["is_you"]),
-        "inferred_move": row["inferred_move"],
-        "latency": row["latency"],
-      })
-
-    return {
-      "game": {
-        "game_id": game_row["game_id"],
-        "started_at": game_row["started_at"],
-        "ended_at": game_row["ended_at"],
-        "width": game_row["width"],
-        "height": game_row["height"],
-        "source": game_row["source"],
-        "map": game_row["map_name"],
-        "ruleset_name": game_row["ruleset_name"],
-        "ruleset_version": game_row["ruleset_version"],
-        "game_type": game_row["game_type"],
-        "your_snake_id": game_row["your_snake_id"],
-        "your_snake_name": game_row["your_snake_name"],
-        "your_snake_type": game_row["your_snake_type"],
-        "your_snake_version": game_row["your_snake_version"],
-        "winner_name": game_row["winner_name"],
-        "winner_you": bool(game_row["winner_you"]),
-        "final_turn": int(game_row["final_turn"] or 0),
-        "status": game_row["status"],
-      },
-      "turns": [
-        {
-          "turn": int(row["turn"]),
-          "observed_at": row["observed_at"],
-          "my_move": row["my_move"],
-          "my_thinking": self._from_json(row["my_thinking_json"]),
-          "board": self._from_json(row["board_state_json"]),
-          "food": self._from_json(row["food_json"]) or [],
-          "hazards": self._from_json(row["hazards_json"]) or [],
-          "you": self._from_json(row["you_json"]) or {},
-          "snakes": snakes_by_turn.get(int(row["turn"]), []),
-        }
-        for row in turn_rows
-      ],
-    }
+    return self._build_game_replay_output(game_row, turn_rows, snake_rows, decode_json=self._from_json)
 
   # ── public async interface ─────────────────────────────────────────────────