1499 lines
57 KiB
Python
1499 lines
57 KiB
Python
#!/usr/bin/env python
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
工作流 API 接口
|
||
"""
|
||
import json
|
||
import logging
|
||
from typing import List
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException, Query, Request
|
||
from fastapi.responses import StreamingResponse
|
||
|
||
logger = logging.getLogger(__name__)
|
||
from sqlalchemy import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.database import get_db
|
||
from core.application.model import Application
|
||
from app.config import settings
|
||
from app.base_schema import PaginatedResponse, ResponseModel
|
||
from online_dev.workflow.schema import (
|
||
WorkflowDefinitionCreate,
|
||
WorkflowDefinitionUpdate,
|
||
WorkflowDefinitionOut,
|
||
WorkflowDefinitionListOut,
|
||
WorkflowImportCheckIn,
|
||
WorkflowImportCheckOut,
|
||
WorkflowImportIn,
|
||
WorkflowInstanceCreate,
|
||
WorkflowInstanceOut,
|
||
WorkflowInstanceListOut,
|
||
WorkflowTaskOut,
|
||
WorkflowTaskListOut,
|
||
WorkflowLogOut,
|
||
TaskApproveInput,
|
||
TaskHandleInput,
|
||
TaskReviseInput,
|
||
TaskTransferInput,
|
||
TaskDelegateInput,
|
||
TaskAddSignInput,
|
||
MessageResponse,
|
||
CountResponse,
|
||
)
|
||
from online_dev.workflow.service import (
|
||
WorkflowDefinitionService,
|
||
WorkflowInstanceService,
|
||
WorkflowTaskService,
|
||
WorkflowLogService,
|
||
)
|
||
|
||
router = APIRouter(prefix="/workflow", tags=["工作流管理"])
|
||
|
||
|
||
# ==================== 辅助函数 ====================
|
||
|
||
def _get_action_label(action: str) -> str:
|
||
"""获取操作标签"""
|
||
labels = {
|
||
'approve': '通过',
|
||
'reject': '拒绝',
|
||
'return': '驳回',
|
||
'transfer': '转办',
|
||
'delegate': '委派',
|
||
'add_sign': '加签',
|
||
'reduce_sign': '减签',
|
||
}
|
||
return labels.get(action, action)
|
||
|
||
async def _build_definition_out(db: AsyncSession, workflow) -> dict:
|
||
"""构建流程定义输出"""
|
||
return {
|
||
"id": str(workflow.id),
|
||
"application_id": workflow.application_id,
|
||
"name": workflow.name,
|
||
"code": workflow.code,
|
||
"workflow_type": workflow.workflow_type or "other",
|
||
"icon": workflow.icon or "",
|
||
"icon_bg_color": workflow.icon_bg_color or "",
|
||
"category": workflow.category or "",
|
||
"description": workflow.description or "",
|
||
"status": workflow.status,
|
||
"version": workflow.version,
|
||
"form_code": workflow.form_code,
|
||
"form_name": workflow.form_name or "",
|
||
"flow_definition": workflow.flow_definition or {},
|
||
"sort": workflow.sort or 0,
|
||
"created_at": workflow.sys_create_datetime,
|
||
"updated_at": workflow.sys_update_datetime,
|
||
}
|
||
|
||
|
||
def _build_definition_list_out(workflow, application_name: str = "") -> dict:
|
||
"""构建流程定义列表输出"""
|
||
return {
|
||
"id": str(workflow.id),
|
||
"application_id": workflow.application_id,
|
||
"application_name": application_name,
|
||
"name": workflow.name,
|
||
"code": workflow.code,
|
||
"workflow_type": workflow.workflow_type or "other",
|
||
"icon": workflow.icon or "",
|
||
"icon_bg_color": workflow.icon_bg_color or "",
|
||
"category": workflow.category or "",
|
||
"description": workflow.description or "",
|
||
"status": workflow.status,
|
||
"version": workflow.version,
|
||
"form_code": workflow.form_code,
|
||
"form_name": workflow.form_name or "",
|
||
"sort": workflow.sort or 0,
|
||
"created_at": workflow.sys_create_datetime,
|
||
"updated_at": workflow.sys_update_datetime,
|
||
}
|
||
|
||
|
||
async def _build_instance_out(db: AsyncSession, instance) -> dict:
|
||
"""构建流程实例输出"""
|
||
from online_dev.workflow.model import WorkflowDefinition
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
|
||
# 获取流程定义
|
||
stmt = select(WorkflowDefinition).where(WorkflowDefinition.id == instance.workflow_id)
|
||
result = await db.execute(stmt)
|
||
workflow = result.scalar_one_or_none()
|
||
|
||
# 获取发起人
|
||
stmt = select(User).where(User.id == instance.initiator_id)
|
||
result = await db.execute(stmt)
|
||
initiator = result.scalar_one_or_none()
|
||
|
||
# 判断流程是否绑定了单据模板（通过 DocumentTemplate.workflow_code 查找）
|
||
has_document_templates = False
|
||
if workflow:
|
||
from online_dev.document_generator.service import DocumentTemplateService
|
||
bound_templates = await DocumentTemplateService.get_by_workflow_code(db, workflow.code)
|
||
has_document_templates = len(bound_templates) > 0
|
||
|
||
return {
|
||
"id": str(instance.id),
|
||
"instance_no": instance.instance_no,
|
||
"title": instance.title,
|
||
"status": instance.status,
|
||
"workflow_id": str(instance.workflow_id),
|
||
"workflow_name": workflow.name if workflow else "",
|
||
"workflow_code": workflow.code if workflow else "",
|
||
"form_code": instance.form_code,
|
||
"form_data_id": instance.form_data_id,
|
||
"current_node_id": instance.current_node_id or "",
|
||
"current_node_name": instance.current_node_name or "",
|
||
"initiator_id": str(instance.initiator_id),
|
||
"initiator_name": initiator.name if initiator else "",
|
||
"started_at": instance.started_at,
|
||
"completed_at": instance.completed_at,
|
||
"has_document_templates": has_document_templates,
|
||
}
|
||
|
||
|
||
async def _build_instance_list_out(db: AsyncSession, instance) -> dict:
|
||
"""构建流程实例列表输出"""
|
||
from online_dev.workflow.model import WorkflowDefinition
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
|
||
# 获取流程定义
|
||
stmt = select(WorkflowDefinition).where(WorkflowDefinition.id == instance.workflow_id)
|
||
result = await db.execute(stmt)
|
||
workflow = result.scalar_one_or_none()
|
||
|
||
# 获取发起人
|
||
stmt = select(User).where(User.id == instance.initiator_id)
|
||
result = await db.execute(stmt)
|
||
initiator = result.scalar_one_or_none()
|
||
|
||
# 判断流程是否绑定了单据模板（通过 DocumentTemplate.workflow_code 查找）
|
||
has_document_templates = False
|
||
application_name = ""
|
||
if workflow:
|
||
from online_dev.document_generator.service import DocumentTemplateService
|
||
bound_templates = await DocumentTemplateService.get_by_workflow_code(db, workflow.code)
|
||
has_document_templates = len(bound_templates) > 0
|
||
if workflow.application_id:
|
||
from core.application.model import Application
|
||
app_stmt = select(Application).where(Application.id == workflow.application_id)
|
||
app_result = await db.execute(app_stmt)
|
||
app = app_result.scalar_one_or_none()
|
||
application_name = app.name if app else ""
|
||
|
||
return {
|
||
"id": str(instance.id),
|
||
"instance_no": instance.instance_no,
|
||
"title": instance.title,
|
||
"status": instance.status,
|
||
"workflow_name": workflow.name if workflow else "",
|
||
"application_name": application_name,
|
||
"current_node_name": instance.current_node_name or "",
|
||
"initiator_name": initiator.name if initiator else "",
|
||
"started_at": instance.started_at,
|
||
"completed_at": instance.completed_at,
|
||
"has_document_templates": has_document_templates,
|
||
}
|
||
|
||
|
||
async def _build_task_out(db: AsyncSession, task, include_form: bool = False) -> dict:
|
||
"""构建任务输出"""
|
||
from online_dev.workflow.model import WorkflowInstance, WorkflowDefinition, WorkflowLog
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
|
||
# 获取实例
|
||
stmt = select(WorkflowInstance).where(WorkflowInstance.id == task.instance_id)
|
||
result = await db.execute(stmt)
|
||
instance = result.scalar_one_or_none()
|
||
|
||
# 获取流程定义
|
||
workflow = None
|
||
if instance:
|
||
stmt = select(WorkflowDefinition).where(WorkflowDefinition.id == instance.workflow_id)
|
||
result = await db.execute(stmt)
|
||
workflow = result.scalar_one_or_none()
|
||
|
||
# 缓存 workflow 属性，避免后续 service.get() 内部 db.rollback() 导致 session 对象过期
|
||
_workflow_name = workflow.name if workflow else ""
|
||
_flow_definition = workflow.flow_definition if workflow else {}
|
||
|
||
# 获取处理人
|
||
stmt = select(User).where(User.id == task.assignee_id)
|
||
result = await db.execute(stmt)
|
||
assignee = result.scalar_one_or_none()
|
||
|
||
# 获取发起人
|
||
initiator = None
|
||
if instance:
|
||
stmt = select(User).where(User.id == instance.initiator_id)
|
||
result = await db.execute(stmt)
|
||
initiator = result.scalar_one_or_none()
|
||
|
||
# 判断取消原因
|
||
cancel_reason = ""
|
||
if task.status == 'canceled':
|
||
if (task.comment or '') == '__or_sign_canceled__':
|
||
cancel_reason = "or_sign"
|
||
else:
|
||
cancel_reason = "revoked"
|
||
|
||
# 判断流程是否绑定了单据模板
|
||
has_document_templates = False
|
||
if workflow:
|
||
from online_dev.document_generator.service import DocumentTemplateService
|
||
bound_templates = await DocumentTemplateService.get_by_workflow_code(db, workflow.code)
|
||
has_document_templates = len(bound_templates) > 0
|
||
|
||
out = {
|
||
"id": str(task.id),
|
||
"instance_id": str(task.instance_id),
|
||
"instance_no": instance.instance_no if instance else "",
|
||
"instance_title": instance.title if instance else "",
|
||
"instance_status": instance.status if instance else "",
|
||
"node_id": task.node_id,
|
||
"node_name": task.node_name,
|
||
"task_type": task.task_type,
|
||
"status": task.status,
|
||
"assignee_id": str(task.assignee_id),
|
||
"assignee_name": assignee.name if assignee else "",
|
||
"comment": "" if cancel_reason == "or_sign" else (task.comment or ""),
|
||
"cancel_reason": cancel_reason,
|
||
"handled_at": task.handled_at,
|
||
"sys_create_datetime": task.sys_create_datetime,
|
||
"workflow_name": _workflow_name,
|
||
"initiator_name": initiator.name if initiator else "",
|
||
"started_at": instance.started_at if instance else None,
|
||
"has_document_templates": has_document_templates,
|
||
}
|
||
|
||
if include_form:
|
||
form_code = instance.form_code if instance else None
|
||
form_data_id = instance.form_data_id if instance else None
|
||
out["form_code"] = form_code
|
||
|
||
# 获取表单元数据（form_config）
|
||
form_config = None
|
||
if form_code:
|
||
try:
|
||
from online_dev.form_manager.model import FormMeta
|
||
stmt = select(FormMeta).where(
|
||
FormMeta.code == form_code,
|
||
FormMeta.is_deleted == False,
|
||
)
|
||
result = await db.execute(stmt)
|
||
form_meta = result.scalar_one_or_none()
|
||
if form_meta:
|
||
form_config = form_meta.form_config
|
||
except Exception as e:
|
||
import logging
|
||
logging.warning(f"获取表单配置失败: {e}")
|
||
out["form_config"] = form_config
|
||
|
||
# 获取表单数据（form_data）
|
||
form_data = {}
|
||
if form_code and form_data_id:
|
||
try:
|
||
from online_dev.form_data_manager.service import FormDataService
|
||
service = await FormDataService.create_service(db, form_code)
|
||
form_data = await service.get(db, form_data_id)
|
||
except Exception as e:
|
||
import logging
|
||
logging.warning(f"获取表单数据失败: {e}")
|
||
out["form_data"] = form_data
|
||
|
||
# 获取当前节点的字段权限和操作权限
|
||
form_permissions = []
|
||
action_permissions = []
|
||
flow_def = _flow_definition
|
||
nodes = flow_def.get('nodes', {})
|
||
|
||
# 递归查找节点
|
||
def find_node(node, target_id):
|
||
if not node:
|
||
return None
|
||
if isinstance(node, dict):
|
||
if node.get('id') == target_id:
|
||
return node
|
||
children = node.get('children')
|
||
if children:
|
||
found = find_node(children, target_id)
|
||
if found:
|
||
return found
|
||
branches = node.get('branches', [])
|
||
for branch in branches:
|
||
if branch.get('id') == target_id:
|
||
return branch
|
||
branch_children = branch.get('children')
|
||
if branch_children:
|
||
found = find_node(branch_children, target_id)
|
||
if found:
|
||
return found
|
||
elif isinstance(node, list):
|
||
for item in node:
|
||
found = find_node(item, target_id)
|
||
if found:
|
||
return found
|
||
return None
|
||
|
||
current_node = find_node(nodes, task.node_id)
|
||
|
||
if current_node:
|
||
node_config = current_node.get('config', {})
|
||
form_permissions = node_config.get('formPermissions', [])
|
||
action_permissions = node_config.get('actionPermissions', [])
|
||
# 如果没有新格式的配置，从旧的 actions 数组生成
|
||
if not action_permissions:
|
||
actions = node_config.get('actions', ['approve', 'reject'])
|
||
action_permissions = [
|
||
{'action': a, 'enabled': True, 'label': _get_action_label(a)}
|
||
for a in actions
|
||
]
|
||
|
||
# 默认操作权限
|
||
if not action_permissions:
|
||
action_permissions = [
|
||
{'action': 'approve', 'enabled': True, 'label': '通过'},
|
||
{'action': 'reject', 'enabled': True, 'label': '拒绝'},
|
||
]
|
||
|
||
out["form_permissions"] = form_permissions
|
||
out["action_permissions"] = action_permissions
|
||
|
||
# 获取签名配置
|
||
require_signature = False
|
||
if current_node:
|
||
node_config = current_node.get('config', {})
|
||
require_signature = node_config.get('requireSignature', False)
|
||
out["require_signature"] = require_signature
|
||
|
||
# 获取最后一条驳回日志
|
||
last_return_log = None
|
||
if task.task_type == 'revise':
|
||
stmt = select(WorkflowLog).where(
|
||
WorkflowLog.instance_id == task.instance_id,
|
||
WorkflowLog.action == 'return',
|
||
).order_by(WorkflowLog.sys_create_datetime.desc()).limit(1)
|
||
result = await db.execute(stmt)
|
||
log = result.scalar_one_or_none()
|
||
if log:
|
||
# 获取操作人
|
||
stmt = select(User).where(User.id == log.operator_id)
|
||
result = await db.execute(stmt)
|
||
operator = result.scalar_one_or_none()
|
||
last_return_log = {
|
||
"operator_name": operator.name if operator else "",
|
||
"comment": log.comment or "",
|
||
"created_at": log.sys_create_datetime,
|
||
}
|
||
out["last_return_log"] = last_return_log
|
||
|
||
return out
|
||
|
||
|
||
async def _build_task_list_out(db: AsyncSession, task) -> dict:
|
||
"""构建任务列表输出"""
|
||
from online_dev.workflow.model import WorkflowInstance, WorkflowDefinition
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
from datetime import datetime
|
||
|
||
# 获取实例
|
||
stmt = select(WorkflowInstance).where(WorkflowInstance.id == task.instance_id)
|
||
result = await db.execute(stmt)
|
||
instance = result.scalar_one_or_none()
|
||
|
||
# 获取流程定义
|
||
workflow = None
|
||
if instance:
|
||
stmt = select(WorkflowDefinition).where(WorkflowDefinition.id == instance.workflow_id)
|
||
result = await db.execute(stmt)
|
||
workflow = result.scalar_one_or_none()
|
||
|
||
# 获取处理人
|
||
stmt = select(User).where(User.id == task.assignee_id)
|
||
result = await db.execute(stmt)
|
||
assignee = result.scalar_one_or_none()
|
||
|
||
# 获取发起人
|
||
initiator = None
|
||
if instance:
|
||
stmt = select(User).where(User.id == instance.initiator_id)
|
||
result = await db.execute(stmt)
|
||
initiator = result.scalar_one_or_none()
|
||
|
||
# 计算是否超时
|
||
is_timeout = False
|
||
if task.timeout_at and task.status == 'pending':
|
||
is_timeout = datetime.now() > task.timeout_at
|
||
|
||
# 判断流程是否绑定了单据模板
|
||
has_document_templates = False
|
||
if workflow:
|
||
from online_dev.document_generator.service import DocumentTemplateService
|
||
bound_templates = await DocumentTemplateService.get_by_workflow_code(db, workflow.code)
|
||
has_document_templates = len(bound_templates) > 0
|
||
|
||
return {
|
||
"id": str(task.id),
|
||
"instance_id": str(task.instance_id),
|
||
"instance_no": instance.instance_no if instance else "",
|
||
"instance_title": instance.title if instance else "",
|
||
"instance_status": instance.status if instance else "",
|
||
"node_name": task.node_name,
|
||
"task_type": task.task_type,
|
||
"status": task.status,
|
||
"assignee_id": str(task.assignee_id),
|
||
"assignee_name": assignee.name if assignee else "",
|
||
"workflow_name": workflow.name if workflow else "",
|
||
"initiator_name": initiator.name if initiator else "",
|
||
"started_at": instance.started_at if instance else None,
|
||
"sys_create_datetime": task.sys_create_datetime,
|
||
"has_document_templates": has_document_templates,
|
||
"timeout_at": task.timeout_at,
|
||
"timeout_action": task.timeout_action or "",
|
||
"is_timeout": is_timeout,
|
||
"workflow_icon": workflow.icon if workflow else "",
|
||
"workflow_icon_bg_color": workflow.icon_bg_color if workflow else "",
|
||
}
|
||
|
||
|
||
async def _build_log_out(db: AsyncSession, log) -> dict:
|
||
"""构建日志输出"""
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
|
||
# 获取操作人
|
||
stmt = select(User).where(User.id == log.operator_id)
|
||
result = await db.execute(stmt)
|
||
operator = result.scalar_one_or_none()
|
||
|
||
return {
|
||
"id": str(log.id),
|
||
"node_id": log.node_id or "",
|
||
"node_name": log.node_name or "",
|
||
"action": log.action,
|
||
"operator_id": str(log.operator_id),
|
||
"operator_name": operator.name if operator else "",
|
||
"comment": log.comment or "",
|
||
"extra_data": log.extra_data or {},
|
||
"sys_create_datetime": log.sys_create_datetime,
|
||
}
|
||
|
||
|
||
# ==================== 流程定义 API ====================
|
||
|
||
@router.get("/list", response_model=PaginatedResponse[WorkflowDefinitionListOut], summary="流程定义列表")
|
||
async def get_definitions(
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=1000, alias="pageSize", description="每页数量"),
|
||
application_id: str = Query(default=None, alias="applicationId", description="所属应用ID"),
|
||
all_apps: bool = Query(default=False, alias="allApps", description="是否返回所有应用的流程"),
|
||
name: str = Query(default=None, description="流程名称"),
|
||
code: str = Query(default=None, description="流程编码"),
|
||
workflow_type: str = Query(default=None, alias="workflowType", description="流程类型"),
|
||
category: str = Query(default=None, description="分类"),
|
||
status: str = Query(default=None, description="状态"),
|
||
form_code: str = Query(default=None, alias="formCode", description="表单编码"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程定义列表（自动应用数据权限）"""
|
||
items, total = await WorkflowDefinitionService.get_list_with_data_scope(
|
||
db, page=page, page_size=page_size,
|
||
application_id=application_id, all_apps=all_apps, name=name, code=code, workflow_type=workflow_type, category=category, status=status, form_code=form_code,
|
||
)
|
||
|
||
# 批量查询应用名称
|
||
app_ids = list({item.application_id for item in items if item.application_id})
|
||
app_name_map = {}
|
||
if app_ids:
|
||
app_result = await db.execute(
|
||
select(Application.id, Application.name).where(Application.id.in_(app_ids))
|
||
)
|
||
app_name_map = {row.id: row.name for row in app_result}
|
||
|
||
result_items = [_build_definition_list_out(item, app_name_map.get(item.application_id, "")) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.post("", response_model=WorkflowDefinitionOut, summary="创建流程")
|
||
async def create_definition(
|
||
request: Request,
|
||
data: WorkflowDefinitionCreate,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""创建流程定义"""
|
||
# 检查编码唯一性
|
||
existing = await WorkflowDefinitionService.get_by_code(db, data.code)
|
||
if existing:
|
||
raise HTTPException(status_code=400, detail="流程编码已存在")
|
||
|
||
user_id = request.state.user_id
|
||
workflow = await WorkflowDefinitionService.create(db, data.model_dump(), user_id)
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.get("/categories", summary="获取分类列表")
|
||
async def get_definition_categories(db: AsyncSession = Depends(get_db)):
|
||
"""获取所有流程分类"""
|
||
categories = await WorkflowDefinitionService.get_categories(db)
|
||
return {"items": categories}
|
||
|
||
|
||
@router.get("/available-forms", summary="获取可关联的表单列表")
|
||
async def get_available_forms(
|
||
form_type: str = Query(default="workflow", description="表单类型，默认只获取流程表单"),
|
||
application_id: str = Query(None, alias="applicationId", description="所属应用ID"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取已发布的表单列表供流程关联（按应用隔离，含全局可见跨应用表单）"""
|
||
from online_dev.form_manager.model import FormMeta
|
||
from online_dev.form_manager.service import FormService
|
||
|
||
conditions = [
|
||
FormMeta.status == 'published',
|
||
FormMeta.is_deleted == False,
|
||
]
|
||
conditions.append(
|
||
FormService.build_app_scope_condition(
|
||
application_id,
|
||
for_selection=True,
|
||
)
|
||
)
|
||
|
||
if form_type:
|
||
conditions.append(FormMeta.form_type == form_type)
|
||
|
||
stmt = (
|
||
select(
|
||
FormMeta.code,
|
||
FormMeta.name,
|
||
FormMeta.application_id,
|
||
Application.name.label("application_name"),
|
||
)
|
||
.outerjoin(Application, Application.id == FormMeta.application_id)
|
||
.where(*conditions)
|
||
.order_by(FormMeta.name)
|
||
)
|
||
result = await db.execute(stmt)
|
||
forms = [
|
||
{
|
||
"code": row[0],
|
||
"name": row[1],
|
||
"application_id": row[2],
|
||
"application_name": row[3] or "主应用",
|
||
}
|
||
for row in result.all()
|
||
]
|
||
return forms
|
||
|
||
|
||
@router.get("/by-form/{form_code}", response_model=List[WorkflowDefinitionListOut], summary="获取表单关联的流程")
|
||
async def get_workflows_by_form(
|
||
form_code: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取关联指定表单的已发布流程列表"""
|
||
from online_dev.workflow.model import WorkflowDefinition
|
||
from sqlalchemy import select
|
||
|
||
stmt = select(WorkflowDefinition).where(
|
||
WorkflowDefinition.form_code == form_code,
|
||
WorkflowDefinition.status == 'published',
|
||
WorkflowDefinition.is_deleted == False,
|
||
)
|
||
result = await db.execute(stmt)
|
||
workflows = result.scalars().all()
|
||
return [_build_definition_list_out(w) for w in workflows]
|
||
|
||
|
||
@router.get("/code/{code}", response_model=WorkflowDefinitionOut, summary="根据编码获取流程")
|
||
async def get_definition_by_code(
|
||
code: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""根据编码获取流程定义"""
|
||
workflow = await WorkflowDefinitionService.get_by_code(db, code)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程不存在")
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.get("/{workflow_id}", response_model=WorkflowDefinitionOut, summary="流程定义详情")
|
||
async def get_definition(
|
||
workflow_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程定义详情"""
|
||
workflow = await WorkflowDefinitionService.get_by_id(db, workflow_id)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.put("/{workflow_id}", response_model=WorkflowDefinitionOut, summary="更新流程")
|
||
async def update_definition(
|
||
request: Request,
|
||
workflow_id: str,
|
||
data: WorkflowDefinitionUpdate,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""更新流程定义"""
|
||
user_id = request.state.user_id
|
||
workflow = await WorkflowDefinitionService.update(db, workflow_id, data.model_dump(exclude_unset=True), user_id)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.delete("/{workflow_id}", response_model=ResponseModel, summary="删除流程")
|
||
async def delete_definition(
|
||
workflow_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""删除流程定义"""
|
||
success = await WorkflowDefinitionService.delete(db, workflow_id)
|
||
if not success:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
await db.commit()
|
||
return ResponseModel(message="删除成功")
|
||
|
||
|
||
@router.delete("/batch/delete", response_model=CountResponse, summary="批量删除流程")
|
||
async def batch_delete_definitions(
|
||
ids: List[str] = Query(..., description="要删除的ID列表"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""批量删除流程定义"""
|
||
count = await WorkflowDefinitionService.batch_delete(db, ids)
|
||
await db.commit()
|
||
return CountResponse(count=count)
|
||
|
||
|
||
@router.post("/{workflow_id}/publish", response_model=WorkflowDefinitionOut, summary="发布流程")
|
||
async def publish_definition(
|
||
request: Request,
|
||
workflow_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""发布流程"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
workflow = await WorkflowDefinitionService.publish(db, workflow_id, user_id)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/{workflow_id}/disable", response_model=WorkflowDefinitionOut, summary="停用流程")
|
||
async def disable_definition(
|
||
request: Request,
|
||
workflow_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""停用流程"""
|
||
user_id = request.state.user_id
|
||
workflow = await WorkflowDefinitionService.disable(db, workflow_id, user_id)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.post("/{workflow_id}/copy", response_model=WorkflowDefinitionOut, summary="复制流程")
|
||
async def copy_definition(
|
||
request: Request,
|
||
workflow_id: str,
|
||
new_code: str = Query(..., alias="newCode", description="新流程编码"),
|
||
new_name: str = Query(default=None, alias="newName", description="新流程名称"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""复制流程"""
|
||
# 检查新编码唯一性
|
||
existing = await WorkflowDefinitionService.get_by_code(db, new_code)
|
||
if existing:
|
||
raise HTTPException(status_code=400, detail="新流程编码已存在")
|
||
|
||
user_id = request.state.user_id
|
||
workflow = await WorkflowDefinitionService.copy(db, workflow_id, new_code, new_name, user_id)
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
|
||
|
||
@router.get("/{workflow_id}/export", summary="导出流程配置")
|
||
async def export_workflow_config(
|
||
workflow_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""导出流程配置为 JSON 文件"""
|
||
config = await WorkflowDefinitionService.export_config(db, workflow_id)
|
||
if not config:
|
||
raise HTTPException(status_code=404, detail="流程不存在")
|
||
|
||
content = json.dumps(config, ensure_ascii=False, indent=2)
|
||
return StreamingResponse(
|
||
iter([content]),
|
||
media_type="application/json",
|
||
headers={
|
||
"Content-Disposition": f'attachment; filename="{config["code"]}.json"'
|
||
},
|
||
)
|
||
|
||
|
||
@router.post("/import/check", response_model=WorkflowImportCheckOut, summary="流程导入预检查")
|
||
async def check_import_workflow_config(
|
||
data: WorkflowImportCheckIn,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""导入预检查：检查流程编码是否冲突"""
|
||
return await WorkflowDefinitionService.check_import(db, data.code)
|
||
|
||
|
||
@router.post("/import", response_model=WorkflowDefinitionOut, summary="导入流程配置")
|
||
async def import_workflow_config(
|
||
request: Request,
|
||
data: WorkflowImportIn,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""导入流程配置"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
workflow = await WorkflowDefinitionService.import_config(
|
||
db, data.model_dump(), user_id
|
||
)
|
||
await db.commit()
|
||
return await _build_definition_out(db, workflow)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
# ==================== 流程实例 API ====================
|
||
|
||
@router.post("/instance/start", response_model=WorkflowInstanceOut, summary="发起流程")
|
||
async def start_instance(
|
||
request: Request,
|
||
data: WorkflowInstanceCreate,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""发起流程"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
instance = await WorkflowInstanceService.start(
|
||
db,
|
||
workflow_code=data.workflow_code,
|
||
title=data.title,
|
||
form_data=data.form_data,
|
||
user_id=user_id,
|
||
)
|
||
await db.commit()
|
||
return await _build_instance_out(db, instance)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.get("/instance/list", response_model=PaginatedResponse[WorkflowInstanceListOut], summary="流程实例列表")
|
||
async def get_instances(
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize", description="每页数量"),
|
||
status: str = Query(default=None, description="状态"),
|
||
title: str = Query(default=None, description="标题"),
|
||
workflow_name: str = Query(default=None, alias="workflowName", description="流程名称"),
|
||
instance_no: str = Query(default=None, alias="instanceNo", description="流程编号"),
|
||
initiator_name: str = Query(default=None, alias="initiatorName", description="发起人姓名"),
|
||
workflow_id: str = Query(default=None, alias="workflowId", description="流程定义ID"),
|
||
application_id: str = Query(default=None, alias="applicationId", description="所属应用ID"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程实例列表（需 workflow:instance:list 权限）"""
|
||
items, total = await WorkflowInstanceService.get_list(
|
||
db, page=page, page_size=page_size,
|
||
status=status, title=title, workflow_name=workflow_name,
|
||
instance_no=instance_no, initiator_name=initiator_name,
|
||
workflow_id=workflow_id, application_id=application_id,
|
||
)
|
||
result_items = [await _build_instance_list_out(db, item) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.get("/instance/my-initiated", response_model=PaginatedResponse[WorkflowInstanceListOut], summary="我发起的流程")
|
||
async def get_my_instances(
|
||
request: Request,
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize", description="每页数量"),
|
||
status: str = Query(default=None, description="状态"),
|
||
title: str = Query(default=None, description="标题"),
|
||
workflow_name: str = Query(default=None, alias="workflowName", description="流程名称"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取我发起的流程"""
|
||
user_id = request.state.user_id
|
||
items, total = await WorkflowInstanceService.get_list(
|
||
db, page=page, page_size=page_size,
|
||
status=status, initiator_id=user_id, title=title, workflow_name=workflow_name,
|
||
)
|
||
result_items = [await _build_instance_list_out(db, item) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.get("/instance/{instance_id}", response_model=WorkflowInstanceOut, summary="流程实例详情")
|
||
async def get_instance(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程实例详情"""
|
||
instance = await WorkflowInstanceService.get_by_id(db, instance_id)
|
||
if not instance:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
return await _build_instance_out(db, instance)
|
||
|
||
|
||
@router.post("/instance/{instance_id}/cancel", response_model=WorkflowInstanceOut, summary="撤回流程")
|
||
async def cancel_instance(
|
||
request: Request,
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""撤回流程"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
instance = await WorkflowInstanceService.cancel(db, instance_id, user_id)
|
||
if not instance:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
await db.commit()
|
||
return await _build_instance_out(db, instance)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/instance/{instance_id}/urge", response_model=MessageResponse, summary="催办")
|
||
async def urge_instance(
|
||
request: Request,
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""催办流程"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
await WorkflowInstanceService.urge(db, instance_id, user_id)
|
||
await db.commit()
|
||
return MessageResponse(message="催办成功")
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.get("/instance/{instance_id}/logs", response_model=List[WorkflowLogOut], summary="流程日志")
|
||
async def get_instance_logs(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程实例的操作日志"""
|
||
logs = await WorkflowLogService.get_by_instance(db, instance_id)
|
||
return [await _build_log_out(db, log) for log in logs]
|
||
|
||
|
||
@router.get("/instance/{instance_id}/pending-tasks", response_model=List[WorkflowTaskListOut], summary="流程当前待办")
|
||
async def get_instance_pending_tasks(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程实例当前待处理的任务"""
|
||
tasks = await WorkflowTaskService.get_instance_pending_tasks(db, instance_id)
|
||
return [await _build_task_list_out(db, task) for task in tasks]
|
||
|
||
|
||
@router.get("/instance/{instance_id}/form-data", summary="获取流程表单数据")
|
||
async def get_instance_form_data(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取流程实例的表单数据"""
|
||
instance = await WorkflowInstanceService.get_by_id(db, instance_id)
|
||
if not instance:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
|
||
if not instance.form_data_id:
|
||
return {}
|
||
|
||
try:
|
||
from online_dev.form_data_manager.service import FormDataService
|
||
|
||
# 创建表单数据服务
|
||
service = await FormDataService.create_service(db, instance.form_code)
|
||
# 获取表单数据
|
||
form_data = await service.get(db, instance.form_data_id)
|
||
return form_data
|
||
except Exception as e:
|
||
# 如果获取失败，返回空对象
|
||
return {"error": str(e)}
|
||
|
||
|
||
@router.get("/instance/{instance_id}/progress", summary="流程执行进度")
|
||
async def get_instance_progress(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""
|
||
获取流程实例的执行进度
|
||
|
||
返回完整的流程节点列表及其状态，包括：
|
||
- 节点基本信息（ID、名称、类型）
|
||
- 节点状态（completed/active/pending/skipped/rejected）
|
||
- 处理人信息（姓名、操作、意见、时间）
|
||
- 额外操作（加签、转交、委托）
|
||
- 驳回记录
|
||
"""
|
||
from online_dev.workflow.progress_service import FlowProgressService
|
||
|
||
progress = await FlowProgressService.get_progress(db, instance_id)
|
||
if not progress:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
return progress
|
||
|
||
|
||
@router.get("/instance/{instance_id}/documents", summary="获取流程实例关联的单据")
|
||
async def get_instance_documents(
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""
|
||
获取流程实例关联的已生成单据列表
|
||
"""
|
||
from online_dev.document_generator.service import GeneratedDocumentService
|
||
|
||
# 获取流程实例
|
||
instance = await WorkflowInstanceService.get_by_id(db, instance_id)
|
||
if not instance:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
|
||
# 获取关联的单据
|
||
documents = await GeneratedDocumentService.get_by_instance_id(db, instance_id)
|
||
return documents
|
||
|
||
|
||
@router.post("/instance/{instance_id}/generate-documents", summary="生成流程实例单据")
|
||
async def generate_instance_documents(
|
||
request: Request,
|
||
instance_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""
|
||
手动生成流程实例绑定的单据
|
||
"""
|
||
from online_dev.document_generator.service import DocumentTemplateService, GeneratedDocumentService
|
||
from online_dev.document_generator.generator import pdf_generator
|
||
from online_dev.document_generator.calculation_engine import CalculationEngine
|
||
from core.file_manager.service import FileManagerService
|
||
from online_dev.workflow.engine.utils import FormDataUtils
|
||
from online_dev.workflow.model import WorkflowLog
|
||
|
||
# 获取流程实例
|
||
instance = await WorkflowInstanceService.get_by_id(db, instance_id)
|
||
if not instance:
|
||
raise HTTPException(status_code=404, detail="流程实例不存在")
|
||
|
||
# 检查流程状态
|
||
if instance.status != 'approved':
|
||
raise HTTPException(status_code=400, detail="只有审批通过的流程才能生成单据")
|
||
|
||
# 获取流程定义
|
||
workflow = await WorkflowDefinitionService.get_by_id(db, str(instance.workflow_id))
|
||
if not workflow:
|
||
raise HTTPException(status_code=404, detail="流程定义不存在")
|
||
|
||
# 根据 workflow_code 查找绑定的单据模板
|
||
bound_templates = await DocumentTemplateService.get_by_workflow_code(db, workflow.code)
|
||
if not bound_templates:
|
||
raise HTTPException(status_code=400, detail="该流程未绑定文档模板")
|
||
|
||
# 加载表单数据
|
||
form_data = await FormDataUtils.load_form_data(db, instance.form_code, instance.form_data_id) or {}
|
||
|
||
# 加载流程实例数据
|
||
form_data["_instance"] = {
|
||
"id": str(instance.id),
|
||
"instance_no": instance.instance_no,
|
||
"title": instance.title,
|
||
"status": instance.status,
|
||
"started_at": str(instance.started_at) if instance.started_at else None,
|
||
"completed_at": str(instance.completed_at) if instance.completed_at else None,
|
||
}
|
||
|
||
# 加载审批日志
|
||
log_stmt = select(WorkflowLog).where(
|
||
WorkflowLog.instance_id == instance_id
|
||
).order_by(WorkflowLog.sys_create_datetime)
|
||
log_result = await db.execute(log_stmt)
|
||
logs = list(log_result.scalars().all())
|
||
|
||
form_data["_logs"] = [
|
||
{
|
||
"node_name": log.node_name,
|
||
"action": log.action,
|
||
"comment": log.comment or "",
|
||
"created_at": str(log.sys_create_datetime) if log.sys_create_datetime else "",
|
||
}
|
||
for log in logs
|
||
]
|
||
|
||
# 加载审批任务（包含审批人、审批意见、签名）
|
||
from online_dev.workflow.model import WorkflowTask
|
||
from core.user.model import User
|
||
|
||
task_stmt = select(WorkflowTask).where(
|
||
WorkflowTask.instance_id == instance_id,
|
||
WorkflowTask.task_type.in_(['approval', 'handle']),
|
||
WorkflowTask.status.in_(['approved', 'rejected', 'handled'])
|
||
).order_by(WorkflowTask.handled_at)
|
||
task_result = await db.execute(task_stmt)
|
||
tasks = list(task_result.scalars().all())
|
||
|
||
# 构建审批任务数据
|
||
approval_tasks = []
|
||
for task in tasks:
|
||
# 获取审批人信息
|
||
user_stmt = select(User).where(User.id == task.assignee_id)
|
||
user_result = await db.execute(user_stmt)
|
||
user = user_result.scalar_one_or_none()
|
||
|
||
task_data = {
|
||
"node_name": task.node_name,
|
||
"assignee_name": user.name if user else "",
|
||
"assignee_username": user.username if user else "",
|
||
"comment": task.comment or "",
|
||
"status": task.status,
|
||
"handled_at": str(task.handled_at) if task.handled_at else "",
|
||
"signature_url": None,
|
||
}
|
||
|
||
# 如果有签名，获取签名图片的 base64 或 URL
|
||
if task.signature_file_id:
|
||
try:
|
||
signature_data = await FileManagerService.get_file_as_data_url(db, task.signature_file_id)
|
||
task_data["signature_url"] = signature_data
|
||
except Exception as e:
|
||
logger.warning(f"获取签名图片失败: task_id={task.id}, error={e}")
|
||
|
||
approval_tasks.append(task_data)
|
||
|
||
form_data["_approvals"] = approval_tasks
|
||
|
||
# 按节点名称索引审批数据（方便模板按节点名称访问）
|
||
approvals_by_node = {}
|
||
for task_data in approval_tasks:
|
||
node_name = task_data.get("node_name", "")
|
||
if node_name:
|
||
approvals_by_node[node_name] = task_data
|
||
form_data["_approvals_by_node"] = approvals_by_node
|
||
|
||
# 加载子表数据（用于聚合计算）
|
||
# 子表数据在 form_data 中以 sub_tables 形式存在，需要展开到顶层
|
||
if "sub_tables" in form_data:
|
||
for sub_table_name, sub_table_data in form_data["sub_tables"].items():
|
||
form_data[sub_table_name] = sub_table_data
|
||
|
||
generated_docs = []
|
||
user_id = request.state.user_id
|
||
|
||
# 删除该实例已有的单据（重新生成时替换旧单据）
|
||
existing_docs = await GeneratedDocumentService.get_by_instance_id(db, instance_id)
|
||
for old_doc in existing_docs:
|
||
# 删除关联的文件
|
||
if old_doc.file_id:
|
||
await FileManagerService.delete_item(db, old_doc.file_id, hard=True, is_superuser=True)
|
||
# 删除单据记录
|
||
await GeneratedDocumentService.delete(db, old_doc.id, hard=True, auto_commit=False)
|
||
|
||
# 为每个绑定的模板生成文档
|
||
for template in bound_templates:
|
||
try:
|
||
# 检查模板内容
|
||
if not template.template_content:
|
||
logger.error(f"模板内容为空: {template.code}")
|
||
raise HTTPException(status_code=400, detail=f"模板内容为空: {template.code}")
|
||
|
||
logger.info(f"生成单据 - 模板: {template.code}, 类型: {template.template_type}, 内容长度: {len(template.template_content)}")
|
||
|
||
# 执行计算规则（如果配置了）
|
||
template_data = dict(form_data)
|
||
if template.calculation_rules:
|
||
try:
|
||
calculated_values = await CalculationEngine.calculate_all(
|
||
template.calculation_rules,
|
||
form_data
|
||
)
|
||
# 将计算结果合并到模板数据中
|
||
template_data.update(calculated_values)
|
||
# 同时添加到 _calculated 命名空间，方便模板引用
|
||
template_data["_calculated"] = calculated_values
|
||
logger.info(f"计算完成 - 模板: {template.code}, 计算结果: {calculated_values}")
|
||
except Exception as calc_error:
|
||
logger.warning(f"计算规则执行失败: {template.code}, 错误: {calc_error}")
|
||
|
||
page_config = {
|
||
"size": template.page_size,
|
||
"orientation": template.page_orientation,
|
||
"margin": template.page_margin or {"top": 20, "right": 20, "bottom": 20, "left": 20},
|
||
}
|
||
|
||
pdf_bytes = pdf_generator.generate(
|
||
template_type=template.template_type,
|
||
template_content=template.template_content,
|
||
data=template_data,
|
||
css=template.template_css,
|
||
page_config=page_config,
|
||
)
|
||
|
||
# 验证 PDF 文件头
|
||
pdf_header = pdf_bytes[:8] if len(pdf_bytes) >= 8 else pdf_bytes
|
||
logger.info(f"PDF 生成成功 - 大小: {len(pdf_bytes)} bytes, 文件头: {pdf_header}")
|
||
|
||
if not pdf_bytes.startswith(b'%PDF'):
|
||
logger.error(f"生成的 PDF 文件头无效: {pdf_header}")
|
||
raise HTTPException(status_code=500, detail="生成的 PDF 文件无效")
|
||
|
||
page_count = pdf_generator.get_page_count(pdf_bytes)
|
||
|
||
# 保存文件
|
||
document_name = f"{template.name}_{instance.instance_no}"
|
||
filename = f"{document_name}.pdf"
|
||
|
||
file_record = await FileManagerService.upload_file(
|
||
db=db,
|
||
file_content=pdf_bytes,
|
||
filename=filename,
|
||
file_size=len(pdf_bytes),
|
||
parent_id=None,
|
||
is_public=False,
|
||
source="workflow",
|
||
)
|
||
|
||
logger.info(f"文件保存成功 - ID: {file_record.id}, 存储路径: {file_record.storage_path}")
|
||
|
||
# 创建文档记录
|
||
doc = await GeneratedDocumentService.create_document(
|
||
db=db,
|
||
template=template,
|
||
file_id=file_record.id,
|
||
file_size=len(pdf_bytes),
|
||
page_count=page_count,
|
||
document_name=document_name,
|
||
form_data_id=instance.form_data_id,
|
||
instance_id=instance_id,
|
||
generator_id=user_id,
|
||
generate_type="manual",
|
||
)
|
||
generated_docs.append(doc)
|
||
|
||
except Exception as e:
|
||
raise HTTPException(status_code=500, detail=f"生成单据失败: {str(e)}")
|
||
|
||
await db.commit()
|
||
return {"message": f"成功生成 {len(generated_docs)} 个单据", "count": len(generated_docs)}
|
||
|
||
|
||
# ==================== 任务 API ====================
|
||
|
||
@router.get("/task/pending", response_model=PaginatedResponse[WorkflowTaskListOut], summary="获取待处理任务")
|
||
async def get_pending_tasks(
|
||
request: Request,
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize", description="每页数量"),
|
||
task_type: str = Query(default=None, alias="taskType", description="任务类型"),
|
||
instance_title: str = Query(default=None, alias="instanceTitle", description="流程标题"),
|
||
workflow_name: str = Query(default=None, alias="workflowName", description="流程名称"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取当前用户的待处理任务"""
|
||
user_id = request.state.user_id
|
||
items, total = await WorkflowTaskService.get_pending_tasks(
|
||
db, user_id=user_id, page=page, page_size=page_size,
|
||
task_type=task_type, instance_title=instance_title, workflow_name=workflow_name,
|
||
)
|
||
result_items = [await _build_task_list_out(db, item) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.get("/task/pending/count", response_model=CountResponse, summary="获取待处理任务数量")
|
||
async def get_pending_tasks_count(
|
||
request: Request,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取当前用户的待处理任务数量"""
|
||
user_id = request.state.user_id
|
||
count = await WorkflowTaskService.get_pending_count(db, user_id)
|
||
return CountResponse(count=count)
|
||
|
||
|
||
@router.get("/task/handled", response_model=PaginatedResponse[WorkflowTaskListOut], summary="获取已处理任务")
|
||
async def get_handled_tasks(
|
||
request: Request,
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize", description="每页数量"),
|
||
instance_title: str = Query(default=None, alias="instanceTitle", description="流程标题"),
|
||
workflow_name: str = Query(default=None, alias="workflowName", description="流程名称"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取当前用户的已处理任务"""
|
||
user_id = request.state.user_id
|
||
items, total = await WorkflowTaskService.get_handled_tasks(
|
||
db, user_id=user_id, page=page, page_size=page_size,
|
||
instance_title=instance_title, workflow_name=workflow_name,
|
||
)
|
||
result_items = [await _build_task_list_out(db, item) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.get("/task/cc", response_model=PaginatedResponse[WorkflowTaskListOut], summary="抄送给我")
|
||
async def get_copy_tasks(
|
||
request: Request,
|
||
page: int = Query(default=1, ge=1, description="页码"),
|
||
page_size: int = Query(default=settings.PAGE_SIZE, ge=1, le=settings.PAGE_MAX_SIZE, alias="pageSize", description="每页数量"),
|
||
instance_title: str = Query(default=None, alias="instanceTitle", description="流程标题"),
|
||
workflow_name: str = Query(default=None, alias="workflowName", description="流程名称"),
|
||
is_read: bool = Query(default=None, alias="isRead", description="是否已读，false=仅未读"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取抄送给当前用户的任务"""
|
||
user_id = request.state.user_id
|
||
items, total = await WorkflowTaskService.get_copy_tasks(
|
||
db, user_id=user_id, page=page, page_size=page_size,
|
||
instance_title=instance_title, workflow_name=workflow_name, is_read=is_read,
|
||
)
|
||
result_items = [await _build_task_list_out(db, item) for item in items]
|
||
return PaginatedResponse(items=result_items, total=total)
|
||
|
||
|
||
@router.get("/task/{task_id}", response_model=WorkflowTaskOut, summary="获取任务详情")
|
||
async def get_task(
|
||
task_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取任务详情"""
|
||
task = await WorkflowTaskService.get_by_id(db, task_id)
|
||
if not task:
|
||
raise HTTPException(status_code=404, detail="任务不存在")
|
||
return await _build_task_out(db, task, include_form=True)
|
||
|
||
|
||
@router.post("/task/{task_id}/approve", response_model=WorkflowTaskOut, summary="审批任务")
|
||
async def approve_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskApproveInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""审批任务（通过/拒绝/驳回）"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.approve(
|
||
db, task_id,
|
||
action=data.action,
|
||
comment=data.comment,
|
||
user_id=user_id,
|
||
return_to=data.return_to,
|
||
form_data=data.form_data,
|
||
signature=data.signature,
|
||
)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/handle", response_model=WorkflowTaskOut, summary="办理任务")
|
||
async def handle_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskHandleInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""办理任务"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.handle(db, task_id, data.comment, user_id, form_data=data.form_data)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/transfer", response_model=WorkflowTaskOut, summary="转交任务")
|
||
async def transfer_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskTransferInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""转交任务"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.transfer(db, task_id, data.to_user_id, data.comment, user_id)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/delegate", response_model=WorkflowTaskOut, summary="委派任务")
|
||
async def delegate_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskDelegateInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""委派任务"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.delegate(db, task_id, data.to_user_id, data.comment, user_id)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/add-sign", response_model=List[WorkflowTaskOut], summary="加签任务")
|
||
async def add_sign_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskAddSignInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""加签任务"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
tasks = await WorkflowTaskService.add_sign(
|
||
db, task_id,
|
||
sign_type=data.sign_type,
|
||
to_user_ids=data.to_user_ids,
|
||
comment=data.comment,
|
||
user_id=user_id,
|
||
)
|
||
await db.commit()
|
||
return [await _build_task_out(db, task) for task in tasks]
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/read", response_model=WorkflowTaskOut, summary="标记抄送已读")
|
||
async def mark_task_read(
|
||
request: Request,
|
||
task_id: str,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""标记抄送任务为已读"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.mark_read(db, task_id, user_id)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
@router.post("/task/{task_id}/revise", response_model=WorkflowTaskOut, summary="修改重提")
|
||
async def revise_task(
|
||
request: Request,
|
||
task_id: str,
|
||
data: TaskReviseInput,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""修改任务（驳回后重新提交）"""
|
||
user_id = request.state.user_id
|
||
try:
|
||
task = await WorkflowTaskService.revise(db, task_id, data.form_data, data.comment, user_id)
|
||
await db.commit()
|
||
return await _build_task_out(db, task)
|
||
except ValueError as e:
|
||
raise HTTPException(status_code=400, detail=str(e))
|
||
|
||
|
||
# ==================== 管理员 API ====================
|
||
|
||
@router.post("/admin/check-timeouts", response_model=ResponseModel, summary="手动触发超时检查")
|
||
async def check_timeouts(
|
||
request: Request,
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""
|
||
手动触发任务超时检查（管理员使用）
|
||
正常情况下由定时任务自动执行，此接口用于调试或紧急处理
|
||
"""
|
||
if not getattr(request.state, 'is_superuser', False):
|
||
raise HTTPException(status_code=403, detail='需要管理员权限')
|
||
|
||
from online_dev.workflow.engine.task_timeout_process import check_and_handle_timeouts
|
||
|
||
await check_and_handle_timeouts(db)
|
||
await db.commit()
|
||
return ResponseModel(message='超时检查完成')
|
||
|
||
|
||
@router.get("/admin/timeout-tasks", summary="获取即将超时的任务")
|
||
async def get_timeout_tasks(
|
||
request: Request,
|
||
hours: int = Query(default=24, description="查询未来N小时内超时的任务"),
|
||
db: AsyncSession = Depends(get_db),
|
||
):
|
||
"""获取即将超时的任务列表（管理员使用）"""
|
||
if not getattr(request.state, 'is_superuser', False):
|
||
raise HTTPException(status_code=403, detail='需要管理员权限')
|
||
|
||
from datetime import datetime, timedelta
|
||
from online_dev.workflow.model import WorkflowTask, WorkflowInstance
|
||
from core.user.model import User
|
||
from sqlalchemy import select
|
||
|
||
now = datetime.now()
|
||
deadline = now + timedelta(hours=hours)
|
||
|
||
stmt = select(WorkflowTask).where(
|
||
WorkflowTask.status == 'pending',
|
||
WorkflowTask.timeout_at.isnot(None),
|
||
WorkflowTask.timeout_at <= deadline,
|
||
WorkflowTask.is_deleted == False,
|
||
).order_by(WorkflowTask.timeout_at)
|
||
|
||
result = await db.execute(stmt)
|
||
tasks = result.scalars().all()
|
||
|
||
result_list = []
|
||
for task in tasks:
|
||
# 获取实例
|
||
stmt = select(WorkflowInstance).where(WorkflowInstance.id == task.instance_id)
|
||
inst_result = await db.execute(stmt)
|
||
instance = inst_result.scalar_one_or_none()
|
||
|
||
# 获取处理人
|
||
stmt = select(User).where(User.id == task.assignee_id)
|
||
user_result = await db.execute(stmt)
|
||
assignee = user_result.scalar_one_or_none()
|
||
|
||
is_overdue = task.timeout_at <= now if task.timeout_at else False
|
||
|
||
result_list.append({
|
||
'id': str(task.id),
|
||
'instance_id': str(task.instance_id),
|
||
'instance_title': instance.title if instance else '',
|
||
'node_name': task.node_name,
|
||
'assignee_id': str(task.assignee_id) if task.assignee_id else '',
|
||
'assignee_name': assignee.name if assignee else '',
|
||
'timeout_at': task.timeout_at,
|
||
'timeout_action': task.timeout_action,
|
||
'timeout_notified': task.timeout_notified,
|
||
'is_overdue': is_overdue,
|
||
'created_at': task.sys_create_datetime,
|
||
})
|
||
|
||
return result_list
|