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

"""SQLAlchemy implementation of TemplateClipConfigRepository."""

from __future__ import annotations

from typing import List, Optional

from sqlalchemy.orm import Session

from packages.adapters.sqlalchemy_impl.models import (
    TemplateClipConfigModel,
    TemplateModel,
)
from packages.domain.template_clip_config import (
    ClipType,
    TemplateClipConfig,
    TransitionEffect,
)


class SQLAlchemyTemplateClipConfigRepository:
    """SQLAlchemy 模板片段配置仓储"""

    def __init__(self, session: Session) -> None:
        self.session = session

    def list_by_template(
        self,
        template_id: str,
        *,
        clip_type: Optional[ClipType] = None,
        skip: int = 0,
        limit: int = 100,
    ) -> List[TemplateClipConfig]:
        """按模板列出片段配置，按 order 排序"""
        query = self.session.query(TemplateClipConfigModel).filter(
            TemplateClipConfigModel.template_id == template_id,
        )
        if clip_type:
            query = query.filter(TemplateClipConfigModel.clip_type == clip_type)
        query = query.order_by(TemplateClipConfigModel.order)
        models = query.offset(skip).limit(limit).all()
        return [self._model_to_entity(m) for m in models]

    def template_owned_by(self, template_id: str, user_id: str) -> bool:
        """校验旧模板主表 ``templates`` 中模板归属当前用户且未删除（is_active=True）.

        片段配置主表 ``template_clip_configs`` 本身没有 user_id 列，
        归属关系通过模板主表 ``templates.user_id`` 确定。
        新表 ``edit_templates`` 为全局模板库（无 user_id 列），不走此校验。
        """
        return (
            self.session.query(TemplateModel.id)
            .filter(
                TemplateModel.id == template_id,
                TemplateModel.user_id == user_id,
                TemplateModel.is_active.is_(True),
            )
            .first()
            is not None
        )

    def get(self, config_id: str) -> Optional[TemplateClipConfig]:
        """根据 ID 获取配置"""
        model = self.session.query(TemplateClipConfigModel).filter(TemplateClipConfigModel.id == config_id).first()
        if model is None:
            return None
        return self._model_to_entity(model)

    def create(self, config: TemplateClipConfig) -> TemplateClipConfig:
        """创建配置"""
        model = TemplateClipConfigModel(
            id=config.id,
            template_id=config.template_id,
            clip_type=config.clip_type,
            order=config.order,
            min_duration=config.min_duration,
            max_duration=config.max_duration,
            text_template=config.text_template,
            material_requirements=config.material_requirements,
            transition_effect=config.transition_effect,
            config=config.config,
        )
        self.session.add(model)
        self.session.commit()
        self.session.refresh(model)
        return self._model_to_entity(model)

    def update(self, config: TemplateClipConfig) -> TemplateClipConfig:
        """更新配置"""
        model = self.session.query(TemplateClipConfigModel).filter(TemplateClipConfigModel.id == config.id).first()
        if model is None:
            raise ValueError(f"TemplateClipConfig {config.id} not found")
        model.template_id = config.template_id
        model.clip_type = config.clip_type
        model.order = config.order
        model.min_duration = config.min_duration
        model.max_duration = config.max_duration
        model.text_template = config.text_template
        model.material_requirements = config.material_requirements
        model.transition_effect = config.transition_effect
        model.config = config.config
        model.updated_at = config.updated_at
        self.session.commit()
        self.session.refresh(model)
        return self._model_to_entity(model)

    def delete(self, config_id: str) -> bool:
        """删除配置"""
        model = self.session.query(TemplateClipConfigModel).filter(TemplateClipConfigModel.id == config_id).first()
        if model is None:
            return False
        self.session.delete(model)
        self.session.commit()
        return True

    def delete_by_template(self, template_id: str, *, commit: bool = True) -> int:
        """删除模板下所有片段配置，返回删除数量

        Args:
            template_id: 模板ID
            commit: 是否提交事务，默认True。外层有事务控制时传False。
        """
        count = (
            self.session.query(TemplateClipConfigModel)
            .filter(TemplateClipConfigModel.template_id == template_id)
            .delete()
        )
        if commit:
            self.session.commit()
        return count

    def count(self, *, template_id: Optional[str] = None) -> int:
        """统计配置数量"""
        query = self.session.query(TemplateClipConfigModel)
        if template_id:
            query = query.filter(TemplateClipConfigModel.template_id == template_id)
        return query.count()

    @staticmethod
    def _model_to_entity(model: TemplateClipConfigModel) -> TemplateClipConfig:
        return TemplateClipConfig(
            id=model.id,
            template_id=model.template_id,
            clip_type=ClipType(model.clip_type),
            order=model.order,
            min_duration=model.min_duration or 0.0,
            max_duration=model.max_duration or 0.0,
            text_template=model.text_template or "",
            material_requirements=model.material_requirements or {},
            transition_effect=(
                TransitionEffect(model.transition_effect) if model.transition_effect else TransitionEffect.CUT
            ),
            config=model.config or {},
            created_at=model.created_at,
            updated_at=model.updated_at,
        )