tdm_server_rust/repository/

episode_workflow_assemble.rs

//! 话数 workflow 列表组装（SeaORM 多表批量加载，对齐 episode_mapper 联查）

use crate::entity::episode::{
    EpisodeDetailVo, EpisodeListVo, EpisodeSimpleListVo, EpisodeType, NewestEpisodeVo, RoleTakerVo,
    UploadPageVo,
};
use crate::repository::episode_sort;
use crate::sea_entity::{
    editor_page, episode_role_taker, mangaepisodedetail, mangaepisodetb, mangatb, membertb, oss,
};
use chrono::{DateTime, Utc};
use sea_orm::{
    sea_query::{NullOrdering, Order},
    ColumnTrait, Condition, DatabaseConnection, EntityTrait, PaginatorTrait, QueryFilter,
    QueryOrder, QuerySelect,
};
use std::collections::HashMap;

/// workflow 关联数据缓存
struct WorkflowContext {
    /// episodeId -> detail
    details: HashMap<i32, mangaepisodedetail::Model>,
    /// memberId -> username
    members: HashMap<i32, String>,
    /// memberId -> email
    member_emails: HashMap<i32, String>,
    /// ossId -> filename
    oss_names: HashMap<i32, String>,
    /// episodeId -> 编辑器图源页面数量
    editor_page_counts: HashMap<i32, i64>,
    /// (episodeId, role) -> 共同接稿人
    role_takers: HashMap<(i32, String), Vec<RoleTakerVo>>,
}

/// 按漫画 ID 查询话数简单列表
pub async fn list_simple_by_manga_id(
    db: &DatabaseConnection,
    manga_id: i32,
) -> crate::error::ApiResult<Vec<EpisodeSimpleListVo>> {
    let episodes = episodes_by_manga_ordered(db, manga_id).await?;
    let ctx = load_workflow_context(db, &episodes).await?;
    Ok(episodes
        .iter()
        .map(|ep| to_simple_list_vo(ep, &ctx))
        .collect())
}

/// 按漫画 ID 分页查询话数完整列表（COUNT 与当前页并行，仅组装当前页）
pub async fn page_episodes_by_manga(
    db: &DatabaseConnection,
    manga_id: i32,
    page: i32,
    page_size: i32,
    episode_type: EpisodeType,
) -> crate::error::ApiResult<(i64, Vec<EpisodeListVo>)> {
    let page = page.max(1);
    let page_size = page_size.max(1);
    let offset = ((page - 1) * page_size) as u64;
    let filter = Condition::all()
        .add(mangaepisodetb::Column::MangaId.eq(manga_id))
        .add(mangaepisodetb::Column::EpisodeType.eq(episode_type.as_str()));
    let order = episode_sort::episode_label_sort_expr(r#""mangaEpisode""#);
    let filter_count = filter.clone();
    let filter_page = filter.clone();
    let (total, episodes) = tokio::try_join!(
        async move {
            Ok::<_, crate::error::AppError>(
                mangaepisodetb::Entity::find()
                    .filter(filter_count)
                    .count(db)
                    .await? as i64,
            )
        },
        async move {
            Ok(mangaepisodetb::Entity::find()
                .filter(filter_page)
                .order_by_with_nulls(order, Order::Desc, NullOrdering::Last)
                .limit(page_size as u64)
                .offset(offset)
                .all(db)
                .await?)
        },
    )?;
    if episodes.is_empty() {
        return Ok((total, vec![]));
    }
    let ctx = load_workflow_context(db, &episodes).await?;
    Ok((
        total,
        episodes.iter().map(|ep| to_list_vo(ep, &ctx)).collect(),
    ))
}

/// 按漫画 ID 查询话数完整列表
pub async fn list_full_by_manga_id(
    db: &DatabaseConnection,
    manga_id: i32,
) -> crate::error::ApiResult<Vec<EpisodeListVo>> {
    let episodes = episodes_by_manga_ordered(db, manga_id).await?;
    let ctx = load_workflow_context(db, &episodes).await?;
    Ok(episodes.iter().map(|ep| to_list_vo(ep, &ctx)).collect())
}

/// 按 ID 查询话数详情
pub async fn get_detail_by_id(
    db: &DatabaseConnection,
    id: i32,
) -> crate::error::ApiResult<Option<EpisodeDetailVo>> {
    let ep = mangaepisodetb::Entity::find_by_id(id).one(db).await?;
    let Some(ep) = ep else {
        return Ok(None);
    };
    let ctx = load_workflow_context(db, std::slice::from_ref(&ep)).await?;
    Ok(Some(to_detail_vo(&ep, &ctx)))
}

/// 查询漫画最新话
pub async fn get_newest_by_manga_id(
    db: &DatabaseConnection,
    manga_id: i32,
) -> crate::error::ApiResult<Option<NewestEpisodeVo>> {
    let ep = mangaepisodetb::Entity::find()
        .filter(mangaepisodetb::Column::MangaId.eq(manga_id))
        .filter(mangaepisodetb::Column::EpisodeType.eq(EpisodeType::Main.as_str()))
        .order_by_desc(mangaepisodetb::Column::Id)
        .one(db)
        .await?;
    Ok(ep.map(|e| NewestEpisodeVo {
        manga_episode: Some(e.manga_episode),
        translator_id: e.translator_id,
        proofreader_id: e.proofreader_id,
        letterer_id: e.letterer_id,
        reviewer_id: e.reviewer_id,
    }))
}

/// 藏宝处分页：已上传稿件列表（COUNT 与当前页并行）
pub async fn page_uploaded_submit(
    db: &DatabaseConnection,
    page: i32,
    page_size: i32,
    manga_tran_name: Option<&str>,
    username: Option<&str>,
) -> crate::error::ApiResult<(i64, Vec<UploadPageVo>)> {
    let filter = uploaded_submit_filter(db, manga_tran_name, username).await?;
    let page = page.max(1);
    let page_size = page_size.max(1);
    let offset = ((page - 1) * page_size) as u64;
    let filter_count = filter.clone();
    let filter_page = filter.clone();
    let (total, episodes) = tokio::try_join!(
        async move {
            Ok::<_, crate::error::AppError>(
                mangaepisodetb::Entity::find()
                    .filter(filter_count)
                    .count(db)
                    .await? as i64,
            )
        },
        async move {
            Ok(mangaepisodetb::Entity::find()
                .filter(filter_page)
                .order_by_desc(mangaepisodetb::Column::UpdateTime)
                .limit(page_size as u64)
                .offset(offset)
                .all(db)
                .await?)
        },
    )?;
    if total == 0 {
        return Ok((0, vec![]));
    }
    let ctx = load_upload_context(db, &episodes).await?;
    Ok((
        total,
        episodes.iter().map(|ep| to_upload_vo(ep, &ctx)).collect(),
    ))
}

/// 按话数标签降序取漫画下话数（非数字标签如 e32103 排最后）
async fn episodes_by_manga_ordered(
    db: &DatabaseConnection,
    manga_id: i32,
) -> crate::error::ApiResult<Vec<mangaepisodetb::Model>> {
    let rows = mangaepisodetb::Entity::find()
        .filter(mangaepisodetb::Column::MangaId.eq(manga_id))
        .order_by_with_nulls(
            episode_sort::episode_label_sort_expr(r#""mangaEpisode""#),
            Order::Desc,
            NullOrdering::Last,
        )
        .all(db)
        .await?;
    Ok(rows)
}

/// 藏宝处筛选条件
async fn uploaded_submit_filter(
    db: &DatabaseConnection,
    manga_tran_name: Option<&str>,
    username: Option<&str>,
) -> crate::error::ApiResult<Condition> {
    use mangaepisodetb::Column as C;
    let file_cond = Condition::any()
        .add(C::TranslatorFile.is_not_null())
        .add(C::ProofreaderFile.is_not_null())
        .add(C::TimerFile.is_not_null())
        .add(C::TranslatorFileOssId.is_not_null())
        .add(C::ProofreaderFileOssId.is_not_null())
        .add(C::TimerFileOssId.is_not_null());
    let mut all = Condition::all().add(file_cond);
    if let Some(name) = manga_tran_name {
        let manga = mangatb::Entity::find()
            .filter(mangatb::Column::MangaTranName.eq(name))
            .one(db)
            .await?;
        let Some(m) = manga else {
            return Ok(Condition::all().add(C::Id.eq(-1)));
        };
        all = all.add(C::MangaId.eq(m.id));
    }
    if let Some(u) = username {
        let members = membertb::Entity::find()
            .filter(membertb::Column::Username.eq(u))
            .all(db)
            .await?;
        if members.is_empty() {
            return Ok(Condition::all().add(C::Id.eq(-1)));
        }
        let ids: Vec<i32> = members.iter().map(|m| m.id).collect();
        all = all.add(
            Condition::any()
                .add(C::TranslatorId.is_in(ids.clone()))
                .add(C::ProofreaderId.is_in(ids)),
        );
    }
    Ok(all)
}

/// 加载 workflow 关联数据
async fn load_workflow_context(
    db: &DatabaseConnection,
    episodes: &[mangaepisodetb::Model],
) -> crate::error::ApiResult<WorkflowContext> {
    if episodes.is_empty() {
        return Ok(WorkflowContext {
            details: HashMap::new(),
            members: HashMap::new(),
            member_emails: HashMap::new(),
            oss_names: HashMap::new(),
            editor_page_counts: HashMap::new(),
            role_takers: HashMap::new(),
        });
    }
    let ep_ids: Vec<i32> = episodes.iter().map(|e| e.id).collect();
    let details: HashMap<i32, mangaepisodedetail::Model> = mangaepisodedetail::Entity::find()
        .filter(mangaepisodedetail::Column::EpisodeId.is_in(ep_ids.clone()))
        .all(db)
        .await?
        .into_iter()
        .map(|d| (d.episode_id, d))
        .collect();
    let editor_page_counts = load_editor_page_counts(db, &ep_ids).await?;

    let mut member_ids = Vec::new();
    let mut oss_ids = Vec::new();
    let role_taker_rows = episode_role_taker::Entity::find()
        .filter(episode_role_taker::Column::EpisodeId.is_in(ep_ids.clone()))
        .order_by_asc(episode_role_taker::Column::SetupTime)
        .all(db)
        .await?;
    for ep in episodes {
        for mid in [
            ep.provider_id,
            ep.translator_id,
            ep.proofreader_id,
            ep.letterer_id,
            ep.timer_id,
            ep.reviewer_id,
        ] {
            if let Some(id) = mid {
                member_ids.push(id);
            }
        }
        for oid in [
            ep.provider_file_oss_id,
            ep.translator_file_oss_id,
            ep.proofreader_file_oss_id,
            ep.letterer_file_oss_id,
            ep.timer_file_oss_id,
        ] {
            if let Some(id) = oid {
                oss_ids.push(id);
            }
        }
    }
    for taker in &role_taker_rows {
        member_ids.push(taker.member_id);
        if let Some(oss_id) = taker.file_oss_id {
            oss_ids.push(oss_id);
        }
    }
    member_ids.sort_unstable();
    member_ids.dedup();
    oss_ids.sort_unstable();
    oss_ids.dedup();

    let (members, member_emails, member_avatars) = load_members(db, &member_ids).await?;
    let oss_names = load_oss_names(db, &oss_ids).await?;
    let role_takers = group_role_takers(role_taker_rows, &members, &member_avatars, &oss_names);
    Ok(WorkflowContext {
        details,
        members,
        member_emails,
        oss_names,
        editor_page_counts,
        role_takers,
    })
}

/// 批量统计编辑器图源页面数量
async fn load_editor_page_counts(
    db: &DatabaseConnection,
    episode_ids: &[i32],
) -> crate::error::ApiResult<HashMap<i32, i64>> {
    if episode_ids.is_empty() {
        return Ok(HashMap::new());
    }
    let rows: Vec<(i32, i64)> = editor_page::Entity::find()
        .select_only()
        .column(editor_page::Column::EpisodeId)
        .column_as(editor_page::Column::Id.count(), "page_count")
        .filter(editor_page::Column::EpisodeId.is_in(episode_ids.to_vec()))
        .group_by(editor_page::Column::EpisodeId)
        .into_tuple()
        .all(db)
        .await?;
    Ok(rows.into_iter().collect())
}

/// 藏宝处扩展上下文（含漫画名）
struct UploadContext {
    /// workflow 基础上下文
    workflow: WorkflowContext,
    /// mangaId -> 译名
    manga_names: HashMap<i32, String>,
}

/// 加载藏宝处关联数据
async fn load_upload_context(
    db: &DatabaseConnection,
    episodes: &[mangaepisodetb::Model],
) -> crate::error::ApiResult<UploadContext> {
    let workflow = load_workflow_context(db, episodes).await?;
    let manga_ids: Vec<i32> = episodes.iter().map(|e| e.manga_id).collect();
    let mangas: HashMap<i32, String> = if manga_ids.is_empty() {
        HashMap::new()
    } else {
        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()
    };
    Ok(UploadContext {
        workflow,
        manga_names: mangas,
    })
}

/// 批量加载组员名与邮箱
async fn load_members(
    db: &DatabaseConnection,
    ids: &[i32],
) -> crate::error::ApiResult<(
    HashMap<i32, String>,
    HashMap<i32, String>,
    HashMap<i32, String>,
)> {
    if ids.is_empty() {
        return Ok((HashMap::new(), HashMap::new(), HashMap::new()));
    }
    let rows = membertb::Entity::find()
        .filter(membertb::Column::Id.is_in(ids.to_vec()))
        .all(db)
        .await?;
    let mut names = HashMap::new();
    let mut emails = HashMap::new();
    let mut avatars = HashMap::new();
    for m in rows {
        let id = m.id;
        names.insert(m.id, m.username);
        if let Some(e) = m.email {
            emails.insert(id, e);
        }
        if let Some(a) = m.avatar_url {
            avatars.insert(id, a);
        }
    }
    Ok((names, emails, avatars))
}

/// 批量加载 OSS 文件名
async fn load_oss_names(
    db: &DatabaseConnection,
    ids: &[i32],
) -> crate::error::ApiResult<HashMap<i32, String>> {
    if ids.is_empty() {
        return Ok(HashMap::new());
    }
    Ok(oss::Entity::find()
        .filter(oss::Column::Id.is_in(ids.to_vec()))
        .all(db)
        .await?
        .into_iter()
        .map(|o| (o.id, o.filename))
        .collect())
}

/// 将共同接稿记录按话数与岗位分组。
fn group_role_takers(
    rows: Vec<episode_role_taker::Model>,
    members: &HashMap<i32, String>,
    avatars: &HashMap<i32, String>,
    oss_names: &HashMap<i32, String>,
) -> HashMap<(i32, String), Vec<RoleTakerVo>> {
    let mut grouped: HashMap<(i32, String), Vec<RoleTakerVo>> = HashMap::new();
    for row in rows {
        let role = row.role.clone();
        grouped
            .entry((row.episode_id, role))
            .or_default()
            .push(RoleTakerVo {
                member_id: row.member_id,
                member_name: members.get(&row.member_id).cloned(),
                avatar_url: avatars.get(&row.member_id).cloned(),
                setup_time: dt_legacy(row.setup_time),
                update_time: dt_legacy_opt(row.update_time),
                file_oss_id: row.file_oss_id,
                filename: row.file_oss_id.and_then(|id| oss_names.get(&id).cloned()),
            });
    }
    grouped
}

/// 组装 EpisodeListVo
fn to_list_vo(ep: &mangaepisodetb::Model, ctx: &WorkflowContext) -> EpisodeListVo {
    let med = ctx.details.get(&ep.id);
    EpisodeListVo {
        id: ep.id,
        manga_id: ep.manga_id,
        manga_episode: Some(ep.manga_episode.clone()),
        manga_episode_name: ep.manga_episode_name.clone(),
        episode_type: if ep.episode_type == EpisodeType::Extra.as_str() {
            EpisodeType::Extra
        } else {
            EpisodeType::Main
        },
        provider_id: ep.provider_id,
        translator_id: ep.translator_id,
        proofreader_id: ep.proofreader_id,
        letterer_id: ep.letterer_id,
        timer_id: ep.timer_id,
        reviewer_id: ep.reviewer_id,
        setup_time: dt_legacy(ep.setup_time),
        update_time: dt_legacy(ep.update_time),
        translator_file: ep.translator_file.clone(),
        proofreader_file: ep.proofreader_file.clone(),
        timer_file: ep.timer_file.clone(),
        publish_link: ep.publish_link.clone(),
        provider_file_oss_id: ep.provider_file_oss_id,
        editor_page_count: ctx.editor_page_counts.get(&ep.id).copied().unwrap_or(0),
        translator_file_oss_id: ep.translator_file_oss_id,
        proofreader_file_oss_id: ep.proofreader_file_oss_id,
        letterer_file_oss_id: ep.letterer_file_oss_id,
        timer_file_oss_id: ep.timer_file_oss_id,
        translator_setup_time: med.and_then(|d| dt_legacy_opt(d.translator_setup_time)),
        translator_update_time: med.and_then(|d| dt_legacy_opt(d.translator_update_time)),
        proofreader_setup_time: med.and_then(|d| dt_legacy_opt(d.proofreader_setup_time)),
        proofreader_update_time: med.and_then(|d| dt_legacy_opt(d.proofreader_update_time)),
        letterer_setup_time: med.and_then(|d| dt_legacy_opt(d.letterer_setup_time)),
        letterer_update_time: med.and_then(|d| dt_legacy_opt(d.letterer_update_time)),
        timer_setup_time: med.and_then(|d| dt_legacy_opt(d.timer_setup_time)),
        timer_update_time: med.and_then(|d| dt_legacy_opt(d.timer_update_time)),
        reviewer_setup_time: med.and_then(|d| dt_legacy_opt(d.reviewer_setup_time)),
        reviewer_update_time: med.and_then(|d| dt_legacy_opt(d.reviewer_update_time)),
        provider_name: ep.provider_id.and_then(|id| ctx.members.get(&id).cloned()),
        translator_name: ep
            .translator_id
            .and_then(|id| ctx.members.get(&id).cloned()),
        proofreader_name: ep
            .proofreader_id
            .and_then(|id| ctx.members.get(&id).cloned()),
        letterer_name: ep.letterer_id.and_then(|id| ctx.members.get(&id).cloned()),
        timer_name: ep.timer_id.and_then(|id| ctx.members.get(&id).cloned()),
        reviewer_name: ep.reviewer_id.and_then(|id| ctx.members.get(&id).cloned()),
        provider_filename: ep
            .provider_file_oss_id
            .and_then(|id| ctx.oss_names.get(&id).cloned()),
        translator_filename: ep
            .translator_file_oss_id
            .and_then(|id| ctx.oss_names.get(&id).cloned()),
        proofreader_filename: ep
            .proofreader_file_oss_id
            .and_then(|id| ctx.oss_names.get(&id).cloned()),
        letterer_filename: ep
            .letterer_file_oss_id
            .and_then(|id| ctx.oss_names.get(&id).cloned()),
        timer_filename: ep
            .timer_file_oss_id
            .and_then(|id| ctx.oss_names.get(&id).cloned()),
        translator_co_takers: ctx
            .role_takers
            .get(&(ep.id, "translator".to_string()))
            .cloned()
            .unwrap_or_default(),
        proofreader_co_takers: ctx
            .role_takers
            .get(&(ep.id, "proofreader".to_string()))
            .cloned()
            .unwrap_or_default(),
    }
}

/// 组装 EpisodeSimpleListVo
fn to_simple_list_vo(ep: &mangaepisodetb::Model, ctx: &WorkflowContext) -> EpisodeSimpleListVo {
    let full = to_list_vo(ep, ctx);
    EpisodeSimpleListVo {
        id: full.id,
        manga_episode: full.manga_episode,
        manga_episode_name: full.manga_episode_name,
        episode_type: full.episode_type,
        translator_file: full.translator_file,
        proofreader_file: full.proofreader_file,
        timer_file: full.timer_file,
        provider_file_oss_id: full.provider_file_oss_id,
        editor_page_count: full.editor_page_count,
        translator_file_oss_id: full.translator_file_oss_id,
        proofreader_file_oss_id: full.proofreader_file_oss_id,
        letterer_file_oss_id: full.letterer_file_oss_id,
        timer_file_oss_id: full.timer_file_oss_id,
        publish_link: full.publish_link,
    }
}

/// 组装 EpisodeDetailVo
fn to_detail_vo(ep: &mangaepisodetb::Model, ctx: &WorkflowContext) -> EpisodeDetailVo {
    let full = to_list_vo(ep, ctx);
    EpisodeDetailVo {
        id: full.id,
        manga_id: full.manga_id,
        manga_episode: full.manga_episode,
        manga_episode_name: full.manga_episode_name,
        episode_type: full.episode_type,
        provider_id: full.provider_id,
        translator_id: full.translator_id,
        proofreader_id: full.proofreader_id,
        letterer_id: full.letterer_id,
        timer_id: full.timer_id,
        reviewer_id: full.reviewer_id,
        setup_time: full.setup_time,
        update_time: full.update_time,
        publish_link: full.publish_link,
    }
}

/// 组装 UploadPageVo
fn to_upload_vo(ep: &mangaepisodetb::Model, ctx: &UploadContext) -> UploadPageVo {
    let w = &ctx.workflow;
    UploadPageVo {
        id: ep.id,
        manga_id: ep.manga_id,
        manga_name: ctx.manga_names.get(&ep.manga_id).cloned(),
        manga_episode: Some(ep.manga_episode.clone()),
        update_time: dt_legacy(ep.update_time),
        translator_file: ep.translator_file.clone(),
        proofreader_file: ep.proofreader_file.clone(),
        timer_file: ep.timer_file.clone(),
        provider_id: ep.provider_id,
        translator_id: ep.translator_id,
        proofreader_id: ep.proofreader_id,
        letterer_id: ep.letterer_id,
        timer_id: ep.timer_id,
        reviewer_id: ep.reviewer_id,
        provider_name: None,
        translator_name: ep.translator_id.and_then(|id| w.members.get(&id).cloned()),
        proofreader_name: ep.proofreader_id.and_then(|id| w.members.get(&id).cloned()),
        letterer_name: ep.letterer_id.and_then(|id| w.members.get(&id).cloned()),
        timer_name: ep.timer_id.and_then(|id| w.members.get(&id).cloned()),
        reviewer_name: ep.reviewer_id.and_then(|id| w.members.get(&id).cloned()),
        provider_file_oss_id: ep.provider_file_oss_id,
        translator_file_oss_id: ep.translator_file_oss_id,
        proofreader_file_oss_id: ep.proofreader_file_oss_id,
        letterer_file_oss_id: ep.letterer_file_oss_id,
        timer_file_oss_id: ep.timer_file_oss_id,
        provider_filename: ep
            .provider_file_oss_id
            .and_then(|id| w.oss_names.get(&id).cloned()),
        translator_filename: ep
            .translator_file_oss_id
            .and_then(|id| w.oss_names.get(&id).cloned()),
        proofreader_filename: ep
            .proofreader_file_oss_id
            .and_then(|id| w.oss_names.get(&id).cloned()),
        letterer_filename: ep
            .letterer_file_oss_id
            .and_then(|id| w.oss_names.get(&id).cloned()),
        timer_filename: ep
            .timer_file_oss_id
            .and_then(|id| w.oss_names.get(&id).cloned()),
        email: ep
            .translator_id
            .and_then(|id| w.member_emails.get(&id).cloned()),
        email_now: ep
            .proofreader_id
            .and_then(|id| w.member_emails.get(&id).cloned()),
    }
}

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

/// 可空 naive 时间转 API UTC
fn dt_legacy_opt(n: Option<chrono::NaiveDateTime>) -> Option<DateTime<Utc>> {
    n.map(crate::utils::legacy_time::naive_db_to_api_utc)
}