tdm_server_rust/web/

manga_controller.rs

//! 漫画管理接口 (Manga Controller)
//!
//! 漫画 CRUD、收藏、术语表、常驻管理、RSS 导出。
//! 对应 Java MangaController。

use crate::utils::query_deserialize::{
    de_i16, de_i32, de_opt_i16, de_opt_i32, de_opt_string, de_page, de_page_size,
    de_station_page_size,
};
use crate::{
    common::AppJson,
    app::AppState,
    common::{page_bean::PageBean, result::ResultBody},
    entity::{
        manga::{
            AddStationRequest, CollectedMembersVo, GlossaryRequest, GlossaryVo, MangaCollect,
            MangaDetailVo, MangaListVo, MangaSimpleVo, MangaUpdateRequest,
        },
        member::Member,
        rss::{EpisodeRssRow, RssMangaRow},
    },
    error::{ApiResult, AppError},
    middleware::AuthMember,
    service::{
        episode_service::EpisodeService,
        manga_service::{MangaService, StationMemberBody},
    },
};
use axum::{
    body::Bytes,
    extract::{Extension, Multipart, Path, Query, State},
    http::{header, HeaderValue, StatusCode},
    response::{IntoResponse, Response},
    routing::{delete, get, post},
    Router,
};
use serde::Deserialize;

/// 漫画分页查询参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MangaPageQuery {
    /// 页码
    #[serde(default, deserialize_with = "de_page")]
    pub page: i32,
    /// 每页条数
    #[serde(default, deserialize_with = "de_page_size")]
    pub page_size: i32,
    /// 译名
    #[serde(default, deserialize_with = "de_opt_string")]
    pub manga_tran_name: Option<String>,
    /// 原名
    #[serde(default, deserialize_with = "de_opt_string")]
    pub manga_ori_name: Option<String>,
    /// 分类
    #[serde(default, deserialize_with = "de_opt_i16")]
    pub category: Option<i16>,
    /// 连载状态
    #[serde(default, deserialize_with = "de_opt_i16")]
    pub manga_status: Option<i16>,
    /// 作者 ID
    #[serde(default, deserialize_with = "de_opt_i16")]
    pub author_id: Option<i16>,
    /// 作者名
    #[serde(default, deserialize_with = "de_opt_string")]
    pub author_name: Option<String>,
    /// 杂志名
    #[serde(default, deserialize_with = "de_opt_string")]
    pub magazine_name: Option<String>,
}

/// 收藏列表查询参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CollectListQuery {
    /// 页码
    #[serde(default, deserialize_with = "de_page")]
    pub page: i32,
    /// 每页条数
    #[serde(default, deserialize_with = "de_page_size")]
    pub page_size: i32,
    /// 组员或漫画 ID
    #[serde(default, deserialize_with = "de_opt_i32")]
    pub id: Option<i32>,
}

/// 收藏详情查询参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CollectDetailQuery {
    /// 漫画 ID
    #[serde(deserialize_with = "de_i32")]
    pub manga_id: i32,
    /// 组员 ID
    #[serde(deserialize_with = "de_i32")]
    pub member_id: i32,
}

/// 术语分页参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GlossaryPageQuery {
    /// 页码
    #[serde(default, deserialize_with = "de_page")]
    pub page: i32,
    /// 每页条数
    #[serde(default, deserialize_with = "de_page_size")]
    pub page_size: i32,
    /// 术语类型
    #[serde(default, deserialize_with = "de_opt_i16")]
    pub r#type: Option<i16>,
    /// 漫画 ID
    #[serde(deserialize_with = "de_i16")]
    pub manga_id: i16,
}

/// 上传文件表单参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UploadFormQuery {
    /// 话数 ID
    #[serde(deserialize_with = "de_i32")]
    pub id: i32,
    /// 岗位名
    pub my_name: String,
    /// 漫画 ID
    #[serde(deserialize_with = "de_i32")]
    pub manga_id: i32,
}

/// 常驻组员分页参数
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StationedMembersQuery {
    /// 页码
    #[serde(default, deserialize_with = "de_page")]
    pub page: i32,
    /// 每页条数
    #[serde(default, deserialize_with = "de_station_page_size")]
    pub page_size: i32,
    /// 漫画 ID
    #[serde(deserialize_with = "de_i32")]
    pub id: i32,
}

/// 漫画路由（挂载于 `/api/mangas`）
pub fn routes() -> Router<AppState> {
    Router::new()
        .route("/", get(page_manga).post(add_manga).put(update_manga))
        .route("/mangaTranName", get(get_manga_tran_name))
        .route("/mangaOriName", get(get_manga_ori_name))
        .route("/:id", get(get_manga_by_id).delete(delete_manga))
        .route(
            "/collect",
            get(get_collect_detail)
                .delete(del_collect)
                .post(add_collect),
        )
        .route("/collectList", get(get_collect_list))
        .route("/collectedMembers", get(get_collected_members))
        .route(
            "/glossary",
            get(page_glossary).post(add_glossary).put(update_glossary),
        )
        .route(
            "/glossary/:id",
            get(get_glossary_by_id).delete(delete_glossary),
        )
        .route("/mangaRss", get(get_manga_rss))
        .route("/episodeRss", get(get_episode_rss))
        .route("/rssOutput", post(rss_output))
        .route("/uploadService", post(upload))
        .route("/downloadService", post(download_file))
        .route("/stationedMembers", get(get_stationed_members))
        .route("/station/:stationId", delete(del_station))
        .route("/station", post(add_station).put(update_station))
        .route("/station/admin", post(add_station_by_admin))
}

/// 分页查询漫画
#[tracing::instrument(skip_all, level = "info")]
pub async fn page_manga(
    State(state): State<AppState>,
    Query(q): Query<MangaPageQuery>,
) -> ApiResult<ResultBody<PageBean<MangaListVo>>> {
    let data = MangaService::page(
        &state,
        q.page,
        q.page_size,
        q.manga_tran_name,
        q.manga_ori_name,
        q.category,
        q.manga_status,
        q.author_id,
        q.author_name,
        q.magazine_name,
    )
    .await?;
    Ok(ResultBody::success_data(data))
}

/// 全部译名
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_manga_tran_name(
    State(state): State<AppState>,
) -> ApiResult<ResultBody<Vec<MangaSimpleVo>>> {
    let data = MangaService::get_manga_tran_name(&state).await?;
    Ok(ResultBody::success_data(data))
}

/// 全部原名
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_manga_ori_name(
    State(state): State<AppState>,
) -> ApiResult<ResultBody<Vec<MangaSimpleVo>>> {
    let data = MangaService::get_manga_ori_name(&state).await?;
    Ok(ResultBody::success_data(data))
}

/// 删除漫画
#[tracing::instrument(skip_all, level = "info")]
pub async fn delete_manga(
    State(state): State<AppState>,
    Path(id): Path<i32>,
) -> ApiResult<ResultBody<()>> {
    MangaService::delete_manga(&state, id).await?;
    Ok(ResultBody::success())
}

/// 新增漫画（multipart）
#[tracing::instrument(skip_all, level = "info")]
pub async fn add_manga(
    State(state): State<AppState>,
    Extension(AuthMember(member)): Extension<AuthMember>,
    mut multipart: Multipart,
) -> ApiResult<ResultBody<()>> {
    let member_id = member.map(|m| m.id).unwrap_or(0);
    let (image, metadata) = parse_manga_multipart(&mut multipart).await?;
    MangaService::add_new_manga(&state, metadata, image, member_id).await?;
    Ok(ResultBody::success())
}

/// 按 ID 查询漫画
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_manga_by_id(
    State(state): State<AppState>,
    Path(id): Path<i32>,
) -> ApiResult<ResultBody<MangaDetailVo>> {
    let data = MangaService::get_manga_by_id(&state, id).await?;
    Ok(ResultBody::success_data(data))
}

/// 更新漫画（multipart）
#[tracing::instrument(skip_all, level = "info")]
pub async fn update_manga(
    State(state): State<AppState>,
    Extension(AuthMember(member)): Extension<AuthMember>,
    mut multipart: Multipart,
) -> ApiResult<ResultBody<()>> {
    let member_id = member.map(|m| m.id).unwrap_or(0);
    let (image, metadata) = parse_manga_multipart(&mut multipart).await?;
    MangaService::update_manga(&state, metadata, image, member_id).await?;
    Ok(ResultBody::success())
}

/// 查询收藏详情
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_collect_detail(
    State(state): State<AppState>,
    Query(q): Query<CollectDetailQuery>,
) -> ApiResult<ResultBody<MangaCollect>> {
    let collect = MangaCollect {
        id: None,
        manga_id: q.manga_id,
        member_id: q.member_id,
    };
    let data = MangaService::get_collect_detail(&state, collect).await?;
    Ok(ResultBody::success_data(data))
}

/// 收藏列表
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_collect_list(
    State(state): State<AppState>,
    Query(q): Query<CollectListQuery>,
) -> ApiResult<ResultBody<PageBean<MangaListVo>>> {
    let id = q.id.ok_or_else(|| AppError::business("无效的 ID 喵"))?;
    let data = MangaService::get_collect_list(&state, q.page, q.page_size, id).await?;
    Ok(ResultBody::success_data(data))
}

/// 收藏组员列表
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_collected_members(
    State(state): State<AppState>,
    Query(q): Query<CollectListQuery>,
) -> ApiResult<ResultBody<PageBean<CollectedMembersVo>>> {
    let id = q.id.ok_or_else(|| AppError::business("无效的 ID 喵"))?;
    let data = MangaService::get_collected_members(&state, q.page, q.page_size, id).await?;
    Ok(ResultBody::success_data(data))
}

/// 删除收藏
#[tracing::instrument(skip_all, level = "info")]
pub async fn del_collect(
    State(state): State<AppState>,
    Query(q): Query<CollectDetailQuery>,
) -> ApiResult<ResultBody<()>> {
    MangaService::del_collect(
        &state,
        MangaCollect {
            id: None,
            manga_id: q.manga_id,
            member_id: q.member_id,
        },
    )
    .await?;
    Ok(ResultBody::success())
}

/// 新增收藏
#[tracing::instrument(skip_all, level = "info")]
pub async fn add_collect(
    State(state): State<AppState>,
    AppJson(body): AppJson<MangaCollect>,
) -> ApiResult<ResultBody<()>> {
    MangaService::add_collect(&state, body).await?;
    Ok(ResultBody::success())
}

/// 分页查询术语
#[tracing::instrument(skip_all, level = "info")]
pub async fn page_glossary(
    State(state): State<AppState>,
    Query(q): Query<GlossaryPageQuery>,
) -> ApiResult<ResultBody<PageBean<GlossaryVo>>> {
    let data =
        MangaService::page_glossary(&state, q.page, q.page_size, q.r#type, q.manga_id).await?;
    Ok(ResultBody::success_data(data))
}

/// 删除术语
#[tracing::instrument(skip_all, level = "info")]
pub async fn delete_glossary(
    State(state): State<AppState>,
    Path(id): Path<i32>,
) -> ApiResult<ResultBody<()>> {
    MangaService::delete_glossary(&state, id).await?;
    Ok(ResultBody::success())
}

/// 新增术语
#[tracing::instrument(skip_all, level = "info")]
pub async fn add_glossary(
    State(state): State<AppState>,
    Extension(AuthMember(member)): Extension<AuthMember>,
    mut multipart: Multipart,
) -> ApiResult<ResultBody<()>> {
    let member_id = member.map(|m| m.id).unwrap_or(0);
    let metadata = parse_glossary_multipart(&mut multipart).await?;
    MangaService::add_glossary(&state, metadata, member_id).await?;
    Ok(ResultBody::success())
}

/// 查询术语
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_glossary_by_id(
    State(state): State<AppState>,
    Path(id): Path<i32>,
) -> ApiResult<ResultBody<GlossaryVo>> {
    let data = MangaService::get_glossary_by_id(&state, id).await?;
    Ok(ResultBody::success_data(data))
}

/// 更新术语
#[tracing::instrument(skip_all, level = "info")]
pub async fn update_glossary(
    State(state): State<AppState>,
    Extension(AuthMember(member)): Extension<AuthMember>,
    mut multipart: Multipart,
) -> ApiResult<ResultBody<()>> {
    let member_id = member.map(|m| m.id).unwrap_or(0);
    let metadata = parse_glossary_multipart(&mut multipart).await?;
    MangaService::update_glossary(&state, metadata, member_id).await?;
    Ok(ResultBody::success())
}

/// 漫画 RSS
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_manga_rss(State(state): State<AppState>) -> ApiResult<ResultBody<Vec<RssMangaRow>>> {
    let data = MangaService::get_manga_rss(&state).await?;
    Ok(ResultBody::success_data(data))
}

/// 话数 RSS
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_episode_rss(
    State(state): State<AppState>,
) -> ApiResult<ResultBody<Vec<EpisodeRssRow>>> {
    let data = MangaService::get_episode_rss(&state).await?;
    Ok(ResultBody::success_data(data))
}

/// RSS 输出
#[tracing::instrument(skip_all, level = "info")]
pub async fn rss_output(
    State(state): State<AppState>,
    AppJson(xml): AppJson<String>,
) -> ApiResult<ResultBody<()>> {
    MangaService::rss_output(&state, xml).await?;
    Ok(ResultBody::success())
}

/// 上传话数文件
#[tracing::instrument(skip_all, level = "info")]
pub async fn upload(
    State(state): State<AppState>,
    Query(q): Query<UploadFormQuery>,
    mut multipart: Multipart,
) -> ApiResult<ResultBody<()>> {
    let mut data = Bytes::new();
    let mut filename = String::from("upload.dat");
    while let Some(field) = multipart
        .next_field()
        .await
        .map_err(|e| AppError::Internal(e.to_string()))?
    {
        if field.name() == Some("dataRaw") {
            if let Some(name) = field.file_name() {
                filename = name.to_string();
            }
            data = field
                .bytes()
                .await
                .map_err(|e| AppError::Internal(e.to_string()))?;
        }
    }
    EpisodeService::upload_manga_file(&state, data, q.id, &q.my_name, q.manga_id, &filename).await?;
    Ok(ResultBody::success())
}

/// 下载话数文件
#[tracing::instrument(skip_all, level = "info")]
pub async fn download_file(
    State(state): State<AppState>,
    AppJson(body): AppJson<crate::entity::manga::EpisodeDownloadRequest>,
) -> ApiResult<Response> {
    let (filename, bytes) = EpisodeService::download_episode_file(&state, body).await?;
    let encoded = urlencoding::encode(&filename);
    let mut headers = axum::http::HeaderMap::new();
    headers.insert(header::CONTENT_TYPE, HeaderValue::from_static("text/plain"));
    headers.insert(
        header::CONTENT_DISPOSITION,
        HeaderValue::from_str(&format!("attachment; filename={encoded}"))
            .map_err(|e| AppError::Internal(format!("生成下载文件名响应头失败: {e}")))?,
    );
    headers.insert(
        header::ACCESS_CONTROL_EXPOSE_HEADERS,
        HeaderValue::from_static("Content-Disposition,Content-Type,Content-Length"),
    );
    Ok((StatusCode::OK, headers, bytes).into_response())
}

/// 常驻组员列表
#[tracing::instrument(skip_all, level = "info")]
pub async fn get_stationed_members(
    State(state): State<AppState>,
    Query(q): Query<StationedMembersQuery>,
) -> ApiResult<ResultBody<PageBean<Member>>> {
    let data = MangaService::get_stationed_members(&state, q.page, q.page_size, q.id).await?;
    Ok(ResultBody::success_data(data))
}

/// 删除常驻
#[tracing::instrument(skip_all, level = "info")]
pub async fn del_station(
    State(state): State<AppState>,
    Path(station_id): Path<i32>,
) -> ApiResult<ResultBody<()>> {
    MangaService::del_station(&state, station_id).await?;
    Ok(ResultBody::success())
}

/// 申请常驻
#[tracing::instrument(skip_all, level = "info")]
pub async fn add_station(
    State(state): State<AppState>,
    AppJson(body): AppJson<StationMemberBody>,
) -> ApiResult<ResultBody<()>> {
    MangaService::add_station(&state, body).await?;
    Ok(ResultBody::success())
}

/// 管理员添加常驻
#[tracing::instrument(skip_all, level = "info")]
pub async fn add_station_by_admin(
    State(state): State<AppState>,
    AppJson(body): AppJson<AddStationRequest>,
) -> ApiResult<ResultBody<()>> {
    MangaService::add_station_by_admin(&state, body).await?;
    Ok(ResultBody::success())
}

/// 更新常驻状态
#[tracing::instrument(skip_all, level = "info")]
pub async fn update_station(
    State(state): State<AppState>,
    AppJson(body): AppJson<StationMemberBody>,
) -> ApiResult<ResultBody<()>> {
    MangaService::update_station(&state, body).await?;
    Ok(ResultBody::success())
}

#[tracing::instrument(skip_all, level = "info")]
async fn parse_manga_multipart(
    multipart: &mut Multipart,
) -> ApiResult<(Option<Bytes>, MangaUpdateRequest)> {
    let mut image = None;
    let mut metadata = MangaUpdateRequest::default();
    while let Some(field) = multipart
        .next_field()
        .await
        .map_err(|e| AppError::Internal(e.to_string()))?
    {
        match field.name() {
            Some("imageRaw") => {
                image = Some(
                    field
                        .bytes()
                        .await
                        .map_err(|e| AppError::Internal(e.to_string()))?,
                );
            }
            Some("metadata") => {
                let raw = field
                    .bytes()
                    .await
                    .map_err(|e| AppError::Internal(e.to_string()))?;
                metadata = serde_json::from_slice(&raw)
                    .map_err(|e| AppError::business(format!("metadata 解析失败: {e}")))?;
            }
            _ => {}
        }
    }
    Ok((image, metadata))
}

#[tracing::instrument(skip_all, level = "info")]
async fn parse_glossary_multipart(multipart: &mut Multipart) -> ApiResult<GlossaryRequest> {
    let mut metadata = GlossaryRequest::default();
    while let Some(field) = multipart
        .next_field()
        .await
        .map_err(|e| AppError::Internal(e.to_string()))?
    {
        if field.name() == Some("metadata") {
            let raw = field
                .bytes()
                .await
                .map_err(|e| AppError::Internal(e.to_string()))?;
            // #region agent log
            crate::utils::agent_debug::log(
                "C",
                "manga_controller.rs:parse_glossary_multipart",
                "glossary metadata raw",
                serde_json::json!({ "raw": String::from_utf8_lossy(&raw) }),
            );
            // #endregion
            metadata = serde_json::from_slice(&raw)
                .map_err(|e| AppError::business(format!("metadata 解析失败: {e}")))?;
        }
    }
    Ok(metadata)
}