xiaoxia-saas/packages/adapters/sqlalchemy_impl/generated_video_repository.py

import json

from sqlalchemy.orm import Session

from packages.adapters.sqlalchemy_impl.models import GeneratedVideoModel
from packages.domain import GeneratedVideo


class SQLAlchemyGeneratedVideoRepository:
    def __init__(self, session: Session):
        self.session = session

    def create(self, video: GeneratedVideo) -> GeneratedVideo:
        model = GeneratedVideoModel(
            id=video.id,
            project_id=video.project_id,
            user_id=video.user_id,
            generation_task_id=video.generation_task_id,
            name=video.name,
            file_url=video.file_url,
            file_size=video.file_size,
            duration=video.duration,
            thumbnail_url=video.thumbnail_url,
            width=video.width,
            height=video.height,
            fps=video.fps,
            status=video.status,
            review_status=video.review_status,
            generation_params=json.dumps(video.generation_params, ensure_ascii=False),
            video_fingerprint=json.dumps(video.video_fingerprint) if video.video_fingerprint else None,
            is_duplicate=video.is_duplicate,
            duplicate_of=video.duplicate_of,
            duplicate_rate=video.duplicate_rate,
            match_count=getattr(video, "match_count", 0),
            visual_similarity=getattr(video, "visual_similarity", 0.0),
            generated_at=video.generated_at,
            created_at=video.created_at,
        )
        self.session.add(model)
        self.session.commit()
        return video

    def get(self, video_id: str) -> GeneratedVideo | None:
        model = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id == video_id).first()
        if model is None:
            return None
        return GeneratedVideo(
            id=model.id,
            project_id=model.project_id,
            user_id=getattr(model, "user_id", ""),
            generation_task_id=model.generation_task_id,
            name=model.name,
            file_url=model.file_url,
            file_size=int(model.file_size or 0),
            duration=model.duration,
            thumbnail_url=model.thumbnail_url,
            width=int(model.width or 0),
            height=int(model.height or 0),
            fps=model.fps,
            status=getattr(model, "status", "completed"),
            review_status=getattr(model, "review_status", "pending_review"),
            generation_params=json.loads(getattr(model, "generation_params", "{}") or "{}"),
            video_fingerprint=json.loads(getattr(model, "video_fingerprint", "null") or "null"),
            is_duplicate=getattr(model, "is_duplicate", False),
            duplicate_of=getattr(model, "duplicate_of", None),
            duplicate_rate=getattr(model, "duplicate_rate", None),
            match_count=getattr(model, "match_count", 0) or 0,
            visual_similarity=getattr(model, "visual_similarity", 0.0) or 0.0,
            generated_at=model.generated_at,
            created_at=model.created_at,
        )

    def update(self, video: GeneratedVideo) -> GeneratedVideo:
        model = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id == video.id).first()
        if model is None:
            return video
        model.status = video.status
        model.review_status = video.review_status
        model.generation_params = json.dumps(video.generation_params, ensure_ascii=False)
        model.video_fingerprint = json.dumps(video.video_fingerprint) if video.video_fingerprint else None
        model.is_duplicate = video.is_duplicate
        model.duplicate_of = video.duplicate_of
        model.duplicate_rate = video.duplicate_rate
        model.match_count = getattr(video, "match_count", 0)
        model.visual_similarity = getattr(video, "visual_similarity", 0.0)
        self.session.add(model)
        self.session.commit()
        return video

    def list_by_project(self, project_id: str) -> list[GeneratedVideo]:
        models = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.project_id == project_id).all()
        return [self._to_domain(model) for model in models]

    def list_by_user(self, user_id: str, *, duration_min: float = 0, duration_max: float = 0) -> list[GeneratedVideo]:
        """按 user_id 查询用户所有项目的视频（跨项目查重）。

        Args:
            user_id: 用户 ID
            duration_min: 时长下限（秒），0 表示不限
            duration_max: 时长上限（秒），0 表示不限
        """
        query = self.session.query(GeneratedVideoModel).filter(
            GeneratedVideoModel.user_id == user_id,
        )
        if duration_min > 0:
            query = query.filter(GeneratedVideoModel.duration >= duration_min)
        if duration_max > 0:
            query = query.filter(GeneratedVideoModel.duration <= duration_max)
        models = query.all()
        return [self._to_domain(model) for model in models]

    def list_by_generation_task(self, generation_task_id: str) -> list[GeneratedVideo]:
        models = (
            self.session.query(GeneratedVideoModel)
            .filter(GeneratedVideoModel.generation_task_id == generation_task_id)
            .all()
        )
        return [self._to_domain(model) for model in models]

    def list_by_batch(self, batch_id: str) -> list[GeneratedVideo]:
        """通过 batch_id 查找同批次生成的所有视频（跨 generation_task 关联查询）。"""
        from packages.adapters.sqlalchemy_impl.models import GenerationTaskModel

        task_ids = (
            self.session.query(GenerationTaskModel.id).filter(GenerationTaskModel.batch_id == batch_id).subquery()
        )
        models = (
            self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.generation_task_id.in_(task_ids)).all()
        )
        return [self._to_domain(model) for model in models]

    def list_paginated(
        self,
        *,
        user_id: str | None = None,
        project_id: str | None = None,
        status: str | None = None,
        review_status: str | None = None,
        page: int = 1,
        page_size: int = 20,
    ) -> tuple[list[GeneratedVideo], int]:
        """分页查询成片列表，支持按用户、项目、状态、复核状态筛选。"""
        query = self.session.query(GeneratedVideoModel)

        if user_id:
            query = query.filter(GeneratedVideoModel.user_id == user_id)
        if project_id:
            query = query.filter(GeneratedVideoModel.project_id == project_id)
        if status:
            query = query.filter(GeneratedVideoModel.status == status)
        if review_status:
            query = query.filter(GeneratedVideoModel.review_status == review_status)

        total = query.count()

        models = (
            query.order_by(GeneratedVideoModel.generated_at.desc())
            .offset((page - 1) * page_size)
            .limit(page_size)
            .all()
        )

        return [self._to_domain(model) for model in models], total

    def update_review_status(self, video_id: str, review_status: str) -> GeneratedVideo | None:
        """更新成片复核状态。"""
        model = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id == video_id).first()
        if model is None:
            return None
        model.review_status = review_status
        self.session.add(model)
        self.session.commit()
        return self._to_domain(model)

    def update_thumbnail(self, video_id: str, thumbnail_url: str) -> bool:
        """更新成片封面图URL。"""
        model = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id == video_id).first()
        if model is None:
            return False
        model.thumbnail_url = thumbnail_url
        self.session.add(model)
        self.session.commit()
        return True

    def get_by_ids(self, video_ids: list[str]) -> list[GeneratedVideo]:
        """批量获取成片记录。"""
        if not video_ids:
            return []
        models = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id.in_(video_ids)).all()
        return [self._to_domain(model) for model in models]

    def delete(self, video_id: str) -> bool:
        """删除单个成片记录（硬删除）。"""
        model = self.session.query(GeneratedVideoModel).filter(GeneratedVideoModel.id == video_id).first()
        if model is None:
            return False
        self.session.delete(model)
        self.session.commit()
        return True

    def batch_delete(self, video_ids: list[str]) -> int:
        """批量删除成片记录，返回成功删除数量。"""
        if not video_ids:
            return 0
        result = (
            self.session.query(GeneratedVideoModel)
            .filter(GeneratedVideoModel.id.in_(video_ids))
            .delete(synchronize_session=False)
        )
        self.session.commit()
        return result

    @staticmethod
    def _to_domain(model: GeneratedVideoModel) -> GeneratedVideo:
        return GeneratedVideo(
            id=model.id,
            project_id=model.project_id,
            user_id=getattr(model, "user_id", ""),
            generation_task_id=model.generation_task_id,
            name=model.name,
            file_url=model.file_url,
            file_size=int(model.file_size or 0),
            duration=model.duration,
            thumbnail_url=model.thumbnail_url,
            width=int(model.width or 0),
            height=int(model.height or 0),
            fps=model.fps,
            status=getattr(model, "status", "completed"),
            review_status=getattr(model, "review_status", "pending_review"),
            generation_params=json.loads(getattr(model, "generation_params", "{}") or "{}"),
            video_fingerprint=json.loads(getattr(model, "video_fingerprint", "null") or "null"),
            is_duplicate=getattr(model, "is_duplicate", False),
            duplicate_of=getattr(model, "duplicate_of", None),
            duplicate_rate=getattr(model, "duplicate_rate", None),
            match_count=getattr(model, "match_count", 0) or 0,
            visual_similarity=getattr(model, "visual_similarity", 0.0) or 0.0,
            generated_at=model.generated_at,
            created_at=model.created_at,
        )