1634 lines
50 KiB
Rust
1634 lines
50 KiB
Rust
use axum::{
|
|
extract::{Path, Query, State},
|
|
http::{header, HeaderValue, Method, StatusCode},
|
|
response::{IntoResponse, Response},
|
|
routing::get,
|
|
Json, Router,
|
|
};
|
|
use rusqlite::{params, Connection, OptionalExtension};
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::json;
|
|
use std::{
|
|
collections::{BTreeMap, HashMap},
|
|
env, fs,
|
|
net::{IpAddr, Ipv4Addr, SocketAddr},
|
|
path::{Path as FsPath, PathBuf},
|
|
sync::{Arc, Mutex},
|
|
time::Duration,
|
|
};
|
|
use tokio::net::TcpListener;
|
|
use tower_http::{
|
|
cors::{AllowOrigin, CorsLayer},
|
|
trace::TraceLayer,
|
|
};
|
|
|
|
const MAX_TEAM_NAME_LENGTH: usize = 80;
|
|
const LEADERBOARD_CACHE_TTL: Duration = Duration::from_secs(300);
|
|
|
|
struct AppState {
|
|
battles_db: PathBuf,
|
|
teams_db: PathBuf,
|
|
leaderboard_cache: Mutex<Option<CachedLeaderboard>>,
|
|
}
|
|
|
|
struct CachedLeaderboard {
|
|
teams: Vec<TeamLeaderboardRow>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct ApiError {
|
|
status: StatusCode,
|
|
message: String,
|
|
}
|
|
|
|
impl ApiError {
|
|
fn bad_request(message: impl Into<String>) -> Self {
|
|
Self {
|
|
status: StatusCode::BAD_REQUEST,
|
|
message: message.into(),
|
|
}
|
|
}
|
|
|
|
fn not_found(message: impl Into<String>) -> Self {
|
|
Self {
|
|
status: StatusCode::NOT_FOUND,
|
|
message: message.into(),
|
|
}
|
|
}
|
|
|
|
fn internal(message: impl Into<String>) -> Self {
|
|
Self {
|
|
status: StatusCode::INTERNAL_SERVER_ERROR,
|
|
message: message.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl IntoResponse for ApiError {
|
|
fn into_response(self) -> Response {
|
|
(self.status, Json(json!({ "error": self.message }))).into_response()
|
|
}
|
|
}
|
|
|
|
type ApiResult<T> = Result<Json<T>, ApiError>;
|
|
|
|
#[derive(Deserialize)]
|
|
struct LimitQuery {
|
|
limit: Option<u32>,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct ResolveQuery {
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct SearchQuery {
|
|
q: Option<String>,
|
|
name: Option<String>,
|
|
limit: Option<u32>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct HealthResponse {
|
|
ok: bool,
|
|
service: &'static str,
|
|
battles_db: String,
|
|
teams_db: String,
|
|
databases: BTreeMap<&'static str, bool>,
|
|
}
|
|
|
|
#[derive(Clone, Serialize)]
|
|
struct LeaderboardResponse {
|
|
teams: Vec<TeamLeaderboardRow>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct RecentGamesResponse {
|
|
matches: Vec<GameRow>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct SearchResponse {
|
|
teams: Vec<TeamSearchRow>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct ResolveResponse {
|
|
team_id: i64,
|
|
name: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct TeamSearchRow {
|
|
team_id: i64,
|
|
name: String,
|
|
members: i64,
|
|
}
|
|
|
|
#[derive(Clone, Serialize)]
|
|
struct TeamLeaderboardRow {
|
|
team_id: i64,
|
|
name: String,
|
|
player_count: i64,
|
|
total_battles: i64,
|
|
wins: i64,
|
|
losses: i64,
|
|
win_rate: f64,
|
|
total_kills: i64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct TeamDetail {
|
|
team_id: i64,
|
|
name: String,
|
|
members: i64,
|
|
captain_uid: Option<String>,
|
|
data_set: &'static str,
|
|
team_summary: TeamSummary,
|
|
players: Vec<PlayerSummary>,
|
|
}
|
|
|
|
#[derive(Default, Serialize)]
|
|
struct TeamSummary {
|
|
player_count: i64,
|
|
total_battles: i64,
|
|
wins: i64,
|
|
losses: i64,
|
|
win_rate: f64,
|
|
kdr: f64,
|
|
total_kills: i64,
|
|
total_points: i64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerSummary {
|
|
uid: String,
|
|
nick: Option<String>,
|
|
role: String,
|
|
total_battles: i64,
|
|
wins: i64,
|
|
losses: i64,
|
|
win_rate: f64,
|
|
total_kills: i64,
|
|
ground_kills: i64,
|
|
air_kills: i64,
|
|
assists: i64,
|
|
deaths: i64,
|
|
kdr: f64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct HistoryResponse {
|
|
team_id: i64,
|
|
name: String,
|
|
history: Vec<PeriodHistory>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PeriodHistory {
|
|
period: String,
|
|
battles: i64,
|
|
wins: i64,
|
|
losses: i64,
|
|
win_rate: f64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct GamesResponse {
|
|
team_id: i64,
|
|
name: String,
|
|
games: Vec<GameRow>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct GameResponse {
|
|
game: GameRow,
|
|
participants: Vec<GameParticipant>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct GameRow {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
team_name: Option<String>,
|
|
session_id: String,
|
|
timestamp: i64,
|
|
endtime_unix: i64,
|
|
map_name: Option<String>,
|
|
mission_mode: Option<String>,
|
|
result: String,
|
|
player_count: i64,
|
|
winning_team: Option<String>,
|
|
losing_team: Option<String>,
|
|
stats: GameStats,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct GameStats {
|
|
ground_kills: i64,
|
|
air_kills: i64,
|
|
assists: i64,
|
|
captures: i64,
|
|
deaths: i64,
|
|
score: i64,
|
|
missile_evades: i64,
|
|
shell_interceptions: i64,
|
|
team_kills_stat: i64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct GameParticipant {
|
|
team_name: String,
|
|
result: String,
|
|
player_count: i64,
|
|
stats: GameStats,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerSearchResponse {
|
|
players: Vec<PlayerRef>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerRef {
|
|
uid: String,
|
|
nick: Option<String>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerProfile {
|
|
uid: String,
|
|
nick: Option<String>,
|
|
data_set: &'static str,
|
|
career: PlayerCareer,
|
|
teams: Vec<PlayerTeamRef>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerCareer {
|
|
total_battles: i64,
|
|
wins: i64,
|
|
losses: i64,
|
|
win_rate: f64,
|
|
ground_kills: i64,
|
|
air_kills: i64,
|
|
total_kills: i64,
|
|
assists: i64,
|
|
captures: i64,
|
|
deaths: i64,
|
|
kdr: f64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct PlayerTeamRef {
|
|
team_id: Option<i64>,
|
|
team_name: Option<String>,
|
|
games: i64,
|
|
last_seen: i64,
|
|
}
|
|
|
|
struct TeamRecord {
|
|
team_id: i64,
|
|
name: String,
|
|
members: i64,
|
|
captain_uid: Option<String>,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
load_root_env();
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
|
|
.init();
|
|
|
|
let host = env_ip("BACKEND_HOST").unwrap_or(IpAddr::V4(Ipv4Addr::LOCALHOST));
|
|
let port = env_u16("BACKEND_PORT")
|
|
.or_else(|| env_u16("PORT"))
|
|
.unwrap_or(6000);
|
|
let state = Arc::new(AppState {
|
|
battles_db: resolve_db_path("TSS_BATTLES_DB", "tss_battles.db"),
|
|
teams_db: resolve_db_path("TSS_TEAMS_DB", "tss_teams.db"),
|
|
leaderboard_cache: Mutex::new(None),
|
|
});
|
|
spawn_leaderboard_refresh(state.clone());
|
|
|
|
let app = Router::new()
|
|
.route("/health", get(health))
|
|
.route("/api/tss/leaderboard/teams", get(leaderboard))
|
|
.route("/api/tss/games/recent", get(recent_games))
|
|
.route("/api/tss/games/{session_id}", get(game_detail))
|
|
.route("/api/tss/teams/resolve", get(resolve_team))
|
|
.route("/api/tss/teams/search", get(search_teams))
|
|
.route("/api/tss/teams/{team}", get(team_detail))
|
|
.route("/api/tss/teams/{team}/history", get(team_history))
|
|
.route("/api/tss/teams/{team}/games", get(team_games))
|
|
.route("/api/tss/players/resolve", get(resolve_player))
|
|
.route("/api/tss/players/search", get(search_players))
|
|
.route("/api/tss/player/{uid}", get(player_detail))
|
|
.layer(
|
|
CorsLayer::new()
|
|
.allow_methods([Method::GET])
|
|
.allow_origin(allowed_origins())
|
|
.allow_headers([header::ACCEPT, header::CONTENT_TYPE]),
|
|
)
|
|
.layer(TraceLayer::new_for_http())
|
|
.with_state(state);
|
|
|
|
let addr = SocketAddr::from((host, port));
|
|
let listener = TcpListener::bind(addr).await?;
|
|
tracing::info!("tssbot backend listening on http://{}", addr);
|
|
axum::serve(listener, app)
|
|
.with_graceful_shutdown(shutdown_signal())
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn shutdown_signal() {
|
|
let ctrl_c = async {
|
|
tokio::signal::ctrl_c()
|
|
.await
|
|
.expect("failed to install Ctrl+C handler");
|
|
};
|
|
|
|
#[cfg(unix)]
|
|
let terminate = async {
|
|
tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
|
.expect("failed to install signal handler")
|
|
.recv()
|
|
.await;
|
|
};
|
|
|
|
#[cfg(not(unix))]
|
|
let terminate = std::future::pending::<()>();
|
|
|
|
tokio::select! {
|
|
_ = ctrl_c => {},
|
|
_ = terminate => {},
|
|
}
|
|
}
|
|
|
|
async fn health(State(state): State<Arc<AppState>>) -> Json<HealthResponse> {
|
|
let mut databases = BTreeMap::new();
|
|
databases.insert(
|
|
"battles",
|
|
Connection::open_with_flags(
|
|
&state.battles_db,
|
|
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY,
|
|
)
|
|
.is_ok(),
|
|
);
|
|
databases.insert(
|
|
"teams",
|
|
Connection::open_with_flags(&state.teams_db, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)
|
|
.is_ok(),
|
|
);
|
|
|
|
Json(HealthResponse {
|
|
ok: databases.values().all(|ok| *ok),
|
|
service: "tssbot-backend",
|
|
battles_db: state.battles_db.display().to_string(),
|
|
teams_db: state.teams_db.display().to_string(),
|
|
databases,
|
|
})
|
|
}
|
|
|
|
async fn leaderboard(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<LimitQuery>,
|
|
) -> ApiResult<LeaderboardResponse> {
|
|
let limit = usize::try_from(query.limit.unwrap_or(100).clamp(1, 100)).unwrap_or(100);
|
|
if let Some(teams) = cached_leaderboard(&state, limit)? {
|
|
return Ok(Json(LeaderboardResponse { teams }));
|
|
}
|
|
|
|
let teams = leaderboard_roster_rows(&state, limit)?;
|
|
Ok(Json(LeaderboardResponse { teams }))
|
|
}
|
|
|
|
fn leaderboard_teams(state: &AppState, limit: usize) -> Result<Vec<TeamRecord>, ApiError> {
|
|
let teams_conn = open_db(&state.teams_db)?;
|
|
// Deduplicate teams by name across tournaments — pick the highest team_id
|
|
// (most recent) per name for the roster count, but stats come from team_name.
|
|
let mut stmt = teams_conn
|
|
.prepare(
|
|
"SELECT MAX(team_id), name, MAX(members), MAX(captain_uid)
|
|
FROM teams_data
|
|
GROUP BY name COLLATE NOCASE
|
|
ORDER BY MAX(members) DESC, name COLLATE NOCASE ASC
|
|
LIMIT ?1",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let teams = stmt
|
|
.query_map(params![limit as i64], |row| read_team_record(row))
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
Ok(teams)
|
|
}
|
|
|
|
fn leaderboard_roster_rows(
|
|
state: &AppState,
|
|
limit: usize,
|
|
) -> Result<Vec<TeamLeaderboardRow>, ApiError> {
|
|
leaderboard_teams(state, limit).map(|teams| {
|
|
teams
|
|
.into_iter()
|
|
.map(|team| TeamLeaderboardRow {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
player_count: team.members,
|
|
total_battles: 0,
|
|
wins: 0,
|
|
losses: 0,
|
|
win_rate: 0.0,
|
|
total_kills: 0,
|
|
})
|
|
.collect()
|
|
})
|
|
}
|
|
|
|
fn leaderboard_rows(state: &AppState, limit: usize) -> Result<Vec<TeamLeaderboardRow>, ApiError> {
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let teams = leaderboard_teams(state, limit)?;
|
|
let team_names = teams
|
|
.iter()
|
|
.map(|team| team.name.as_str())
|
|
.collect::<Vec<_>>();
|
|
let mut summaries = team_summaries_for(&battles_conn, &team_names)?;
|
|
|
|
let mut rows = Vec::with_capacity(teams.len());
|
|
for team in teams {
|
|
let summary = summaries
|
|
.remove(&team.name.to_ascii_lowercase())
|
|
.unwrap_or_default();
|
|
rows.push(TeamLeaderboardRow {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
player_count: team.members,
|
|
total_battles: summary.total_battles,
|
|
wins: summary.wins,
|
|
losses: summary.losses,
|
|
win_rate: summary.win_rate,
|
|
total_kills: summary.total_kills,
|
|
});
|
|
}
|
|
|
|
Ok(rows)
|
|
}
|
|
|
|
fn spawn_leaderboard_refresh(state: Arc<AppState>) {
|
|
tokio::spawn(async move {
|
|
loop {
|
|
let refresh_state = state.clone();
|
|
match tokio::task::spawn_blocking(move || leaderboard_rows(&refresh_state, 100)).await {
|
|
Ok(Ok(rows)) => {
|
|
if let Err(error) = cache_leaderboard(&state, &rows) {
|
|
tracing::warn!("could not cache leaderboard refresh: {}", error.message);
|
|
}
|
|
}
|
|
Ok(Err(error)) => {
|
|
tracing::warn!("could not refresh leaderboard cache: {}", error.message);
|
|
}
|
|
Err(error) => {
|
|
tracing::warn!("leaderboard refresh task failed: {}", error);
|
|
}
|
|
}
|
|
tokio::time::sleep(LEADERBOARD_CACHE_TTL).await;
|
|
}
|
|
});
|
|
}
|
|
|
|
async fn recent_games(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<LimitQuery>,
|
|
) -> ApiResult<RecentGamesResponse> {
|
|
let limit = i64::from(query.limit.unwrap_or(50).clamp(1, 100));
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let matches = recent_games_for(&battles_conn, limit)?;
|
|
Ok(Json(RecentGamesResponse { matches }))
|
|
}
|
|
|
|
async fn game_detail(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(session_id): Path<String>,
|
|
) -> ApiResult<GameResponse> {
|
|
let session_id = validate_session_id(&session_id)?;
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let game = game_for(&battles_conn, session_id)?
|
|
.ok_or_else(|| ApiError::not_found("Game not found"))?;
|
|
let participants = game_participants_for(&battles_conn, session_id)?;
|
|
Ok(Json(GameResponse { game, participants }))
|
|
}
|
|
|
|
async fn resolve_team(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<ResolveQuery>,
|
|
) -> ApiResult<ResolveResponse> {
|
|
let name = validate_team_name(&query.name)?;
|
|
let conn = open_db(&state.teams_db)?;
|
|
let team = find_team(&conn, name)?.ok_or_else(|| ApiError::not_found("Team not found"))?;
|
|
Ok(Json(ResolveResponse {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
}))
|
|
}
|
|
|
|
async fn search_teams(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<SearchQuery>,
|
|
) -> ApiResult<SearchResponse> {
|
|
let raw = query.q.as_deref().or(query.name.as_deref()).unwrap_or("");
|
|
let name = validate_team_name(raw)?;
|
|
let limit = i64::from(query.limit.unwrap_or(10).clamp(1, 20));
|
|
let like = format!("%{}%", escape_like(name));
|
|
let conn = open_db(&state.teams_db)?;
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT team_id, name, members
|
|
FROM teams_data
|
|
WHERE name LIKE ?1 ESCAPE '\\'
|
|
ORDER BY
|
|
CASE WHEN name = ?2 COLLATE NOCASE THEN 0 ELSE 1 END,
|
|
members DESC,
|
|
name COLLATE NOCASE ASC
|
|
LIMIT ?3",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let teams = stmt
|
|
.query_map(params![like, name, limit], |row| {
|
|
Ok(TeamSearchRow {
|
|
team_id: row.get(0)?,
|
|
name: row.get(1)?,
|
|
members: row.get(2)?,
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
Ok(Json(SearchResponse { teams }))
|
|
}
|
|
|
|
async fn team_detail(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(team_name): Path<String>,
|
|
) -> ApiResult<TeamDetail> {
|
|
let decoded = decode_path_team(&team_name)?;
|
|
let teams_conn = open_db(&state.teams_db)?;
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let team =
|
|
find_team(&teams_conn, &decoded)?.ok_or_else(|| ApiError::not_found("Team not found"))?;
|
|
let summary = team_summary_for(&battles_conn, &team.name)?;
|
|
// team_id is the most recent tournament entry — used only for the roster lookup.
|
|
let players = player_summaries_for(&teams_conn, &battles_conn, team.team_id, &team.name)?;
|
|
|
|
Ok(Json(TeamDetail {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
members: team.members,
|
|
captain_uid: team.captain_uid,
|
|
data_set: "tss",
|
|
team_summary: summary,
|
|
players,
|
|
}))
|
|
}
|
|
|
|
async fn team_history(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(team_name): Path<String>,
|
|
) -> ApiResult<HistoryResponse> {
|
|
let decoded = decode_path_team(&team_name)?;
|
|
let teams_conn = open_db(&state.teams_db)?;
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let team =
|
|
find_team(&teams_conn, &decoded)?.ok_or_else(|| ApiError::not_found("Team not found"))?;
|
|
|
|
let history = period_history_for(&battles_conn, &team.name)?;
|
|
|
|
Ok(Json(HistoryResponse {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
history,
|
|
}))
|
|
}
|
|
|
|
async fn team_games(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(team_name): Path<String>,
|
|
) -> ApiResult<GamesResponse> {
|
|
let decoded = decode_path_team(&team_name)?;
|
|
let teams_conn = open_db(&state.teams_db)?;
|
|
let battles_conn = open_db(&state.battles_db)?;
|
|
let team =
|
|
find_team(&teams_conn, &decoded)?.ok_or_else(|| ApiError::not_found("Team not found"))?;
|
|
let games = games_for(&battles_conn, &team.name)?;
|
|
|
|
Ok(Json(GamesResponse {
|
|
team_id: team.team_id,
|
|
name: team.name,
|
|
games,
|
|
}))
|
|
}
|
|
|
|
async fn resolve_player(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<ResolveQuery>,
|
|
) -> ApiResult<PlayerSearchResponse> {
|
|
let name = validate_player_name(&query.name)?;
|
|
let conn = open_db(&state.battles_db)?;
|
|
let players = player_resolve(&conn, name)?;
|
|
if players.is_empty() {
|
|
return Err(ApiError::not_found("Player not found"));
|
|
}
|
|
Ok(Json(PlayerSearchResponse { players }))
|
|
}
|
|
|
|
async fn search_players(
|
|
State(state): State<Arc<AppState>>,
|
|
Query(query): Query<SearchQuery>,
|
|
) -> ApiResult<PlayerSearchResponse> {
|
|
let raw = query.q.as_deref().or(query.name.as_deref()).unwrap_or("");
|
|
let name = validate_player_name(raw)?;
|
|
let limit = i64::from(query.limit.unwrap_or(25).clamp(1, 25));
|
|
let conn = open_db(&state.battles_db)?;
|
|
let players = player_search(&conn, name, limit)?;
|
|
Ok(Json(PlayerSearchResponse { players }))
|
|
}
|
|
|
|
async fn player_detail(
|
|
State(state): State<Arc<AppState>>,
|
|
Path(uid): Path<String>,
|
|
) -> ApiResult<PlayerProfile> {
|
|
let uid = validate_uid(&uid)?;
|
|
let conn = open_db(&state.battles_db)?;
|
|
let career =
|
|
player_career_for(&conn, &uid)?.ok_or_else(|| ApiError::not_found("Player not found"))?;
|
|
let nick = latest_nick_for(&conn, &uid)?;
|
|
let teams = player_teams_for(&conn, &uid)?;
|
|
Ok(Json(PlayerProfile {
|
|
uid,
|
|
nick,
|
|
data_set: "tss",
|
|
career,
|
|
teams,
|
|
}))
|
|
}
|
|
|
|
fn open_db(path: &FsPath) -> Result<Connection, ApiError> {
|
|
Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).map_err(|error| {
|
|
ApiError::internal(format!("Could not open {}: {}", path.display(), error))
|
|
})
|
|
}
|
|
|
|
fn db_error(error: rusqlite::Error) -> ApiError {
|
|
ApiError::internal(format!("Database query failed: {}", error))
|
|
}
|
|
|
|
fn read_team_record(row: &rusqlite::Row<'_>) -> rusqlite::Result<TeamRecord> {
|
|
Ok(TeamRecord {
|
|
team_id: row.get(0)?,
|
|
name: row.get(1)?,
|
|
members: row.get(2)?,
|
|
captain_uid: row.get(3)?,
|
|
})
|
|
}
|
|
|
|
fn find_team(conn: &Connection, name: &str) -> Result<Option<TeamRecord>, ApiError> {
|
|
// Return the most recent tournament entry for this team (highest team_id).
|
|
conn.query_row(
|
|
"SELECT team_id, name, members, captain_uid
|
|
FROM teams_data
|
|
WHERE name = ?2 COLLATE NOCASE OR team_id = ?1
|
|
ORDER BY team_id DESC
|
|
LIMIT 1",
|
|
params![name.parse::<i64>().ok(), name],
|
|
read_team_record,
|
|
)
|
|
.optional()
|
|
.map_err(db_error)
|
|
}
|
|
|
|
fn team_summary_for(conn: &Connection, team_name: &str) -> Result<TeamSummary, ApiError> {
|
|
conn.query_row(
|
|
"SELECT
|
|
COUNT(DISTINCT session_id),
|
|
SUM(CASE WHEN victor_bool = 'Win' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN victor_bool != 'Win' THEN 1 ELSE 0 END),
|
|
COALESCE(SUM(ground_kills), 0),
|
|
COALESCE(SUM(air_kills), 0),
|
|
COALESCE(SUM(assists), 0),
|
|
COALESCE(SUM(deaths), 0),
|
|
COALESCE(SUM(score), 0),
|
|
COUNT(DISTINCT UID)
|
|
FROM player_games_hist
|
|
WHERE team_name = ?1 COLLATE NOCASE",
|
|
params![team_name],
|
|
|row| {
|
|
let battles: i64 = row.get(0)?;
|
|
let wins: i64 = row.get(1)?;
|
|
let losses: i64 = row.get(2)?;
|
|
let ground: i64 = row.get(3)?;
|
|
let air: i64 = row.get(4)?;
|
|
let assists: i64 = row.get(5)?;
|
|
let deaths: i64 = row.get(6)?;
|
|
let score: i64 = row.get(7)?;
|
|
let player_count: i64 = row.get(8)?;
|
|
let total_kills = ground + air;
|
|
Ok(TeamSummary {
|
|
player_count,
|
|
total_battles: battles,
|
|
wins,
|
|
losses,
|
|
win_rate: percent(wins, battles),
|
|
kdr: ratio(total_kills, deaths),
|
|
total_kills,
|
|
total_points: score + assists + total_kills,
|
|
})
|
|
},
|
|
)
|
|
.map_err(db_error)
|
|
}
|
|
|
|
fn team_summaries_for(
|
|
conn: &Connection,
|
|
team_names: &[&str],
|
|
) -> Result<HashMap<String, TeamSummary>, ApiError> {
|
|
if team_names.is_empty() {
|
|
return Ok(HashMap::new());
|
|
}
|
|
|
|
let placeholders = std::iter::repeat("?")
|
|
.take(team_names.len())
|
|
.collect::<Vec<_>>()
|
|
.join(", ");
|
|
let sql = format!(
|
|
"SELECT
|
|
team_name,
|
|
COUNT(DISTINCT session_id),
|
|
SUM(CASE WHEN victor_bool = 'Win' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN victor_bool != 'Win' THEN 1 ELSE 0 END),
|
|
COALESCE(SUM(ground_kills), 0),
|
|
COALESCE(SUM(air_kills), 0),
|
|
COALESCE(SUM(assists), 0),
|
|
COALESCE(SUM(deaths), 0),
|
|
COALESCE(SUM(score), 0),
|
|
COUNT(DISTINCT UID)
|
|
FROM player_games_hist
|
|
WHERE team_name COLLATE NOCASE IN ({placeholders})
|
|
GROUP BY team_name COLLATE NOCASE"
|
|
);
|
|
let mut stmt = conn.prepare(&sql).map_err(db_error)?;
|
|
|
|
let summaries = stmt
|
|
.query_map(rusqlite::params_from_iter(team_names.iter()), |row| {
|
|
let name: String = row.get(0)?;
|
|
let battles: i64 = row.get(1)?;
|
|
let wins: i64 = row.get(2)?;
|
|
let losses: i64 = row.get(3)?;
|
|
let ground: i64 = row.get(4)?;
|
|
let air: i64 = row.get(5)?;
|
|
let assists: i64 = row.get(6)?;
|
|
let deaths: i64 = row.get(7)?;
|
|
let score: i64 = row.get(8)?;
|
|
let player_count: i64 = row.get(9)?;
|
|
let total_kills = ground + air;
|
|
Ok((
|
|
name.to_ascii_lowercase(),
|
|
TeamSummary {
|
|
player_count,
|
|
total_battles: battles,
|
|
wins,
|
|
losses,
|
|
win_rate: percent(wins, battles),
|
|
kdr: ratio(total_kills, deaths),
|
|
total_kills,
|
|
total_points: score + assists + total_kills,
|
|
},
|
|
))
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<HashMap<_, _>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
Ok(summaries)
|
|
}
|
|
|
|
fn cached_leaderboard(
|
|
state: &AppState,
|
|
limit: usize,
|
|
) -> Result<Option<Vec<TeamLeaderboardRow>>, ApiError> {
|
|
let cache = state
|
|
.leaderboard_cache
|
|
.lock()
|
|
.map_err(|_| ApiError::internal("Leaderboard cache lock failed"))?;
|
|
Ok(cache.as_ref().and_then(|cached| {
|
|
(cached.teams.len() >= limit).then(|| cached.teams.iter().take(limit).cloned().collect())
|
|
}))
|
|
}
|
|
|
|
fn cache_leaderboard(state: &AppState, teams: &[TeamLeaderboardRow]) -> Result<(), ApiError> {
|
|
let mut cache = state
|
|
.leaderboard_cache
|
|
.lock()
|
|
.map_err(|_| ApiError::internal("Leaderboard cache lock failed"))?;
|
|
*cache = Some(CachedLeaderboard {
|
|
teams: teams.to_vec(),
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
fn player_summaries_for(
|
|
teams_conn: &Connection,
|
|
battles_conn: &Connection,
|
|
// team_id: roster for this specific tournament entry only
|
|
team_id: i64,
|
|
// team_name: cross-tournament stats key
|
|
team_name: &str,
|
|
) -> Result<Vec<PlayerSummary>, ApiError> {
|
|
let mut stmt = teams_conn
|
|
.prepare(
|
|
"SELECT uid, role
|
|
FROM team_members
|
|
WHERE team_id = ?1
|
|
ORDER BY uid",
|
|
)
|
|
.map_err(db_error)?;
|
|
let members = stmt
|
|
.query_map(params![team_id], |row| {
|
|
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
let mut stats_stmt = battles_conn
|
|
.prepare(
|
|
"SELECT
|
|
UID,
|
|
COUNT(DISTINCT session_id),
|
|
SUM(CASE WHEN victor_bool = 'Win' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN victor_bool != 'Win' THEN 1 ELSE 0 END),
|
|
COALESCE(SUM(ground_kills), 0),
|
|
COALESCE(SUM(air_kills), 0),
|
|
COALESCE(SUM(assists), 0),
|
|
COALESCE(SUM(deaths), 0),
|
|
(SELECT nick FROM player_games_hist
|
|
WHERE UID = p.UID AND nick IS NOT NULL
|
|
ORDER BY endtime_unix DESC LIMIT 1)
|
|
FROM player_games_hist p
|
|
WHERE team_name = ?1 COLLATE NOCASE
|
|
GROUP BY UID",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let mut summaries = stats_stmt
|
|
.query_map(params![team_name], |row| {
|
|
let uid: String = row.get(0)?;
|
|
let battles: i64 = row.get(1)?;
|
|
let wins: i64 = row.get(2)?;
|
|
let losses: i64 = row.get(3)?;
|
|
let ground: i64 = row.get(4)?;
|
|
let air: i64 = row.get(5)?;
|
|
let assists: i64 = row.get(6)?;
|
|
let deaths: i64 = row.get(7)?;
|
|
let nick: Option<String> = row.get(8)?;
|
|
let total_kills = ground + air;
|
|
Ok((
|
|
uid.clone(),
|
|
PlayerSummary {
|
|
uid,
|
|
nick,
|
|
role: String::new(),
|
|
total_battles: battles,
|
|
wins,
|
|
losses,
|
|
win_rate: percent(wins, battles),
|
|
total_kills,
|
|
ground_kills: ground,
|
|
air_kills: air,
|
|
assists,
|
|
deaths,
|
|
kdr: ratio(total_kills, deaths),
|
|
},
|
|
))
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<HashMap<_, _>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
let mut out = Vec::with_capacity(members.len());
|
|
for (uid, role) in members {
|
|
let mut summary = summaries.remove(&uid).unwrap_or(PlayerSummary {
|
|
uid,
|
|
nick: None,
|
|
role: String::new(),
|
|
total_battles: 0,
|
|
wins: 0,
|
|
losses: 0,
|
|
win_rate: 0.0,
|
|
total_kills: 0,
|
|
ground_kills: 0,
|
|
air_kills: 0,
|
|
assists: 0,
|
|
deaths: 0,
|
|
kdr: 0.0,
|
|
});
|
|
summary.role = role;
|
|
out.push(summary);
|
|
}
|
|
|
|
out.sort_by(|a, b| b.total_battles.cmp(&a.total_battles));
|
|
Ok(out)
|
|
}
|
|
|
|
fn player_search(conn: &Connection, query: &str, limit: i64) -> Result<Vec<PlayerRef>, ApiError> {
|
|
let like = format!("%{}%", escape_like(query));
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT UID, MIN(nick) AS nick, MAX(endtime_unix) AS last_seen
|
|
FROM player_games_hist
|
|
WHERE nick LIKE ?1 ESCAPE '\\' COLLATE NOCASE
|
|
GROUP BY UID
|
|
ORDER BY
|
|
CASE WHEN MIN(nick) = ?2 COLLATE NOCASE THEN 0 ELSE 1 END,
|
|
last_seen DESC
|
|
LIMIT ?3",
|
|
)
|
|
.map_err(db_error)?;
|
|
let players = stmt
|
|
.query_map(params![like, query, limit], |row| {
|
|
Ok(PlayerRef {
|
|
uid: row.get(0)?,
|
|
nick: row.get(1)?,
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
Ok(players)
|
|
}
|
|
|
|
fn player_resolve(conn: &Connection, name: &str) -> Result<Vec<PlayerRef>, ApiError> {
|
|
// Exact nick match first; fall back to substring search.
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT UID, MIN(nick) AS nick
|
|
FROM player_games_hist
|
|
WHERE nick = ?1 COLLATE NOCASE
|
|
GROUP BY UID
|
|
ORDER BY nick
|
|
LIMIT 25",
|
|
)
|
|
.map_err(db_error)?;
|
|
let exact = stmt
|
|
.query_map(params![name], |row| {
|
|
Ok(PlayerRef {
|
|
uid: row.get(0)?,
|
|
nick: row.get(1)?,
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
if !exact.is_empty() {
|
|
return Ok(exact);
|
|
}
|
|
player_search(conn, name, 25)
|
|
}
|
|
|
|
fn latest_nick_for(conn: &Connection, uid: &str) -> Result<Option<String>, ApiError> {
|
|
conn.query_row(
|
|
"SELECT nick FROM player_games_hist WHERE UID = ?1 ORDER BY endtime_unix DESC LIMIT 1",
|
|
params![uid],
|
|
|row| row.get::<_, Option<String>>(0),
|
|
)
|
|
.optional()
|
|
.map_err(db_error)
|
|
.map(|opt| opt.flatten())
|
|
}
|
|
|
|
fn player_career_for(conn: &Connection, uid: &str) -> Result<Option<PlayerCareer>, ApiError> {
|
|
// Player totals repeat across a player's per-vehicle rows for a session, so
|
|
// collapse to one value per session (MAX) before summing.
|
|
conn.query_row(
|
|
"SELECT
|
|
COUNT(*) AS battles,
|
|
COALESCE(SUM(CASE WHEN UPPER(victor_bool) = 'WIN' THEN 1 ELSE 0 END), 0) AS wins,
|
|
COALESCE(SUM(CASE WHEN UPPER(victor_bool) = 'LOSS' THEN 1 ELSE 0 END), 0) AS losses,
|
|
COALESCE(SUM(gk), 0), COALESCE(SUM(ak), 0),
|
|
COALESCE(SUM(asi), 0), COALESCE(SUM(cap), 0), COALESCE(SUM(de), 0)
|
|
FROM (
|
|
SELECT session_id,
|
|
MAX(victor_bool) AS victor_bool,
|
|
MAX(ground_kills) AS gk, MAX(air_kills) AS ak,
|
|
MAX(assists) AS asi, MAX(captures) AS cap, MAX(deaths) AS de
|
|
FROM player_games_hist
|
|
WHERE UID = ?1
|
|
GROUP BY session_id
|
|
)",
|
|
params![uid],
|
|
|row| {
|
|
let battles: i64 = row.get(0)?;
|
|
let wins: i64 = row.get(1)?;
|
|
let losses: i64 = row.get(2)?;
|
|
let ground: i64 = row.get(3)?;
|
|
let air: i64 = row.get(4)?;
|
|
let assists: i64 = row.get(5)?;
|
|
let captures: i64 = row.get(6)?;
|
|
let deaths: i64 = row.get(7)?;
|
|
let total_kills = ground + air;
|
|
Ok((
|
|
battles,
|
|
wins,
|
|
losses,
|
|
ground,
|
|
air,
|
|
assists,
|
|
captures,
|
|
deaths,
|
|
total_kills,
|
|
))
|
|
},
|
|
)
|
|
.optional()
|
|
.map_err(db_error)
|
|
.map(|opt| {
|
|
opt.and_then(
|
|
|(battles, wins, losses, ground, air, assists, captures, deaths, total_kills)| {
|
|
if battles == 0 {
|
|
None
|
|
} else {
|
|
Some(PlayerCareer {
|
|
total_battles: battles,
|
|
wins,
|
|
losses,
|
|
win_rate: percent(wins, battles),
|
|
ground_kills: ground,
|
|
air_kills: air,
|
|
total_kills,
|
|
assists,
|
|
captures,
|
|
deaths,
|
|
kdr: ratio(total_kills, deaths),
|
|
})
|
|
}
|
|
},
|
|
)
|
|
})
|
|
}
|
|
|
|
fn player_teams_for(conn: &Connection, uid: &str) -> Result<Vec<PlayerTeamRef>, ApiError> {
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT team_id, MAX(team_name) AS team_name,
|
|
COUNT(DISTINCT session_id) AS games, MAX(endtime_unix) AS last_seen
|
|
FROM player_games_hist
|
|
WHERE UID = ?1 AND team_id IS NOT NULL
|
|
GROUP BY team_id
|
|
ORDER BY last_seen DESC",
|
|
)
|
|
.map_err(db_error)?;
|
|
let teams = stmt
|
|
.query_map(params![uid], |row| {
|
|
Ok(PlayerTeamRef {
|
|
team_id: row.get(0)?,
|
|
team_name: row.get(1)?,
|
|
games: row.get(2)?,
|
|
last_seen: row.get(3)?,
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
Ok(teams)
|
|
}
|
|
|
|
fn period_history_for(conn: &Connection, team_name: &str) -> Result<Vec<PeriodHistory>, ApiError> {
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT
|
|
strftime('%Y-%m', endtime_unix, 'unixepoch') AS period,
|
|
COUNT(DISTINCT session_id),
|
|
SUM(CASE WHEN victor_bool = 'Win' THEN 1 ELSE 0 END),
|
|
SUM(CASE WHEN victor_bool != 'Win' THEN 1 ELSE 0 END)
|
|
FROM player_games_hist
|
|
WHERE team_name = ?1 COLLATE NOCASE AND endtime_unix > 0
|
|
GROUP BY period
|
|
ORDER BY period ASC",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let rows = stmt
|
|
.query_map(params![team_name], |row| {
|
|
let period: String = row.get(0)?;
|
|
let battles: i64 = row.get(1)?;
|
|
let wins: i64 = row.get(2)?;
|
|
let losses: i64 = row.get(3)?;
|
|
Ok(PeriodHistory {
|
|
period,
|
|
battles,
|
|
wins,
|
|
losses,
|
|
win_rate: percent(wins, battles),
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
Ok(rows)
|
|
}
|
|
|
|
fn games_for(conn: &Connection, team_name: &str) -> Result<Vec<GameRow>, ApiError> {
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT
|
|
p.session_id,
|
|
COALESCE(m.endtime_unix, MAX(p.endtime_unix), 0) AS timestamp,
|
|
m.mission_name,
|
|
m.mission_mode,
|
|
CASE
|
|
WHEN MAX(CASE WHEN p.victor_bool = 'Win' THEN 1 ELSE 0 END) = 1 THEN 'Win'
|
|
ELSE 'Loss'
|
|
END AS result,
|
|
COUNT(DISTINCT p.UID),
|
|
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),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = p.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Win'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = p.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Loss'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1)
|
|
FROM player_games_hist p
|
|
LEFT JOIN match_summary m ON m.session_id = p.session_id
|
|
WHERE p.team_name = ?1 COLLATE NOCASE
|
|
GROUP BY p.session_id
|
|
ORDER BY timestamp DESC
|
|
LIMIT 100",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let rows = stmt
|
|
.query_map(params![team_name], |row| {
|
|
let session_id: String = row.get(0)?;
|
|
let timestamp: i64 = row.get(1)?;
|
|
let map_name: Option<String> = row.get(2)?;
|
|
let mission_mode: Option<String> = row.get(3)?;
|
|
Ok(GameRow {
|
|
team_name: None,
|
|
session_id,
|
|
timestamp,
|
|
endtime_unix: timestamp,
|
|
map_name,
|
|
mission_mode,
|
|
result: row.get(4)?,
|
|
player_count: row.get(5)?,
|
|
winning_team: row.get(15)?,
|
|
losing_team: row.get(16)?,
|
|
stats: GameStats {
|
|
ground_kills: row.get(6)?,
|
|
air_kills: row.get(7)?,
|
|
assists: row.get(8)?,
|
|
captures: row.get(9)?,
|
|
deaths: row.get(10)?,
|
|
score: row.get(11)?,
|
|
missile_evades: row.get(12)?,
|
|
shell_interceptions: row.get(13)?,
|
|
team_kills_stat: row.get(14)?,
|
|
},
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
Ok(rows)
|
|
}
|
|
|
|
fn recent_games_for(conn: &Connection, limit: i64) -> Result<Vec<GameRow>, ApiError> {
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"WITH recent AS (
|
|
SELECT team_name, session_id, MAX(endtime_unix) AS timestamp
|
|
FROM player_games_hist
|
|
WHERE team_name IS NOT NULL AND team_name != ''
|
|
GROUP BY session_id
|
|
ORDER BY timestamp DESC
|
|
LIMIT ?1
|
|
)
|
|
SELECT
|
|
r.team_name,
|
|
r.session_id,
|
|
COALESCE(m.endtime_unix, r.timestamp, 0) AS timestamp,
|
|
m.mission_name,
|
|
m.mission_mode,
|
|
CASE
|
|
WHEN MAX(CASE WHEN p.victor_bool = 'Win' THEN 1 ELSE 0 END) = 1 THEN 'Win'
|
|
ELSE 'Loss'
|
|
END AS result,
|
|
COUNT(DISTINCT p.UID),
|
|
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),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = r.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Win'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = r.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Loss'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1)
|
|
FROM recent r
|
|
JOIN player_games_hist p
|
|
ON p.session_id = r.session_id AND p.team_name = r.team_name COLLATE NOCASE
|
|
LEFT JOIN match_summary m ON m.session_id = r.session_id
|
|
GROUP BY r.team_name COLLATE NOCASE, r.session_id
|
|
ORDER BY timestamp DESC
|
|
LIMIT ?1",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let rows = stmt
|
|
.query_map(params![limit], |row| {
|
|
let timestamp: i64 = row.get(2)?;
|
|
Ok(GameRow {
|
|
team_name: row.get(0)?,
|
|
session_id: row.get(1)?,
|
|
timestamp,
|
|
endtime_unix: timestamp,
|
|
map_name: row.get(3)?,
|
|
mission_mode: row.get(4)?,
|
|
result: row.get(5)?,
|
|
player_count: row.get(6)?,
|
|
winning_team: row.get(16)?,
|
|
losing_team: row.get(17)?,
|
|
stats: GameStats {
|
|
ground_kills: row.get(7)?,
|
|
air_kills: row.get(8)?,
|
|
assists: row.get(9)?,
|
|
captures: row.get(10)?,
|
|
deaths: row.get(11)?,
|
|
score: row.get(12)?,
|
|
missile_evades: row.get(13)?,
|
|
shell_interceptions: row.get(14)?,
|
|
team_kills_stat: row.get(15)?,
|
|
},
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
Ok(rows)
|
|
}
|
|
|
|
fn game_for(conn: &Connection, session_id: &str) -> Result<Option<GameRow>, ApiError> {
|
|
conn.query_row(
|
|
"SELECT
|
|
p.session_id,
|
|
COALESCE(m.endtime_unix, MAX(p.endtime_unix), 0) AS timestamp,
|
|
m.mission_name,
|
|
m.mission_mode,
|
|
COUNT(DISTINCT p.UID),
|
|
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),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = p.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Win'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1),
|
|
(SELECT pg.team_name
|
|
FROM player_games_hist pg
|
|
WHERE pg.session_id = p.session_id
|
|
AND pg.team_name IS NOT NULL
|
|
AND pg.team_name != ''
|
|
AND pg.victor_bool = 'Loss'
|
|
GROUP BY pg.team_name COLLATE NOCASE
|
|
ORDER BY COUNT(DISTINCT pg.UID) DESC, pg.team_name COLLATE NOCASE
|
|
LIMIT 1)
|
|
FROM player_games_hist p
|
|
LEFT JOIN match_summary m ON m.session_id = p.session_id
|
|
WHERE p.session_id = ?1
|
|
GROUP BY p.session_id",
|
|
params![session_id],
|
|
|row| {
|
|
let timestamp: i64 = row.get(1)?;
|
|
Ok(GameRow {
|
|
team_name: None,
|
|
session_id: row.get(0)?,
|
|
timestamp,
|
|
endtime_unix: timestamp,
|
|
map_name: row.get(2)?,
|
|
mission_mode: row.get(3)?,
|
|
result: String::new(),
|
|
player_count: row.get(4)?,
|
|
winning_team: row.get(14)?,
|
|
losing_team: row.get(15)?,
|
|
stats: GameStats {
|
|
ground_kills: row.get(5)?,
|
|
air_kills: row.get(6)?,
|
|
assists: row.get(7)?,
|
|
captures: row.get(8)?,
|
|
deaths: row.get(9)?,
|
|
score: row.get(10)?,
|
|
missile_evades: row.get(11)?,
|
|
shell_interceptions: row.get(12)?,
|
|
team_kills_stat: row.get(13)?,
|
|
},
|
|
})
|
|
},
|
|
)
|
|
.optional()
|
|
.map_err(db_error)
|
|
}
|
|
|
|
fn game_participants_for(
|
|
conn: &Connection,
|
|
session_id: &str,
|
|
) -> Result<Vec<GameParticipant>, ApiError> {
|
|
let mut stmt = conn
|
|
.prepare(
|
|
"SELECT
|
|
p.team_name,
|
|
CASE
|
|
WHEN MAX(CASE WHEN p.victor_bool = 'Win' THEN 1 ELSE 0 END) = 1 THEN 'Win'
|
|
ELSE 'Loss'
|
|
END AS result,
|
|
COUNT(DISTINCT p.UID),
|
|
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 IS NOT NULL AND p.team_name != ''
|
|
GROUP BY p.team_name COLLATE NOCASE
|
|
ORDER BY
|
|
CASE
|
|
WHEN MAX(CASE WHEN p.victor_bool = 'Win' THEN 1 ELSE 0 END) = 1 THEN 0
|
|
ELSE 1
|
|
END,
|
|
p.team_name COLLATE NOCASE",
|
|
)
|
|
.map_err(db_error)?;
|
|
|
|
let rows = stmt
|
|
.query_map(params![session_id], |row| {
|
|
Ok(GameParticipant {
|
|
team_name: row.get(0)?,
|
|
result: row.get(1)?,
|
|
player_count: row.get(2)?,
|
|
stats: GameStats {
|
|
ground_kills: row.get(3)?,
|
|
air_kills: row.get(4)?,
|
|
assists: row.get(5)?,
|
|
captures: row.get(6)?,
|
|
deaths: row.get(7)?,
|
|
score: row.get(8)?,
|
|
missile_evades: row.get(9)?,
|
|
shell_interceptions: row.get(10)?,
|
|
team_kills_stat: row.get(11)?,
|
|
},
|
|
})
|
|
})
|
|
.map_err(db_error)?
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.map_err(db_error)?;
|
|
|
|
Ok(rows)
|
|
}
|
|
|
|
fn validate_team_name(name: &str) -> Result<&str, ApiError> {
|
|
let trimmed = name.trim();
|
|
if trimmed.len() < 2 || trimmed.len() > MAX_TEAM_NAME_LENGTH {
|
|
return Err(ApiError::bad_request(
|
|
"Team name must be 2 to 80 characters",
|
|
));
|
|
}
|
|
Ok(trimmed)
|
|
}
|
|
|
|
fn validate_player_name(name: &str) -> Result<&str, ApiError> {
|
|
let trimmed = name.trim();
|
|
if trimmed.len() < 2 || trimmed.len() > MAX_TEAM_NAME_LENGTH {
|
|
return Err(ApiError::bad_request(
|
|
"Player name must be 2 to 80 characters",
|
|
));
|
|
}
|
|
Ok(trimmed)
|
|
}
|
|
|
|
fn validate_uid(value: &str) -> Result<String, ApiError> {
|
|
let trimmed = value.trim();
|
|
if trimmed.is_empty() || trimmed.len() > 32 || !trimmed.chars().all(|c| c.is_ascii_digit()) {
|
|
return Err(ApiError::bad_request("Invalid player UID"));
|
|
}
|
|
Ok(trimmed.to_string())
|
|
}
|
|
|
|
fn validate_session_id(value: &str) -> Result<&str, ApiError> {
|
|
if value.is_empty()
|
|
|| value.len() > 96
|
|
|| !value
|
|
.bytes()
|
|
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
|
|
{
|
|
return Err(ApiError::bad_request("Invalid game ID"));
|
|
}
|
|
|
|
Ok(value)
|
|
}
|
|
|
|
fn decode_path_team(value: &str) -> Result<String, ApiError> {
|
|
let decoded = urlencoding::decode(value)
|
|
.map_err(|_| ApiError::bad_request("Invalid team name"))?
|
|
.into_owned();
|
|
validate_team_name(&decoded)?;
|
|
Ok(decoded)
|
|
}
|
|
|
|
fn escape_like(value: &str) -> String {
|
|
value
|
|
.replace('\\', "\\\\")
|
|
.replace('%', "\\%")
|
|
.replace('_', "\\_")
|
|
}
|
|
|
|
fn percent(part: i64, total: i64) -> f64 {
|
|
if total <= 0 {
|
|
0.0
|
|
} else {
|
|
(part as f64 / total as f64) * 100.0
|
|
}
|
|
}
|
|
|
|
fn ratio(top: i64, bottom: i64) -> f64 {
|
|
if bottom <= 0 {
|
|
top as f64
|
|
} else {
|
|
top as f64 / bottom as f64
|
|
}
|
|
}
|
|
|
|
fn env_u16(key: &str) -> Option<u16> {
|
|
env::var(key).ok()?.parse().ok()
|
|
}
|
|
|
|
fn env_ip(key: &str) -> Option<IpAddr> {
|
|
env::var(key).ok()?.parse().ok()
|
|
}
|
|
|
|
fn allowed_origins() -> AllowOrigin {
|
|
let origins = env::var("BACKEND_ALLOWED_ORIGINS")
|
|
.or_else(|_| env::var("PUBLIC_ORIGIN"))
|
|
.unwrap_or_default()
|
|
.split(',')
|
|
.filter_map(|origin| {
|
|
let origin = origin.trim();
|
|
if origin.is_empty() {
|
|
return None;
|
|
}
|
|
HeaderValue::from_str(origin).ok()
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
if origins.is_empty() {
|
|
AllowOrigin::list(Vec::<HeaderValue>::new())
|
|
} else {
|
|
AllowOrigin::list(origins)
|
|
}
|
|
}
|
|
|
|
fn resolve_db_path(env_key: &str, default_file: &str) -> PathBuf {
|
|
let raw = env::var(env_key).unwrap_or_else(|_| default_file.to_string());
|
|
let expanded = expand_home(&raw);
|
|
let path = PathBuf::from(expanded);
|
|
if path.is_absolute() {
|
|
path
|
|
} else {
|
|
env::current_dir()
|
|
.unwrap_or_else(|_| PathBuf::from("."))
|
|
.join(path)
|
|
}
|
|
}
|
|
|
|
fn expand_home(value: &str) -> String {
|
|
if value == "~" {
|
|
return home_dir()
|
|
.map(|p| p.display().to_string())
|
|
.unwrap_or_else(|| value.to_string());
|
|
}
|
|
if let Some(rest) = value
|
|
.strip_prefix("~/")
|
|
.or_else(|| value.strip_prefix("~\\"))
|
|
{
|
|
if let Some(home) = home_dir() {
|
|
return home.join(rest).display().to_string();
|
|
}
|
|
}
|
|
value.to_string()
|
|
}
|
|
|
|
fn home_dir() -> Option<PathBuf> {
|
|
env::var_os("HOME")
|
|
.or_else(|| env::var_os("USERPROFILE"))
|
|
.map(PathBuf::from)
|
|
}
|
|
|
|
fn load_root_env() {
|
|
let candidates = [
|
|
env::current_dir().ok().map(|path| path.join(".env")),
|
|
env::current_dir()
|
|
.ok()
|
|
.and_then(|path| path.parent().map(|parent| parent.join(".env"))),
|
|
Some(
|
|
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("..")
|
|
.join(".env"),
|
|
),
|
|
];
|
|
|
|
for candidate in candidates.into_iter().flatten() {
|
|
if candidate.exists() {
|
|
load_env_file(&candidate);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn load_env_file(path: &FsPath) {
|
|
let Ok(contents) = fs::read_to_string(path) else {
|
|
return;
|
|
};
|
|
for line in contents.lines() {
|
|
let trimmed = line.trim();
|
|
if trimmed.is_empty() || trimmed.starts_with('#') {
|
|
continue;
|
|
}
|
|
let Some((key, value)) = trimmed.split_once('=') else {
|
|
continue;
|
|
};
|
|
let key = key.trim();
|
|
if key.is_empty() || env::var_os(key).is_some() {
|
|
continue;
|
|
}
|
|
let value = value
|
|
.trim()
|
|
.trim_matches('"')
|
|
.trim_matches('\'')
|
|
.to_string();
|
|
env::set_var(key, value);
|
|
}
|
|
}
|