Job 批次完成任務 Implementation Plan

{
  "status": true,
  "data": {
    "total": 3,
    "completed_count": 2,
    "failed_count": 1,
    "results": [
      {"job_uid": "job-uid-1", "success": true},
      {"job_uid": "job-uid-2", "success": true},
      {"job_uid": "job-uid-3", "success": false, "error": "任務不在處理中狀態"}
    ]
  }
}

"""Job 批次完成 Serializers"""
from marshmallow import Schema, fields


class BatchCompleteRequestSchema(Schema):
    comment = fields.String(allow_none=True, load_default="")
    job_uids = fields.List(fields.String(), required=True)


class BatchCompleteResultItemSchema(Schema):
    job_uid = fields.String()
    success = fields.Boolean()
    error = fields.String(allow_none=True, load_default=None)


class BatchCompleteResponseSchema(Schema):
    total = fields.Integer()
    completed_count = fields.Integer()
    failed_count = fields.Integer()
    results = fields.List(fields.Nested(BatchCompleteResultItemSchema))

"""Job 批次完成 Service"""
import logging

from jedi_common.session.database.session_context import get_session
from jedi_flow_engine.common.enum.job_code import JobType
from jedi_flow_engine.infra.models.job_execution import JobExecution
from infra.flow_engine.models.ext_workflow_execution import ExtWorkflowExecution
from app.flow_engine.service.workflow_execution_service import WorkflowExecutionService

logger = logging.getLogger(__name__)


class JobBatchCompleteService:

    def __init__(self, workflow_execution_service: WorkflowExecutionService):
        self._wf_svc = workflow_execution_service

    def batch_complete(self, job_uids: list, comment: str, login_name: str, nickname: str) -> dict:
        """批次完成任務

        逐筆呼叫 complete_job，每筆獨立處理成功/失敗。
        """
        session = get_session()

        # 批次查詢 job_uid → (template_job_id, workflow_execution_id)
        jobs = (
            session.query(
                JobExecution.uid,
                JobExecution.template_job_id,
                JobExecution.workflow_execution_id,
            )
            .filter(
                JobExecution.uid.in_(job_uids),
                JobExecution.type == JobType.USER,
            )
            .all()
        )
        job_map = {str(j.uid): (j.template_job_id, j.workflow_execution_id) for j in jobs}

        # 批次查詢 workflow_execution_id → uid
        wf_exec_ids = list({v[1] for v in job_map.values() if v[1]})
        wf_uid_map = {}
        if wf_exec_ids:
            wf_rows = (
                session.query(ExtWorkflowExecution.id, ExtWorkflowExecution.uid)
                .filter(ExtWorkflowExecution.id.in_(wf_exec_ids))
                .all()
            )
            wf_uid_map = {r.id: str(r.uid) for r in wf_rows}

        results = []
        completed_count = 0

        for job_uid in job_uids:
            if job_uid not in job_map:
                results.append({"job_uid": job_uid, "success": False, "error": "任務不存在"})
                continue

            template_job_id, wf_exec_id = job_map[job_uid]
            wf_uid = wf_uid_map.get(wf_exec_id)
            if not wf_uid or not template_job_id:
                results.append({"job_uid": job_uid, "success": False, "error": "找不到對應的工作流程"})
                continue

            try:
                self._wf_svc.complete_job(
                    workflow_execution_uid=wf_uid,
                    job_id=template_job_id,
                    user=login_name,
                    comment=comment,
                    user_nickname=nickname,
                )
                completed_count += 1
                results.append({"job_uid": job_uid, "success": True, "error": None})
            except Exception as e:
                logger.warning(f"Batch complete failed for job {job_uid}: {e}")
                results.append({"job_uid": job_uid, "success": False, "error": str(e)})

        return {
            "total": len(job_uids),
            "completed_count": completed_count,
            "failed_count": len(job_uids) - completed_count,
            "results": results,
        }

"""Job 批次完成 Route"""
from dependency_injector.wiring import inject, Provide
from flask import request
from flask_apispec import MethodResource, doc, use_kwargs, marshal_with
from flask_jwt_extended import jwt_required
from jedi_common.session.auth.auth_context import get_user_context

from api.grc.serializers.job_batch_complete import (
    BatchCompleteRequestSchema,
    BatchCompleteResponseSchema,
)
from app.grc.service.job_batch_complete_service import JobBatchCompleteService
from common.util.response_util import return_response
from di_containers.containers import Containers

AUTH_PARAMS = {"Authorization": {"description": "Bearer token", "in": "header", "type": "string"}}


class JobBatchCompleteRoute(MethodResource):
    """POST /grc/project/<project_uid>/jobs/batch-complete"""

    @doc(description="批次完成任務", tags=["GRC Projects"], params=AUTH_PARAMS)
    @use_kwargs(BatchCompleteRequestSchema, location="json", apply=False)
    @marshal_with(BatchCompleteResponseSchema, apply=False)
    @jwt_required()
    @inject
    def post(
        self,
        project_uid: str,
        batch_complete_service: JobBatchCompleteService = Provide[
            Containers.grc_container.job_batch_complete_service
        ],
    ):
        payload = request.get_json(silent=True) or {}
        data = BatchCompleteRequestSchema().load(payload)
        user = get_user_context()
        result = batch_complete_service.batch_complete(
            job_uids=data["job_uids"],
            comment=data.get("comment", ""),
            login_name=user.login_name,
            nickname=user.nickname or "",
        )
        return return_response(True, BatchCompleteResponseSchema().dump(result))

from api.grc.routes.job_batch_complete_route import JobBatchCompleteRoute

api.add_resource(
    JobBatchCompleteRoute,
    "/project/<project_uid>/jobs/batch-complete",
)

from app.grc.service.job_batch_complete_service import JobBatchCompleteService

job_batch_complete_service = providers.Factory(
    JobBatchCompleteService,
    workflow_execution_service=workflow_execution_container.workflow_execution_service,
)