Panel: plugin integrations (LuckPerms ranks + group mapping, reports), server event queue, developer API endpoints

2026-09-30 18:06:18 +00:00
1 parent c256c15d0e
commit badb5fccc0
@@ -0,0 +1,231 @@
+//! Data and actions for in-game plugins: what the SCOPENET Developer API, the
+//! PlaceholderAPI expansion and other plugins read and change for a player.
+
+use crate::error::{AppError, AppResult};
+use crate::routes::economy::{begin_operation, finish_operation};
+use crate::routes::servers::GameServer;
+use crate::state::AppState;
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+use serde_json::{json, Value};
+
+#[derive(Deserialize)]
+pub struct Who {
+    pub uuid: String,
+}
+
+fn dashed_or_err(uuid: &str) -> AppResult<String> {
+    crate::yggdrasil::dashed(uuid).ok_or_else(|| AppError::bad_request("invalid player UUID"))
+}
+
+/// Everything a placeholder or `getPlayer()` needs in one round trip.
+pub async fn player_info(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<Who>) -> AppResult<Json<Value>> {
+    let uuid = dashed_or_err(&p.uuid)?;
+    let user: Option<(String, String, String)> = sqlx::query_as("SELECT username, role, created_at FROM users WHERE uuid = ?").bind(&uuid).fetch_optional(&state.db).await?;
+    let Some((name, role, joined)) = user else {
+        return Ok(Json(json!({ "exists": false, "uuid": uuid })));
+    };
+    let levels = crate::routes::leveling::get_user_levels_by_uuid(&state, &uuid).await?;
+    let here = levels.server_levels.iter().find(|s| s.server_id == server.id);
+    let guild: Option<(String, String, String, String, i64)> = sqlx::query_as(
+        "SELECT g.id, g.name, g.tag, gm.role, (SELECT COUNT(*) FROM guild_claims gc WHERE gc.guild_id = g.id)
+         FROM guild_members gm JOIN guilds g ON g.id = gm.guild_id WHERE gm.uuid = ? AND g.instance_id = ?",
+    )
+    .bind(&uuid)
+    .bind(&server.instance_id)
+    .fetch_optional(&state.db)
+    .await?;
+    let balance = crate::routes::economy::balance_for(&state, server.id, &uuid).await?;
+    let (playtime, kills, deaths): (Option<i64>, Option<i64>, Option<i64>) =
+        sqlx::query_as("SELECT SUM(playtime_secs), SUM(player_kills + mob_kills), SUM(deaths) FROM player_stats WHERE uuid = ?").bind(&uuid).fetch_one(&state.db).await?;
+    let (server_playtime,): (Option<i64>,) = sqlx::query_as("SELECT SUM(playtime_secs) FROM player_stats WHERE uuid = ? AND server_id = ?").bind(&uuid).bind(server.id).fetch_one(&state.db).await?;
+    let friends: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM friendships WHERE status = 'accepted' AND (user_uuid = ?1 OR friend_uuid = ?1)").bind(&uuid).fetch_one(&state.db).await?;
+    let achievements: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM user_achievements WHERE user_uuid = ?").bind(&uuid).fetch_one(&state.db).await?;
+
+    // Quest progress for this period: how many of the player's quests are done.
+    let cfg = crate::progression::load_pool(&state.db).await?;
+    let mut conn = state.db.acquire().await?;
+    let mut quests = serde_json::Map::new();
+    for (period, key) in [("daily", crate::routes::quests::current_daily_key()), ("weekly", crate::routes::quests::current_weekly_key())] {
+        let ids = crate::progression::assigned_quest_ids(&mut conn, &cfg, &uuid, period, &key).await?;
+        let (done, claimed): (i64, i64) = if ids.is_empty() {
+            (0, 0)
+        } else {
+            sqlx::query_as(
+                "SELECT COALESCE(SUM(completed), 0), COALESCE(SUM(claimed), 0) FROM user_quests
+                 WHERE user_uuid = ? AND period_key = ? AND quest_id IN (SELECT value FROM json_each(?))",
+            )
+            .bind(&uuid)
+            .bind(&key)
+            .bind(serde_json::to_string(&ids)?)
+            .fetch_one(&mut *conn)
+            .await?
+        };
+        quests.insert(period.into(), json!({ "total": ids.len(), "completed": done, "claimed": claimed }));
+    }
+    drop(conn); // give the connection back before the pool is used again
+    let rank: Option<(String, String, String)> = sqlx::query_as("SELECT primary_group, display, prefix FROM player_ranks WHERE server_id = ? AND uuid = ?").bind(server.id).bind(&uuid).fetch_optional(&state.db).await?;
+    let online: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM server_online WHERE uuid = ?)").bind(&uuid).fetch_one(&state.db).await?;
+
+    Ok(Json(json!({
+        "exists": true,
+        "uuid": uuid,
+        "name": name,
+        "role": role,
+        "joined": joined,
+        "online": online,
+        "global": { "level": levels.global_level, "xp": levels.global_xp, "next_level_xp": levels.next_level_xp, "current_level_xp": levels.current_level_xp, "progress_pct": levels.progress_pct, "title": levels.title, "rank": levels.rank, "badges": levels.badges },
+        "server": here.map(|s| json!({ "level": s.server_level, "xp": s.server_xp, "next_level_xp": s.next_level_xp, "current_level_xp": s.current_level_xp, "progress_pct": s.progress_pct, "rank_name": s.rank_name }))
+            .unwrap_or(json!({ "level": 1, "xp": 0, "next_level_xp": 0, "current_level_xp": 0, "progress_pct": 0.0, "rank_name": null })),
+        "guild": guild.map(|(id, name, tag, role, claims)| json!({ "id": id, "name": name, "tag": tag, "role": role, "claims": claims })),
+        "balance": balance,
+        "playtime_secs": playtime.unwrap_or(0),
+        "server_playtime_secs": server_playtime.unwrap_or(0),
+        "kills": kills.unwrap_or(0),
+        "deaths": deaths.unwrap_or(0),
+        "friends": friends,
+        "achievements": achievements,
+        "quests": quests,
+        "rank": rank.map(|(primary, display, prefix)| json!({ "group": primary, "display": display, "prefix": prefix })),
+    })))
+}
+
+#[derive(Deserialize)]
+pub struct XpPayload {
+    pub operation_id: String,
+    pub uuid: String,
+    /// `global` or `server` (the calling server).
+    #[serde(default = "global")]
+    pub scope: String,
+    /// Positive grants XP, negative takes it away.
+    pub amount: i64,
+    #[serde(default)]
+    pub reason: String,
+}
+fn global() -> String {
+    "global".into()
+}
+
+/// `addXP()`: grant (or remove) XP on behalf of a plugin. Idempotent on `operation_id`.
+pub async fn add_xp(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<XpPayload>) -> AppResult<Json<Value>> {
+    let uuid = dashed_or_err(&p.uuid)?;
+    if p.amount == 0 || p.amount.abs() > 10_000_000 {
+        return Err(AppError::bad_request("amount must be between -10,000,000 and 10,000,000 and not zero"));
+    }
+    let (mut tx, previous) = begin_operation(&state, server.id, &p.operation_id).await?;
+    if let Some(previous) = previous {
+        return Ok(Json(previous));
+    }
+    let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM users WHERE uuid = ?)").bind(&uuid).fetch_one(&mut *tx).await?;
+    if !exists {
+        return Err(AppError::not_found("player not found"));
+    }
+    let now = chrono::Utc::now().to_rfc3339();
+    let (mode, amount) = if p.amount > 0 { (crate::progression::Mode::Add, p.amount) } else { (crate::progression::Mode::Remove, -p.amount) };
+    let change = match p.scope.as_str() {
+        "global" => crate::progression::adjust_global(&mut tx, &uuid, mode, amount, &now).await?,
+        "server" => crate::progression::adjust_server(&mut tx, server.id, &uuid, mode, amount, &now).await?,
+        _ => return Err(AppError::bad_request("scope must be global or server")),
+    };
+    if change.new_xp > change.old_xp {
+        crate::routes::leveling::grant_rewards(&mut tx, &uuid, &now).await?;
+    }
+    let detail = format!("{} XP {} → {} (level {} → {}) via {}: {}", p.scope, change.old_xp, change.new_xp, change.old_level, change.new_level, server.name, p.reason.chars().filter(|c| !c.is_control()).take(100).collect::<String>());
+    sqlx::query("INSERT INTO server_events (server_id, uuid, name, kind, detail, created_at) VALUES (?, ?, NULL, 'xp', ?, ?)").bind(server.id).bind(&uuid).bind(detail).bind(crate::db::now()).execute(&mut *tx).await?;
+    finish_operation(tx, server.id, &p.operation_id, json!({ "ok": true, "scope": p.scope, "xp": change.new_xp, "level": change.new_level, "previous_level": change.old_level })).await
+}
+
+#[derive(Deserialize)]
+pub struct ObjectivePayload {
+    pub operation_id: String,
+    pub uuid: String,
+    /// A quest id (`q_d_mine_coal`), or an action such as `block_broken:DIAMOND_ORE`.
+    pub objective: String,
+    /// Progress to add. `0` completes the quest outright.
+    #[serde(default)]
+    pub amount: i64,
+}
+
+/// `completeQuestObjective()`: move a player's quest forward from another plugin.
+pub async fn quest_objective(GameServer(server): GameServer, State(state): State<AppState>, Json(p): Json<ObjectivePayload>) -> AppResult<Json<Value>> {
+    let uuid = dashed_or_err(&p.uuid)?;
+    if !(0..=1_000_000).contains(&p.amount) || p.objective.is_empty() || p.objective.len() > 120 {
+        return Err(AppError::bad_request("invalid objective"));
+    }
+    let (mut tx, previous) = begin_operation(&state, server.id, &p.operation_id).await?;
+    if let Some(previous) = previous {
+        return Ok(Json(previous));
+    }
+    let now = crate::db::now();
+    let quest: Option<(String, i64)> = sqlx::query_as("SELECT period, target_count FROM quests WHERE id = ? AND enabled = 1").bind(&p.objective).fetch_optional(&mut *tx).await?;
+    let advanced = if let Some((period, target)) = quest {
+        let cfg = crate::progression::load(&mut tx).await?;
+        let key = if period == "weekly" { crate::routes::quests::current_weekly_key() } else { crate::routes::quests::current_daily_key() };
+        if !crate::progression::is_assigned(&mut tx, &cfg, &uuid, &period, &key, &p.objective).await? {
+            return Err(AppError::bad_request("that quest isn't one of the player's quests this period"));
+        }
+        let add = if p.amount == 0 { target } else { p.amount };
+        sqlx::query(
+            "INSERT INTO user_quests (user_uuid, quest_id, period_key, progress, completed, claimed, updated_at) VALUES (?, ?, ?, ?, ?, 0, ?)
+             ON CONFLICT (user_uuid, quest_id, period_key) DO UPDATE SET progress = progress + excluded.progress,
+                completed = CASE WHEN progress + excluded.progress >= ? THEN 1 ELSE completed END, updated_at = excluded.updated_at",
+        )
+        .bind(&uuid).bind(&p.objective).bind(&key).bind(add).bind(add >= target).bind(&now).bind(target)
+        .execute(&mut *tx)
+        .await?;
+        true
+    } else {
+        // Not a quest id: treat it as an action ("block_broken:STONE") like the plugin's own events.
+        let before: i64 = sqlx::query_scalar("SELECT COALESCE(SUM(progress), 0) FROM user_quests WHERE user_uuid = ?").bind(&uuid).fetch_one(&mut *tx).await?;
+        crate::routes::quests::advance_action_quests(&mut tx, &uuid, &p.objective, p.amount.max(1), &now).await?;
+        let after: i64 = sqlx::query_scalar("SELECT COALESCE(SUM(progress), 0) FROM user_quests WHERE user_uuid = ?").bind(&uuid).fetch_one(&mut *tx).await?;
+        after > before
+    };
+    finish_operation(tx, server.id, &p.operation_id, json!({ "ok": true, "advanced": advanced })).await
+}
+
+/// `getFriends()`: accepted friends with where they are playing.
+pub async fn friends(GameServer(_): GameServer, State(state): State<AppState>, Json(p): Json<Who>) -> AppResult<Json<Value>> {
+    let uuid = dashed_or_err(&p.uuid)?;
+    let rows: Vec<(String, String, bool, Option<String>)> = sqlx::query_as(
+        "SELECT u.uuid, u.username, EXISTS(SELECT 1 FROM server_online so WHERE so.uuid = u.uuid),
+                (SELECT gs.name FROM server_online so JOIN game_servers gs ON gs.id = so.server_id WHERE so.uuid = u.uuid LIMIT 1)
+         FROM friendships f JOIN users u ON u.uuid = (CASE WHEN f.user_uuid = ?1 THEN f.friend_uuid ELSE f.user_uuid END)
+         WHERE f.status = 'accepted' AND (f.user_uuid = ?1 OR f.friend_uuid = ?1) ORDER BY 3 DESC, u.username COLLATE NOCASE LIMIT 500",
+    )
+    .bind(&uuid)
+    .fetch_all(&state.db)
+    .await?;
+    Ok(Json(json!({ "friends": rows.into_iter().map(|(uuid, name, online, playing_on)| json!({ "uuid": uuid, "name": name, "online": online, "playing_on": playing_on })).collect::<Vec<_>>() })))
+}
+
+#[derive(Deserialize)]
+pub struct GuildQuery {
+    /// Look a guild up by id, tag or name — or by one of its members.
+    #[serde(default)]
+    pub guild: String,
+    #[serde(default)]
+    pub member: String,
+}
+
+/// `getGuild()`.
+pub async fn guild(GameServer(server): GameServer, State(state): State<AppState>, Json(q): Json<GuildQuery>) -> AppResult<Json<Value>> {
+    let id: Option<String> = if !q.member.is_empty() {
+        let uuid = dashed_or_err(&q.member)?;
+        sqlx::query_scalar("SELECT g.id FROM guild_members gm JOIN guilds g ON g.id = gm.guild_id WHERE gm.uuid = ? AND g.instance_id = ?").bind(uuid).bind(&server.instance_id).fetch_optional(&state.db).await?
+    } else {
+        sqlx::query_scalar("SELECT id FROM guilds WHERE instance_id = ?2 AND (id = ?1 OR tag = ?1 COLLATE NOCASE OR name = ?1 COLLATE NOCASE)").bind(q.guild.trim()).bind(&server.instance_id).fetch_optional(&state.db).await?
+    };
+    let Some(id) = id else { return Ok(Json(json!({ "exists": false }))) };
+    let (name, tag, desc, leader, created): (String, String, String, String, String) =
+        sqlx::query_as("SELECT name, tag, description, leader_uuid, created_at FROM guilds WHERE id = ?").bind(&id).fetch_one(&state.db).await?;
+    let members: Vec<(String, String, String)> = sqlx::query_as("SELECT uuid, name, role FROM guild_members WHERE guild_id = ? ORDER BY joined_at").bind(&id).fetch_all(&state.db).await?;
+    let claims: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM guild_claims WHERE guild_id = ? AND server_id = ?").bind(&id).bind(server.id).fetch_one(&state.db).await?;
+    let balance: f64 = sqlx::query_scalar("SELECT COALESCE((SELECT balance FROM guild_wallets WHERE guild_id = ? AND server_id = ?), 0)").bind(&id).bind(server.id).fetch_one(&state.db).await?;
+    Ok(Json(json!({
+        "exists": true, "id": id, "name": name, "tag": tag, "description": desc, "leader": leader, "created": created,
+        "claims": claims, "balance": balance,
+        "members": members.into_iter().map(|(uuid, name, role)| json!({ "uuid": uuid, "name": name, "role": role })).collect::<Vec<_>>(),
+    })))
+}