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

"""项目管理 SQLAlchemy Repository 实现"""

import json

from sqlalchemy.orm import Session

from packages.domain import Milestone, Task, TaskIssue
from packages.ports.project_management_repositories import (
    MilestoneRepository,
    TaskIssueRepository,
    TaskRepository,
)

from .models import MilestoneModel, TaskIssueModel, TaskModel


class SQLAlchemyTaskRepository(TaskRepository):
    """任务 SQLAlchemy 仓储实现"""

    def __init__(self, session: Session):
        self._session = session

    def create(self, task: Task) -> Task:
        model = TaskModel(
            id=task.id,
            project_id=task.project_id,
            workspace_id=task.workspace_id,
            name=task.name,
            description=task.description,
            status=task.status.value,
            priority=task.priority.value,
            parent_task_id=task.parent_task_id,
            assignee_user_id=task.assignee_user_id,
            progress=task.progress,
            planned_start_date=task.planned_start_date,
            planned_end_date=task.planned_end_date,
            actual_start_date=task.actual_start_date,
            actual_end_date=task.actual_end_date,
            tags_json=json.dumps(task.tags, ensure_ascii=False),
            created_at=task.created_at,
            updated_at=task.updated_at,
        )
        self._session.add(model)
        self._session.commit()
        return task

    def get_by_id(self, task_id: str) -> Task | None:
        model = self._session.query(TaskModel).filter(TaskModel.id == task_id).first()
        if not model:
            return None
        return self._model_to_entity(model)

    def list_by_project(self, project_id: str) -> list[Task]:
        models = self._session.query(TaskModel).filter(TaskModel.project_id == project_id).all()
        return [self._model_to_entity(m) for m in models]

    def list_by_parent(self, parent_task_id: str) -> list[Task]:
        models = self._session.query(TaskModel).filter(TaskModel.parent_task_id == parent_task_id).all()
        return [self._model_to_entity(m) for m in models]

    def update(self, task: Task) -> Task:
        model = self._session.query(TaskModel).filter(TaskModel.id == task.id).first()
        if not model:
            raise ValueError(f"Task {task.id} not found")

        model.name = task.name
        model.description = task.description
        model.status = task.status.value
        model.priority = task.priority.value
        model.parent_task_id = task.parent_task_id
        model.assignee_user_id = task.assignee_user_id
        model.progress = task.progress
        model.planned_start_date = task.planned_start_date
        model.planned_end_date = task.planned_end_date
        model.actual_start_date = task.actual_start_date
        model.actual_end_date = task.actual_end_date
        model.tags_json = json.dumps(task.tags, ensure_ascii=False)
        model.updated_at = task.updated_at

        self._session.commit()
        return task

    def delete(self, task_id: str) -> None:
        self._session.query(TaskModel).filter(TaskModel.id == task_id).delete()
        self._session.commit()

    def _model_to_entity(self, model: TaskModel) -> Task:
        from packages.domain.project_management import TaskPriority, TaskStatus

        return Task(
            id=model.id,
            project_id=model.project_id,
            workspace_id=model.workspace_id,
            name=model.name,
            description=model.description,
            status=TaskStatus(model.status),
            priority=TaskPriority(model.priority),
            parent_task_id=model.parent_task_id,
            assignee_user_id=model.assignee_user_id,
            progress=model.progress,
            planned_start_date=model.planned_start_date,
            planned_end_date=model.planned_end_date,
            actual_start_date=model.actual_start_date,
            actual_end_date=model.actual_end_date,
            tags=json.loads(model.tags_json),
            created_at=model.created_at,
            updated_at=model.updated_at,
        )


class SQLAlchemyMilestoneRepository(MilestoneRepository):
    """里程碑 SQLAlchemy 仓储实现"""

    def __init__(self, session: Session):
        self._session = session

    def create(self, milestone: Milestone) -> Milestone:
        model = MilestoneModel(
            id=milestone.id,
            project_id=milestone.project_id,
            workspace_id=milestone.workspace_id,
            name=milestone.name,
            description=milestone.description,
            target_date=milestone.target_date,
            completed=milestone.completed,
            completed_at=milestone.completed_at,
            created_at=milestone.created_at,
            updated_at=milestone.updated_at,
        )
        self._session.add(model)
        self._session.commit()
        return milestone

    def get_by_id(self, milestone_id: str) -> Milestone | None:
        model = self._session.query(MilestoneModel).filter(MilestoneModel.id == milestone_id).first()
        if not model:
            return None
        return self._model_to_entity(model)

    def list_by_project(self, project_id: str) -> list[Milestone]:
        models = self._session.query(MilestoneModel).filter(MilestoneModel.project_id == project_id).all()
        return [self._model_to_entity(m) for m in models]

    def update(self, milestone: Milestone) -> Milestone:
        model = self._session.query(MilestoneModel).filter(MilestoneModel.id == milestone.id).first()
        if not model:
            raise ValueError(f"Milestone {milestone.id} not found")

        model.name = milestone.name
        model.description = milestone.description
        model.target_date = milestone.target_date
        model.completed = milestone.completed
        model.completed_at = milestone.completed_at
        model.updated_at = milestone.updated_at

        self._session.commit()
        return milestone

    def delete(self, milestone_id: str) -> None:
        self._session.query(MilestoneModel).filter(MilestoneModel.id == milestone_id).delete()
        self._session.commit()

    def _model_to_entity(self, model: MilestoneModel) -> Milestone:
        return Milestone(
            id=model.id,
            project_id=model.project_id,
            workspace_id=model.workspace_id,
            name=model.name,
            description=model.description,
            target_date=model.target_date,
            completed=model.completed,
            completed_at=model.completed_at,
            created_at=model.created_at,
            updated_at=model.updated_at,
        )


class SQLAlchemyTaskIssueRepository(TaskIssueRepository):
    """任务问题 SQLAlchemy 仓储实现"""

    def __init__(self, session: Session):
        self._session = session

    def create(self, issue: TaskIssue) -> TaskIssue:
        model = TaskIssueModel(
            id=issue.id,
            task_id=issue.task_id,
            project_id=issue.project_id,
            workspace_id=issue.workspace_id,
            title=issue.title,
            description=issue.description,
            resolved=issue.resolved,
            resolved_at=issue.resolved_at,
            created_by_user_id=issue.created_by_user_id,
            created_at=issue.created_at,
            updated_at=issue.updated_at,
        )
        self._session.add(model)
        self._session.commit()
        return issue

    def get_by_id(self, issue_id: str) -> TaskIssue | None:
        model = self._session.query(TaskIssueModel).filter(TaskIssueModel.id == issue_id).first()
        if not model:
            return None
        return self._model_to_entity(model)

    def list_by_task(self, task_id: str) -> list[TaskIssue]:
        models = self._session.query(TaskIssueModel).filter(TaskIssueModel.task_id == task_id).all()
        return [self._model_to_entity(m) for m in models]

    def list_by_project(self, project_id: str) -> list[TaskIssue]:
        models = self._session.query(TaskIssueModel).filter(TaskIssueModel.project_id == project_id).all()
        return [self._model_to_entity(m) for m in models]

    def update(self, issue: TaskIssue) -> TaskIssue:
        model = self._session.query(TaskIssueModel).filter(TaskIssueModel.id == issue.id).first()
        if not model:
            raise ValueError(f"TaskIssue {issue.id} not found")

        model.title = issue.title
        model.description = issue.description
        model.resolved = issue.resolved
        model.resolved_at = issue.resolved_at
        model.updated_at = issue.updated_at

        self._session.commit()
        return issue

    def delete(self, issue_id: str) -> None:
        self._session.query(TaskIssueModel).filter(TaskIssueModel.id == issue_id).delete()
        self._session.commit()

    def _model_to_entity(self, model: TaskIssueModel) -> TaskIssue:
        return TaskIssue(
            id=model.id,
            task_id=model.task_id,
            project_id=model.project_id,
            workspace_id=model.workspace_id,
            title=model.title,
            description=model.description,
            resolved=model.resolved,
            resolved_at=model.resolved_at,
            created_by_user_id=model.created_by_user_id,
            created_at=model.created_at,
            updated_at=model.updated_at,
        )