链式调用可以用来处理复杂的业务流程

最新推荐文章于 2025-12-15 16:19:48 发布

原创最新推荐文章于 2025-12-15 16:19:48 发布 · 1.3k 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#fastapi

在FastAPI中，链式调用可以用来处理复杂的业务流程，例如MES系统中的工艺流程。链式调用可以帮助你将多个步骤组合在一起，每个步骤可以处理一部分逻辑，并且可以方便地处理异常和驳回。

以下是一个示例代码，展示如何使用链式调用来处理三个工艺流程，每个流程需要录入一些信息，并且中间可能有驳回和异常处理。

示例代码

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel

app = FastAPI()

# 定义工艺流程步骤
class ProcessStep(BaseModel):
    step_id: int
    step_name: str
    data: dict
    is_approved: bool = False

# 定义工艺流程
class ProcessFlow:
    def __init__(self, steps: list[ProcessStep]):
        self.steps = steps
        self.current_step_index = 0

    # 开始流程
    def start(self):
        if self.current_step_index >= len(self.steps):
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="流程已结束")
        return self._process_step()

    # 处理当前步骤
    def _process_step(self):
        step = self.steps[self.current_step_index]
        if step.is_approved:
            self.current_step_index += 1
            if self.current_step_index < len(self.steps):
                return self._process_step()
            else:
                return {"message": "流程已成功完成"}
        else:
            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="当前步骤未通过审批")

    # 审批步骤
    def approve_step(self, step_id: int, approval_data: dict):
        for step in self.steps:
            if step.step_id == step_id:
                step.is_approved = True
                step.data.update(approval_data)
                return self._process_step()
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="步骤未找到")

    # 驳回步骤
    def reject_step(self, step_id: int, rejection_data: dict):
        for step in self.steps:
            if step.step_id == step_id:
                step.is_approved = False
                step.data.update(rejection_data)
                return {"message": "步骤已驳回"}
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="步骤未找到")

# 示例工艺流程
steps = [
    ProcessStep(step_id=1, step_name="第一步", data={}),
    ProcessStep(step_id=2, step_name="第二步", data={}),
    ProcessStep(step_id=3, step_name="第三步", data={}),
]

process_flow = ProcessFlow(steps=steps)

# FastAPI路由
@app.post("/process/start")
async def start_process():
    return process_flow.start()

@app.post("/process/approve/{step_id}")
async def approve_process_step(step_id: int, approval_data: dict):
    return process_flow.approve_step(step_id, approval_data)

@app.post("/process/reject/{step_id}")
async def reject_process_step(step_id: int, rejection_data: dict):
    return process_flow.reject_step(step_id, rejection_data)

代码说明

ProcessStep 类：定义了每个工艺流程步骤的基本结构，包括步骤ID、步骤名称、录入的数据和审批状态。
ProcessFlow 类：管理整个工艺流程，包括开始流程、审批步骤、驳回步骤等。
start 方法：启动流程，从第一个步骤开始处理。
approve_step 方法：审批某个步骤，更新步骤数据并继续处理下一个步骤。
reject_step 方法：驳回某个步骤，更新步骤数据并停止流程。
FastAPI 路由：提供了三个路由，分别用于启动流程、审批步骤和驳回步骤。

示例流程

启动流程：

POST /process/start

{
    "step_id": 1,
    "step_name": "第一步",
    "data": {},
    "is_approved": false
}

审批第一步：

POST /process/approve/1
Content-Type: application/json

{
    "approval_data": {
        "approved_by": "user1",
        "approval_time": "2024-10-10T10:00:00"
    }
}

{
    "step_id": 2,
    "step_name": "第二步",
    "data": {},
    "is_approved": false
}

驳回第二步：

POST /process/reject/2
Content-Type: application/json

{
    "rejection_data": {
        "rejected_by": "user2",
        "rejection_reason": "数据不完整"
    }
}

{
    "message": "步骤已驳回"
}

再次审批第二步：

POST /process/approve/2
Content-Type: application/json

{
    "approval_data": {
        "approved_by": "user3",
        "approval_time": "2024-10-10T11:00:00"
    }
}

{
    "step_id": 3,
    "step_name": "第三步",
    "data": {},
    "is_approved": false
}

审批第三步：

POST /process/approve/3
Content-Type: application/json

{
    "approval_data": {
        "approved_by": "user4",
        "approval_time": "2024-10-10T12:00:00"
    }
}

{
    "message": "流程已成功完成"
}

总结

通过链式调用，可以将复杂的工艺流程分解为多个步骤，并且每个步骤可以独立处理审批和驳回逻辑。这种方式不仅清晰易懂，而且可以方便地扩展和维护。