Files
OpenFUT-Core/src/routes/statistics.rs
T
funman300 4ae1081aa9 feat: Phase 3 — polish & settings complete
Card pool:
- TOTW cards (5): overall 88-92, rarity "totw"
- Hero cards (5): overall 85-88, rarity "hero"
- Icon cards (5): overall 93-95, rarity "icon" (permanent, non-loan)

Packs:
- TOTW Pack (30,000 coins): 5 TOTW cards guaranteed
- Icon Pack (50,000 coins): 3 icon cards guaranteed
- Hero Pack (20,000 coins): 5 hero cards guaranteed

Objectives:
- Milestone objectives (6): win 10/50, score 100/500 goals, 10 SBCs, 25 packs

Formations:
- GET /formations returns 12 valid formation strings

Multiple named squads (#20):
- POST /squad with no squad_id always creates a new squad
- POST /squad with squad_id updates that specific squad
- GET /squads: list all squads for the club (metadata only)
- GET /squads/🆔 squad with players + chemistry
- DELETE /squads/🆔 remove a squad

Per-position goal stats (#41):
- Migration 0003: position_goals table
- POST /matches/result accepts optional goal_positions: ["ST","CAM",...]
- GET /statistics now includes position_goals map

Settings (#44-46):
- GET /settings: { difficulty, preferred_formation } with defaults
- PUT /settings: upsert any key-value combination

Draft mode skeleton (#38):
- GET /draft/squad?difficulty=... returns a randomly generated 11-player squad

Integration tests:
- 9 new tests covering: formations, pack buy/open, SBC submit, settings R/W,
  multiple squads, draft endpoint, goal position tracking, win streak

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-25 15:46:20 -07:00

83 lines
2.6 KiB
Rust

use axum::{
extract::{Query, State},
Json,
};
use serde::Deserialize;
use serde_json::{json, Value};
use crate::{
app::AppState,
error::AppResult,
models::match_result::Match,
services::{profile as profile_svc, statistics as stats_svc},
};
pub async fn get_statistics(State(state): State<AppState>) -> AppResult<Json<Value>> {
let profile = profile_svc::get_active_profile(&state.pool).await?;
let stats = stats_svc::get_or_create(&state.pool, &profile.id).await?;
let pos_goals = stats_svc::get_position_goals(&state.pool, &profile.id).await?;
let pos_map: serde_json::Map<String, Value> = pos_goals
.into_iter()
.map(|(pos, goals)| (pos, Value::Number(goals.into())))
.collect();
let mut val = serde_json::to_value(&stats)?;
if let Some(obj) = val.as_object_mut() {
obj.insert("position_goals".into(), Value::Object(pos_map));
}
Ok(Json(val))
}
#[derive(Deserialize)]
pub struct HistoryQuery {
pub limit: Option<i64>,
}
pub async fn get_statistics_history(
State(state): State<AppState>,
Query(query): Query<HistoryQuery>,
) -> AppResult<Json<Value>> {
let profile = profile_svc::get_active_profile(&state.pool).await?;
let limit = query.limit.unwrap_or(20).clamp(1, 100);
let matches = sqlx::query_as::<_, Match>(
"SELECT id, profile_id, squad_id, opponent_name, goals_for, goals_against, outcome, coins_awarded, xp_awarded, mode, played_at FROM matches WHERE profile_id = ? ORDER BY played_at DESC LIMIT ?",
)
.bind(&profile.id)
.bind(limit)
.fetch_all(&state.pool)
.await?;
let total = matches.len();
let wins = matches.iter().filter(|m| m.outcome == "win").count();
let draws = matches.iter().filter(|m| m.outcome == "draw").count();
let losses = matches.iter().filter(|m| m.outcome == "loss").count();
let goals_for: i64 = matches.iter().map(|m| m.goals_for).sum();
let goals_against: i64 = matches.iter().map(|m| m.goals_against).sum();
let win_rate = if total > 0 {
wins as f64 / total as f64
} else {
0.0
};
let avg_goals = if total > 0 {
goals_for as f64 / total as f64
} else {
0.0
};
Ok(Json(json!({
"matches": matches,
"summary": {
"total": total,
"wins": wins,
"draws": draws,
"losses": losses,
"win_rate": (win_rate * 100.0).round() / 100.0,
"total_goals_for": goals_for,
"total_goals_against": goals_against,
"avg_goals_per_game": (avg_goals * 100.0).round() / 100.0,
}
})))
}