tdm_server_rust/repository/

manga_repo.rs

//! 漫画数据访问层 (Manga Repository)
//!
//! 封装 `mangatb`、`mangacollect`、`glossary` 等表的查询（SeaORM）。

use crate::db::DbConn;
use crate::entity::manga::{
    AddStationRequest, GlossaryRequest, GlossaryVo, Manga, MangaCardVo, MangaCollect,
    MangaDetailVo, MangaSimpleVo,
};
use crate::entity::member::Member;
use crate::error::AppError;
use crate::repository::manga_list_assemble::{self, MangaListSort};
use crate::sea_entity::{
    glossary, mangaauthor, mangacollect, mangaepisodedetail, mangaepisodetb, mangamagazine,
    mangastationed, mangatb, membertb,
};
use chrono::{DateTime, Utc};
use sea_orm::{
    ActiveModelTrait, ColumnTrait, ConnectionTrait, DatabaseConnection, EntityTrait,
    PaginatorTrait, QueryFilter, QueryOrder, Set,
};
use sqlx::postgres::PgPool;

/// 漫画仓储
pub struct MangaRepository {
    /// SeaORM 数据库连接
    db: DbConn,
}

impl MangaRepository {
    /// 从 `PgPool` 构造
    pub fn new(pool: PgPool) -> Self {
        Self {
            db: crate::db::from_sqlx_pool(pool),
        }
    }

    /// 从 `DatabaseConnection` 构造
    pub fn from_db(db: DatabaseConnection) -> Self {
        Self { db }
    }

    /// 查询全部漫画原名（SeaORM，供 service 缓存）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_ori_names(&self) -> crate::error::ApiResult<Vec<MangaSimpleVo>> {
        let rows = mangatb::Entity::find()
            .order_by_asc(mangatb::Column::Id)
            .all(&self.db)
            .await?;
        Ok(rows
            .into_iter()
            .map(|m| MangaSimpleVo {
                id: m.id,
                manga_ori_name: Some(m.manga_ori_name),
                ..Default::default()
            })
            .collect())
    }

    /// 条件分页查询漫画卡片（全量，Service 层内存分页）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list(
        &self,
        manga_tran_name: Option<&str>,
        manga_ori_name: Option<&str>,
        category: Option<i16>,
        manga_status: Option<i16>,
        author_name: Option<&str>,
        magazine_name: Option<&str>,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        self.list_page(
            manga_tran_name,
            manga_ori_name,
            category,
            manga_status,
            author_name,
            magazine_name,
            i32::MAX,
            0,
        )
        .await
    }

    /// 统计符合条件的漫画总数
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn count_list(
        &self,
        manga_tran_name: Option<&str>,
        manga_ori_name: Option<&str>,
        category: Option<i16>,
        manga_status: Option<i16>,
        author_name: Option<&str>,
        magazine_name: Option<&str>,
    ) -> crate::error::ApiResult<i64> {
        manga_list_assemble::count_list(
            &self.db,
            manga_tran_name,
            manga_ori_name,
            category,
            manga_status,
            author_name,
            magazine_name,
        )
        .await
    }

    /// 条件分页查询漫画卡片（SQL LIMIT/OFFSET）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_page(
        &self,
        manga_tran_name: Option<&str>,
        manga_ori_name: Option<&str>,
        category: Option<i16>,
        manga_status: Option<i16>,
        author_name: Option<&str>,
        magazine_name: Option<&str>,
        limit: i32,
        offset: i32,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        manga_list_assemble::list_page(
            &self.db,
            manga_tran_name,
            manga_ori_name,
            category,
            manga_status,
            author_name,
            magazine_name,
            limit,
            offset,
        )
        .await
    }

    /// 条件分页查询漫画卡片（SQL LIMIT/OFFSET，支持排序）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_page_sorted(
        &self,
        manga_tran_name: Option<&str>,
        manga_ori_name: Option<&str>,
        category: Option<i16>,
        manga_status: Option<i16>,
        author_name: Option<&str>,
        magazine_name: Option<&str>,
        sort: MangaListSort,
        limit: i32,
        offset: i32,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        manga_list_assemble::list_page_sorted(
            &self.db,
            manga_tran_name,
            manga_ori_name,
            category,
            manga_status,
            author_name,
            magazine_name,
            sort,
            limit,
            offset,
        )
        .await
    }

    /// 按作者 ID 分页查询漫画卡片
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_by_author_page(
        &self,
        author_id: i32,
        page: i32,
        page_size: i32,
    ) -> crate::error::ApiResult<(i64, Vec<MangaCardVo>)> {
        manga_list_assemble::list_by_author_page(&self.db, author_id, page, page_size).await
    }

    /// 按作者 ID 查询漫画卡片
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_by_author(
        &self,
        author_id: i32,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        manga_list_assemble::list_by_author(&self.db, author_id).await
    }

    /// 按杂志 ID 分页查询漫画卡片
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_by_magazine_page(
        &self,
        magazine_id: i32,
        page: i32,
        page_size: i32,
    ) -> crate::error::ApiResult<(i64, Vec<MangaCardVo>)> {
        manga_list_assemble::list_by_magazine_page(&self.db, magazine_id, page, page_size).await
    }

    /// 按杂志 ID 查询漫画卡片
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_by_magazine(
        &self,
        magazine_id: i32,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        manga_list_assemble::list_by_magazine(&self.db, magazine_id).await
    }

    /// 按 ID 删除漫画主表
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_by_id(&self, id: i32) -> crate::error::ApiResult<()> {
        mangatb::Entity::delete_by_id(id).exec(&self.db).await?;
        Ok(())
    }

    /// 删除漫画作者关联
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_manga_author(&self, id: i32) -> crate::error::ApiResult<()> {
        mangaauthor::Entity::delete_many()
            .filter(mangaauthor::Column::MangaId.eq(id))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 删除漫画作者关联（作画作者 type=2）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_manga_author2(&self, id: i32) -> crate::error::ApiResult<()> {
        mangaauthor::Entity::delete_many()
            .filter(mangaauthor::Column::MangaId.eq(id))
            .filter(mangaauthor::Column::Type.eq(2))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 删除漫画话数
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_manga_episode(&self, id: i32) -> crate::error::ApiResult<()> {
        mangaepisodetb::Entity::delete_many()
            .filter(mangaepisodetb::Column::MangaId.eq(id))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 删除漫画杂志关联
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_manga_magazine(&self, id: i32) -> crate::error::ApiResult<()> {
        mangamagazine::Entity::delete_many()
            .filter(mangamagazine::Column::MangaId.eq(id))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 新增漫画
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn insert(&self, manga: &Manga) -> crate::error::ApiResult<i32> {
        let inserted = mangatb::ActiveModel {
            manga_tran_name: Set(manga.manga_tran_name.clone().unwrap_or_default()),
            manga_ori_name: Set(manga.manga_ori_name.clone().unwrap_or_default()),
            category: Set(manga.category.unwrap_or(0) as i32),
            manga_status: Set(manga.manga_status.unwrap_or(0) as i32),
            image: Set(manga.img_url.clone().unwrap_or_default()),
            link: Set(manga.link.clone()),
            introduction: Set(manga.introduction.clone()),
            setup_time: Set(chrono::Utc::now().naive_utc()),
            update_time: Set(chrono::Utc::now().naive_utc()),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(inserted.id)
    }

    /// 新增漫画作者（type=1）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn insert_manga_author(
        &self,
        manga_id: i32,
        author_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangaauthor::ActiveModel {
            manga_id: Set(manga_id),
            author_id: Set(author_id),
            r#type: Set(1),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(())
    }

    /// 新增漫画作者（type=2）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn insert_manga_author2(
        &self,
        manga_id: i32,
        author_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangaauthor::ActiveModel {
            manga_id: Set(manga_id),
            author_id: Set(author_id),
            r#type: Set(2),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(())
    }

    /// 新增漫画杂志关联
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn insert_manga_magazine(
        &self,
        manga_id: i32,
        magazine_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangamagazine::ActiveModel {
            manga_id: Set(Some(manga_id)),
            magazine_id: Set(Some(magazine_id)),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(())
    }

    /// 按 ID 查询漫画详情
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_detail_by_id(
        &self,
        id: i32,
    ) -> crate::error::ApiResult<Option<MangaDetailVo>> {
        manga_list_assemble::get_manga_detail_by_id(&self.db, id).await
    }

    /// 按 ID 查询漫画（对齐 Java getMangaById）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_response_by_id(
        &self,
        id: i32,
    ) -> crate::error::ApiResult<Option<crate::entity::manga::MangaResponse>> {
        manga_list_assemble::get_manga_response_by_id(&self.db, id).await
    }

    /// 批量按 ID 查询漫画
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_responses_by_ids(
        &self,
        ids: &[i32],
    ) -> crate::error::ApiResult<std::collections::HashMap<i32, crate::entity::manga::MangaResponse>>
    {
        manga_list_assemble::get_manga_responses_by_ids(&self.db, ids).await
    }

    /// 按 ID 查询漫画卡片详情
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_card_by_id(
        &self,
        id: i32,
    ) -> crate::error::ApiResult<Option<MangaCardVo>> {
        manga_list_assemble::get_manga_card_by_id(&self.db, id).await
    }

    /// 按 ID 查询漫画
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_by_id(&self, id: i32) -> crate::error::ApiResult<Option<Manga>> {
        let row = mangatb::Entity::find_by_id(id).one(&self.db).await?;
        Ok(row.map(model_to_manga))
    }

    /// 更新漫画
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_manga(&self, manga: &Manga) -> crate::error::ApiResult<()> {
        let id = manga
            .id
            .ok_or_else(|| AppError::business("漫画 ID 不能为空"))?;
        let existing = mangatb::Entity::find_by_id(id)
            .one(&self.db)
            .await?
            .ok_or_else(|| AppError::business("漫画不存在"))?;
        let mut am: mangatb::ActiveModel = existing.into();
        if let Some(ref v) = manga.manga_tran_name {
            am.manga_tran_name = Set(v.clone());
        }
        if let Some(ref v) = manga.manga_ori_name {
            am.manga_ori_name = Set(v.clone());
        }
        if let Some(v) = manga.category {
            am.category = Set(v as i32);
        }
        if let Some(v) = manga.manga_status {
            am.manga_status = Set(v as i32);
        }
        if let Some(ref v) = manga.img_url {
            am.image = Set(v.clone());
        }
        if manga.link.is_some() {
            am.link = Set(manga.link.clone());
        }
        if manga.introduction.is_some() {
            am.introduction = Set(manga.introduction.clone());
        }
        am.update_time = Set(chrono::Utc::now().naive_utc());
        am.update(&self.db).await?;
        Ok(())
    }

    /// 更新漫画作者（type=1）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_manga_author(
        &self,
        manga_id: i32,
        author_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangaauthor::Entity::update_many()
            .col_expr(mangaauthor::Column::AuthorId, author_id.into())
            .filter(mangaauthor::Column::MangaId.eq(manga_id))
            .filter(mangaauthor::Column::Type.eq(1))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 更新漫画作者（type=2）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_manga_author2(
        &self,
        manga_id: i32,
        author_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangaauthor::Entity::update_many()
            .col_expr(mangaauthor::Column::AuthorId, author_id.into())
            .filter(mangaauthor::Column::MangaId.eq(manga_id))
            .filter(mangaauthor::Column::Type.eq(2))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 更新漫画杂志关联
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_manga_magazine(
        &self,
        manga_id: i32,
        magazine_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangamagazine::Entity::update_many()
            .col_expr(mangamagazine::Column::MagazineId, magazine_id.into())
            .filter(mangamagazine::Column::MangaId.eq(manga_id))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 检测作画作者是否存在
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn test_author2(&self, manga_id: i32) -> crate::error::ApiResult<bool> {
        let n = mangaauthor::Entity::find()
            .filter(mangaauthor::Column::MangaId.eq(manga_id))
            .filter(mangaauthor::Column::Type.eq(2))
            .count(&self.db)
            .await?;
        Ok(n > 0)
    }

    /// 检测原名是否重复
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn test_ori_name(&self, manga_ori_name: &str) -> crate::error::ApiResult<bool> {
        self.exists_ori_name_for_other(manga_ori_name, None).await
    }

    /// 检测译名是否与其他漫画重复
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn exists_tran_name_for_other(
        &self,
        manga_tran_name: &str,
        exclude_id: Option<i32>,
    ) -> crate::error::ApiResult<bool> {
        let mut q =
            mangatb::Entity::find().filter(mangatb::Column::MangaTranName.eq(manga_tran_name));
        if let Some(id) = exclude_id {
            q = q.filter(mangatb::Column::Id.ne(id));
        }
        Ok(q.one(&self.db).await?.is_some())
    }

    /// 检测原名是否与其他漫画重复
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn exists_ori_name_for_other(
        &self,
        manga_ori_name: &str,
        exclude_id: Option<i32>,
    ) -> crate::error::ApiResult<bool> {
        let mut q =
            mangatb::Entity::find().filter(mangatb::Column::MangaOriName.eq(manga_ori_name));
        if let Some(id) = exclude_id {
            q = q.filter(mangatb::Column::Id.ne(id));
        }
        Ok(q.one(&self.db).await?.is_some())
    }

    /// 检测漫画是否已有杂志关联
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn test_manga_magazine(&self, manga_id: i32) -> crate::error::ApiResult<bool> {
        let n = mangamagazine::Entity::find()
            .filter(mangamagazine::Column::MangaId.eq(manga_id))
            .count(&self.db)
            .await?;
        Ok(n > 0)
    }

    /// 检测漫画是否已有原作作者关联（type=1）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn test_manga_author1(&self, manga_id: i32) -> crate::error::ApiResult<bool> {
        let n = mangaauthor::Entity::find()
            .filter(mangaauthor::Column::MangaId.eq(manga_id))
            .filter(mangaauthor::Column::Type.eq(1))
            .count(&self.db)
            .await?;
        Ok(n > 0)
    }

    /// 查询全部译名
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_tran_names(&self) -> crate::error::ApiResult<Vec<MangaSimpleVo>> {
        let rows = mangatb::Entity::find()
            .order_by_asc(mangatb::Column::Id)
            .all(&self.db)
            .await?;
        Ok(rows
            .into_iter()
            .map(|m| MangaSimpleVo {
                id: m.id,
                manga_tran_name: Some(m.manga_tran_name),
                ..Default::default()
            })
            .collect())
    }

    /// 获取最大漫画 ID
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_max_manga_id(&self) -> crate::error::ApiResult<Option<i32>> {
        let row = mangatb::Entity::find()
            .order_by_desc(mangatb::Column::Id)
            .one(&self.db)
            .await?;
        Ok(row.map(|r| r.id))
    }

    /// 查询收藏详情
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_collect_detail(
        &self,
        manga_id: i32,
        member_id: i32,
    ) -> crate::error::ApiResult<Option<MangaCollect>> {
        let row = mangacollect::Entity::find()
            .filter(mangacollect::Column::MangaId.eq(manga_id))
            .filter(mangacollect::Column::MemberId.eq(member_id))
            .one(&self.db)
            .await?;
        Ok(row.map(|r| MangaCollect {
            id: Some(r.id),
            manga_id: r.manga_id,
            member_id: r.member_id,
        }))
    }

    /// 分页查询组员收藏（SQL 真分页）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_collect_list(
        &self,
        member_id: i32,
    ) -> crate::error::ApiResult<Vec<MangaCardVo>> {
        manga_list_assemble::get_collect_list(&self.db, member_id).await
    }

    /// 分页查询组员收藏（返回 total + 当前页卡片）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_collect_list_page(
        &self,
        member_id: i32,
        page: i32,
        page_size: i32,
    ) -> crate::error::ApiResult<(i64, Vec<MangaCardVo>)> {
        manga_list_assemble::get_collect_list_page(&self.db, member_id, page, page_size).await
    }

    /// 查询收藏该漫画的组员
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_collected_members(
        &self,
        manga_id: i32,
    ) -> crate::error::ApiResult<Vec<crate::entity::manga::CollectedMembersVo>> {
        manga_list_assemble::get_collected_members(&self.db, manga_id).await
    }

    /// 删除收藏
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn del_collect(&self, manga_id: i32, member_id: i32) -> crate::error::ApiResult<()> {
        mangacollect::Entity::delete_many()
            .filter(mangacollect::Column::MangaId.eq(manga_id))
            .filter(mangacollect::Column::MemberId.eq(member_id))
            .exec(&self.db)
            .await?;
        Ok(())
    }

    /// 新增收藏
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn add_collect(&self, manga_id: i32, member_id: i32) -> crate::error::ApiResult<()> {
        mangacollect::ActiveModel {
            member_id: Set(member_id),
            manga_id: Set(manga_id),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(())
    }

    /// 查询术语列表
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn list_glossary(
        &self,
        manga_id: i32,
        type_: Option<i16>,
    ) -> crate::error::ApiResult<Vec<GlossaryVo>> {
        let mut q = glossary::Entity::find().filter(glossary::Column::MangaId.eq(manga_id));
        if let Some(t) = type_ {
            q = q.filter(glossary::Column::Type.eq(t as i32));
        }
        let rows = q.all(&self.db).await?;
        Ok(assemble_glossary_list(&self.db, rows).await?)
    }

    /// 按 ID 删除术语
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn delete_glossary_by_id(&self, id: i32) -> crate::error::ApiResult<()> {
        glossary::Entity::delete_by_id(id).exec(&self.db).await?;
        Ok(())
    }

    /// 新增术语
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn insert_glossary(
        &self,
        req: &GlossaryRequest,
        update_by: i32,
    ) -> crate::error::ApiResult<i32> {
        let inserted = glossary::ActiveModel {
            r#type: Set(req.r#type.map(|v| v as i32)),
            image: Set(req.image.clone()),
            title: Set(req.title.clone()),
            content: Set(req.content.clone()),
            manga_id: Set(req.manga_id.map(|v| v as i32)),
            first: Set(req.first.clone()),
            update_time: Set(Some(chrono::Utc::now().naive_utc())),
            update_by: Set(Some(update_by)),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(inserted.id)
    }

    /// 按 ID 查询术语
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_glossary_by_id(&self, id: i32) -> crate::error::ApiResult<Option<GlossaryVo>> {
        let row = glossary::Entity::find_by_id(id).one(&self.db).await?;
        let Some(g) = row else {
            return Ok(None);
        };
        let name = load_glossary_member_name(&self.db, g.update_by).await?;
        Ok(Some(manga_list_assemble::glossary_to_vo(g, name)))
    }

    /// 更新术语
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_glossary(
        &self,
        req: &GlossaryRequest,
        update_by: i32,
    ) -> crate::error::ApiResult<()> {
        let id = req
            .id
            .ok_or_else(|| AppError::business("术语 ID 不能为空"))?;
        let existing = glossary::Entity::find_by_id(id)
            .one(&self.db)
            .await?
            .ok_or_else(|| AppError::business("术语不存在"))?;
        let mut am: glossary::ActiveModel = existing.into();
        if let Some(t) = req.r#type {
            am.r#type = Set(Some(t as i32));
        }
        if req.title.is_some() {
            am.title = Set(req.title.clone());
        }
        if req.content.is_some() {
            am.content = Set(req.content.clone());
        }
        if req.image.is_some() {
            am.image = Set(req.image.clone());
        }
        if req.first.is_some() {
            am.first = Set(req.first.clone());
        }
        am.update_time = Set(Some(chrono::Utc::now().naive_utc()));
        am.update_by = Set(Some(update_by));
        am.update(&self.db).await?;
        Ok(())
    }

    /// 漫画 RSS 列表
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_rss(
        &self,
    ) -> crate::error::ApiResult<Vec<crate::entity::rss::RssMangaRow>> {
        manga_list_assemble::get_manga_rss(&self.db).await
    }

    /// 最近更新漫画 RSS
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_manga_updated_rss(
        &self,
    ) -> crate::error::ApiResult<Vec<crate::entity::rss::RssMangaRow>> {
        manga_list_assemble::get_manga_updated_rss(&self.db).await
    }

    /// 话数 RSS 列表
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_episode_rss(
        &self,
    ) -> crate::error::ApiResult<Vec<crate::entity::rss::EpisodeRssRow>> {
        manga_list_assemble::get_episode_rss(&self.db).await
    }

    /// 交稿提醒 RSS
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_work_reminder_rss(
        &self,
        post_name: &str,
    ) -> crate::error::ApiResult<Vec<crate::entity::rss::WorkReminderRssRow>> {
        manga_list_assemble::get_work_reminder_rss(&self.db, post_name).await
    }

    /// 查询漫画常驻组员
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_stationed_members(
        &self,
        manga_id: i32,
    ) -> crate::error::ApiResult<Vec<Member>> {
        if manga_id == 0 {
            return self.get_pending_stationed_members().await;
        }
        let stations = mangastationed::Entity::find()
            .filter(mangastationed::Column::MangaId.eq(manga_id))
            .all(&self.db)
            .await?;
        assemble_station_members(&self.db, stations, false).await
    }

    /// 查询待审批常驻组员（mangaId=0）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_pending_stationed_members(&self) -> crate::error::ApiResult<Vec<Member>> {
        let stations = mangastationed::Entity::find()
            .filter(
                sea_orm::Condition::any()
                    .add(mangastationed::Column::Status.eq(0))
                    .add(mangastationed::Column::Status.eq(2)),
            )
            .all(&self.db)
            .await?;
        assemble_station_members(&self.db, stations, true).await
    }

    /// 删除常驻记录
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn del_station(&self, station_id: i32) -> crate::error::ApiResult<()> {
        Self::del_station_with(&self.db, station_id).await
    }

    /// 按 ID 查询常驻记录
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_station_by_id(
        &self,
        station_id: i32,
    ) -> crate::error::ApiResult<Option<StationRecord>> {
        Self::get_station_by_id_with(&self.db, station_id).await
    }

    /// 填充漫画内该岗位为空且未交稿的单话
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn fill_empty_episodes(
        &self,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        Self::fill_empty_episodes_with(&self.db, req).await
    }

    /// 填充后写入岗位指派时间
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn fill_episode_detail(
        &self,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        Self::fill_episode_detail_with(&self.db, req).await
    }

    /// 清空组员未交稿单话分配
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn clear_member_unsubmitted_episodes(
        &self,
        manga_id: i32,
        member_id: i32,
        post: i32,
    ) -> crate::error::ApiResult<()> {
        Self::clear_member_unsubmitted_episodes_with(&self.db, manga_id, member_id, post).await
    }

    /// 组员申请常驻
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn add_station(
        &self,
        manga_id: i32,
        member_id: i32,
        post: i32,
    ) -> crate::error::ApiResult<()> {
        mangastationed::ActiveModel {
            manga_id: Set(manga_id),
            member_id: Set(member_id),
            post: Set(post),
            status: Set(Some(0)),
            ..Default::default()
        }
        .insert(&self.db)
        .await?;
        Ok(())
    }

    /// 管理员添加常驻
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn add_station_by_admin(
        &self,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        Self::add_station_by_admin_with(&self.db, req).await
    }

    /// 事务内：按 ID 查询常驻记录
    pub(crate) async fn get_station_by_id_with<C: ConnectionTrait>(
        conn: &C,
        station_id: i32,
    ) -> crate::error::ApiResult<Option<StationRecord>> {
        let row = mangastationed::Entity::find_by_id(station_id)
            .one(conn)
            .await?;
        Ok(row.map(|r| StationRecord {
            manga_id: r.manga_id,
            member_id: r.member_id,
            post: r.post,
        }))
    }

    /// 事务内：插入已通过常驻记录
    pub(crate) async fn add_station_by_admin_with<C: ConnectionTrait>(
        conn: &C,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        mangastationed::ActiveModel {
            manga_id: Set(req.manga_id),
            member_id: Set(req.member_id),
            post: Set(req.post),
            status: Set(Some(1)),
            ..Default::default()
        }
        .insert(conn)
        .await?;
        Ok(())
    }

    /// 事务内：填充空且未交稿的单话岗位
    pub(crate) async fn fill_empty_episodes_with<C: ConnectionTrait>(
        conn: &C,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        let ep_ids =
            episode_ids_for_fill(conn, req.manga_id, req.post, req.member_id, true).await?;
        if ep_ids.is_empty() {
            return Ok(());
        }
        apply_member_assignment(conn, req.post, &ep_ids, Some(req.member_id)).await
    }

    /// 事务内：为刚填充的单话写入岗位指派时间
    pub(crate) async fn fill_episode_detail_with<C: ConnectionTrait>(
        conn: &C,
        req: &AddStationRequest,
    ) -> crate::error::ApiResult<()> {
        let Some(setup_col) = post_setup_column(req.post) else {
            return Ok(());
        };
        let ep_ids =
            episode_ids_assigned_with_null_setup(conn, req.manga_id, req.post, req.member_id)
                .await?;
        if ep_ids.is_empty() {
            return Ok(());
        }
        let details = mangaepisodedetail::Entity::find()
            .filter(mangaepisodedetail::Column::EpisodeId.is_in(ep_ids))
            .all(conn)
            .await?;
        let now = chrono::Utc::now().naive_utc();
        for d in details {
            if detail_setup_is_null(&d, setup_col) {
                let mut am: mangaepisodedetail::ActiveModel = d.into();
                set_detail_setup(&mut am, setup_col, now);
                am.update(conn).await?;
            }
        }
        Ok(())
    }

    /// 事务内：清空组员未交稿单话岗位分配
    pub(crate) async fn clear_member_unsubmitted_episodes_with<C: ConnectionTrait>(
        conn: &C,
        manga_id: i32,
        member_id: i32,
        post: i32,
    ) -> crate::error::ApiResult<()> {
        let ep_ids = episode_ids_for_clear(conn, manga_id, post, member_id).await?;
        if ep_ids.is_empty() {
            return Ok(());
        }
        apply_member_assignment(conn, post, &ep_ids, None).await
    }

    /// 事务内：删除常驻记录
    pub(crate) async fn del_station_with<C: ConnectionTrait>(
        conn: &C,
        station_id: i32,
    ) -> crate::error::ApiResult<()> {
        mangastationed::Entity::delete_by_id(station_id)
            .exec(conn)
            .await?;
        Ok(())
    }

    /// 更新常驻状态
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn update_station_status(
        &self,
        station_id: i32,
        status: i16,
    ) -> crate::error::ApiResult<()> {
        mangastationed::Entity::update_many()
            .col_expr(mangastationed::Column::Status, (status as i32).into())
            .filter(mangastationed::Column::Id.eq(station_id))
            .exec(&self.db)
            .await?;
        Ok(())
    }
}

/// 常驻记录摘要
pub struct StationRecord {
    /// 漫画 ID
    pub manga_id: i32,
    /// 组员 ID
    pub member_id: i32,
    /// 岗位 ID
    pub post: i32,
}

/// Model 映射为 Manga
fn model_to_manga(m: mangatb::Model) -> Manga {
    Manga {
        id: Some(m.id),
        manga_tran_name: Some(m.manga_tran_name),
        manga_ori_name: Some(m.manga_ori_name),
        category: Some(m.category as i16),
        manga_status: Some(m.manga_status as i16),
        img_url: Some(m.image),
        link: m.link,
        introduction: m.introduction,
        update_time: dt_legacy(m.update_time),
    }
}

/// 组装术语列表（含更新人名）
async fn assemble_glossary_list(
    db: &DatabaseConnection,
    rows: Vec<glossary::Model>,
) -> crate::error::ApiResult<Vec<GlossaryVo>> {
    let member_ids: Vec<i32> = rows.iter().filter_map(|g| g.update_by).collect();
    let names: std::collections::HashMap<i32, String> = if member_ids.is_empty() {
        std::collections::HashMap::new()
    } else {
        membertb::Entity::find()
            .filter(membertb::Column::Id.is_in(member_ids))
            .all(db)
            .await?
            .into_iter()
            .map(|m| (m.id, m.username))
            .collect()
    };
    Ok(rows
        .into_iter()
        .map(|g| {
            let name = g.update_by.and_then(|id| names.get(&id).cloned());
            manga_list_assemble::glossary_to_vo(g, name)
        })
        .collect())
}

/// 加载术语更新人名
async fn load_glossary_member_name(
    db: &DatabaseConnection,
    update_by: Option<i32>,
) -> crate::error::ApiResult<Option<String>> {
    let Some(id) = update_by else {
        return Ok(None);
    };
    let m = membertb::Entity::find_by_id(id).one(db).await?;
    Ok(m.map(|r| r.username))
}

/// 组装常驻组员列表
async fn assemble_station_members(
    db: &DatabaseConnection,
    stations: Vec<mangastationed::Model>,
    with_manga_name: bool,
) -> crate::error::ApiResult<Vec<Member>> {
    if stations.is_empty() {
        return Ok(vec![]);
    }
    let member_ids: Vec<i32> = stations.iter().map(|s| s.member_id).collect();
    let members: std::collections::HashMap<i32, membertb::Model> = membertb::Entity::find()
        .filter(membertb::Column::Id.is_in(member_ids))
        .all(db)
        .await?
        .into_iter()
        .map(|m| (m.id, m))
        .collect();
    let manga_names: std::collections::HashMap<i32, String> = if with_manga_name {
        let manga_ids: Vec<i32> = stations.iter().map(|s| s.manga_id).collect();
        mangatb::Entity::find()
            .filter(mangatb::Column::Id.is_in(manga_ids))
            .all(db)
            .await?
            .into_iter()
            .map(|m| (m.id, m.manga_tran_name))
            .collect()
    } else {
        std::collections::HashMap::new()
    };
    Ok(stations
        .into_iter()
        .filter_map(|s| {
            let m = members.get(&s.member_id)?;
            Some(Member {
                id: m.id,
                username: Some(m.username.clone()),
                password: None,
                intern: m.intern as i16,
                email: m.email.clone(),
                avatar_url: m.avatar_url.clone(),
                registration_time: dt_legacy(m.registration_time),
                last_submit_time: dt_legacy(m.last_submit_time),
                posts: vec![],
                post_ids: vec![],
                station_count: None,
                station_id: Some(s.id),
                post: Some(s.post),
                status: s.status.map(|v| v as i16),
                manga_id: Some(s.manga_id),
                manga_name: manga_names.get(&s.manga_id).cloned(),
            })
        })
        .collect())
}

/// 填充用：筛选待写入岗位的单话 ID
async fn episode_ids_for_fill<C: ConnectionTrait>(
    conn: &C,
    manga_id: i32,
    post: i32,
    member_id: i32,
    member_must_be_null: bool,
) -> crate::error::ApiResult<Vec<i32>> {
    let episodes = mangaepisodetb::Entity::find()
        .filter(mangaepisodetb::Column::MangaId.eq(manga_id))
        .all(conn)
        .await?;
    let ep_ids: Vec<i32> = episodes
        .iter()
        .filter(|ep| {
            if member_must_be_null {
                episode_member_id(ep, post).is_none()
            } else {
                episode_member_id(ep, post) == Some(member_id)
            }
        })
        .map(|ep| ep.id)
        .collect();
    if ep_ids.is_empty() {
        return Ok(vec![]);
    }
    let Some(update_col) = post_update_column(post) else {
        return Ok(ep_ids);
    };
    let details: std::collections::HashMap<i32, mangaepisodedetail::Model> =
        mangaepisodedetail::Entity::find()
            .filter(mangaepisodedetail::Column::EpisodeId.is_in(ep_ids.clone()))
            .all(conn)
            .await?
            .into_iter()
            .map(|d| (d.episode_id, d))
            .collect();
    Ok(ep_ids
        .into_iter()
        .filter(|id| {
            details
                .get(id)
                .map(|d| detail_update_is_null(d, update_col))
                .unwrap_or(true)
        })
        .collect())
}

/// 填充接稿时间用：组员已占位且接稿时间为空
async fn episode_ids_assigned_with_null_setup<C: ConnectionTrait>(
    conn: &C,
    manga_id: i32,
    post: i32,
    member_id: i32,
) -> crate::error::ApiResult<Vec<i32>> {
    let Some(setup_col) = post_setup_column(post) else {
        return Ok(vec![]);
    };
    let episodes = mangaepisodetb::Entity::find()
        .filter(mangaepisodetb::Column::MangaId.eq(manga_id))
        .all(conn)
        .await?;
    let ep_ids: Vec<i32> = episodes
        .iter()
        .filter(|ep| episode_member_id(ep, post) == Some(member_id))
        .map(|ep| ep.id)
        .collect();
    if ep_ids.is_empty() {
        return Ok(vec![]);
    }
    let details: std::collections::HashMap<i32, mangaepisodedetail::Model> =
        mangaepisodedetail::Entity::find()
            .filter(mangaepisodedetail::Column::EpisodeId.is_in(ep_ids.clone()))
            .all(conn)
            .await?
            .into_iter()
            .map(|d| (d.episode_id, d))
            .collect();
    Ok(ep_ids
        .into_iter()
        .filter(|id| {
            details
                .get(id)
                .map(|d| detail_setup_is_null(d, setup_col))
                .unwrap_or(true)
        })
        .collect())
}

/// 清空用：筛选未交稿且由该组员占位的单话 ID
async fn episode_ids_for_clear<C: ConnectionTrait>(
    conn: &C,
    manga_id: i32,
    post: i32,
    member_id: i32,
) -> crate::error::ApiResult<Vec<i32>> {
    episode_ids_for_fill(conn, manga_id, post, member_id, false).await
}

/// 按岗位批量写入或清空组员 ID
async fn apply_member_assignment<C: ConnectionTrait>(
    conn: &C,
    post: i32,
    ep_ids: &[i32],
    member_id: Option<i32>,
) -> crate::error::ApiResult<()> {
    let value = member_id.into();
    match post {
        0 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::ProviderId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        1 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::TranslatorId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        2 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::ProofreaderId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        3 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::LettererId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        4 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::ReviewerId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        6 => {
            mangaepisodetb::Entity::update_many()
                .col_expr(mangaepisodetb::Column::TimerId, value)
                .filter(mangaepisodetb::Column::Id.is_in(ep_ids.to_vec()))
                .exec(conn)
                .await?;
        }
        _ => return Err(AppError::business("不支持的常驻岗位喵")),
    }
    Ok(())
}

/// 读取话数岗位组员 ID
fn episode_member_id(ep: &mangaepisodetb::Model, post: i32) -> Option<i32> {
    match post {
        0 => ep.provider_id,
        1 => ep.translator_id,
        2 => ep.proofreader_id,
        3 => ep.letterer_id,
        4 => ep.reviewer_id,
        6 => ep.timer_id,
        _ => None,
    }
}

/// 岗位交稿时间列标识
fn post_update_column(post: i32) -> Option<&'static str> {
    match post {
        1 => Some("translatorUpdateTime"),
        2 => Some("proofreaderUpdateTime"),
        3 => Some("lettererUpdateTime"),
        4 => Some("reviewerUpdateTime"),
        6 => Some("timerUpdateTime"),
        _ => None,
    }
}

/// 岗位接稿时间列标识
fn post_setup_column(post: i32) -> Option<&'static str> {
    match post {
        1 => Some("translatorSetupTime"),
        2 => Some("proofreaderSetupTime"),
        3 => Some("lettererSetupTime"),
        4 => Some("reviewerSetupTime"),
        6 => Some("timerSetupTime"),
        _ => None,
    }
}

/// 判断详情交稿时间是否为空
fn detail_update_is_null(d: &mangaepisodedetail::Model, col: &str) -> bool {
    match col {
        "translatorUpdateTime" => d.translator_update_time.is_none(),
        "proofreaderUpdateTime" => d.proofreader_update_time.is_none(),
        "lettererUpdateTime" => d.letterer_update_time.is_none(),
        "reviewerUpdateTime" => d.reviewer_update_time.is_none(),
        "timerUpdateTime" => d.timer_update_time.is_none(),
        _ => true,
    }
}

/// 判断详情接稿时间是否为空
fn detail_setup_is_null(d: &mangaepisodedetail::Model, col: &str) -> bool {
    match col {
        "translatorSetupTime" => d.translator_setup_time.is_none(),
        "proofreaderSetupTime" => d.proofreader_setup_time.is_none(),
        "lettererSetupTime" => d.letterer_setup_time.is_none(),
        "reviewerSetupTime" => d.reviewer_setup_time.is_none(),
        "timerSetupTime" => d.timer_setup_time.is_none(),
        _ => true,
    }
}

/// 写入详情接稿时间
fn set_detail_setup(
    am: &mut mangaepisodedetail::ActiveModel,
    col: &str,
    now: chrono::NaiveDateTime,
) {
    match col {
        "translatorSetupTime" => am.translator_setup_time = Set(Some(now)),
        "proofreaderSetupTime" => am.proofreader_setup_time = Set(Some(now)),
        "lettererSetupTime" => am.letterer_setup_time = Set(Some(now)),
        "reviewerSetupTime" => am.reviewer_setup_time = Set(Some(now)),
        "timerSetupTime" => am.timer_setup_time = Set(Some(now)),
        _ => {}
    }
}

/// naive 时间转 API UTC
fn dt_legacy(n: chrono::NaiveDateTime) -> Option<DateTime<Utc>> {
    Some(crate::utils::legacy_time::naive_db_to_api_utc(n))
}