funman300
e438b58d88
CI / Build, lint & test (push) Failing after 2m10s
- Market: record buy/sell history in market_history table; expose via GET /market/trade-history (last 30 events, newest first) - Division: GET /division/leaderboard returns 10-club table with 9 seeded NPC entries + player row, sorted by pts; stable within a season - rand feature small_rng enabled in Cargo.toml for SmallRng use - 3 new integration tests (leaderboard count, sort order, empty trade history) - Core: 96 tests passing Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
262 lines
11 KiB
Rust
262 lines
11 KiB
Rust
use crate::middleware::{limit_concurrency, MakeRequestUuid};
|
|
use crate::{
|
|
config::Config,
|
|
db::Pool,
|
|
models::achievement::AchievementDefinition,
|
|
models::chemistry_style::{load_chemistry_styles, ChemistryStyle},
|
|
models::event::EventDefinition,
|
|
models::objective::{ObjectiveDefinition, ObjectiveType},
|
|
models::pack::PackDefinition,
|
|
models::sbc::SbcDefinition,
|
|
routes,
|
|
services::{
|
|
achievement::load_achievement_definitions, card_db::CardDb, event::load_event_definitions,
|
|
market, objective::load_objective_definitions, pack::load_pack_definitions,
|
|
sbc::load_sbc_definitions,
|
|
},
|
|
};
|
|
use anyhow::Result;
|
|
use axum::{
|
|
extract::DefaultBodyLimit,
|
|
middleware,
|
|
routing::{delete, get, patch, post, put},
|
|
Router,
|
|
};
|
|
use std::sync::Arc;
|
|
use tower_http::{
|
|
cors::CorsLayer,
|
|
request_id::{PropagateRequestIdLayer, SetRequestIdLayer},
|
|
trace::TraceLayer,
|
|
};
|
|
|
|
#[derive(Clone)]
|
|
pub struct AppState {
|
|
pub pool: Pool,
|
|
pub card_db: Arc<CardDb>,
|
|
pub pack_defs: Arc<Vec<PackDefinition>>,
|
|
pub obj_defs: Arc<Vec<ObjectiveDefinition>>,
|
|
pub sbc_defs: Arc<Vec<SbcDefinition>>,
|
|
pub event_defs: Arc<Vec<EventDefinition>>,
|
|
pub chem_styles: Arc<Vec<ChemistryStyle>>,
|
|
pub achievement_defs: Arc<Vec<AchievementDefinition>>,
|
|
}
|
|
|
|
pub async fn build(pool: Pool, cfg: Config) -> Result<Router> {
|
|
let card_db = Arc::new(CardDb::load(&cfg.data_dir)?);
|
|
let pack_defs = Arc::new(load_pack_definitions(&cfg.data_dir)?);
|
|
let obj_defs = Arc::new(load_objective_definitions(&cfg.data_dir)?);
|
|
let sbc_defs = Arc::new(load_sbc_definitions(&cfg.data_dir)?);
|
|
let event_defs = Arc::new(load_event_definitions(&cfg.data_dir)?);
|
|
let chem_styles = Arc::new(load_chemistry_styles(&cfg.data_dir)?);
|
|
let achievement_defs = Arc::new(load_achievement_definitions(&cfg.data_dir)?);
|
|
|
|
tracing::info!(
|
|
"Loaded {} cards, {} packs, {} objectives, {} SBCs, {} events, {} chemistry styles, {} achievements",
|
|
card_db.cards.len(),
|
|
pack_defs.len(),
|
|
obj_defs.len(),
|
|
sbc_defs.len(),
|
|
event_defs.len(),
|
|
chem_styles.len(),
|
|
achievement_defs.len(),
|
|
);
|
|
|
|
let state = AppState {
|
|
pool: pool.clone(),
|
|
card_db: card_db.clone(),
|
|
pack_defs,
|
|
obj_defs: obj_defs.clone(),
|
|
sbc_defs,
|
|
event_defs: event_defs.clone(),
|
|
chem_styles,
|
|
achievement_defs,
|
|
};
|
|
|
|
// Background task: refresh NPC market at startup and every 24 hours
|
|
{
|
|
let pool = pool.clone();
|
|
let card_db = card_db.clone();
|
|
let event_defs_bg = event_defs.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = market::refresh_npc_listings(&pool, &card_db, &event_defs_bg).await {
|
|
tracing::warn!("initial market refresh failed: {e}");
|
|
}
|
|
loop {
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(86_400)).await;
|
|
if let Err(e) = market::refresh_npc_listings(&pool, &card_db, &event_defs_bg).await
|
|
{
|
|
tracing::warn!("market refresh failed: {e}");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Background task: reset daily objective progress at midnight UTC
|
|
{
|
|
let pool = pool.clone();
|
|
let daily_ids: Vec<String> = obj_defs
|
|
.iter()
|
|
.filter(|d| matches!(d.objective_type, ObjectiveType::Daily))
|
|
.map(|d| d.id.clone())
|
|
.collect();
|
|
tokio::spawn(async move {
|
|
loop {
|
|
let now = chrono::Utc::now();
|
|
let tomorrow = now.date_naive() + chrono::Days::new(1);
|
|
let midnight = tomorrow
|
|
.and_hms_opt(0, 0, 0)
|
|
.map(|dt| dt.and_utc())
|
|
.unwrap_or_else(|| now + chrono::Duration::hours(24));
|
|
let secs = (midnight - now).num_seconds().max(1) as u64;
|
|
tokio::time::sleep(tokio::time::Duration::from_secs(secs)).await;
|
|
|
|
for id in &daily_ids {
|
|
if let Err(e) = sqlx::query(
|
|
"UPDATE objective_progress SET current = 0, completed = 0, claimed = 0 WHERE objective_id = ?",
|
|
)
|
|
.bind(id)
|
|
.execute(&pool)
|
|
.await
|
|
{
|
|
tracing::warn!("daily reset failed for {id}: {e}");
|
|
}
|
|
}
|
|
tracing::info!("Daily objectives reset ({} objectives)", daily_ids.len());
|
|
}
|
|
});
|
|
}
|
|
|
|
let router = Router::new()
|
|
.route("/health", get(routes::health::get_health))
|
|
.route("/formations", get(routes::health::get_formations))
|
|
.route("/auth/local", post(routes::auth::post_auth_local))
|
|
.route("/auth/status", get(routes::auth::get_auth_status))
|
|
.route("/auth/reset", post(routes::auth::post_auth_reset))
|
|
.route("/profile", get(routes::profile::get_profile))
|
|
.route("/club", get(routes::club::get_club))
|
|
.route("/club", put(routes::club::put_club))
|
|
.route("/club/checkin", get(routes::club::get_checkin_status))
|
|
.route("/club/checkin", post(routes::club::post_checkin))
|
|
.route("/club/milestones", get(routes::club::get_milestones))
|
|
.route("/cards", get(routes::cards::get_cards))
|
|
.route("/cards/:card_id", get(routes::cards::get_card))
|
|
.route("/collection", get(routes::cards::get_collection))
|
|
.route(
|
|
"/collection/:owned_card_id",
|
|
delete(routes::cards::delete_owned_card),
|
|
)
|
|
.route(
|
|
"/collection/:owned_card_id/chemistry-style",
|
|
post(routes::upgrades::post_apply_chemistry_style),
|
|
)
|
|
.route(
|
|
"/collection/:owned_card_id/position",
|
|
post(routes::upgrades::post_change_position),
|
|
)
|
|
.route(
|
|
"/collection/:owned_card_id/training",
|
|
post(routes::upgrades::post_apply_training),
|
|
)
|
|
.route(
|
|
"/chemistry-styles",
|
|
get(routes::upgrades::get_chemistry_styles),
|
|
)
|
|
.route("/packs", get(routes::packs::get_packs))
|
|
.route("/packs/store", get(routes::packs::get_pack_store))
|
|
.route("/packs/history", get(routes::packs::get_pack_history))
|
|
.route("/packs/buy", post(routes::packs::post_buy_pack))
|
|
.route("/packs/open/:pack_id", post(routes::packs::post_open_pack))
|
|
.route("/squad", get(routes::squad::get_squad))
|
|
.route("/squad", post(routes::squad::post_squad))
|
|
.route("/squads", get(routes::squad::get_squads))
|
|
.route("/squads/:squad_id", get(routes::squad::get_squad_by_id))
|
|
.route("/squads/:squad_id", delete(routes::squad::delete_squad))
|
|
.route("/objectives", get(routes::objectives::get_objectives))
|
|
.route("/objectives/:objective_id", get(routes::objectives::get_objective))
|
|
.route(
|
|
"/objectives/claim",
|
|
post(routes::objectives::post_claim_objective),
|
|
)
|
|
.route(
|
|
"/objectives/:objective_id/claim",
|
|
post(routes::objectives::post_claim_objective_by_id),
|
|
)
|
|
.route("/matches", get(routes::matches::get_matches))
|
|
.route("/matches/opponent", get(routes::matches::get_opponent))
|
|
.route("/matches/result", post(routes::matches::post_match_result))
|
|
.route("/sbc", get(routes::sbc::get_sbcs))
|
|
.route("/sbc/submit", post(routes::sbc::post_sbc_submit))
|
|
.route("/sbc/:sbc_id", get(routes::sbc::get_sbc))
|
|
.route("/market", get(routes::market::get_market))
|
|
.route("/market/buy", post(routes::market::post_market_buy))
|
|
.route("/market/sell", post(routes::market::post_market_sell))
|
|
.route("/market/trade-history", get(routes::market::get_trade_history))
|
|
.route("/market/refresh", post(routes::market::post_market_refresh))
|
|
.route("/market/my-listings", get(routes::market::get_my_listings))
|
|
.route(
|
|
"/market/listings/:listing_id",
|
|
delete(routes::market::delete_market_listing),
|
|
)
|
|
.route("/statistics", get(routes::statistics::get_statistics))
|
|
.route(
|
|
"/statistics/history",
|
|
get(routes::statistics::get_statistics_history),
|
|
)
|
|
.route("/settings", get(routes::settings::get_settings))
|
|
.route("/settings", put(routes::settings::put_settings))
|
|
.route("/division", get(routes::division::get_division))
|
|
.route("/division/history", get(routes::division::get_division_history))
|
|
.route("/division/leaderboard", get(routes::division::get_division_leaderboard))
|
|
.route("/achievements", get(routes::achievements::get_achievements))
|
|
.route("/notifications", get(routes::notifications::get_notifications))
|
|
.route("/notifications/read-all", post(routes::notifications::mark_all_notifications_read))
|
|
.route("/notifications/:id/read", patch(routes::notifications::mark_notification_read))
|
|
.route("/fut-champs", get(routes::fut_champs::get_fut_champs))
|
|
.route("/fut-champs/start", post(routes::fut_champs::post_start_fut_champs))
|
|
.route("/fut-champs/history", get(routes::fut_champs::get_champs_history))
|
|
.route(
|
|
"/fut-champs/:session_id/result",
|
|
post(routes::fut_champs::post_champs_result),
|
|
)
|
|
.route(
|
|
"/fut-champs/:session_id/claim",
|
|
post(routes::fut_champs::post_claim_champs_rewards),
|
|
)
|
|
.route(
|
|
"/rivals/claim-weekly",
|
|
post(routes::fut_champs::post_claim_rivals_reward),
|
|
)
|
|
.route("/draft/squad", get(routes::draft::get_draft_squad))
|
|
.route("/draft/start", post(routes::draft::post_draft_start))
|
|
.route("/draft/sessions/:id", get(routes::draft::get_draft_session))
|
|
.route(
|
|
"/draft/sessions/:id/pick",
|
|
post(routes::draft::post_draft_pick),
|
|
)
|
|
.route(
|
|
"/draft/sessions/:id/abandon",
|
|
post(routes::draft::post_draft_abandon),
|
|
)
|
|
.route("/events", get(routes::events::get_events))
|
|
.route("/events/:event_id", get(routes::events::get_event))
|
|
.route(
|
|
"/events/:event_id/activate",
|
|
post(routes::events::post_activate_event),
|
|
)
|
|
.route(
|
|
"/events/:event_id/deactivate",
|
|
post(routes::events::post_deactivate_event),
|
|
)
|
|
// Layers run outermost-first (last added = outermost).
|
|
// CORS → body limit → concurrency limit → request ID → trace
|
|
.layer(PropagateRequestIdLayer::x_request_id())
|
|
.layer(TraceLayer::new_for_http())
|
|
.layer(SetRequestIdLayer::x_request_id(MakeRequestUuid))
|
|
.layer(middleware::from_fn(limit_concurrency))
|
|
.layer(DefaultBodyLimit::max(256 * 1024))
|
|
.layer(CorsLayer::permissive())
|
|
.with_state(state);
|
|
|
|
Ok(router)
|
|
}
|