collection.rs
collection.rs
//! 收藏頁的後台(2026-10 後台提案的「收藏」頁):觀看紀錄與聽的歌要不要出現在前台。
//!
//! 這些都是同步進來的(巴哈、Simkl、Spotify),站長沒辦法決定「有沒有看」,只能決定
//! 「這一部/這一首要不要出現在前台」。不公開的記在 `collection_hidden`,公開端點
//! (`/api/anime/history`、`/api/films/recent`、`/api/tv/recent`、`/api/watch/stats`、
//! Spotify 那幾支)讀的時候拿掉。
//!
//! 最愛(`watch_favorites`)沿用 `/api/watch/favorites` 的增改刪,這裡只在每一部後面標出
//! 「是不是已經在最愛裡」。
use std::collections::HashSet;
use axum::{
Json,
extract::State,
http::StatusCode,
response::{IntoResponse, Response},
};
use serde::{Deserialize, Serialize};
use serde_json::json;
use sqlx::{FromRow, SqlitePool};
use crate::state::AppState;
pub const KINDS: &[&str] = &["anime", "film", "tv", "track"];
/// 後台「在看」列幾部
const WATCH_LIMIT: i64 = 120;
/// 某一種不公開的 key。讀失敗就當作沒有藏任何東西(記 log),不讓整個公開端點掛掉
pub async fn hidden_keys(pool: &SqlitePool, kind: &str) -> HashSet<String> {
match sqlx::query_scalar::<_, String>("SELECT key FROM collection_hidden WHERE kind = ?")
.bind(kind)
.fetch_all(pool)
.await
{
Ok(keys) => keys.into_iter().collect(),
Err(e) => {
tracing::error!("[collection] 讀不到不公開清單:{e}");
HashSet::new()
}
}
}
/// 後台「在看」的一部(動畫、電影、影集混在一起,照最後看的時間排)
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct AdminWatchItem {
/// anime | film | tv
pub kind: String,
/// 不公開清單用的 key:動畫是 anime_sn、電影是 film_history.id、影集是劇名
pub key: String,
pub title: String,
pub cover: Option<String>,
/// 動畫是最後一集、影集是看了幾集、電影是評分
pub detail: Option<String>,
pub watched_at: Option<String>,
/// bahamut | simkl | trakt …
pub source: Option<String>,
#[specta(type = Option<specta_typescript::Number>)]
pub tmdb_id: Option<i64>,
pub hidden: bool,
/// 在最愛裡的話是那一筆的 id
#[specta(type = Option<specta_typescript::Number>)]
pub favorite_id: Option<i64>,
}
/// 後台「在聽」的一首(Spotify 最近播放,含不公開的)
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct AdminTrackItem {
pub id: String,
pub name: String,
pub artists: String,
pub cover: Option<String>,
pub played_at: String,
pub hidden: bool,
}
/// 不公開的一筆(給後台列「藏了哪些」,Spotify 的歌不在最近播放裡也看得到)
#[derive(Debug, Serialize, FromRow, specta::Type, utoipa::ToSchema)]
pub struct HiddenItem {
pub kind: String,
pub key: String,
pub title: String,
pub hidden_at: String,
}
#[derive(Debug, Serialize, specta::Type, utoipa::ToSchema)]
pub struct AdminCollectionResponse {
pub watch: Vec<AdminWatchItem>,
pub tracks: Vec<AdminTrackItem>,
/// Spotify 抓失敗的話是理由(沒接 Spotify 不算失敗,tracks 就是空的)
pub tracks_error: Option<String>,
pub hidden: Vec<HiddenItem>,
}
/// `GET /api/admin/collection` —— 在看(含不公開的)、在聽、不公開清單
#[utoipa::path(get, path = "/api/admin/collection", tag = "admin", security(("bearer" = [])),
responses((status = 200, body = AdminCollectionResponse), (status = 401, description = "未授權")))]
pub async fn admin_collection(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
) -> Result<Json<AdminCollectionResponse>, crate::error::AppError> {
let pool = &state.pool;
// 一部一列:動畫照 anime_sn 併、影集照劇名併;最愛照 tmdb_id+種類對上
let mut watch = sqlx::query_as::<_, AdminWatchItem>(
"SELECT w.kind, w.key, w.title, w.cover, w.detail, w.watched_at, w.source, w.tmdb_id, \
EXISTS (SELECT 1 FROM collection_hidden h WHERE h.kind = w.kind AND h.key = w.key) AS hidden, \
(SELECT f.id FROM watch_favorites f WHERE f.tmdb_id = w.tmdb_id \
AND f.kind = CASE w.kind WHEN 'film' THEN 'film' ELSE 'tv' END LIMIT 1) AS favorite_id \
FROM ( \
SELECT 'anime' AS kind, CAST(anime_sn AS TEXT) AS key, COALESCE(MAX(title), '') AS title, \
MAX(cover_url) AS cover, MAX(episode) AS detail, MAX(last_watched_at) AS watched_at, \
'bahamut' AS source, MAX(tmdb_id) AS tmdb_id \
FROM anime_history GROUP BY anime_sn \
UNION ALL \
SELECT 'film', CAST(id AS TEXT), title, poster_url, \
CASE WHEN rating IS NULL THEN NULL ELSE '★ ' || rating END, watched_date, source, tmdb_id \
FROM film_history \
UNION ALL \
SELECT 'tv', series_name, series_name, MAX(poster_url), '看了 ' || COUNT(*) || ' 集', \
MAX(watched_date), MAX(source), MAX(tmdb_id) \
FROM tv_history GROUP BY series_name \
) w ORDER BY w.watched_at DESC NULLS LAST LIMIT ?",
)
.bind(WATCH_LIMIT)
.fetch_all(pool)
.await?;
// Simkl/Trakt 的電影與影集帶 tmdb_id、不存海報,前台讀的時候才從 TMDb 補;後台也要補,
// 不然那些列在後台永遠是空框
for w in &mut watch {
let kind = match w.kind.as_str() {
"film" => "movie",
"tv" => "tv",
_ => continue,
};
if w.cover.as_deref().unwrap_or("").is_empty()
&& let Some(id) = w.tmdb_id
{
w.cover = crate::handlers::watch::tmdb_poster(&state, kind, id).await;
}
}
let hidden_tracks = hidden_keys(pool, "track").await;
let (tracks, tracks_error) = match crate::handlers::spotify::recent_unfiltered(&state).await {
Ok(r) => (
r.items
.into_iter()
.map(|i| AdminTrackItem {
hidden: hidden_tracks.contains(&i.track.id),
artists: i.track.artists.iter().map(|a| a.name.as_str()).collect::<Vec<_>>().join("、"),
cover: i.track.album.images.last().map(|img| img.url.clone()),
id: i.track.id,
name: i.track.name,
played_at: i.played_at,
})
.collect(),
None,
),
Err(e) => (Vec::new(), Some(e)),
};
let hidden = sqlx::query_as::<_, HiddenItem>(
"SELECT kind, key, title, hidden_at FROM collection_hidden ORDER BY hidden_at DESC",
)
.fetch_all(pool)
.await?;
Ok(Json(AdminCollectionResponse { watch, tracks, tracks_error, hidden }))
}
#[derive(Debug, Deserialize, utoipa::ToSchema)]
pub struct HiddenBody {
kind: String,
key: String,
/// 藏的時候記下名字(Spotify 的歌不在 DB 裡,之後要列出來只能靠這個)
title: Option<String>,
hidden: bool,
}
/// `PUT /api/admin/collection/hidden` —— 某一部/某一首設成不公開或改回公開
#[utoipa::path(put, path = "/api/admin/collection/hidden", tag = "admin", security(("bearer" = [])),
request_body = HiddenBody,
responses((status = 200, description = "改好了"), (status = 400, description = "種類或 key 不對"), (status = 401, description = "未授權")))]
pub async fn admin_set_hidden(
State(state): State<AppState>,
_auth: crate::auth::AdminAuth,
crate::error::JsonBody(b): crate::error::JsonBody<HiddenBody>,
) -> Response {
let key = b.key.trim();
if !KINDS.contains(&b.kind.as_str()) || key.is_empty() || key.chars().count() > 200 {
return (StatusCode::BAD_REQUEST, Json(json!({ "error": "種類或 key 不對" }))).into_response();
}
let title: String = b.title.as_deref().unwrap_or_default().trim().chars().take(200).collect();
let r = if b.hidden {
sqlx::query(
"INSERT INTO collection_hidden (kind, key, title) VALUES (?, ?, ?) \
ON CONFLICT (kind, key) DO UPDATE SET title = excluded.title",
)
.bind(&b.kind)
.bind(key)
.bind(&title)
.execute(&state.pool)
.await
} else {
sqlx::query("DELETE FROM collection_hidden WHERE kind = ? AND key = ?")
.bind(&b.kind)
.bind(key)
.execute(&state.pool)
.await
};
match r {
Ok(_) => Json(json!({ "kind": b.kind, "key": key, "hidden": b.hidden })).into_response(),
Err(e) => crate::error::internal_error(StatusCode::INTERNAL_SERVER_ERROR, e),
}
}