watch.rs
watch.rs
//! watch 域:anime/films/tv/stats 公開讀、watch_favorites CRUD(TMDb 在地化)、
//! now-watching(由動畫瘋擴充的 heartbeat 推進來)。
//!
//! Trakt 相關的一切(token 輪替、即時輪詢、歷史同步 worker)已於 2026-08 移除——
//! Trakt 刪掉了免費帳號的 API app(見 handlers/simkl.rs 檔頭),那些程式從此
//! 不可能成功。留著的代價不只是死碼:`/api/watch/now` 每 25 秒仍會為此付一次
//! 連線成本(實測正式站首發 513ms,移除後 1–2ms)。
//! 觀看紀錄的來源現在是 handlers/simkl.rs。DB 裡 source='trakt' 的歷史列保留不動。
//! ⚠️ bahamut sync **留在 Express**;`/admin/bahamut/*` 留 proxy(anigamer 硬骨頭輪)。
use axum::{
Json,
extract::{Path, Query, State},
http::{HeaderMap, StatusCode},
response::{IntoResponse, Response},
};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};
use sqlx::FromRow;
use crate::handlers::admin::bind_num;
use crate::state::AppState;
use crate::util::{
bind_val, js_interp, js_normalize_numbers, js_substring_prefix, js_truthy, now_ms, row_to_json,
};
// ── 公開讀端點的 typed 回應(欄位序 = SELECT 序,對齊舊 row_to_json)─────────────
/// `GET /api/anime/history` 一列。
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct AnimeRow {
#[specta(type = specta_typescript::Number)]
pub anime_sn: i64,
#[specta(type = specta_typescript::Number)]
pub video_sn: i64,
pub title: Option<String>,
pub cover_url: Option<String>,
pub episode: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
pub last_watched_at: Option<String>,
}
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct AnimeHistoryResponse {
pub message: String,
pub history: Vec<AnimeRow>,
}
/// `GET /api/films/recent` 一列。
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct FilmRow {
#[specta(type = specta_typescript::Number)]
pub id: i64,
pub title: String,
pub watched_date: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub rating: Option<i64>,
pub source: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
pub poster_url: Option<String>,
// DB 沒這欄(sqlx default);films_recent 補圖時順便帶 TMDb 橫式劇照,給「最近看完」hero 用。
#[sqlx(default)]
pub backdrop_url: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub release_year: Option<i64>,
pub genres: Option<String>,
}
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct FilmsResponse {
pub message: String,
pub films: Vec<FilmRow>,
}
/// `GET /api/tv/recent` 一列(GROUP BY series_name 聚合)。
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct TvRow {
pub series_name: String,
pub last_watched: Option<String>,
#[specta(type = specta_typescript::Number)]
pub ep_count: i64,
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
pub poster_url: Option<String>,
pub genres: Option<String>,
pub source: Option<String>,
}
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct TvResponse {
pub message: String,
pub series: Vec<TvRow>,
}
/// `GET /api/watch/stats` —— 5 個 count(key 為 camelCase)。
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct WatchStatsResponse {
pub message: String,
#[serde(rename = "animeCount")]
#[specta(type = specta_typescript::Number)]
pub anime_count: i64,
#[serde(rename = "animeEpisodes")]
#[specta(type = specta_typescript::Number)]
pub anime_episodes: i64,
#[serde(rename = "filmCount")]
#[specta(type = specta_typescript::Number)]
pub film_count: i64,
#[serde(rename = "tvSeriesCount")]
#[specta(type = specta_typescript::Number)]
pub tv_series_count: i64,
#[serde(rename = "tvEpisodes")]
#[specta(type = specta_typescript::Number)]
pub tv_episodes: i64,
}
/// `GET /api/watch/now` 的 `watching`。原本是 in-memory 的 serde_json::Value,
/// specta 生不出型別,前端只好手寫一份 LiveNow。
///
/// 兩個寫入點(動畫瘋擴充的 heartbeat、Trakt 輪詢)欄位集合本來就一致,
/// 各欄位的正規型別也是確定的,不是猜的:
/// episode —— 擴充送的是 `ep ? ep[1] : null`(regex 捕獲組,必為字串);
/// anime_history.episode 是 TEXT(anigamer SDK 已正規化成 Option<String>);
/// Trakt 那條是 format!("S{:02}E{:02}")。三個來源都是字串。
/// tmdbId —— anime_history.tmdb_id 是 INTEGER;Trakt 的 /ids/tmdb 是數字。
/// progressPct —— 兩條路徑都先 round 成整數才存。
///
/// ⚠ expiresAt 不在這裡:那是伺服器記帳(TTL),不是 API 資料。
/// 舊寫法把它塞進同一個 JSON、serve 時再 remove("expiresAt"),靠「記得移除」維持正確;
/// 現在改由 WatchState 以 (NowWatching, expires_at_ms) 分開存,型別上就不可能洩漏。
#[derive(Debug, Clone, Serialize, specta::Type, utoipa::ToSchema)]
pub struct NowWatching {
/// 目前只會是 "anime"——唯一的產生者是 bahamut 的 heartbeat。
/// 舊資料裡還有 "movie" / "tv"(Trakt 時期),型別因此保持字串不收窄。
#[serde(rename = "type")]
pub kind: String,
pub title: String,
pub cover: Option<String>,
#[serde(rename = "tmdbId")]
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
pub episode: Option<String>,
#[serde(rename = "progressPct")]
#[specta(type = Option<specta_typescript::Number>)]
pub progress_pct: Option<i64>,
/// 目前只會是 "bahamut"(Trakt 輪詢已移除)。歷史列仍可能是 "trakt"。
pub source: String,
#[serde(rename = "externalUrl")]
pub external_url: Option<String>,
/// epoch ms;與 endsAt 一起給前端做 client 端進度插值
#[serde(rename = "startedAt")]
#[specta(type = specta_typescript::Number)]
pub started_at: i64,
/// bahamut 的 heartbeat 給不出結束時間,所以目前恆為 None(Trakt 那條已移除)
#[serde(rename = "endsAt")]
#[specta(type = Option<specta_typescript::Number>)]
pub ends_at: Option<i64>,
}
/// `GET /api/watch/now`
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct WatchNowResponse {
pub watching: Option<NowWatching>,
}
/// `GET /api/watch/favorites` 的一列:DB 的 watch_favorites + TMDb 即時在地化。
/// year 兩個來源都是整數(TMDb 那條走 js_parse_int_opt、DB 欄位是 INTEGER),
/// 所以不是前端手寫版本猜的 string | number。
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct WatchFavoriteRow {
#[specta(type = specta_typescript::Number)]
pub id: i64,
/// "film" | "tv"
pub kind: String,
#[serde(rename = "tmdbId")]
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
#[specta(type = Option<specta_typescript::Number>)]
pub rating: Option<i64>,
pub quote: Option<String>,
/// TMDb 在地化標題;查不到時退成 `#<tmdbId>`,所以一定有值
pub title: String,
pub poster: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub year: Option<i64>,
#[serde(rename = "externalUrl")]
pub external_url: String,
}
/// `GET /api/watch/favorites`
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct WatchFavoritesResponse {
pub message: String,
pub favorites: Vec<WatchFavoriteRow>,
}
// ── 公開讀 ────────────────────────────────────────────────────────────────
#[derive(Debug, Deserialize)]
pub struct LimitQuery {
limit: Option<String>,
}
/// `parseInt(limit||default)` 後 `Math.min(cap)`。
///
/// 解不出數字時回 **-1**(SQLite:LIMIT 為負=沒有上限),不是 NULL。
/// 原本綁的是 `Option::<i64>::None`,註解寫「LIMIT NULL=無限制」——那是錯的:
/// SQLite 對 `LIMIT NULL` 直接回 `(code: 20) datatype mismatch`,於是
/// `GET /api/films/recent?limit=abc` 這種**公開、免認證**的請求就是 500。
/// 三支 watch 端點都中。(schemathesis 從 spec 自動生輸入時撞出來的)
fn js_limit(q: &LimitQuery, default: &str, cap: i64) -> i64 {
let raw = q.limit.as_deref().filter(|s| !s.is_empty()).unwrap_or(default);
crate::util::js_parse_int_opt(raw).map_or(-1, |n| n.min(cap))
}
/// `GET /api/anime/history`
#[utoipa::path(
get, path = "/api/anime/history", tag = "watch",
params(("limit" = Option<String>, Query, description = "筆數上限")),
responses((status = 200, body = AnimeHistoryResponse)),
)]
pub async fn anime_history(State(state): State<AppState>, Query(q): Query<LimitQuery>) -> Response {
let mut query = sqlx::query_as::<_, AnimeRow>(
// 後台收藏頁設成不公開的整部拿掉(collection_hidden,見 handlers/collection)
"SELECT anime_sn, video_sn, title, cover_url, episode, tmdb_id, last_watched_at \
FROM anime_history \
WHERE CAST(anime_sn AS TEXT) NOT IN (SELECT key FROM collection_hidden WHERE kind = 'anime') \
ORDER BY last_watched_at DESC LIMIT ?",
);
query = query.bind(js_limit(&q, "50", 2000));
match query.fetch_all(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(history) => Json(AnimeHistoryResponse { message: "success".into(), history }).into_response(),
}
}
/// `GET /api/films/recent`
#[utoipa::path(
get, path = "/api/films/recent", tag = "watch",
params(("limit" = Option<String>, Query, description = "筆數上限")),
responses((status = 200, body = FilmsResponse)),
)]
pub async fn films_recent(State(state): State<AppState>, Query(q): Query<LimitQuery>) -> Response {
let mut query = sqlx::query_as::<_, FilmRow>(
"SELECT id, title, watched_date, rating, source, tmdb_id, poster_url, release_year, genres \
FROM film_history \
WHERE CAST(id AS TEXT) NOT IN (SELECT key FROM collection_hidden WHERE kind = 'film') \
ORDER BY watched_date DESC NULLS LAST, id DESC LIMIT ?",
);
query = query.bind(js_limit(&q, "50", 200));
match query.fetch_all(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(mut films) => {
// Trakt 同步進來的 film 沒存 poster_url(sync 只寫 title/date/tmdb_id)→ 用 tmdb_id
// 從 TMDb 補海報(w342 小卡夠;tmdb_detail 有快取,只有缺圖的才打)。
for f in &mut films {
if f.poster_url.as_deref().unwrap_or("").is_empty()
&& let Some(id) = f.tmdb_id
&& let Some(dd) = tmdb_detail(&state, "movie", &Value::from(id), "zh-TW").await
{
let get = |k: &str| dd.get(k).and_then(|v| v.as_str().map(String::from));
f.poster_url = get("poster_url"); // w342 給小卡
f.backdrop_url = get("backdrop_url"); // 橫式原圖給「最近看完」hero
}
}
Json(FilmsResponse { message: "success".into(), films }).into_response()
}
}
}
/// `GET /api/tv/recent`
#[utoipa::path(
get, path = "/api/tv/recent", tag = "watch",
params(("limit" = Option<String>, Query, description = "筆數上限")),
responses((status = 200, body = TvResponse)),
)]
pub async fn tv_recent(State(state): State<AppState>, Query(q): Query<LimitQuery>) -> Response {
let mut query = sqlx::query_as::<_, TvRow>(
"SELECT series_name, MAX(watched_date) AS last_watched, COUNT(*) AS ep_count, \
MAX(tmdb_id) AS tmdb_id, MAX(poster_url) AS poster_url, MAX(genres) AS genres, MAX(source) AS source \
FROM tv_history \
WHERE series_name NOT IN (SELECT key FROM collection_hidden WHERE kind = 'tv') \
GROUP BY series_name ORDER BY last_watched DESC NULLS LAST LIMIT ?",
);
query = query.bind(js_limit(&q, "50", 200));
match query.fetch_all(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(mut series) => {
// Simkl 同步進來的影集帶 tmdb_id、不存海報(同 films_recent 的電影)
for s in &mut series {
if s.poster_url.as_deref().unwrap_or("").is_empty()
&& let Some(id) = s.tmdb_id
{
s.poster_url = tmdb_poster(&state, "tv", id).await;
}
}
Json(TvResponse { message: "success".into(), series }).into_response()
}
}
}
/// `GET /api/watch/stats` —— 5 個 count(單一 count 失敗 → 0,照抄)。
#[utoipa::path(get, path = "/api/watch/stats", tag = "watch", responses((status = 200, body = WatchStatsResponse)))]
pub async fn watch_stats(State(state): State<AppState>) -> Response {
let count = |sql: &'static str| {
let pool = state.pool.clone();
async move { sqlx::query_scalar::<_, i64>(sql).fetch_one(&pool).await.unwrap_or(0) }
};
// 不公開的不算:不然前台寫「看了 12 部」卻只列得出 11 部
let (anime_count, anime_episodes, film_count, tv_series_count, tv_episodes) = tokio::join!(
count(
"SELECT COUNT(DISTINCT anime_sn) AS n FROM anime_history \
WHERE CAST(anime_sn AS TEXT) NOT IN (SELECT key FROM collection_hidden WHERE kind = 'anime')"
),
count(
"SELECT COUNT(*) AS n FROM anime_history \
WHERE CAST(anime_sn AS TEXT) NOT IN (SELECT key FROM collection_hidden WHERE kind = 'anime')"
),
count(
"SELECT COUNT(*) AS n FROM film_history \
WHERE CAST(id AS TEXT) NOT IN (SELECT key FROM collection_hidden WHERE kind = 'film')"
),
count(
"SELECT COUNT(DISTINCT series_name) AS n FROM tv_history \
WHERE series_name NOT IN (SELECT key FROM collection_hidden WHERE kind = 'tv')"
),
count(
"SELECT COUNT(*) AS n FROM tv_history \
WHERE series_name NOT IN (SELECT key FROM collection_hidden WHERE kind = 'tv')"
)
);
Json(WatchStatsResponse {
message: "success".into(),
anime_count,
anime_episodes,
film_count,
tv_series_count,
tv_episodes,
})
.into_response()
}
// ── TMDb detail(含 in-process 快取,無 TTL=同 Express)────────────────────
fn tmdb_lang(locale: &str) -> Option<&'static str> {
match locale {
"zh-TW" => Some("zh-TW"),
"zh-CN" => Some("zh-CN"),
"en" => Some("en-US"),
"ja" => Some("ja-JP"),
"ko" => Some("ko-KR"),
_ => None,
}
}
async fn tmdb_detail(state: &AppState, kind: &str, id: &Value, locale: &str) -> Option<Value> {
let lang = tmdb_lang(locale).unwrap_or("zh-TW");
let id_s = js_interp(id);
let key = format!("{kind}:{id_s}:{lang}");
if let Some(v) = state.watch.tmdb_detail.lock().get(&key) {
return Some(v.clone());
}
let token = crate::util::tmdb_token()?;
let path = if kind == "tv" { "tv" } else { "movie" };
let mut j =
crate::util::tmdb_get_json(&state.http, &token, &format!("/3/{path}/{id_s}?language={lang}")).await?;
js_normalize_numbers(&mut j);
let title = j
.get("title")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.or_else(|| j.get("name").and_then(|v| v.as_str()).filter(|s| !s.is_empty()))
.unwrap_or("");
let poster = j
.get("poster_path")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map_or(Value::Null, |p| Value::from(format!("https://image.tmdb.org/t/p/w342{p}")));
// backdrop = 橫式劇照(給「正在看」橫幅 hero 用;poster 是直式、放橫幅會被切到剩中間)。
let backdrop = j
.get("backdrop_path")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map_or(Value::Null, |p| Value::from(format!("https://image.tmdb.org/t/p/original{p}")));
let date = j
.get("release_date")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.or_else(|| j.get("first_air_date").and_then(|v| v.as_str()).filter(|s| !s.is_empty()))
.unwrap_or("");
let year = crate::util::js_parse_int_opt(&date.chars().take(4).collect::<String>())
.filter(|&y| y != 0)
.map_or(Value::Null, Value::from);
// runtime(分鐘)曾經算在這裡,唯一的讀者是 Trakt 那條「用 duration 推 endsAt」的路徑。
// Trakt 移除後就沒有人讀它了——`cargo mutants` 是這樣抓到的:把 `r > 0` 改成 `r >= 0`、
// `r < 0`、`r == 0` 測試全綠,因為那個值根本不會被任何斷言看到。一併刪掉。
let out = json!({ "title": title, "poster_url": poster, "backdrop_url": backdrop, "year": year });
state.watch.tmdb_detail.lock().insert(key, out.clone());
Some(out)
}
/// 用 tmdb_id 從 TMDb 補直式海報(w342)。Simkl/Trakt 同步進來、帶 tmdb_id 的列刻意不存海報
/// (見 simkl.rs 的 `poster_for`),讀的時候才補;`kind` 是 "movie" 或 "tv"。
pub(crate) async fn tmdb_poster(state: &AppState, kind: &str, tmdb_id: i64) -> Option<String> {
tmdb_detail(state, kind, &Value::from(tmdb_id), "zh-TW")
.await?
.get("poster_url")
.and_then(|v| v.as_str().map(String::from))
}
// ── watch_favorites ──────────────────────────────────────────────────────
#[derive(Debug, Deserialize)]
pub struct FavQuery {
locale: Option<String>,
}
/// `GET /api/watch/favorites?locale=` —— 公開;TMDb 即時在地化、失敗退 DB 快照;Cache-Control: no-store。
#[utoipa::path(get, path = "/api/watch/favorites", tag = "watch",
responses((status = 200, description = "收藏影視清單(TMDb 在地化,動態 JSON)")))]
pub async fn favorites(State(state): State<AppState>, Query(q): Query<FavQuery>) -> Response {
let locale = q.locale.as_deref().filter(|l| tmdb_lang(l).is_some()).unwrap_or("zh-TW").to_string();
let rows = match sqlx::query("SELECT * FROM watch_favorites ORDER BY sort_order ASC, id ASC")
.fetch_all(&state.pool)
.await
{
Ok(r) => r,
Err(e) => return crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
};
let mut out = Vec::new();
for row in &rows {
let f = row_to_json(row);
let kind = f.get("kind").and_then(|v| v.as_str()).unwrap_or("film").to_string();
let tmdb_id = f.get("tmdb_id").cloned().unwrap_or(Value::Null);
let d = tmdb_detail(&state, &kind, &tmdb_id, &locale).await;
let title = d
.as_ref()
.and_then(|x| x.get("title"))
.filter(|v| js_truthy(Some(v)))
.cloned()
.unwrap_or_else(|| Value::from(format!("#{}", js_interp(&tmdb_id))));
let poster = d
.as_ref()
.and_then(|x| x.get("poster_url"))
.filter(|v| js_truthy(Some(v)))
.cloned()
.or_else(|| f.get("poster_url").filter(|v| js_truthy(Some(v))).cloned())
.unwrap_or(Value::Null);
let year = d
.as_ref()
.and_then(|x| x.get("year"))
.filter(|v| js_truthy(Some(v)))
.cloned()
.or_else(|| f.get("year").filter(|v| js_truthy(Some(v))).cloned())
.unwrap_or(Value::Null);
let ext = format!(
"https://www.themoviedb.org/{}/{}",
if kind == "tv" { "tv" } else { "movie" },
js_interp(&tmdb_id)
);
out.push(WatchFavoriteRow {
id: f.get("id").and_then(serde_json::Value::as_i64).unwrap_or(0),
kind,
tmdb_id: tmdb_id.as_i64(),
rating: f.get("rating").and_then(serde_json::Value::as_i64),
quote: f.get("quote").and_then(|v| v.as_str()).map(str::to_owned),
title: js_interp(&title),
poster: poster.as_str().map(str::to_owned),
year: year.as_i64(),
external_url: ext,
});
}
let mut resp = Json(WatchFavoritesResponse { message: "success".into(), favorites: out }).into_response();
resp.headers_mut().insert("Cache-Control", axum::http::HeaderValue::from_static("no-store"));
resp
}
#[derive(Debug, Deserialize)]
pub struct TmdbSearchQuery {
q: Option<String>,
kind: Option<String>,
}
/// `GET /api/watch/tmdb-search` 的一列。TMDb 的搜尋回應在這裡重新塑形成前端真正要的
/// 五個欄位(同 spotify 的做法),不是原樣轉發——所以型別就是我們自己的,不是 TMDb 的。
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct TmdbSearchResult {
#[serde(rename = "tmdbId")]
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
/// 回填請求的 kind("movie" | "tv");TMDb 的 search 端點自己不回這欄
pub kind: &'static str,
/// movie 走 `title`、tv 走 `name`,兩個都沒有才 null
pub title: Option<String>,
/// release_date / first_air_date 的前 4 碼
#[specta(type = Option<specta_typescript::Number>)]
pub year: Option<i64>,
pub poster: Option<String>,
}
/// `GET /api/watch/tmdb-search`
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct TmdbSearchResponse {
pub message: &'static str,
pub results: Vec<TmdbSearchResult>,
}
/// `GET /api/watch/tmdb-search`(requireAdmin)。
#[utoipa::path(get, path = "/api/watch/tmdb-search", tag = "watch", security(("bearer" = [])),
responses((status = 200, body = TmdbSearchResponse), (status = 401, description = "未授權")))]
pub async fn tmdb_search(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
Query(qq): Query<TmdbSearchQuery>,
) -> Response {
let q = qq.q.unwrap_or_default().trim().to_string();
let kind = if qq.kind.as_deref() == Some("tv") { "tv" } else { "movie" };
if q.is_empty() {
return Json(TmdbSearchResponse { message: "success", results: vec![] }).into_response();
}
let Some(token) = crate::util::tmdb_token() else {
return (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "error": "TMDB_API_TOKEN 未設定" })))
.into_response();
};
let r: Result<Value, String> = async {
let path = format!(
"/3/search/{kind}?query={}&language=zh-TW&include_adult=false",
crate::util::encode_uri_component(&q)
);
let resp =
crate::util::tmdb_request(&state.http, &token, &path).send().await.map_err(|e| e.to_string())?;
// 不看狀態碼、直接 parse:TMDb 的錯誤 body 沒有 results,結果就是空清單。
// 不用 `resp.json()`:它把讀 body 與 parse 的錯誤併成同一句 "error decoding
// response body",而這裡的錯誤訊息會原樣回給前端。
let mut v: Value = serde_json::from_str(&resp.text().await.map_err(|e| e.to_string())?)
.map_err(|e| e.to_string())?;
js_normalize_numbers(&mut v);
Ok(v)
}
.await;
match r {
Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, Json(json!({ "error": e }))).into_response(),
Ok(j) => {
let results: Vec<TmdbSearchResult> = j
.get("results")
.and_then(|r| r.as_array())
.map(|a| {
a.iter()
.take(8)
.map(|it| {
let title = it
.get("title")
.filter(|v| js_truthy(Some(v)))
.or_else(|| it.get("name"))
.and_then(|v| v.as_str())
.map(String::from);
let date = it
.get("release_date")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.or_else(|| {
it.get("first_air_date")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
})
.unwrap_or("");
let year =
crate::util::js_parse_int_opt(&date.chars().take(4).collect::<String>())
.filter(|&y| y != 0);
let poster = it
.get("poster_path")
.and_then(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(|p| format!("https://image.tmdb.org/t/p/w185{p}"));
TmdbSearchResult {
tmdb_id: it.get("id").and_then(serde_json::Value::as_i64),
kind,
title,
year,
poster,
}
})
.collect()
})
.unwrap_or_default();
Json(TmdbSearchResponse { message: "success", results }).into_response()
}
}
}
/// JS ToNumber + Math.max(1, Math.min(5, x))(NaN 傳染 → 綁 NULL)。
fn clamp_rating(v: &Value) -> Option<f64> {
let n = match v {
Value::Null => 0.0,
Value::Bool(b) => {
if *b {
1.0
} else {
0.0
}
}
Value::Number(x) => x.as_f64().unwrap_or(f64::NAN),
Value::String(s) => {
let t = s.trim();
if t.is_empty() { 0.0 } else { t.parse::<f64>().unwrap_or(f64::NAN) }
}
_ => f64::NAN,
};
if n.is_nan() { None } else { Some(n.clamp(1.0, 5.0)) }
}
/// `POST /api/watch/favorites`(requireAdmin)。
#[utoipa::path(post, path = "/api/watch/favorites", tag = "watch", security(("bearer" = [])),
responses((status = 200, description = "新增收藏(動態 JSON)"), (status = 401, description = "未授權")))]
pub async fn create_favorite(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
crate::error::JsonBody(b): crate::error::JsonBody<Map<String, Value>>,
) -> Response {
if !js_truthy(b.get("tmdbId")) {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "tmdbId 必填" }))).into_response();
}
let tmdb_id = b.get("tmdbId").cloned().unwrap_or(Value::Null);
let kind = if b.get("kind").and_then(|v| v.as_str()) == Some("tv") { "tv" } else { "film" };
let rating_v =
if b.contains_key("rating") { b.get("rating").cloned().unwrap_or(Value::Null) } else { json!(5) };
let quote_v =
if b.contains_key("quote") { b.get("quote").cloned().unwrap_or(Value::Null) } else { json!("") };
let d = tmdb_detail(&state, kind, &tmdb_id, "zh-TW").await;
let max_order = sqlx::query_scalar::<_, Option<i64>>("SELECT MAX(sort_order) AS m FROM watch_favorites")
.fetch_one(&state.pool)
.await
.ok()
.flatten();
let order = max_order.unwrap_or(-1) + 1;
let mut q = sqlx::query(
"INSERT INTO watch_favorites (tmdb_id, kind, rating, quote, poster_url, year, sort_order) VALUES (?,?,?,?,?,?,?)",
);
q = bind_val(q, Some(&tmdb_id));
q = q.bind(kind);
q = bind_num(q, clamp_rating(&rating_v));
q = q.bind(js_substring_prefix(&js_interp("e_v), 280));
q = bind_val(q, d.as_ref().and_then(|x| x.get("poster_url")).filter(|v| js_truthy(Some(v))));
q = bind_val(q, d.as_ref().and_then(|x| x.get("year")).filter(|v| js_truthy(Some(v))));
q = q.bind(order);
match q.execute(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(r) => Json(json!({ "message": "success", "id": r.last_insert_rowid() })).into_response(),
}
}
/// `PUT /api/watch/favorites/:id`(requireAdmin)—— rating/quote/sort_order 選擇性更新;無 404。
#[utoipa::path(put, path = "/api/watch/favorites/{id}", tag = "watch", security(("bearer" = [])),
params(("id" = String, Path)),
responses((status = 200, description = "更新收藏(動態 JSON)"), (status = 401, description = "未授權")))]
pub async fn update_favorite(
State(state): State<AppState>,
Path(id): Path<String>,
_auth: crate::auth::AdminAuth,
crate::error::JsonBody(b): crate::error::JsonBody<Map<String, Value>>,
) -> Response {
// `x != null`:排除 null 與缺 key
let has = |k: &str| b.get(k).is_some_and(|v| !v.is_null());
let mut sets: Vec<&str> = Vec::new();
if has("rating") {
sets.push("rating = ?");
}
if has("quote") {
sets.push("quote = ?");
}
if has("sort_order") {
sets.push("sort_order = ?");
}
if sets.is_empty() {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "無可更新欄位" }))).into_response();
}
let sql = format!("UPDATE watch_favorites SET {} WHERE id = ?", sets.join(", "));
let mut q = sqlx::query(sqlx::AssertSqlSafe(sql.as_str()));
if has("rating") {
q = bind_num(q, clamp_rating(b.get("rating").unwrap_or(&Value::Null)));
}
if has("quote") {
q = q.bind(js_substring_prefix(&js_interp(b.get("quote").unwrap_or(&Value::Null)), 280));
}
if has("sort_order") {
q = bind_val(q, b.get("sort_order"));
}
q = q.bind(&id);
match q.execute(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(_) => Json(json!({ "message": "success" })).into_response(),
}
}
/// `DELETE /api/watch/favorites/:id`(requireAdmin)—— 無 404。
#[utoipa::path(delete, path = "/api/watch/favorites/{id}", tag = "watch", security(("bearer" = [])),
params(("id" = String, Path)),
responses((status = 200, description = "刪除收藏(動態 JSON)"), (status = 401, description = "未授權")))]
pub async fn delete_favorite(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
Path(id): Path<String>,
) -> Response {
match sqlx::query("DELETE FROM watch_favorites WHERE id = ?").bind(&id).execute(&state.pool).await {
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
Ok(_) => Json(json!({ "message": "success" })).into_response(),
}
}
// ── now-watching(唯一來源=bahamut heartbeat push)────────────────────────
const NOW_WATCHING_TTL_MS: i64 = 90 * 1000;
/// bahamutPushAuth:X-Bahamut-Token(constant-time)或 admin JWT。
///
/// ⚠️ `Err` 裝 `Box<Response>`,理由同 `handlers/bahamut.rs` 的 `push_auth`:
/// rust 1.98 起 clippy 的 `result_large_err` 會咬 128 bytes 的 `axum::Response`。
async fn bahamut_push_auth(headers: &HeaderMap, state: &AppState) -> Result<(), Box<Response>> {
if let Ok(token) = std::env::var("BAHAMUT_PUSH_TOKEN")
&& !token.is_empty()
{
let got = headers.get("X-Bahamut-Token").and_then(|v| v.to_str().ok()).unwrap_or("");
if crate::util::timing_safe_eq(got.as_bytes(), token.as_bytes()) {
return Ok(());
}
}
crate::auth::require_admin(headers, state).await.map(|_| ()).map_err(|e| Box::new(e.into_response()))
}
/// TTL 的邊界判定,抽出來只為了讓它可測:夾在 `now_ms()` 裡面的話,`<` 與 `<=` 的差別
/// 是「剛好那一毫秒」,任何測試都碰不到,於是這個比較符號可以隨便改而沒有人會知道。
/// 語意是半開區間 `[started, expires)`——`expires_at` 當下那一刻已經算過期。
const fn is_live(now: i64, expires_at: i64) -> bool {
now < expires_at
}
fn current_now_watching(state: &AppState) -> Option<NowWatching> {
let g = state.watch.now.lock();
g.as_ref().filter(|(_, expires_at)| is_live(now_ms(), *expires_at)).map(|(w, _)| w.clone())
}
fn tmdb_url_for(kind: &str, id: &Value) -> Value {
if !js_truthy(Some(id)) {
return Value::Null;
}
Value::from(format!(
"https://www.themoviedb.org/{}/{}",
if kind == "movie" { "movie" } else { "tv" },
js_interp(id)
))
}
/// `POST /api/admin/watch/now`(bahamutPushAuth)—— 動畫瘋擴充 heartbeat。
#[utoipa::path(post, path = "/api/admin/watch/now", tag = "admin", security(("bearer" = [])),
responses((status = 200, description = "動畫瘋 heartbeat(動態 JSON)"), (status = 401, description = "未授權")))]
pub async fn heartbeat(
State(state): State<AppState>,
headers: HeaderMap,
crate::error::JsonBody(b): crate::error::JsonBody<Map<String, Value>>,
) -> Response {
if let Err(resp) = bahamut_push_auth(&headers, &state).await {
return *resp;
}
// playing === false(嚴格 boolean)→ 只清 bahamut 那條
if b.get("playing") == Some(&Value::Bool(false)) {
{
let mut g = state.watch.now.lock();
if g.as_ref().is_some_and(|(w, _)| w.source == "bahamut") {
*g = None;
}
}
return Json(json!({ "ok": true, "cleared": true })).into_response();
}
let mut title = b.get("title").filter(|v| js_truthy(Some(v))).cloned();
let mut cover: Value = Value::Null;
let mut tmdb_id: Value = Value::Null;
let mut episode = b.get("episode").filter(|v| js_truthy(Some(v))).cloned();
let video_sn = b.get("videoSn").filter(|v| js_truthy(Some(v))).cloned();
if let Some(sn) = &video_sn {
let row = {
let mut q = sqlx::query(
"SELECT anime_sn, title, cover_url, tmdb_id, episode FROM anime_history WHERE video_sn = ? LIMIT 1",
);
q = bind_val(q, Some(sn));
q.fetch_optional(&state.pool).await.ok().flatten()
};
if let Some(r) = row {
let m = row_to_json(&r);
if let Some(t) = m.get("title").filter(|v| js_truthy(Some(v))) {
title = Some(t.clone());
}
cover = m.get("cover_url").filter(|v| js_truthy(Some(v))).cloned().unwrap_or(Value::Null);
tmdb_id = m.get("tmdb_id").filter(|v| js_truthy(Some(v))).cloned().unwrap_or(Value::Null);
if episode.is_none() {
episode = m.get("episode").filter(|v| js_truthy(Some(v))).cloned();
}
}
}
let Some(title) = title else {
return (
StatusCode::BAD_REQUEST,
Json(json!({ "ok": false, "message": "need title or known videoSn" })),
)
.into_response();
};
let now = now_ms();
let progress = b
.get("progressPct")
.and_then(serde_json::Value::as_f64)
// clamp 到 0..=100 之後再 round,值域是 0..=100,i64 裝得下
.map_or(Value::Null, |p| {
#[allow(clippy::cast_possible_truncation, reason = "前面已 clamp 到 0..=100")]
Value::from(p.clamp(0.0, 100.0).round() as i64)
});
let external = if tmdb_url_for("tv", &tmdb_id) != Value::Null {
tmdb_url_for("tv", &tmdb_id)
} else if let Some(sn) = &video_sn {
Value::from(format!("https://ani.gamer.com.tw/animeVideo.php?sn={}", js_interp(sn)))
} else {
Value::Null
};
let title_s = js_interp(&title);
// 同一部持續播放 → 保留 startedAt
let started = {
let g = state.watch.now.lock();
match g.as_ref() {
Some((w, _)) if w.source == "bahamut" && w.title == title_s => w.started_at,
_ => now,
}
};
let entry = NowWatching {
kind: "anime".into(),
title: title_s,
cover: cover.as_str().map(str::to_owned),
tmdb_id: tmdb_id.as_i64(),
// 擴充送的 episode 必為字串(regex 捕獲組),anime_history.episode 是 TEXT;
// 用 js_interp 保險:若哪天有數字進來也折成字串,型別不會分岔。
episode: episode.filter(|v| js_truthy(Some(v))).map(|v| js_interp(&v)),
progress_pct: progress.as_i64(),
source: "bahamut".into(),
external_url: external.as_str().map(str::to_owned),
started_at: started,
ends_at: None,
};
*state.watch.now.lock() = Some((entry, now + NOW_WATCHING_TTL_MS));
Json(json!({ "ok": true })).into_response()
}
/// `GET /api/watch/now` —— 公開,純讀 state(由 bahamut 的 heartbeat 推進來)。
///
/// 這支原本還會「按需 + 節流輪詢 Trakt」。Trakt 在 2026-07-30 刪掉了免費帳號的
/// app(見 simkl.rs 檔頭),那支呼叫從此必定失敗——但它仍然掛在這條公開路徑上,
/// 每 25 秒就讓一位訪客付一次連線成本。實測正式站:
///
/// /api/watch/now 513, 2, 1, 1, 2, 1 ms ← 第一次是那支死呼叫
/// /api/watch/stats 2, 1, 1, 1 ms ← 同樣是公開讀,沒有上游
///
/// 整段移除之後這裡只剩讀記憶體。
#[utoipa::path(get, path = "/api/watch/now", tag = "watch",
responses((status = 200, description = "目前正在看(動態 JSON)")))]
pub async fn watch_now(State(state): State<AppState>) -> Response {
// 不再需要 remove("expiresAt"):過期時間存在 state 的另一半,本來就不在這個型別裡。
Json(WatchNowResponse { watching: current_now_watching(&state) }).into_response()
}
#[cfg(test)]
mod tests {
use super::*;
fn lq(v: Option<&str>) -> LimitQuery {
LimitQuery { limit: v.map(str::to_owned) }
}
#[test]
fn js_limit_無值或空字串都走預設() {
assert_eq!(js_limit(&lq(None), "50", 200), 50);
// 空字串在 JS 是 `limit || default` 的 falsy 側,不是「parseInt('') → NaN」
assert_eq!(js_limit(&lq(Some("")), "50", 200), 50);
}
#[test]
fn js_limit_解不出數字時回負一而不是_null() {
// 這條是回歸測試:綁 NULL 會讓 SQLite 回 `datatype mismatch`,
// 於是 `/api/films/recent?limit=abc` 這種公開免認證請求變成 500。
assert_eq!(js_limit(&lq(Some("abc")), "50", 200), -1);
assert_eq!(js_limit(&lq(Some(" ")), "50", 200), -1);
}
#[test]
fn js_limit_照抄_parse_int_的前綴語意並套上限() {
assert_eq!(js_limit(&lq(Some("12abc")), "50", 200), 12);
assert_eq!(js_limit(&lq(Some("999")), "50", 200), 200, "超過 cap 要被夾");
assert_eq!(js_limit(&lq(Some("199")), "50", 200), 199, "cap 邊界內不動");
assert_eq!(js_limit(&lq(Some("-5")), "50", 200), -5, "負數是 SQLite 的「無上限」,不夾");
}
#[test]
fn tmdb_lang_五個語系各自對應_其餘回_none() {
assert_eq!(tmdb_lang("zh-TW"), Some("zh-TW"));
assert_eq!(tmdb_lang("zh-CN"), Some("zh-CN"));
assert_eq!(tmdb_lang("en"), Some("en-US"));
assert_eq!(tmdb_lang("ja"), Some("ja-JP"));
assert_eq!(tmdb_lang("ko"), Some("ko-KR"));
// None 這一側有意義:favorites 用它判斷 locale 合不合法,回 Some 就會把亂值送去 TMDb
assert_eq!(tmdb_lang("de"), None);
assert_eq!(tmdb_lang("zh"), None);
assert_eq!(tmdb_lang(""), None);
}
#[test]
fn clamp_rating_照抄_js_的_to_number_再夾到一到五() {
assert_eq!(clamp_rating(&json!(3)), Some(3.0));
assert_eq!(clamp_rating(&json!(7)), Some(5.0));
assert_eq!(clamp_rating(&json!(-3)), Some(1.0));
assert_eq!(clamp_rating(&json!(1)), Some(1.0), "下界含本身");
assert_eq!(clamp_rating(&json!(5)), Some(5.0), "上界含本身");
assert_eq!(clamp_rating(&Value::Null), Some(1.0), "Number(null) === 0 → 夾成 1");
assert_eq!(clamp_rating(&json!("3.5")), Some(3.5));
assert_eq!(clamp_rating(&json!(" 4 ")), Some(4.0), "前後空白 JS 會忽略");
assert_eq!(clamp_rating(&json!("")), Some(1.0), "Number('') === 0");
// bool 這條分支容易被當成不可能發生而刪掉,但 JSON body 是使用者送的,
// `{"rating": true}` 完全合法:JS 的 Number(true)===1、Number(false)===0
assert_eq!(clamp_rating(&json!(true)), Some(1.0));
assert_eq!(clamp_rating(&json!(false)), Some(1.0), "0 夾上來也是 1,但不能變成 NULL");
}
#[test]
fn clamp_rating_算不出數字時回_none_以便綁_null() {
// NaN 在 JS 會一路傳染到 SQL 綁值,這裡改成 None → 綁 NULL,不是夾成 1
assert_eq!(clamp_rating(&json!("abc")), None);
assert_eq!(clamp_rating(&json!([1, 2])), None);
assert_eq!(clamp_rating(&json!({"a": 1})), None);
}
#[test]
fn is_live_的邊界是半開區間() {
assert!(is_live(0, 1));
assert!(is_live(89_999, 90_000));
assert!(!is_live(90_000, 90_000), "剛好到期那一刻算過期,不是還活著");
assert!(!is_live(90_001, 90_000));
}
#[test]
fn tmdb_url_for_依_kind_分流_falsy_的_id_回_null() {
assert_eq!(tmdb_url_for("movie", &json!(603)), json!("https://www.themoviedb.org/movie/603"));
assert_eq!(tmdb_url_for("tv", &json!(1396)), json!("https://www.themoviedb.org/tv/1396"));
// 只有 "movie" 走 movie,其餘一律 tv(含空字串這種非預期值)
assert_eq!(tmdb_url_for("anime", &json!(7)), json!("https://www.themoviedb.org/tv/7"));
// js_truthy:0 與 null 都是 falsy → 不要組出 /movie/0 這種連不到的網址
assert_eq!(tmdb_url_for("movie", &Value::Null), Value::Null);
assert_eq!(tmdb_url_for("movie", &json!(0)), Value::Null);
assert_eq!(tmdb_url_for("movie", &json!("")), Value::Null);
}
}