ai generated solutions to our ai generated problems

backend/src/main.rs

@@ -242,6 +242,14 @@ struct GameParticipant {
     result: String,
     player_count: i64,
     stats: GameStats,
+    players: Vec<GamePlayer>,
+}
+
+#[derive(Serialize)]
+struct GamePlayer {
+    uid: String,
+    nick: Option<String>,
+    stats: GameStats,
 }
 
 #[derive(Serialize)]
@@ -1423,7 +1431,7 @@ fn game_participants_for(
         )
         .map_err(db_error)?;
 
-    let rows = stmt
+    let mut participants = stmt
         .query_map(params![session_id], |row| {
             Ok(GameParticipant {
                 team_name: row.get(0)?,
@@ -1440,13 +1448,76 @@ fn game_participants_for(
                     shell_interceptions: row.get(10)?,
                     team_kills_stat: row.get(11)?,
                 },
+                players: Vec::new(),
             })
         })
         .map_err(db_error)?
         .collect::<Result<Vec<_>, _>>()
         .map_err(db_error)?;
 
-    Ok(rows)
+    for participant in &mut participants {
+        participant.players = game_players_for(conn, session_id, &participant.team_name)?;
+    }
+
+    Ok(participants)
+}
+
+fn game_players_for(
+    conn: &Connection,
+    session_id: &str,
+    team_name: &str,
+) -> Result<Vec<GamePlayer>, ApiError> {
+    let mut stmt = conn
+        .prepare(
+            "SELECT
+                p.UID,
+                (SELECT pg.nick
+                 FROM player_games_hist pg
+                 WHERE pg.session_id = p.session_id
+                   AND pg.UID = p.UID
+                   AND pg.nick IS NOT NULL
+                   AND pg.nick != ''
+                 ORDER BY pg.endtime_unix DESC
+                 LIMIT 1),
+                COALESCE(SUM(p.ground_kills), 0),
+                COALESCE(SUM(p.air_kills), 0),
+                COALESCE(SUM(p.assists), 0),
+                COALESCE(SUM(p.captures), 0),
+                COALESCE(SUM(p.deaths), 0),
+                COALESCE(SUM(p.score), 0),
+                COALESCE(SUM(p.missile_evades), 0),
+                COALESCE(SUM(p.shell_interceptions), 0),
+                COALESCE(SUM(p.team_kills_stat), 0)
+             FROM player_games_hist p
+             WHERE p.session_id = ?1 AND p.team_name = ?2 COLLATE NOCASE
+             GROUP BY p.UID
+             ORDER BY COALESCE(SUM(p.score), 0) DESC, p.UID",
+        )
+        .map_err(db_error)?;
+
+    let players = stmt
+        .query_map(params![session_id, team_name], |row| {
+            Ok(GamePlayer {
+                uid: row.get(0)?,
+                nick: row.get(1)?,
+                stats: GameStats {
+                    ground_kills: row.get(2)?,
+                    air_kills: row.get(3)?,
+                    assists: row.get(4)?,
+                    captures: row.get(5)?,
+                    deaths: row.get(6)?,
+                    score: row.get(7)?,
+                    missile_evades: row.get(8)?,
+                    shell_interceptions: row.get(9)?,
+                    team_kills_stat: row.get(10)?,
+                },
+            })
+        })
+        .map_err(db_error)?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(db_error)?;
+
+    Ok(players)
 }
 
 fn validate_team_name(name: &str) -> Result<&str, ApiError> {