Compare commits

...

26 Commits

Author SHA1 Message Date
d97e69d124 Merge feat/process-modeler T4.3收尾: 安全Critical修复+文档回写(B3完工)
Some checks failed
ci / build-test-parity (push) Has been cancelled
parity-nightly / nightly-parity (push) Has been cancelled
- 安全对抗评审Critical#1修复:nginx关闭/flowable/公网直通(无鉴权引擎不对外)
- 文档回写:总览B3行🔴→🟢+一句话进度+README+计划完成横幅
- 双对抗评审处置:发布链I-1语料dry-run证伪(803formKey全命中)/A10加固backlog

B3 在线流程Modeler v1 全17任务完成。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 16:33:54 +08:00
74b30adb6e docs(B3): 收尾——总览B3行🔴→🟢+一句话进度+README+计划完成横幅+双对抗评审处置
B3 在线流程Modeler v1 全17任务完成合main。评审处置:安全Critical#1(nginx)已修+A10加固backlog;
发布链I-1(formKey门误拒)语料dry-run证伪(803全命中miss=0)/I-2空content已知限制v2/M-1~3低优先。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 16:33:03 +08:00
36aa94db7d fix(deploy): nginx 关闭 /flowable/ 公网直通(安全评审 Critical#1)+A10加固backlog
flowable-service:8089 无鉴权,裸 proxy_pass 对外会绕过网关超管门匿名部署/覆盖生产BPMN。
前端只经 /api/workflow/ 网关访问流程能力,/flowable/ 改 return 404。
High#2/Medium#3-4 等 A10 生产加固项记入计划 backlog(超管信任模型内可接受)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 16:26:12 +08:00
49d056be09 Merge feat/process-modeler 阶段4: 计划文档回写(e2e发现/已知限制)
Some checks failed
ci / build-test-parity (push) Has been cancelled
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 16:16:14 +08:00
a5e2540c8f docs(plan): 阶段4 e2e 发现——会签空content语义缺口/e2e非幂等/403降级(已知限制)
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 16:14:03 +08:00
93f3823a06 Merge feat/process-modeler 阶段3: 发布门(deploy+校验+审计+同人确认)
Some checks failed
ci / build-test-parity (push) Has been cancelled
- deploy-from-model(incoming/outgoing剥除+id还原中文key+ProcessValidator校验门+
  disableSchemaValidation+metaInfo不可读fail-fast防坏key)+impact影响摘要
- 网关语义校验门 ModelSemanticValidator(办理人JSON items非空+type白名单对齐WfTypes16种防误拒/
  formKey存在性/完成条件三预设∪自定义不阻断)+FlowDeployAuditService+Flyway V4 sys_flow_deploy_audit
- 下游ProcessValidator结构化errors透传前端(不再吞成通用FLOW_REMOTE_ERROR)
- live 验收:改总包合同交底→存草稿→发布 v9,中文key保住+审计行(op=ADMIN)+起实例生成真userTask+
  旧6实例不受影响+非admin 403;全reactor mvn clean install绿+ArchUnit 6/6
- live 揪修CRITICAL:activiti.json缺tagAlias致Modeler输出PascalCase元素名(Flowable大小写敏感断部署)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 15:30:32 +08:00
4af6776164 docs(plan): 回写阶段3 live CRITICAL——activiti.json致bpmn-js Modeler输出PascalCase元素名(部署断)
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 15:02:37 +08:00
732655e776 fix(gateway): 语义门收口——type白名单对齐WfTypes(防误拒存量)+透传下游结构化errors+TOCTOU文档
评审 T3.2 收口(2 Important + 2 Minor):
- I-1(功能回归):ModelSemanticValidator.TYPE_WHITELIST 10 种→16 种,对齐 flowable-service WfTypes
  配置类型 + OrgDirectoryJdbc 运行期分派(权威源,非 BasePropertiesConverter,注释已改)。
  psql 窄查询实证:缺失 6 种里 initiatorDepartManager(24 文档)/fixedDimension(12 文档)在真实
  candidateUsers 有非零命中,旧白名单会 422 误拒这些存量流程(载入→编辑无关节点→发布)。
  网关不依赖 flowable-service 故复刻常量并注同步提醒。
- I-2(UX):FlowRemoteException 加 responseBody;FlowableClient.execute 携带下游原始体;
  FlowGatewayExceptionHandler.onRemote 解析并把下游 errors 数组并入网关响应顶层——发布下游 422
  的引擎结构校验 errors[{activityId,problem,defaultDescription}] 现能到前端,与网关语义 422 顶层
  errors 契约统一(前端 T3.3 同一渲染)。非发布路径纯文本体照旧不加 errors 键(无回归)。
- I-3(TOCTOU):deploy 端点加「已接受风险」javadoc(超管低频+窄窗+非安全洞,v1 不做 content-hash 409)。
- 补测 M-1(flowable: 前缀 candidateUsers 按本地名匹配同校验)+ M-2(新增 4 种 type 放行,锁 I-1)+
  I-2 客户端携带体/handler 并入顶层 errors 两用例。

测试:语义 19(+2)、审计 3、客户端 24(+1)、控制器 30(+1)。全 reactor mvn clean install 退出码 0,
零 <<< FAILURE,ArchitectureRulesTest 6/6。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 14:52:03 +08:00
5eed5f0b26 feat(gateway): 发布语义校验门(ModelSemanticValidator)+部署审计(V4/FlowDeployAuditService)
网关发布门收口(T3.2):
- ModelSemanticValidator(@Service):钉 JDK 解析器解析 bpmn XML,校验办理人/会签内嵌
  JSON(全角【】→半角)items 非空+type 白名单、formKey 存在于 view_wftemplate(读库降级放行)、
  会签 completionCondition 预设∪自定义非空(自定义不阻断,保留 T2.4 自定义态);返 List<String> 错误清单。
- Flyway V4 建 sys_flow_deploy_audit(平台表);FlowDeployAuditService(@Service)收口 INSERT,
  写失败不反噬已成功的部署。SQL 全收口 @Service,@RestController 不直用 JdbcTemplate(ArchUnit 棘轮)。
- ProcessModelerController 加 POST /models/{id}/deploy(超管门→语义校验 fail 则 422 零转发→
  转发 deploy→审计 INSERT operator=userId)+ GET /models/{id}/impact(超管门转发)。
- FlowableClient 加 deployModel(id)/modelImpact(id)(uri 变量转发)。

测试:语义校验 17(各错误类型+通过+items 空 error+自定义完成条件不阻断+读库降级+XXE)、
审计 3、客户端转发 +3、控制器 deploy/impact +7。全 reactor mvn clean install 绿,
ArchitectureRulesTest 6/6(@RestController 未新增直用 JdbcTemplate)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 14:12:21 +08:00
529f73f8f5 fix(flow): 发布门坏key地雷收口——metaInfo不可读fail-fast(防部署净化key)+危险分支补测
评审 I1(高后果):readIdMap 把三种情况塌成「空 idMap→跳过还原」——(a)真新建 (b)JSON 解析失败
(c)解析成功但缺 eip4IdMap 键。对 from-procdef 存量草稿(editorSource 的 <process id> 是净化 nXXX),
(b)/(c) 会跳过还原 → 静默部署 key=nXXX 而非中文原 key(HTTP 200,违 D7,且与 restore 非双射 fail-fast 自相矛盾)。

修:readIdMap→resolveIdMap,据 from-procdef 写的 sourceProcDefId/originalKey 标记分流——
metaInfo 非空且(解析失败 或 带标记但缺/非-Map eip4IdMap)→ IllegalStateException fail-fast,
deploy catch→422「草稿 id 映射不可用,无法还原原 key」,不部署。eip4IdMap 存在(含空 {})即可用
(空=全 ASCII 存量流程无需还原);真·新建(metaInfo {}/null、无标记)仍空 map 正常放行。impact 只读
最终回退 model.key(from-procdef 的 model.key 即中文原 key),不 500。

补测(评审 I2):非双射 idMap→IllegalArgumentException→422;存量草稿缺 eip4IdMap→422;metaInfo 坏 JSON→422;
存量空 eip4IdMap 全 ASCII 不误拒正常部署;deploy 路径字节级 DOCTYPE 守卫→422。Minor:M1 注释钉边界
(EIP4 语义校验在网关 ModelSemanticValidator/T3.2,此处仅引擎结构校验);M3 impact 注释说明为何不需独立 DOCTYPE 守卫。

ProcessModelControllerTest 30/30(19 既有零改动 + 11 T3.1:6 首轮 + 5 本轮);全 reactor clean install 绿
(ArchitectureRulesTest 6/6)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:48:36 +08:00
6f180522f3 feat(flow): 草稿发布(incoming/outgoing剥除+id还原中文key+ProcessValidator校验门+disableSchemaValidation)+影响摘要
POST /models/{id}/deploy:剥除 bpmn-js 补的 incoming/outgoing 文本引用元素
(Flowable 从 sequenceFlow 自行推导,不剥则 restore 只还原属性位→落库脏 XML,T1.3 I-2)
→ BpmnIdSanitizer.restore 依 eip4IdMap 还原中文原 key(存量 D7 硬需求,新建流程无 idMap 跳过)
→ ProcessValidator 语义校验门(仅 ERROR 级阻断,返 422 {errors:[{activityId,problem,defaultDescription}]}
不部署;WARNING 放行)→ createDeployment().disableSchemaValidation()(只跳 XSD:bpmn-js 默认命名空间
与严格 XSD 已知不兼容,语义已在上一步)部署 → {status,deploymentId,processKey,newVersion}。

GET /models/{id}/impact:还原后解析 processKey → {processKey,currentVersion(最新已部署版本),
runningInstances(运行中实例数)},供同人确认弹窗展示。

控制器加 @Autowired(RepositoryService,RuntimeService) 构造(保留单参构造零改动既有 CRUD 单测)+
全参构造注入 mock ProcessValidator。发布/影响端点 8 单测(还原中文key+剥除无残留净化id+disableSchemaValidation
验证/ERROR 422 不部署/WARNING 放行/404/impact 计数),既有 17 单测零改动;全 reactor clean install 绿
(ArchitectureRulesTest 6/6)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:32:31 +08:00
84be9c658a Merge feat/process-modeler: 修 ArchUnit 棘轮(wftemplates SQL 收口 WfTemplatePickerService)+计划红线
Some checks failed
ci / build-test-parity (push) Has been cancelled
修复 7524e5f 阶段2 merge 引入的 platform-app ArchitectureRulesTest 失败:
ProcessModelerController 直注 JdbcTemplate 违反棘轮,SQL 收口新建 WfTemplatePickerService;
全 reactor mvn clean install 独立验证真绿(ArchitectureRulesTest 6/6)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:17:18 +08:00
647f06836f fix(gateway): wftemplates SQL 收口 WfTemplatePickerService(修 ArchUnit 控制器JdbcTemplate棘轮)
T2.2 给 ProcessModelerController(@RestController)直注 JdbcTemplate 触发 platform-app
ArchitectureRulesTest 棘轮「控制器不得新增直用 JdbcTemplate」(该测试在 platform-app 扫全模块,
模块级 mvn -pl 跑不到故 T2.2 时未暴露,main 全 reactor 失败)。按规则本意收口(不加白名单):

- 新建 platform-flow-gateway aggregate/WfTemplatePickerService(@Service):wftemplates 的 JdbcTemplate
  查询(view_wftemplate_id + entityid→sys_entity.name LEFT JOIN + trim CHAR 补白 + isactive=1 +
  读库异常降级)整体搬入,暴露 listTemplates() 返 {templates} / 降级 {templates:[],degraded:true}。
  Service 用 JdbcTemplate 不违规,规则只禁 @RestController。
- ProcessModelerController 去掉 JdbcTemplate 字段/构造参 + SQL/RowMapper 常量,改注入 WfTemplatePickerService,
  wftemplates 端点只保留超管门 + 透传。

测试:新建 WfTemplatePickerServiceTest(2:trim补白+回退id+正常不带degraded / 读库异常降级带degraded);
ProcessModelerControllerTest 的 wftemplates 三例(直查 JdbcTemplate)收敛为两例(超管透传 service 结果 /
非超管 403 不调 service),jdbcTemplate mock 换 WfTemplatePickerService mock。

验证(全 reactor,ArchitectureRulesTest 真跑):JAVA_HOME=...openjdk@21 mvn clean install -q → 退出码 0;
ArchitectureRulesTest 6/6 绿(JdbcTemplate 棘轮通过)、WfTemplatePickerServiceTest 2、ProcessModelerControllerTest 22、
FlowableClientTest 20,全 reactor 零失败报告。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:13:32 +08:00
26532a64c3 docs(plan): 红线补——合main前全reactor真绿(ArchUnit在platform-app)+控制器SQL收口Service
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:04:58 +08:00
7524e5f7bf Merge feat/process-modeler 阶段2: EIP4 控件+草稿闭环
Some checks failed
ci / build-test-parity (push) Has been cancelled
- 流程草稿 ProcessModelController(act_re_model,Model API 首启;metaInfo 存 eip4IdMap 供发布还原;
  category=eip4 隔离 143 存量;草稿保存 validateSchema=false+字节级DOCTYPE守卫;DELETE 端点)
- 网关 models 五端点+DELETE 转发(requireSuperAdmin 统一门)+wftemplates picker(entityid→sys_entity.name)
- EIP4 侧板五控件(办理人 codec meta 透传/会签保真读回 isSequential/elementVariable/自定义完成条件/
  formKey 过滤/扩展属性/监听器);表达式 codec 与 BasePropertiesConverter 逐字对齐+引号映射防截断JUEL
- 存草稿闭环(三路径保 eip4IdMap+首存回填 modelId 防刷新重复+草稿列表/删除)
- live 验收:总包合同交底 中文key 打开→会签保真→saveXML(bpmn-js默认命名空间,后端XSD修复接受)→
  act_re_model 含完整 eip4IdMap→重开侧板忠实回显;全 reactor mvn clean install 绿
- live 揪修3真bug:options source=model语义/属性面板ref未绑/bpmn-js输出被严格XSD拒
- 评审含金量:codec全库4794表达式往返/反编译Flowable抓XXE参数/28会签流对账保真

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 13:02:45 +08:00
789cb90af3 fix(flow): 草稿保存关严格XSD校验(bpmn-js默认命名空间输出)+字节级DOCTYPE守卫保XXE
阶段2 live 验收阻断 bug:UI 保存草稿恒 422。根因=T2.1 评审 I-1 我把 enableSafeBpmnXml 从
false 改 true 时,convertToBpmnModel(source, validateSchema=true, ...) 的 validateSchema=true
开启严格 XSD 校验;bpmn-js saveXML 用默认命名空间(无前缀 definitions/process)重序列化,Flowable
严格 Xerces XSD 校验拒之(cvc-complex-type.2.4.a: element {MODEL}process ... expected)——bpmn-js
面向 BPMN 模型非字节级 XSD 合规,这是已知固有不兼容;原始 source(带前缀)故能过。

架构:草稿是可视化工具编辑的半成品,不该做完整 XSD 校验(完整校验属部署门 T3.1 ProcessValidator,
在解析后模型上跑,非 XSD)。修法:
1. parseGuard 的 convertToBpmnModel(..., true, true) → (..., false, true)(validateSchema=false)。
   仍解析(非良构 XML 抛→422),不做严格 XSD。
2. XXE 不只靠此:解析前加字节级 DOCTYPE 拒绝守卫(移植 platform-report ReportXmlGuard
   hasDoctypeInBytes/hasDoctype 模式,含 BOM/UTF-16 编码识别,就地复刻不引 platform-* 依赖),
   与 enableSafeBpmnXml=true 双保险防外部实体注入。

测试(TDD 先红后绿):ProcessModelControllerTest 16→19——①bpmn-js 默认命名空间输出(BPMNDiagram
先于 process,触发同族 cvc-complex-type.2.4.a)改前 422 改后 200 落库(回归锚点,改前实测必红);
②含 <!DOCTYPE 声明的 XML → 422(XXE 守卫);③非良构 XML(标签不匹配)→ 关 XSD 后仍 422。
flowable-service 全模块 92 测试绿,BUILD SUCCESS,既有 16 测试零改动。

附带排查(T3.1 deploy 路径同问题,不在本 task 范围):Flowable 6.8.1 BpmnParse 构造器
validateSchema 默认 iconst_1=true,BpmnDeployer 把它传给 convertToBpmnModel → createDeployment()
.addString(bpmnJsXml).deploy() 会被同一 cvc-complex-type.2.4.a 咬。escape hatch:DeploymentBuilder
有 disableSchemaValidation()(仅跳 XSD)。T3.1 应:parse(validateSchema=false)→跑 ProcessValidator
(语义校验,计划已设计)→ createDeployment().disableSchemaValidation().addString().deploy()。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 12:52:51 +08:00
a9d21ec46c docs(plan): 回写阶段2 live 实证——bpmn-js默认命名空间输出被严格XSD拒(草稿已修+警示T3.1部署路径)
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 12:42:56 +08:00
f0d704d1b9 feat(flow+gateway): 草稿删除端点 DELETE /models/{id}(超管门)
补前端 T2.5 已按占位契约做好测试的草稿删除两层端点:

flowable-service ProcessModelController:DELETE /api/flow/models/{id}——先 getModel 判 null→404
{status:1,msg};存在则 deleteModel(id)(连带 editorSource/metaInfo 一并删)→{status:0}。

网关:FlowableClient +deleteModel(id)(id 走 uri 变量严格编码,DELETE 无既有封装→照 put 补私有
delete() 助手,无请求体,幂等重试安全);ProcessModelerController +DELETE /api/workflow/models/{id}
过 requireSuperAdmin 门后透传,{status:0} 原样回(对齐前端 deleteDraft 只判成功),下游 404 经既有
FlowGatewayExceptionHandler 透传。

测试(严格 TDD,均先红后绿):
- flowable ProcessModelControllerTest 14→16(删存在的 verify deleteModel 调 1 次/删不存在 404 verify 零删)
- gateway FlowableClientTest 18→20(DELETE 按 id 透传/下游 404 透传 FlowRemote 不重试)
- gateway ProcessModelerControllerTest 21→23(超管 200 透传+非超管 403 门拦下游恰调 1 次/404 胶水经 handler 出 FLOW_REMOTE_ERROR)
两模块 mvn -pl flowable-service,platform-flow-gateway -am test 全绿,BUILD SUCCESS,既有测试零改动。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 12:21:05 +08:00
653866c852 fix(gateway): T2.2 评审小项——幂等注释/降级标记/PUT胶水测试
M-1(javadoc):FlowableClient put()/post() 点破幂等性差别——PUT 覆盖写幂等,execute 连接级重试安全;
POST 非幂等,重试存在重复创建窗口,接受理由=草稿廉价可覆盖(非不可逆副作用)+本地同机链路瞬时故障概率极低,
语义级 4xx/5xx 绝不重试故无此窗口。
M-2(一行):wftemplates 读库异常降级分支返回 {templates:[],degraded:true},正常路径不带 degraded 键;
测试两分支各断言(正常 doesNotContainKey degraded / 降级 containsEntry degraded=true)。
M-3(胶水):照 glueMvc 补 PUT /api/workflow/models/{id} MockMvc 路由层测试(PUT 谓词匹配+@PathVariable
绑定 id=m1+200 透传)。

测试:ProcessModelerControllerTest 20→21(+PUT 胶水),FlowableClientTest 18(M-1 纯注释不加测试)。
platform-flow-gateway 全模块绿,BUILD SUCCESS,既有测试零改动。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 12:01:18 +08:00
e19bac805e docs(plan): 回写 T2.2 评审——草稿删除端点挂 T2.5/T4.1
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:57:45 +08:00
a25e7ce4b7 docs(plan): 回写 T2.2 实证——wftemplate 无名称列,formKey 下拉须过滤输入
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:49:45 +08:00
b489f3d834 feat(gateway): models 五端点转发(requireSuperAdmin 统一门)+wftemplates picker 数据源
阶段 2 网关侧(对齐 flowable-service T2.1 ProcessModelController 契约):

FlowableClient +5 方法:listModels/getModel/createModel/updateModel/modelFromProcDef,
全 uri 模板变量严格编码(禁字符串拼接);RestClient 无 PUT 封装 → 照 post 补私有 put()
(uriTemplate+uriVars 严格编码);连接级重试 + 4xx/5xx 透传语义复用既有 execute。

ProcessModelerController:抽 requireSuperAdmin(principal) 私有方法(超管返 null,非超管/无身份
返 403 {status:1,msg:"仅系统管理员可用"}),既有两个 source 端点改用它(行为零变,既有 10 测试零改动);
新增五端点 GET /models、GET /models/{id}、POST /models、PUT /models/{id}、POST /models/from-procdef
全部先过门再转发 FlowableClient,返回体原样透传。

GET /api/workflow/wftemplates(同门):formKey 选择器数据源。
**information_schema 实证**:view_wftemplate 无独立名称列(仅 view_wftemplate_id CHAR + xml +
isactive + 审计列),<form> 根标签也无 title/name 属性(0/1016);唯一人类可读名来自 XML 的
entityid → sys_entity.name(378/1016 带 entityid,339 解析出中文名如「通知管理」)。故
name = entityid 解析出的实体名(LEFT JOIN + substring 正则抽 entityid),空则回退 id;
view_wftemplate_id 是 CHAR 补白 → RowMapper trim;isactive=1 过滤;读库异常降级空列表不 500。

测试:FlowableClientTest 12→18(+list/get/create/update/from-procdef body 透传+4xx 透传);
ProcessModelerControllerTest 10→20(五端点各 admin 200 透传+非超管 403 门拦下游 恰调 1 次证明门生效、
无身份 403、422 胶水经 FlowGatewayExceptionHandler 出 FLOW_REMOTE_ERROR、wftemplates 超管 trim 补白+
无名回退 id、非超管 403 零读库、读库异常降级空列表)。platform-flow-gateway 全模块 98 测试绿、
上游 493 测试绿,BUILD SUCCESS,既有测试零改动。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:48:30 +08:00
4abe9f8ce6 docs(plan): 回写 T2.4 评审——T3.2 语义校验加 items 非空与自定义完成条件口径
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:48:29 +08:00
b89447556f fix(flow): 草稿控制器评审收口——safeBpmnXml+category过滤存量+metaInfo保持回归测试等
评审跟进 7 项(评审者反编译 Flowable 6.8.1 实证):
- I-1(安全):parseGuard convertToBpmnModel 第三参 enableSafeBpmnXml false→true,
  启用 flowable 加固解析器(禁外部 DTD/参数实体/DOCTYPE)关 XXE/SSRF 面;javadoc 写明两布尔参语义。
- I-2(列表污染):库里 143 条存量 act_re_model(老 shape+悬空 editorSource)会进草稿列表打不开。
  create/from-procdef 建 model 时 setCategory("eip4");list() 改 modelCategory("eip4") 只查本分类。
- I-3(回归契约):加「PUT 只带 name 不带 metaInfo→verify never setMetaInfo」用例,钉住 eip4IdMap
  不被普通保存抹掉(T3.1 发布逆向还原原 key 的命根)。
- M-1:class javadoc 补「裸 8089 无鉴权,写端点必须经网关超管门访问(T2.2),生产 8089 不对外」。
- M-2:parseGuard 422 msg 改通用文案「BPMN 解析失败」,原始 e.getMessage 只进 log.warn(防内部细节回显)。
- M-3:POST create 对空白 name/key 返 422(key 是 T3.1 部署资源名/还原依赖),在解析守卫前拦;加测试。
- M-4:补 from-procdef「BPMN 读取为空(getProcessModel null)→found:false 不落库」分支测试。

测试:ProcessModelControllerTest 11→14 例(新增 空白 name/key 422 不落库、只带 name 不改 metaInfo、
BPMN 读空 found:false;既有列表用例补 modelCategory 断言、建草稿/from-procdef 补 setCategory 断言)。
flowable-service 全模块 87 测试绿(新增 3,既有其他模块测试零改动)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:32:26 +08:00
93b5433f1e docs(plan): 回写 T2.3 实证——表达式 meta 5 字段透传为 T2.4 正确性硬要求
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:18:53 +08:00
57812f0edc feat(flow): 流程草稿 ProcessModelController(act_re_model,Model API 首次启用)
在线 Modeler 草稿仓:flowable 原生 Model API 存草稿于 act_re_model(全仓首次启用
Model API,表已有 143 行存量,databaseSchemaUpdate=false 不涉 DDL)。5 端点(@RequestMapping
"/api/flow"):GET /models 列表(orderByLastUpdateTime desc,时间转 ISO)、GET /models/{id}
取草稿(getModel+getModelEditorSource,不存在/源空→found:false)、POST /models 建草稿
(XML 过 BpmnXMLConverter 解析守卫,坏 XML→422 不落库)、PUT /models/{id} 更新
(不存在→404;name/metaInfo 仅当请求提供才更新,避免抹掉 eip4IdMap)、
POST /models/from-procdef 从流程定义建草稿(BpmnIdSanitizer 净化中文 id,
metaInfo={eip4IdMap,sourceProcDefId,originalKey} 供发布逆向还原)。

解析守卫就地 catch 转 422,不逸出到 FlowExceptionHandler(那里 FlowableException→400
语义不符)。from-procdef 复用本控制器自带 readProcessModel 小方法,零改动 ProcessDiagramController。

测试:ProcessModelControllerTest 11 例(列表 ISO 降序/取草稿含 metaInfo/model 不存在或
源空 found:false/建草稿合法 XML 落库/坏 XML 422 且 verify 零 saveModel/PUT 404/PUT 合法
更新 status:0/PUT 坏 XML 422/from-procdef 净化 XML 与 idMap 落 metaInfo(捕获 setMetaInfo
断言 JSON 含 eip4IdMap+中文 originalKey、捕获 editorSource 断言净化无中文 id)/procDef
不存在 found:false 不落库)。flowable-service 全模块 84 测试绿(新增 11,既有 73 零改动)。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:15:54 +08:00
19 changed files with 3195 additions and 31 deletions

View File

@@ -1,5 +1,6 @@
# EIP4 单源托管(A10 W3)。挂载为 nginx:alpine 的 /etc/nginx/conf.d/default.conf。 # EIP4 单源托管(A10 W3)。挂载为 nginx:alpine 的 /etc/nginx/conf.d/default.conf。
# 一个源:静态 SPA(eip4-web/dist)+ 反代 /api→platform-app、/flowable→flowable-service。 # 一个源:静态 SPA(eip4-web/dist)+ 反代 /api→platform-app(唯一后端入口)。
# flowable-service:8089 无鉴权,绝不经 nginx 对外(见下 /flowable/ 说明)。
# 消除 dev 的 vite proxy 依赖;切流灰度(W6)可在此用 upstream 权重双跑(eip3↔eip4)。 # 消除 dev 的 vite proxy 依赖;切流灰度(W6)可在此用 upstream 权重双跑(eip3↔eip4)。
server { server {
listen 80; listen 80;
@@ -22,12 +23,14 @@ server {
proxy_read_timeout 130s; # 略大于 statement_timeout(120s),避免反代先于 DB 超时切断 proxy_read_timeout 130s; # 略大于 statement_timeout(120s),避免反代先于 DB 超时切断
} }
# 工作流引擎(按需直达;多数流程经 platform-app 网关,故默认收窄) # 🔴 工作流引擎(flowable-service:8089)绝不对外暴露。
# flowable-service 进程无 Spring Security,鉴权唯一落点=platform-app 网关的超管门
# (ProcessModelerController.requireSuperAdmin);裸直达 8089 会绕过所有鉴权,
# 匿名即可部署/覆盖生产 BPMN、办结/终止任意任务(安全评审 Critical#1)。
# 前端只经 /api/workflow/*(网关)访问流程能力,不需要 /flowable/ 直达。
# 若确需内网调试直达,改为 `internal;` 仅供内部子请求,严禁对公网 proxy_pass。
location /flowable/ { location /flowable/ {
proxy_pass http://flowable-service:8089/; return 404;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
} }
# 静态资源:带 hash 的构建产物可长缓存 # 静态资源:带 hash 的构建产物可长缓存

View File

@@ -79,7 +79,7 @@
| `plans/2026-06-25-报表迁移-JOR引擎重宿主-design.md` | 报表 A3 设计(Phase1-3 已完成 + 安全收口,总览 §11) | | `plans/2026-06-25-报表迁移-JOR引擎重宿主-design.md` | 报表 A3 设计(Phase1-3 已完成 + 安全收口,总览 §11) |
| `plans/2026-06-25-审批闭环-实施计划.md` | 审批闭环 P0-P3(已实施合 main `c95eaee`,剩外部前置) | | `plans/2026-06-25-审批闭环-实施计划.md` | 审批闭环 P0-P3(已实施合 main `c95eaee`,剩外部前置) |
| `plans/2026-06-26-在线流程Modeler-design.md` | B3 流程 Modeler 设计(D1-D9 拍定) | | `plans/2026-06-26-在线流程Modeler-design.md` | B3 流程 Modeler 设计(D1-D9 拍定) |
| `plans/2026-07-02-在线流程Modeler-实施计划.md` | B3 实施计划(4 阶段 TDD 任务,含语料/代码勘探基线 + P1-P6 计划级决策,**执行中**) | | `plans/2026-07-02-在线流程Modeler-实施计划.md` | B3 实施计划(4 阶段 17 任务 **全完成合 main 2026-07-02**;含语料/代码勘探基线 + 计划级决策 + 每阶段 live 验收发现 + 双对抗评审处置) |
| `AI_AGENT_AUTO_DEVELOPMENT.md` + `AI_AGENT_PAGE_BLUEPRINT_CONTRACT.md` / `AI_AGENT_REPAIR_CONTRACT.md` / `AI_AGENT_Nocobase_ADOPTION_PLAN.md` + `skills/` | AI Agent 对外口径红线 + 编译/修复/采纳契约 + Skills 目录 | | `AI_AGENT_AUTO_DEVELOPMENT.md` + `AI_AGENT_PAGE_BLUEPRINT_CONTRACT.md` / `AI_AGENT_REPAIR_CONTRACT.md` / `AI_AGENT_Nocobase_ADOPTION_PLAN.md` + `skills/` | AI Agent 对外口径红线 + 编译/修复/采纳契约 + Skills 目录 |
| `framework定制视图-TODO-2026-06-17.md` | A 兼容线**活清单**(Done/In-Progress/待验三态),每次修完回写 | | `framework定制视图-TODO-2026-06-17.md` | A 兼容线**活清单**(Done/In-Progress/待验三态),每次修完回写 |
| `framework定制视图-engineclass移植backlog-2026-06-17.md` | 46 framework 视图迁移**主 backlog**(verdict/移植项/优先级) | | `framework定制视图-engineclass移植backlog-2026-06-17.md` | 46 framework 视图迁移**主 backlog**(verdict/移植项/优先级) |

View File

@@ -1,5 +1,7 @@
# 在线流程 Modeler(B3)实施计划 # 在线流程 Modeler(B3)实施计划
> **✅ B3 全 17 任务完成并合 main(2026-07-02)**:platform origin/main 阶段1-4 全合、web origin/main 全合;每任务 TDD+对抗评审+修复轮,每阶段出口 live 验收(挡下 3 个单测/评审都没抓到的真 bug:options语义/面板ref/**bpmn-js PascalCase断部署**),末尾双对抗评审(安全+发布链)判定可宣告完成、唯一 Critical(nginx骨架洞)已修。**Modeler 端到端可用**:打开中文key存量流程→改办理人/会签保真读回→存草稿eip4IdMap保全→同人确认发布→部署新版本中文key保住+审计+起实例真userTask+旧实例不动+非admin403。
>
> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. > **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
> >
> 设计权威:`2026-06-26-在线流程Modeler-design.md`(D1-D9 已拍定)。本计划把 design 落成 TDD 任务, > 设计权威:`2026-06-26-在线流程Modeler-design.md`(D1-D9 已拍定)。本计划把 design 落成 TDD 任务,
@@ -255,7 +257,9 @@ commit:`feat(modeler): 办理人/会签表达式编解码器(与 BasePropertie
### Task 2.4 前端:EIP4 侧板(办理人/会签/formKey/扩展属性/监听器) ### Task 2.4 前端:EIP4 侧板(办理人/会签/formKey/扩展属性/监听器)
> 📌 **随本 task 顺带收 T1.5 评审两小项**:①红线回归测试——ProcessModelerPage 测试断言 `ModelerCtor.mock.calls[0][0].moddleExtensions` 键恰为 `['activiti']` 且 `additionalModules` 长度为 2(防有人「顺手」加 provider 静默回归);②canvas ref 为 null 分支也 set error(现停留 loading 无提示)。 > 🔴 **T2.3 实证——meta 透传是正确性硬要求**:真实表达式外层对象除 items 外还有 5 个业务 meta 字段(messageTemplate/taskSuccessService/isSkipInitiator/isNoUserSkip/isSkipBeforeTask;taskSuccessService 是真实任务后置服务钩子如 PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS)。codec 的 parse 已返 `{items,variant,meta}`、build 收 meta 可选参——**侧板写回办理人/会签时必须把 parse 出的 meta 原样传回 build**,否则发布会打掉已部署流程的业务字段。测试必须含「改 items 后 meta 逐字保留」用例。
>
> 📌 **随本 task 顺带收 T1.5 评审遗留**:红线回归测试——ProcessModelerPage 测试断言 `ModelerCtor.mock.calls[0][0].moddleExtensions` 键恰为 `['activiti']` 且 `additionalModules` 长度为 2(防「顺手」加 provider 静默回归)。(canvas ref null 分支已随 dffd1f3 修复,勿重复。)
**Files:** **Files:**
- Create: `src/modeler/Eip4Panel.tsx`(+`Eip4Panel.test.tsx`)、`src/modeler/useSelectedElement.ts`(订阅 `selection.changed`) - Create: `src/modeler/Eip4Panel.tsx`(+`Eip4Panel.test.tsx`)、`src/modeler/useSelectedElement.ts`(订阅 `selection.changed`)
@@ -273,6 +277,10 @@ commit:`feat(modeler): EIP4 侧板三控件+扩展属性/监听器编辑`
### Task 2.5 前端:存草稿 + 草稿列表打开 ### Task 2.5 前端:存草稿 + 草稿列表打开
> 📌 **T2.2 评审遗留——草稿删除端点**:五端点无 DELETE,POST 重试窗口产生的重复草稿无 API 可清、草稿列表 UX 也需要删除。**本 task 或 T4.1 补**:flowable-service `DELETE /api/flow/models/{id}`(deleteModel)+ 网关同门转发 + 前端草稿列表删除按钮(confirm)。
>
> 📌 **T2.2 实证——wftemplates 名称现实**:view_wftemplate **无名称列**(计划原假设错),网关已按 entityid→sys_entity.name 解析——1016 活动模板仅 339 有中文名,其余下拉显 uuid。**formKey 下拉须加过滤输入框**(1016 项不可裸滚动),无名项显示「<uuid 前 8 位>…(未命名)」。此项归本 task 或 T2.4 收口轮顺带。
**Files:** Modify `processModeler.ts`(saveDraft/createDraft/listModels/getModel/fromProcDef)、`ProcessModelerPage.tsx`(顶栏「保存草稿」`saveXML({format:true})`→PUT;打开器加「草稿」tab);tests。 **Files:** Modify `processModeler.ts`(saveDraft/createDraft/listModels/getModel/fromProcDef)、`ProcessModelerPage.tsx`(顶栏「保存草稿」`saveXML({format:true})`→PUT;打开器加「草稿」tab);tests。
**阶段 2 live 验收**:打开「总包合同交底」→ from-procdef 建草稿 → 改办理人(加一个 user)→ 保存 → psql 查 `act_re_model` 新行 + `act_ge_bytearray` 编辑源含改动 + metaInfo 含 eip4IdMap → 重开草稿回显正确。 **阶段 2 live 验收**:打开「总包合同交底」→ from-procdef 建草稿 → 改办理人(加一个 user)→ 保存 → psql 查 `act_re_model` 新行 + `act_ge_bytearray` 编辑源含改动 + metaInfo 含 eip4IdMap → 重开草稿回显正确。
@@ -284,6 +292,8 @@ commit + 合 main:`feat(modeler): 阶段2 EIP4 控件+草稿闭环`
### Task 3.1 后端:deploy-from-model(id 还原 + 引擎校验门) ### Task 3.1 后端:deploy-from-model(id 还原 + 引擎校验门)
> 🔴 **阶段2 live 实证——bpmn-js 输出被严格 XSD 校验拒(已修,且警示 T3.1)**:flowable `convertToBpmnModel(src, validateSchema=true, ...)` 的严格 Xerces XSD 校验**拒绝 bpmn-js saveXML 的默认命名空间输出**(`cvc-complex-type.2.4.a: Invalid content ... {MODEL}Process`),原始带前缀 source 能过。草稿保存已改 validateSchema=false(草稿是半成品,XSD 不适用)+ 字节级 DOCTYPE 守卫保 XXE。**本 task deploy 必须验证同问题**:`createDeployment().addString().deploy()` 也解析 bpmn-js 输出,若 Flowable 部署校验拒默认命名空间/activiti 扩展,需在部署前把 bpmn-js XML 规范化(或确认 deploy 路径不走严格 XSD)——阶段 3 live 必须用「编辑器改过并 saveXML 的真实流程」部署,不能只用原始 source。
> ⚠️ **T1.3 评审 I-2 预警——文本引用**:bpmn-js `saveXML` 会给流节点补 `<bpmn:incoming>/<bpmn:outgoing>` **元素文本**引用(存量 1512 文档 0 命中,但编辑器导出会有),`BpmnIdSanitizer.restore` 只还原**属性位** → 直接部署会落库「属性=中文原 id、文本引用=净化 id」的脏 XML(Flowable 不解析 incoming/outgoing 故功能无害,但再次 from-procdef 重编辑时碰撞序号换位可能指错节点)。**本 task 必须**:restore 前剥除 incoming/outgoing 元素(Flowable 自行从 sequenceFlow 推导)或把文本引用位纳入 restore,二选一并加测试(含「编辑器导出态 XML → 部署 XML 无净化 id 残留」断言)。 > ⚠️ **T1.3 评审 I-2 预警——文本引用**:bpmn-js `saveXML` 会给流节点补 `<bpmn:incoming>/<bpmn:outgoing>` **元素文本**引用(存量 1512 文档 0 命中,但编辑器导出会有),`BpmnIdSanitizer.restore` 只还原**属性位** → 直接部署会落库「属性=中文原 id、文本引用=净化 id」的脏 XML(Flowable 不解析 incoming/outgoing 故功能无害,但再次 from-procdef 重编辑时碰撞序号换位可能指错节点)。**本 task 必须**:restore 前剥除 incoming/outgoing 元素(Flowable 自行从 sequenceFlow 推导)或把文本引用位纳入 restore,二选一并加测试(含「编辑器导出态 XML → 部署 XML 无净化 id 残留」断言)。
**Files:** Modify `ProcessModelController.java` + test。 **Files:** Modify `ProcessModelController.java` + test。
@@ -299,6 +309,8 @@ commit:`feat(flow): 草稿发布(id还原+ProcessValidator校验门)+影响摘
### Task 3.2 网关:EIP4 语义校验 + 部署审计(Flyway V4) ### Task 3.2 网关:EIP4 语义校验 + 部署审计(Flyway V4)
> 📌 **T2.4 评审补充**:语义校验白名单须加两条——①办理人/会签表达式的 `items` **非空**(`items:[]` 的 MI collection 运行期会炸,仅 JSON 可解析+type 白名单不够);②completionCondition 允许「三预设 或 保留的自定义 body」(T2.4 已实现自定义保留态,校验别把存量自定义条件拒了,白名单改为预设正则 ∪ 非空任意表达式加告警)。
**Files:** **Files:**
- Create: `platform-flow-gateway/.../aggregate/ModelSemanticValidator.java` + test:解析 XML(**照 WfTemplateService.newJdkDbf :116-135 钉 JDK 解析器**,防 xerces 击穿)→ ①每个 `activiti:candidateUsers`/multiInstance collection 的内嵌 JSON 可解析且 items[].type ∈ 白名单 ②`activiti:formKey` 存在于 view_wftemplate(JdbcTemplate exists)③completionCondition 匹配预设白名单正则。返回 `List<String> errors`。 - Create: `platform-flow-gateway/.../aggregate/ModelSemanticValidator.java` + test:解析 XML(**照 WfTemplateService.newJdkDbf :116-135 钉 JDK 解析器**,防 xerces 击穿)→ ①每个 `activiti:candidateUsers`/multiInstance collection 的内嵌 JSON 可解析且 items[].type ∈ 白名单 ②`activiti:formKey` 存在于 view_wftemplate(JdbcTemplate exists)③completionCondition 匹配预设白名单正则。返回 `List<String> errors`。
- Create: `platform-app/src/main/resources/db/migration/V4__flow_deploy_audit.sql`(照 V3 风格):`sys_flow_deploy_audit(id bigserial pk, model_id, deployment_id, process_key, new_version int, operator varchar(64), deployed_at timestamp default now())` - Create: `platform-app/src/main/resources/db/migration/V4__flow_deploy_audit.sql`(照 V3 风格):`sys_flow_deploy_audit(id bigserial pk, model_id, deployment_id, process_key, new_version int, operator varchar(64), deployed_at timestamp default now())`
@@ -307,6 +319,8 @@ commit:`feat(flow): 草稿发布(id还原+ProcessValidator校验门)+影响摘
commit:`feat(gateway): 发布语义校验门+sys_flow_deploy_audit 审计(V4)` commit:`feat(gateway): 发布语义校验门+sys_flow_deploy_audit 审计(V4)`
> 🔴🔴 **阶段3 live 揪出 CRITICAL——activiti.json 描述符致 bpmn-js Modeler 输出 PascalCase 元素名(部署链断)**:bpmn-js Modeler.saveXML 对 activiti.json `extends` 的 bpmn 类型(Process/UserTask/StartEvent)序列化成大写 `<Process>/<UserTask>/<StartEvent>`(未扩展的 sequenceFlow/endEvent 仍小写)。Flowable 大小写敏感→`<Process>` 不识别→ProcessValidator 报 flowable-process-definition-not-executable,**部署完全断**。「isExecutable 丢失」是此 bug 症状非独立问题。**T1.1/T1.2 moddle round-trip 测试抓不到**(直接 fromXML→toXML 读写同形),只有真 Modeler saveXML+真部署暴露(live 铁证)。修=重构 activiti.json 扩展类型定义让 Modeler 序列化保持小写 BPMN 元素名(moddle extends 惯用法),验收硬门=saveXML 输出小写 userTask/process + 真部署 200 + 起实例生成 userTask。已挂 T3.3 修复轮 + 需前端保真测试升级到「过 bpmn-js Modeler.saveXML 非仅 bpmn-moddle」。
### Task 3.3 前端:同人确认弹窗(影响摘要)+ 发布流 ### Task 3.3 前端:同人确认弹窗(影响摘要)+ 发布流
**Files:** Create `src/modeler/PublishConfirm.tsx`(+test)、`src/modeler/diffSummary.ts`(+test,P2 节点级 diff);Modify `ProcessModelerPage.tsx`。 **Files:** Create `src/modeler/PublishConfirm.tsx`(+test)、`src/modeler/diffSummary.ts`(+test,P2 节点级 diff);Modify `ProcessModelerPage.tsx`。
@@ -345,6 +359,23 @@ commit:`test(modeler): 流程Modeler live e2e(改存量/新建/走查 3 场景
--- ---
## B3 最终发布链对抗评审处置(2026-07-02)
判定「可宣告完成,无 Critical 无阻断」。id 保真闭环三来源自洽+发布错误契约双形状透传扎实。跟进项处置:
- **I-1 formKey 门误拒改存量——语料 dry-run 证伪(无需修)**:全库 803 个 distinct activiti:formKey **全部命中 view_wftemplate(miss=0)**,formKey 门不会误拒任何存量流程。评审担心的静默回归在真实库不成立。
- **I-2 空 content 语义缺口**:已作已知限制记录(见下),v2 精化(content 可能是变量表达式,硬要求非空会误拒,需按 type 分白名单)。
- **M-1**(下游 422 顶层文案 handler 用 message、前端读 msg,per-node 错误仍渲染)/ M-2(by-id 写删侧无 category 守卫,超管门+UI 已兜)/ M-3(writeCosign 重建只保 4 属性,真实会签仅用 handler-collection 模式暴露低)= 低优先清理 backlog。
## B3 最终安全对抗评审(2026-07-02 阶段4)——1 Critical 已修 + A10 生产加固 backlog
- **✅ Critical#1 已修**:`deploy/nginx.conf` 的 `/flowable/` 裸 proxy 到无鉴权 8089 对公网暴露→绕过网关超管门匿名部署/覆盖生产 BPMN。改 `return 404`(前端只走 `/api/workflow/` 网关,不需要直达)。**注:此洞在 A10 部署骨架里、生产未切流,非 B3 运行时可达**;网关侧超管门本身实现严密无绕过面(评审确认)。
- **A10 生产加固 backlog(非 B3 dev 阻塞,超管信任模型内可接受,随 A10 生产化做)**:High#2 部署 BPMN 可含 serviceTask/JUEL 表达式/监听器=引擎内表达式求值面(超管信任内可接受;修 #1 后降为加固项,v2 可加可执行元素白名单);Medium#3 网关→flowable-service 无凭据纯靠网络隔离(加 X-Internal-Auth 共享密钥纵深);Medium#4 审计只覆盖网关 deploy 路径+写失败静默(下沉审计到 flowable-service 实际部署点或加失败告警)。Low#5(无细粒度流程授权=v1有意)/#6(伪造metaInfo不提权=超管本可写任意key)/#7(impact 缺 DOCTYPE 兜底=enableSafeBpmnXml 已挡)/#8(disableSchemaValidation 只跳 XSD 不开 DTD) 均已缓解/可接受。
## 已知限制 / v2 精化点(2026-07-02 阶段4 e2e 发现)
- **会签办理人 content 为空的语义缺口**:ModelSemanticValidator 校验 `items 非空`(数组长度)但不校验 candidate item 的 `content 非空`。会签模板出厂 items=[{type:user,content:""}] 过语义门,但运行期 multiInstanceUsersHandler 解析空 content → MI 跳过 → 流程无任务直接结束。**不硬修**(content 常是 `${APPLYUSERS}` 变量表达式,硬要求非空会误拒合法流程);v2 可考虑「content 空且非变量表达式 → WARNING」。用户新建会签流程须填办理人,否则部署出空转流程。
- **live e2e 非幂等**:发布无运行时下架端点,每跑场景A「总包合同交底」版本 +1(live 验收固有,非 CI 硬门)。
- **非超管 403 e2e 降级**:dev 库无非超管账号,场景C④用无 token(principal==null 走同一 requireSuperAdmin 分支)+admin 对照证门有效;真非超管 token 断言待 dev 库补账号。
## 验收清单(全项打勾才算 B3 完成) ## 验收清单(全项打勾才算 B3 完成)
- [ ] 1512 流 moddle round-trip 扫描零丢失(Task 1.2 工具实测) - [ ] 1512 流 moddle round-trip 扫描零丢失(Task 1.2 工具实测)
@@ -358,4 +389,4 @@ commit:`test(modeler): 流程Modeler live e2e(改存量/新建/走查 3 场景
## 红线提醒(执行中不可越) ## 红线提醒(执行中不可越)
**生产 8089 不对外**(T1.6 评审:门在网关的前提=flowable-service 网络隔离,阶段 3 部署门验收清单显式检查,deploy/nginx/compose 不得暴露 8089);flowable `databaseSchemaUpdate=false` 不动(act_re_model 已存在无需 DDL;审计表走 Flyway V4 是平台表非引擎表);保真层 `com.dsasp.*` 不改(BasePropertiesConverter 只读对齐,不重构);XML 解析一律钉 JDK 解析器(xerces 击穿前科);JDK 21;部署门只落网关(flowable-service 裸 8089 无安全栈);每 task TDD、每阶段对抗自查后才合 main。 **每阶段合 main 前必须全 reactor `mvn clean install` 真绿**(模块级 `mvn -pl` 跑不到 platform-app 的 ArchitectureRulesTest,阶段2 wftemplates 给 @RestController 注 JdbcTemplate 触棘轮就是模块级漏过、全 reactor 才 catch;且判绿看 `BUILD SUCCESS` 字样,勿信 `| tail` 后的 `$?`=tail 退出码);控制器新增 SQL 一律收口 Service(ArchUnit 棘轮禁 @RestController 直用 JdbcTemplate);**生产 8089 不对外**(T1.6 评审:门在网关的前提=flowable-service 网络隔离,阶段 3 部署门验收清单显式检查,deploy/nginx/compose 不得暴露 8089);flowable `databaseSchemaUpdate=false` 不动(act_re_model 已存在无需 DDL;审计表走 Flyway V4 是平台表非引擎表);保真层 `com.dsasp.*` 不改(BasePropertiesConverter 只读对齐,不重构);XML 解析一律钉 JDK 解析器(xerces 击穿前科);JDK 21;部署门只落网关(flowable-service 裸 8089 无安全栈);每 task TDD、每阶段对抗自查后才合 main。

View File

@@ -16,6 +16,7 @@ EIP3(Vaadin / 老引擎)→ EIP4(amis 前端 + 保真层 + 转换器)迁
- **B 新能力线本期里程碑突破**:「人走五环建新功能」低代码平台 **v1 全链交付并合入 origin/main 两仓**;设计器选型(amis-editor)拍板且 **DesignerPage 全闭环上线**(解除历史 P1 头号阻塞);AI 确定性(非 LLM)五环生产线**已合 main**。 - **B 新能力线本期里程碑突破**:「人走五环建新功能」低代码平台 **v1 全链交付并合入 origin/main 两仓**;设计器选型(amis-editor)拍板且 **DesignerPage 全闭环上线**(解除历史 P1 头号阻塞);AI 确定性(非 LLM)五环生产线**已合 main**。
- **安全基线(§10.1 四项 P0 + 评审追加 2 孪生 + Groovy 沙箱)2026-06-25 全数收口并 push**(platform `eba9ce1` / web `2a37251`),可达 RCE/越权/fail-open 已闭。 - **安全基线(§10.1 四项 P0 + 评审追加 2 孪生 + Groovy 沙箱)2026-06-25 全数收口并 push**(platform `eba9ce1` / web `2a37251`),可达 RCE/越权/fail-open 已闭。
- **报表保真层(套打 JOR)2026-06-25/26 重宿主 + 安全/OOM 收口全数完成并 push origin/main**(§11):SQLi 门 / IDOR 授权 / XXE / 并发·字节·超时·结果集封顶 / CVE 依赖替换 / 报表只读数据源;11 类 79 单测 + live e2e + 安全对抗复审,三批 merge `e6c73a4`/`dccca17`/`d697885`。 - **报表保真层(套打 JOR)2026-06-25/26 重宿主 + 安全/OOM 收口全数完成并 push origin/main**(§11):SQLi 门 / IDOR 授权 / XXE / 并发·字节·超时·结果集封顶 / CVE 依赖替换 / 报表只读数据源;11 类 79 单测 + live e2e + 安全对抗复审,三批 merge `e6c73a4`/`dccca17`/`d697885`。
- **B3 在线流程 Modeler v1 全链交付并合 main(2026-07-02)**:可编辑存量/新建 BPMN→草稿→同人确认发布→部署 Flowable(中文 key 保真+EIP4 办理人/会签控件+发布门+审计),A2 审批线的「流程定义在线编辑」最后一块补齐。
- 项目仍在 **dev 环境**;生产上线工程化(A10)**MVP 骨架已合 main(2026-06-25)**:W1 Flyway(`db/migration/V1-V3`)+ W2-W4 容器化/nginx 单源/compose 编排(`deploy/` + 模块根 Dockerfile),切流执行 / 性能并发 / 灰度未做。 - 项目仍在 **dev 环境**;生产上线工程化(A10)**MVP 骨架已合 main(2026-06-25)**:W1 Flyway(`db/migration/V1-V3`)+ W2-W4 容器化/nginx 单源/compose 编排(`deploy/` + 模块根 Dockerfile),切流执行 / 性能并发 / 灰度未做。
--- ---
@@ -77,7 +78,7 @@ EIP3(Vaadin / 老引擎)→ EIP4(amis 前端 + 保真层 + 转换器)迁
| **人走五环** | NocoBase 式建模器 + 实时设计器 v1 | 🟢 | **v1 全链交付 + live 验收 + 合 main 两仓**(platform 418 单测 / web 73 vitest)。五环①②③④(含引用列)+ AI①面恒 READY_FOR_HUMAN_REVIEW + production 人审部署包(requiresHumanApproval=true)+ 主子表四件套全完,红线全守。**v1 限简单 CRUD/树 recipe + 只建新不改表** | | **人走五环** | NocoBase 式建模器 + 实时设计器 v1 | 🟢 | **v1 全链交付 + live 验收 + 合 main 两仓**(platform 418 单测 / web 73 vitest)。五环①②③④(含引用列)+ AI①面恒 READY_FOR_HUMAN_REVIEW + production 人审部署包(requiresHumanApproval=true)+ 主子表四件套全完,红线全守。**v1 限简单 CRUD/树 recipe + 只建新不改表** |
| **B1** | 新设计器(低代码可视化) | 🟢 | **选型已拍板**:D1 签字下注 amis-editor(接受 amis-fork 6.13.0 冻结天花板 / bus factor≈1 自维护);形态 = NocoBase 式建模器 + 实时设计器,不做线性 wizard。**DesignerPage 已修到全闭环**(`2278cbc` 等 6 提交),原 P1 头号阻塞已解除 | | **B1** | 新设计器(低代码可视化) | 🟢 | **选型已拍板**:D1 签字下注 amis-editor(接受 amis-fork 6.13.0 冻结天花板 / bus factor≈1 自维护);形态 = NocoBase 式建模器 + 实时设计器,不做线性 wizard。**DesignerPage 已修到全闭环**(`2278cbc` 等 6 提交),原 P1 头号阻塞已解除 |
| **B2** | AI 模块 | 🟢 | **确定性(非 LLM)五环增量生产线已合 main**(超 PoC)。platform-ai + platform-cli 落地;终点恒人审、平台不内置生成 LLM(唯 LLM 修复 `HttpAiLlmRepairClient` 默认关、只修不生成)。落地 P0/P1/P2/P4/P5 第一版完成,P3 进行中 | | **B2** | AI 模块 | 🟢 | **确定性(非 LLM)五环增量生产线已合 main**(超 PoC)。platform-ai + platform-cli 落地;终点恒人审、平台不内置生成 LLM(唯 LLM 修复 `HttpAiLlmRepairClient` 默认关、只修不生成)。落地 P0/P1/P2/P4/P5 第一版完成,P3 进行中 |
| **B3** | 流程建模器 BPMN Modeler | 🔴 | 未起步(即 A2 现在唯一缺的「流程定义在线编辑」)。注:BPMN 只读**查看**已做(A2 流程图,bpmn-js NavigatedViewer);Modeler=可编辑+部署,需 S1 拍板自研 vs 嵌入 flowable-modeler | | **B3** | 流程建模器 BPMN Modeler | 🟢 | **v1 全链交付并合 main(2026-07-02,platform+web)**。bpmn-js Modeler 可编辑存量/新建 BPMN 流程→存草稿(act_re_model)→同人确认发布→部署到 Flowable。含:可逆 id 净化(中文流程 key 保真 D7)、EIP4 侧板五控件(办理人/会签保真读回/formKey/扩展属性/监听器)、办理人表达式 codec(逐字对齐引擎)、activiti moddle 完整描述符(1512/1512 保真零丢失)、发布门(ProcessValidator+网关语义校验+超管门+审计 V4)、4 新建模板、Playwright e2e 三场景。17 任务 TDD+对抗评审+每阶段 live 验收(挡 3 真 bug 含 bpmn-js PascalCase 断部署)。设计+实施计划见 `plans/2026-07-02-在线流程Modeler-实施计划.md`。残:A10 生产加固 backlog(nginx 洞已修/引擎表达式白名单/网关内部鉴权)、空 content 语义校验、细粒度流程授权(v2)。BPMN 只读查看(A2 流程图)仍在 |
| **B4** | 生产级 UI/UE 组件体系 | 🟡 | L1 主题(amis-theme.css §10-15 密度/按钮/弹窗/字号)+ L2 行选中 `checkOnItemClick` + 设计中心 DesignCenterPage 已上线;剩选择框统一 / 主子表宿主 / 树编辑 Drawer / 审批待办 未完整(`组件设计体系-design-2026-06-15` 落地状态需对齐本矩阵) | | **B4** | 生产级 UI/UE 组件体系 | 🟡 | L1 主题(amis-theme.css §10-15 密度/按钮/弹窗/字号)+ L2 行选中 `checkOnItemClick` + 设计中心 DesignCenterPage 已上线;剩选择框统一 / 主子表宿主 / 树编辑 Drawer / 审批待办 未完整(`组件设计体系-design-2026-06-15` 落地状态需对齐本矩阵) |
| **B5** | 移动端 / 响应式 | 🔴 | 未起步 | | **B5** | 移动端 / 响应式 | 🔴 | 未起步 |
| **B6** | 报表设计器(自助报表) | 🔴 | 未起步(与 A3 同根待立项) | | **B6** | 报表设计器(自助报表) | 🔴 | 未起步(与 A3 同根待立项) |

View File

@@ -0,0 +1,620 @@
package com.eip4.flowservice.api;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.flowable.bpmn.converter.BpmnXMLConverter;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.common.engine.impl.util.io.StringStreamSource;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.repository.Model;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.validation.ProcessValidator;
import org.flowable.validation.ProcessValidatorFactory;
import org.flowable.validation.ValidationError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StreamUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
* 流程草稿 CRUD(flowable 原生 Model API 存 act_re_model,本控制器为全仓首次启用 Model API)。
*
* <p>在线 Modeler 的草稿仓:编辑中的 BPMN 存为 flowable Model(editorSource=BPMN XML,metaInfo=EIP4 元数据 JSON),
* 不进部署库;发布(T3.1)时才 restore 中文原 key + 校验门 + deploy。act_re_model 表已有 143 行存量、schema 已在,
* {@code databaseSchemaUpdate=false} 不涉 DDL。</p>
*
* <p><b>存量隔离</b>:本控制器建的草稿一律 {@code setCategory("eip4")},{@link #list()} 只查该分类,
* 库里 143 条老 shape act_re_model(旧 metaInfo + 可能悬空 editorSource)不进 Modeler 列表、避免打不开。</p>
*
* <p>写入前 XML 一律过解析守卫({@link #parseGuard}):①字节级拒 DOCTYPE(XXE 门);②{@link BpmnXMLConverter}
* 以 {@code validateSchema=false}(草稿是半成品,不做严格 XSD——bpmn-js 默认命名空间输出与严格 XSD 已知固有不兼容,
* 完整校验属部署门)+ {@code enableSafeBpmnXml=true}(加固解析器,双保险防外部实体)解析。坏 XML 返 422 且绝不落库;
* 422 只回通用文案,原始解析原因仅进日志。守卫异常就地 catch 转 422,不逸出到 {@code FlowExceptionHandler}
* (那里 FlowableException→400,语义不符)。
* {@code from-procdef} 复用「按 procDefId 读部署 BPMN」逻辑(本控制器自带 {@link #readProcessModel} 小方法,
* 零改动 ProcessDiagramController)→ {@link BpmnIdSanitizer#sanitize} 净化中文 id → 建草稿,
* 原→净化映射连同源 procDefId/原 key 写进 metaInfo,供发布逆向还原。</p>
*
* <p><b>鉴权</b>:本控制器随 flowable-service 跑在裸 8089,进程本身无鉴权栈;所有写端点
* (POST/PUT/from-procdef)必须经 platform-flow-gateway 的超管门访问(T2.2),生产环境 8089 不对外暴露。</p>
*/
@RestController
@RequestMapping("/api/flow")
@Tag(name = "流程草稿", description = "flowable Model API 草稿 CRUD(act_re_model)+ 从流程定义建草稿")
public class ProcessModelController {
private static final Logger log = LoggerFactory.getLogger(ProcessModelController.class);
/** EIP4 草稿分类:建草稿时打此标,list() 只查此分类,隔离库里 143 条老 shape 存量 act_re_model。 */
static final String EIP4_CATEGORY = "eip4";
/** DOCTYPE 门 prolog 扫描字节上限(BOM/XML 声明/注释/DOCTYPE 都在最前)。 */
private static final int PROLOG_SCAN_BYTES = 8192;
/**
* bpmn-js {@code saveXML} 补的 {@code <*:incoming>/<*:outgoing>} 文本引用元素(前缀可选:bpmn/bpmn2/默认)。
* 发布前整体剥除——Flowable 从 {@code sequenceFlow} 的 sourceRef/targetRef 自行推导入出边,这些元素冗余;
* 且它们把节点/流 id 存为<b>元素文本</b>(非属性),{@link BpmnIdSanitizer#restore} 只还原属性位不碰文本
* → 不剥则落库「属性=中文原 key、文本引用=净化 id」的脏 XML(T1.3 评审 I-2)。
*/
private static final Pattern FLOW_REF_ELEMENT = Pattern.compile(
"<(?:[\\w.-]+:)?(?:incoming|outgoing)>[^<]*</(?:[\\w.-]+:)?(?:incoming|outgoing)>");
private final RepositoryService repositoryService;
private final RuntimeService runtimeService;
private final ProcessValidator processValidator;
private final ObjectMapper objectMapper = new ObjectMapper();
@Autowired
public ProcessModelController(RepositoryService repositoryService, RuntimeService runtimeService) {
this(repositoryService, runtimeService, new ProcessValidatorFactory().createDefaultProcessValidator());
}
/**
* 单参构造:既有草稿 CRUD 单测保留零改动地 {@code new ProcessModelController(repositoryService)}
* (那些用例不触发发布/影响路径,无需 RuntimeService/校验器)。
*/
ProcessModelController(RepositoryService repositoryService) {
this(repositoryService, null, new ProcessValidatorFactory().createDefaultProcessValidator());
}
/**
* 全参构造:发布/影响端点单测注入 <b>mock</b> {@link ProcessValidator}
* ({@code ProcessValidatorFactory} 产的默认校验器无法 mock,须构造注入以断言 ERROR-vs-WARNING 分支)。
*/
ProcessModelController(RepositoryService repositoryService, RuntimeService runtimeService,
ProcessValidator processValidator) {
this.repositoryService = repositoryService;
this.runtimeService = runtimeService;
this.processValidator = processValidator;
}
@GetMapping("/models")
@Operation(summary = "草稿列表",
description = "createModelQuery().modelCategory(\"eip4\").orderByLastUpdateTime().desc() → "
+ "{models:[{id,name,key,lastUpdateTime(ISO)}]}。只列 EIP4 建的草稿,隔离存量 act_re_model。")
public ResponseEntity<Map<String, Object>> list() {
List<Map<String, Object>> models = repositoryService.createModelQuery()
.modelCategory(EIP4_CATEGORY)
.orderByLastUpdateTime().desc().list().stream()
.map(m -> {
Map<String, Object> row = new LinkedHashMap<>();
row.put("id", m.getId());
row.put("name", m.getName());
row.put("key", m.getKey());
row.put("lastUpdateTime", toIso(m.getLastUpdateTime()));
return row;
})
.collect(Collectors.toList());
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("models", models);
return ResponseEntity.ok(resp);
}
@GetMapping("/models/{id}")
@Operation(summary = "取草稿",
description = "getModel + getModelEditorSource → {found,id,name,key,bpmnXml,metaInfo}。"
+ "草稿不存在或编辑源为空 → {found:false}(HTTP 200,前端降级)。")
public ResponseEntity<Map<String, Object>> get(@PathVariable String id) {
Map<String, Object> resp = new LinkedHashMap<>();
Model model = repositoryService.getModel(id);
if (model == null) {
resp.put("found", false);
return ResponseEntity.ok(resp);
}
byte[] source = repositoryService.getModelEditorSource(id);
if (source == null) {
resp.put("found", false);
return ResponseEntity.ok(resp);
}
resp.put("found", true);
resp.put("id", model.getId());
resp.put("name", model.getName());
resp.put("key", model.getKey());
resp.put("bpmnXml", new String(source, StandardCharsets.UTF_8));
resp.put("metaInfo", model.getMetaInfo());
return ResponseEntity.ok(resp);
}
@PostMapping("/models")
@Operation(summary = "建草稿",
description = "body {name,key,bpmnXml,metaInfo?}。name/key 空白→422;XML 过 BpmnXMLConverter 解析守卫"
+ "(坏 XML→422 不落库);过门后 newModel+setCategory(eip4)+saveModel+addModelEditorSource → {modelId}。")
public ResponseEntity<Map<String, Object>> create(@RequestBody CreateModelRequest req) {
// key 是 T3.1 部署资源名/中文原 key 还原的依赖,name 用于列表展示:空白一律拒。
if (isBlank(req.name) || isBlank(req.key)) {
return status(HttpStatus.UNPROCESSABLE_ENTITY, "name 与 key 不能为空");
}
ResponseEntity<Map<String, Object>> rejected = parseGuard(req.bpmnXml);
if (rejected != null) {
return rejected;
}
Model model = repositoryService.newModel();
model.setName(req.name);
model.setKey(req.key);
model.setCategory(EIP4_CATEGORY);
if (req.metaInfo != null) {
model.setMetaInfo(req.metaInfo);
}
repositoryService.saveModel(model);
repositoryService.addModelEditorSource(model.getId(), req.bpmnXml.getBytes(StandardCharsets.UTF_8));
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("modelId", model.getId());
return ResponseEntity.ok(resp);
}
@PutMapping("/models/{id}")
@Operation(summary = "更新草稿",
description = "草稿不存在→404;更新 name/metaInfo(仅当请求提供,避免覆盖 eip4IdMap)与 editorSource(XML 同守卫 422) → {status:0}。")
public ResponseEntity<Map<String, Object>> update(@PathVariable String id, @RequestBody UpdateModelRequest req) {
Model model = repositoryService.getModel(id);
if (model == null) {
return status(HttpStatus.NOT_FOUND, "草稿不存在: " + id);
}
ResponseEntity<Map<String, Object>> rejected = parseGuard(req.bpmnXml);
if (rejected != null) {
return rejected;
}
if (req.name != null) {
model.setName(req.name);
}
// metaInfo 仅当请求显式提供时更新:草稿存 eip4IdMap 于 metaInfo,普通保存不重发 metaInfo 时不能抹掉它。
if (req.metaInfo != null) {
model.setMetaInfo(req.metaInfo);
}
repositoryService.saveModel(model);
repositoryService.addModelEditorSource(id, req.bpmnXml.getBytes(StandardCharsets.UTF_8));
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("status", 0);
return ResponseEntity.ok(resp);
}
@DeleteMapping("/models/{id}")
@Operation(summary = "删草稿",
description = "草稿不存在→404;存在则 deleteModel(id)(连带 editorSource/metaInfo 一并删) → {status:0}。")
public ResponseEntity<Map<String, Object>> delete(@PathVariable String id) {
Model model = repositoryService.getModel(id);
if (model == null) {
return status(HttpStatus.NOT_FOUND, "草稿不存在: " + id);
}
repositoryService.deleteModel(id);
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("status", 0);
return ResponseEntity.ok(resp);
}
@PostMapping("/models/from-procdef")
@Operation(summary = "从流程定义建草稿",
description = "body {procDefId}。读部署 BPMN → BpmnIdSanitizer.sanitize 净化中文 id → 建草稿"
+ "(name/key=procDef,editorSource=净化 XML,metaInfo={eip4IdMap,sourceProcDefId,originalKey}) → {modelId}。"
+ "procDef 不存在或 BPMN 空 → {found:false}(HTTP 200,前端降级)。")
public ResponseEntity<Map<String, Object>> fromProcDef(@RequestBody FromProcDefRequest req) {
ProcessDefinition def = repositoryService.createProcessDefinitionQuery()
.processDefinitionId(req.procDefId).singleResult();
if (def == null) {
return found(false);
}
String bpmnXml = readProcessModel(req.procDefId);
if (bpmnXml == null || bpmnXml.isBlank()) {
return found(false);
}
BpmnIdSanitizer.Result r = BpmnIdSanitizer.sanitize(bpmnXml);
Map<String, Object> meta = new LinkedHashMap<>();
meta.put("eip4IdMap", r.idMap());
meta.put("sourceProcDefId", req.procDefId);
meta.put("originalKey", def.getKey());
String metaInfoJson;
try {
metaInfoJson = objectMapper.writeValueAsString(meta);
} catch (Exception e) {
// 纯 Map<String,String/Object> 序列化理论上不会失败;防御性 500
log.error("[流程草稿] metaInfo 序列化失败 procDefId={}", req.procDefId, e);
return status(HttpStatus.INTERNAL_SERVER_ERROR, "metaInfo 序列化失败");
}
Model model = repositoryService.newModel();
model.setName(def.getName());
model.setKey(def.getKey());
model.setCategory(EIP4_CATEGORY);
model.setMetaInfo(metaInfoJson);
repositoryService.saveModel(model);
repositoryService.addModelEditorSource(model.getId(), r.xml().getBytes(StandardCharsets.UTF_8));
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("modelId", model.getId());
return ResponseEntity.ok(resp);
}
@PostMapping("/models/{id}/deploy")
@Operation(summary = "发布草稿为流程定义",
description = "草稿不存在→404;还原 eip4IdMap 里的中文原 key(存量流程 D7 硬需求,新建流程无 idMap 跳过)+"
+ "剥除 bpmn-js 补的 incoming/outgoing 文本引用 → 引擎 ProcessValidator 语义校验(仅 ERROR 级阻断,"
+ "返 422 {errors:[{activityId,problem,defaultDescription}]} 不部署;WARNING 放行)→ "
+ "createDeployment().disableSchemaValidation()(只跳 XSD:bpmn-js 默认命名空间与严格 XSD 已知不兼容,"
+ "语义校验已在上一步)部署 → {status:0,deploymentId,processKey,newVersion}。")
public ResponseEntity<Map<String, Object>> deploy(@PathVariable String id) {
Model model = repositoryService.getModel(id);
if (model == null) {
return status(HttpStatus.NOT_FOUND, "草稿不存在: " + id);
}
byte[] source = repositoryService.getModelEditorSource(id);
if (source == null) {
return status(HttpStatus.UNPROCESSABLE_ENTITY, "草稿源为空,无法发布: " + id);
}
String deployXml;
BpmnModel bpmnModel;
try {
// resolveIdMap 在 try 内:存量草稿 metaInfo 不可读/丢 eip4IdMap 时 fail-fast(评审 I1),不静默跳过还原。
Map<String, String> idMap = resolveIdMap(model.getMetaInfo());
deployXml = prepareDeployXml(new String(source, StandardCharsets.UTF_8), idMap);
// XXE 兜底:还原后 XML 再过字节级 DOCTYPE 守卫(与 parseGuard 同源防御);enableSafeBpmnXml 亦禁 DOCTYPE,双保险。
if (hasDoctypeInBytes(deployXml.getBytes(StandardCharsets.UTF_8))) {
log.warn("[流程发布] 拒绝: 还原后 XML 含 DOCTYPE 声明(XXE 防御) id={}", id);
return status(HttpStatus.UNPROCESSABLE_ENTITY, "BPMN 解析失败");
}
// validateSchema=false:bpmn-js 默认命名空间输出与严格 XSD 已知不兼容,语义交给下方 ProcessValidator;
// enableSafeBpmnXml=true:加固解析器关外部实体/DTD。
bpmnModel = new BpmnXMLConverter().convertToBpmnModel(new StringStreamSource(deployXml), false, true);
} catch (IllegalStateException e) {
// resolveIdMap 的 fail-fast:存量草稿 metaInfo 不可读/丢 eip4IdMap,还原不出中文原 key→拒发,防落库 nXXX 坏 key(D7)。
log.warn("[流程发布] id 映射不可用 id={}: {}", id, e.toString());
return status(HttpStatus.UNPROCESSABLE_ENTITY, "草稿 id 映射不可用,无法还原原 key");
} catch (IllegalArgumentException e) {
// BpmnIdSanitizer.restore 的 fail-fast:idMap 非双射(metaInfo 损坏)——须炸不能静默还原成别的 key。
log.warn("[流程发布] id 还原失败(idMap 损坏) id={}: {}", id, e.toString());
return status(HttpStatus.UNPROCESSABLE_ENTITY, "草稿 id 映射损坏,无法还原原 key");
} catch (Exception e) {
log.warn("[流程发布] BPMN 解析失败 id={}: {}", id, e.toString());
return status(HttpStatus.UNPROCESSABLE_ENTITY, "BPMN 解析失败");
}
// 引擎校验门:区分 ERROR/WARNING,只 ERROR 级阻断部署。此处仅引擎「结构」校验(节点连通/网关/多实例等);
// EIP4 「语义」校验(formKey 存在于 view_wftemplate、办理人/会签内嵌 JSON 白名单)在网关 ModelSemanticValidator(T3.2)。
List<Map<String, Object>> blocking = new ArrayList<>();
for (ValidationError ve : processValidator.validate(bpmnModel)) {
if (ve.isWarning()) {
log.info("[流程发布] 校验告警(放行) id={} activityId={} problem={} desc={}",
id, ve.getActivityId(), ve.getProblem(), ve.getDefaultDescription());
continue;
}
Map<String, Object> err = new LinkedHashMap<>();
err.put("activityId", ve.getActivityId());
err.put("problem", ve.getProblem());
err.put("defaultDescription", ve.getDefaultDescription());
blocking.add(err);
}
if (!blocking.isEmpty()) {
log.warn("[流程发布] ProcessValidator 拒绝 id={} errorCount={}", id, blocking.size());
Map<String, Object> body = new LinkedHashMap<>();
body.put("status", 1);
body.put("msg", "流程校验未通过");
body.put("errors", blocking);
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(body);
}
// 部署资源名用中文原 key(仅 act_ge_bytearray 名,不决定 process key——后者取自 XML 的 <process id>)。
String resource = model.getKey() + ".bpmn20.xml";
var deployment = repositoryService.createDeployment()
.disableSchemaValidation()
.name(model.getName())
.addString(resource, deployXml)
.deploy();
var deployed = repositoryService.createProcessDefinitionQuery()
.deploymentId(deployment.getId()).singleResult();
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("status", 0);
resp.put("deploymentId", deployment.getId());
resp.put("processKey", deployed != null ? deployed.getKey() : model.getKey());
resp.put("newVersion", deployed != null ? deployed.getVersion() : 0);
return ResponseEntity.ok(resp);
}
@GetMapping("/models/{id}/impact")
@Operation(summary = "发布影响摘要",
description = "草稿不存在→404;还原后解析 processKey → {processKey,currentVersion(该 key 最新已部署版本,"
+ "无则 0),runningInstances(该 key 运行中实例数)}。供同人确认弹窗展示「新版本/旧版本实例不受影响」。")
public ResponseEntity<Map<String, Object>> impact(@PathVariable String id) {
Model model = repositoryService.getModel(id);
if (model == null) {
return status(HttpStatus.NOT_FOUND, "草稿不存在: " + id);
}
byte[] source = repositoryService.getModelEditorSource(id);
if (source == null) {
return status(HttpStatus.UNPROCESSABLE_ENTITY, "草稿源为空: " + id);
}
String processKey;
try {
// impact 是只读预览:resolveIdMap 抛(存量草稿 metaInfo 不可读)/半成品草稿解析失败,一律回退 model.key
// ——from-procdef 建草稿的 model.key 就是中文原 key(创建时 setKey(def.getKey())),回退即得正确 processKey,
// 不该因草稿未完成/元数据损坏而 500;真正阻断坏 key 部署由 deploy 端点 fail-fast 负责。
// 无独立 DOCTYPE 字节守卫:impact 只查计数不部署,且 convertToBpmnModel 的 enableSafeBpmnXml=true 已禁 DOCTYPE/外部实体。
Map<String, String> idMap = resolveIdMap(model.getMetaInfo());
String deployXml = prepareDeployXml(new String(source, StandardCharsets.UTF_8), idMap);
BpmnModel bpmnModel = new BpmnXMLConverter()
.convertToBpmnModel(new StringStreamSource(deployXml), false, true);
var mainProcess = bpmnModel.getMainProcess();
processKey = mainProcess != null ? mainProcess.getId() : model.getKey();
} catch (Exception e) {
log.warn("[流程发布] 影响摘要解析失败,回退 model.key id={}: {}", id, e.toString());
processKey = model.getKey();
}
var latest = repositoryService.createProcessDefinitionQuery()
.processDefinitionKey(processKey).latestVersion().singleResult();
long runningInstances = runtimeService.createProcessInstanceQuery()
.processDefinitionKey(processKey).count();
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("processKey", processKey);
resp.put("currentVersion", latest != null ? latest.getVersion() : 0);
resp.put("runningInstances", runningInstances);
return ResponseEntity.ok(resp);
}
/**
* 发布/影响摘要前的 XML 规范化:①{@link #FLOW_REF_ELEMENT} 剥除 bpmn-js 补的 incoming/outgoing 文本引用元素;
* ②{@link BpmnIdSanitizer#restore} 依 {@code idMap} 把净化 id 还原为中文原 key(idMap 空=新建流程,原样返回)。
* restore 在剥除后跑:文本引用已消除,还原只作用于属性位,最终部署 XML 无残留净化 id。
* idMap 非双射时 restore fail-fast 抛 {@link IllegalArgumentException},由调用方转 422。
*/
private static String prepareDeployXml(String xml, Map<String, String> idMap) {
String stripped = FLOW_REF_ELEMENT.matcher(xml).replaceAll("");
return BpmnIdSanitizer.restore(stripped, idMap);
}
/** from-procdef 建草稿写入 metaInfo 的存量标记键(其一存在即表明本草稿源自既有流程定义,editorSource 是净化 XML)。 */
private static final String[] FROM_PROCDEF_MARKERS = {"sourceProcDefId", "originalKey"};
/**
* 从 metaInfo JSON 取 {@code eip4IdMap}(原→净化),供 {@link BpmnIdSanitizer#restore} 还原中文原 key。
*
* <p><b>坏 key 地雷收口(评审 I1)</b>:绝不把「idMap 不可读」静默塌成「空 idMap→跳过还原」——那会让 from-procdef
* 存量草稿(editorSource 的 {@code <process id>} 是净化 {@code nXXX})在 metaInfo 损坏时静默部署出 key=nXXX 而非
* 中文原 key(HTTP 200 无声,违 D7;且与 restore 非双射 fail-fast 自相矛盾)。据 from-procdef 写的
* {@link #FROM_PROCDEF_MARKERS} 判存量草稿:</p>
* <ul>
* <li>metaInfo 空/null → 真·新建,空 Map(跳过还原,key 原样)。</li>
* <li>metaInfo 非空但 JSON 解析失败 → 损坏,{@link IllegalStateException} fail-fast(调用方转 422)。</li>
* <li>解析成功、{@code eip4IdMap} <b>存在</b>(是 Map,含空 {@code {}})→ 直接用(空=全 ASCII 存量流程无需还原,正常)。</li>
* <li>解析成功、{@code eip4IdMap} <b>缺失/非 Map</b> 且带 from-procdef 标记 → 存量草稿丢了映射,无法还原原 key,
* {@link IllegalStateException} fail-fast(宁拒不发坏 key)。</li>
* <li>解析成功、无 {@code eip4IdMap} 且无标记 → 真·新建(前端另存了别的 metaInfo),空 Map 正常放行。</li>
* </ul>
*/
private Map<String, String> resolveIdMap(String metaInfo) {
if (metaInfo == null || metaInfo.isBlank()) {
return Map.of();
}
Map<String, Object> meta;
try {
meta = objectMapper.readValue(metaInfo, new TypeReference<Map<String, Object>>() {});
} catch (Exception e) {
// 非空 metaInfo 却解析不了=损坏,不能猜它是不是存量草稿→一律 fail-fast(宁拒不发可能的坏 key)。
throw new IllegalStateException("metaInfo 无法解析,无法确认 id 映射: " + e, e);
}
Object raw = meta.get("eip4IdMap");
if (raw instanceof Map<?, ?> m) {
// eip4IdMap 存在(即使空):空=全 ASCII 存量流程无需还原,直接用。
Map<String, String> idMap = new LinkedHashMap<>();
for (Map.Entry<?, ?> e : m.entrySet()) {
idMap.put(String.valueOf(e.getKey()), String.valueOf(e.getValue()));
}
return idMap;
}
// eip4IdMap 缺失/非 Map:带 from-procdef 标记=存量草稿丢了映射(editorSource 是净化 XML)→fail-fast 防坏 key。
for (String marker : FROM_PROCDEF_MARKERS) {
if (meta.containsKey(marker)) {
throw new IllegalStateException(
"存量草稿 metaInfo 缺 eip4IdMap,无法还原净化 id 为中文原 key(marker=" + marker + ")");
}
}
return Map.of(); // 无标记=真·新建,key 原样部署。
}
/**
* BPMN 解析守卫:过则返回 {@code null}(放行),坏 XML 返回 422 ResponseEntity({status:1,msg})。
* 就地 catch 一切异常,不让引擎 XMLException/FlowableException 逸出到全局 advice(那里映射成 400,语义不符)。
*
* <p><b>两道关</b>:①解析前字节级 {@link #hasDoctypeInBytes} 拒 DOCTYPE 声明(XXE 兜底,不依赖 flowable
* 内部 {@code supportDTD=false} 实现);②{@code convertToBpmnModel(source, validateSchema, enableSafeBpmnXml)}
* 解析——{@code validateSchema=false}:草稿是可视化工具编辑的半成品,<b>不做</b>严格 BPMN 2.0 XSD 校验。
* bpmn-js {@code saveXML} 用默认命名空间(无前缀 definitions/process)重序列化,Flowable 严格 Xerces XSD 校验
* 会拒({@code cvc-complex-type.2.4.a})——这是 bpmn-js(面向 BPMN 模型,非字节级 XSD 合规)与严格 XSD 的
* <b>已知固有不兼容</b>;完整校验属部署门(T3.1 {@code ProcessValidator} 在解析后的模型上跑,非 XSD)。
* {@code validateSchema=false} 仍解析(非良构 XML 抛→422);{@code enableSafeBpmnXml=true} 保加固解析器
* (禁外部 DTD/参数实体/DOCTYPE),双保险关 XXE/SSRF。</p>
*
* <p>422 只回通用文案;原始解析原因(可能含内部路径/实体细节)仅进 {@code log.warn},不回显给调用方。</p>
*/
private ResponseEntity<Map<String, Object>> parseGuard(String xml) {
// ① XXE 兜底:解析前字节级拒 DOCTYPE。按 StringStreamSource 喂解析器的 UTF-8 字节视角扫描(含 BOM/UTF-16
// 识别),消除「扫描端 vs 解析端编码错位」绕过。null XML 同走 422(与解析必抛等价)。
if (xml == null || hasDoctypeInBytes(xml.getBytes(StandardCharsets.UTF_8))) {
log.warn("[流程草稿] BPMN 拒绝: {}", xml == null ? "空 XML" : "含 DOCTYPE 声明(XXE 防御)");
return status(HttpStatus.UNPROCESSABLE_ENTITY, "BPMN 解析失败");
}
try {
// ② validateSchema=false(不做严格 XSD)+ enableSafeBpmnXml=true(加固解析器);详见方法 javadoc。
new BpmnXMLConverter().convertToBpmnModel(new StringStreamSource(xml), false, true);
return null;
} catch (Exception e) {
log.warn("[流程草稿] BPMN 解析守卫拒绝: {}", e.toString());
return status(HttpStatus.UNPROCESSABLE_ENTITY, "BPMN 解析失败");
}
}
/**
* 字节级 DOCTYPE 检测(XXE 门):按 BOM / 无 BOM 的 UTF-16 空字节特征识别编码后解码 prolog,再走
* {@link #hasDoctype}。消除「扫描端与解析端编码视角不一致」的绕过(UTF-8 BOM / UTF-16 会让纯字节扫描漏判
* {@code <!DOCTYPE},而 xerces 仍按 BOM 正确解析触发 XXE)。移植 platform-report {@code ReportXmlGuard}
* (flowable-service 不依赖 platform-* 模块,故就地复刻,不引依赖)。
*/
static boolean hasDoctypeInBytes(byte[] raw) {
if (raw == null || raw.length == 0) {
return false;
}
java.nio.charset.Charset cs;
int off = 0;
int u0 = raw[0] & 0xFF;
int u1 = raw.length > 1 ? raw[1] & 0xFF : -1;
int u2 = raw.length > 2 ? raw[2] & 0xFF : -1;
if (u0 == 0xEF && u1 == 0xBB && u2 == 0xBF) {
cs = StandardCharsets.UTF_8;
off = 3; // UTF-8 BOM
} else if (u0 == 0xFF && u1 == 0xFE) {
cs = StandardCharsets.UTF_16LE;
off = 2; // UTF-16LE BOM
} else if (u0 == 0xFE && u1 == 0xFF) {
cs = StandardCharsets.UTF_16BE;
off = 2; // UTF-16BE BOM
} else if (u0 == '<' && u1 == 0x00) {
cs = StandardCharsets.UTF_16LE; // 无 BOM UTF-16LE(ASCII 起始字符夹空字节)
} else if (u0 == 0x00 && u1 == '<') {
cs = StandardCharsets.UTF_16BE; // 无 BOM UTF-16BE
} else {
cs = StandardCharsets.ISO_8859_1; // UTF-8 / Latin1:prolog 为 ASCII,字节级保真扫描
}
int scanLen = Math.min(raw.length - off, PROLOG_SCAN_BYTES);
return hasDoctype(new String(raw, off, scanLen, cs));
}
/**
* 文档 prolog(根元素之前)是否含 DOCTYPE 声明(大小写不敏感)。正确跳过 XML 声明 {@code <?xml?>} 与注释
* {@code <!-- -->},命中根元素起始标签即停(元素内容里的字面 {@code <!DOCTYPE} 文本不算)。
*/
static boolean hasDoctype(String xml) {
if (xml == null) {
return false;
}
int i = 0;
int n = xml.length();
while (i < n) {
char c = xml.charAt(i);
if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '') {
i++;
continue;
}
if (c != '<') {
return false; // prolog 里非标记的文本 → 视为无 DOCTYPE
}
if (xml.regionMatches(true, i, "<!DOCTYPE", 0, 9)) {
return true;
}
if (xml.startsWith("<!--", i)) { // 注释:整段跳过
int end = xml.indexOf("-->", i + 4);
if (end < 0) {
return false;
}
i = end + 3;
continue;
}
if (xml.startsWith("<?", i)) { // XML 声明 / 处理指令:整段跳过
int end = xml.indexOf("?>", i + 2);
if (end < 0) {
return false;
}
i = end + 2;
continue;
}
return false; // 到达根元素起始标签,prolog 结束,无 DOCTYPE
}
return false;
}
/** 读流程定义部署 BPMN XML(getProcessModel 返回资源流)。读失败/为空返回 null(前端降级)。 */
private String readProcessModel(String procDefId) {
try (InputStream is = repositoryService.getProcessModel(procDefId)) {
if (is == null) {
return null;
}
return StreamUtils.copyToString(is, StandardCharsets.UTF_8);
} catch (Exception e) {
log.warn("[流程草稿] 读取 BPMN 失败 procDefId={}: {}", procDefId, e.toString());
return null;
}
}
private static ResponseEntity<Map<String, Object>> found(boolean value) {
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("found", value);
return ResponseEntity.ok(resp);
}
private static ResponseEntity<Map<String, Object>> status(HttpStatus httpStatus, String msg) {
Map<String, Object> body = new LinkedHashMap<>();
body.put("status", 1);
body.put("msg", msg);
return ResponseEntity.status(httpStatus).body(body);
}
/** {@link Date} → ISO-8601 UTC 字符串(如 {@code 1970-01-01T00:00:00Z});null 原样透传。 */
private static String toIso(Date d) {
return d == null ? null : d.toInstant().toString();
}
/** null 或纯空白(含全角/半角空格)视为空白。 */
private static boolean isBlank(String s) {
return s == null || s.isBlank();
}
/** 建草稿入参。 */
public static class CreateModelRequest {
public String name;
public String key;
public String bpmnXml;
public String metaInfo;
}
/** 更新草稿入参(editorSource 走 bpmnXml;name/metaInfo 为 null 表示不改)。 */
public static class UpdateModelRequest {
public String name;
public String bpmnXml;
public String metaInfo;
}
/** 从流程定义建草稿入参。 */
public static class FromProcDefRequest {
public String procDefId;
}
}

View File

@@ -0,0 +1,743 @@
package com.eip4.flowservice.api;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.List;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.repository.Deployment;
import org.flowable.engine.repository.DeploymentBuilder;
import org.flowable.engine.repository.Model;
import org.flowable.engine.repository.ModelQuery;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.repository.ProcessDefinitionQuery;
import org.flowable.engine.runtime.ProcessInstanceQuery;
import org.flowable.validation.ProcessValidator;
import org.flowable.validation.ValidationError;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
/**
* 流程草稿 CRUD 端点薄层单测:mock RepositoryService + Model API(newModel/saveModel/addModelEditorSource/
* getModelEditorSource/createModelQuery),验证列表/取草稿/建草稿(坏 XML 不落库)/PUT 404/from-procdef
* 净化 XML 与 idMap 落 metaInfo。standaloneSetup 不挂 FlowExceptionHandler——422/404 由控制器本地 ResponseEntity
* 显式产出(不经引擎异常映射)。
*/
@ExtendWith(MockitoExtension.class)
class ProcessModelControllerTest {
@Mock RepositoryService repositoryService;
@Mock ModelQuery modelQuery;
@Mock ProcessDefinitionQuery processDefinitionQuery;
MockMvc mvc;
// 最小 schema 合法 BPMN(default ns=BPMN20 MODEL)。
private static final String VALID_BPMN = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" targetNamespace=\"http://eip4\">"
+ "<process id=\"p1\" name=\"p1\">"
+ "<startEvent id=\"start\"/>"
+ "<sequenceFlow id=\"f1\" sourceRef=\"start\" targetRef=\"end\"/>"
+ "<endEvent id=\"end\"/>"
+ "</process></definitions>";
// bpmn-js saveXML 风格:默认命名空间(无前缀 definitions/process)+ 带前缀 BPMNDI 布局段。
// 此处 BPMNDiagram 排在 process 之前(触发严格 XSD 的 cvc-complex-type.2.4.a 序列违例——definitions 内容
// 模型要求 rootElement* 在 BPMNDiagram* 之前)——模拟 bpmn-js 输出被严格 XSD 拒的真实故障族。
// 草稿保存关 validateSchema 后应良构解析通过 → 200。
private static final String BPMN_JS_STYLE = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\""
+ " xmlns:bpmndi=\"http://www.omg.org/spec/BPMN/20100524/DI\""
+ " xmlns:dc=\"http://www.omg.org/spec/DD/20100524/DC\""
+ " xmlns:di=\"http://www.omg.org/spec/DD/20100524/DI\""
+ " id=\"Definitions_1\" targetNamespace=\"http://bpmn.io/schema/bpmn\">"
+ "<bpmndi:BPMNDiagram id=\"BPMNDiagram_1\">"
+ "<bpmndi:BPMNPlane id=\"BPMNPlane_1\" bpmnElement=\"Process_1\">"
+ "<bpmndi:BPMNShape id=\"StartEvent_1_di\" bpmnElement=\"StartEvent_1\">"
+ "<dc:Bounds x=\"152\" y=\"82\" width=\"36\" height=\"36\"/>"
+ "</bpmndi:BPMNShape></bpmndi:BPMNPlane></bpmndi:BPMNDiagram>"
+ "<process id=\"Process_1\" isExecutable=\"true\">"
+ "<startEvent id=\"StartEvent_1\" name=\"开始\"/>"
+ "</process></definitions>";
// 含 DOCTYPE 声明(XXE 面):正文良构、关严格 XSD 后本可解析,但字节级 DOCTYPE 守卫必须拒。
private static final String DOCTYPE_XML = "<?xml version=\"1.0\"?>"
+ "<!DOCTYPE definitions [<!ENTITY xxe \"payload\">]>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\">"
+ "<process id=\"p1\"><startEvent id=\"s\"/></process></definitions>";
// 存量流程编辑器导出态(发布路径 fixture):process id + sequenceFlow id 原为中文,已被 sanitize 成净化 id
// (n1a2b3c / nflow1 / nflow2);bpmn-js saveXML 给流节点补了 <incoming>/<outgoing> 文本引用(内含净化 id)。
// metaInfo.eip4IdMap 记「中文原 id→净化 id」,发布时 restore 逆向还原。model.key=中文原 key「总包合同交底」。
private static final String DRAFT_SANITIZED_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" targetNamespace=\"http://eip4\">"
+ "<process id=\"n1a2b3c\" name=\"总包合同交底\" isExecutable=\"true\">"
+ "<startEvent id=\"start1\"><outgoing>nflow1</outgoing></startEvent>"
+ "<userTask id=\"taskA\" name=\"交底\"><incoming>nflow1</incoming><outgoing>nflow2</outgoing></userTask>"
+ "<endEvent id=\"end1\"><incoming>nflow2</incoming></endEvent>"
+ "<sequenceFlow id=\"nflow1\" sourceRef=\"start1\" targetRef=\"taskA\"/>"
+ "<sequenceFlow id=\"nflow2\" sourceRef=\"taskA\" targetRef=\"end1\"/>"
+ "</process></definitions>";
// 对应上面 fixture 的 metaInfo:eip4IdMap 三条(process + 两条 sequenceFlow) + sourceProcDefId + 中文 originalKey。
private static final String DRAFT_META_INFO = "{\"eip4IdMap\":{\"总包合同交底\":\"n1a2b3c\","
+ "\"流转1\":\"nflow1\",\"流转2\":\"nflow2\"},\"sourceProcDefId\":\"def-1\",\"originalKey\":\"总包合同交底\"}";
@BeforeEach
void setUp() {
ProcessModelController controller = new ProcessModelController(repositoryService);
mvc = MockMvcBuilders.standaloneSetup(controller).build();
}
@Test
void 列表只查eip4分类并按最近更新降序返回id名key时间() throws Exception {
Model m = Mockito.mock(Model.class);
when(m.getId()).thenReturn("m1");
when(m.getName()).thenReturn("总包合同交底");
when(m.getKey()).thenReturn("总包合同交底");
when(m.getLastUpdateTime()).thenReturn(new Date(0L)); // 1970-01-01T00:00:00Z
when(repositoryService.createModelQuery()).thenReturn(modelQuery);
when(modelQuery.modelCategory("eip4")).thenReturn(modelQuery);
when(modelQuery.orderByLastUpdateTime()).thenReturn(modelQuery);
when(modelQuery.desc()).thenReturn(modelQuery);
when(modelQuery.list()).thenReturn(List.of(m));
mvc.perform(get("/api/flow/models"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.models[0].id").value("m1"))
.andExpect(jsonPath("$.models[0].name").value("总包合同交底"))
.andExpect(jsonPath("$.models[0].key").value("总包合同交底"))
.andExpect(jsonPath("$.models[0].lastUpdateTime").value("1970-01-01T00:00:00Z"));
// 列表只列 EIP4 建的草稿:隔离库里 143 条老 shape 存量 act_re_model(打不开)
verify(modelQuery).modelCategory("eip4");
}
@Test
void 取草稿返回XML与metaInfo() throws Exception {
Model m = Mockito.mock(Model.class);
when(m.getId()).thenReturn("m1");
when(m.getName()).thenReturn("总包合同交底");
when(m.getKey()).thenReturn("总包合同交底");
when(m.getMetaInfo()).thenReturn("{\"eip4IdMap\":{\"总包合同交底\":\"n1\"}}");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn("<definitions/>".getBytes(StandardCharsets.UTF_8));
mvc.perform(get("/api/flow/models/m1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.found").value(true))
.andExpect(jsonPath("$.id").value("m1"))
.andExpect(jsonPath("$.key").value("总包合同交底"))
.andExpect(jsonPath("$.bpmnXml").value("<definitions/>"))
.andExpect(jsonPath("$.metaInfo").value("{\"eip4IdMap\":{\"总包合同交底\":\"n1\"}}"));
}
@Test
void 取草稿_model不存在返found_false() throws Exception {
when(repositoryService.getModel("nope")).thenReturn(null);
mvc.perform(get("/api/flow/models/nope"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.found").value(false));
}
@Test
void 取草稿_editorSource为空返found_false() throws Exception {
Model m = Mockito.mock(Model.class);
when(repositoryService.getModel("m2")).thenReturn(m);
when(repositoryService.getModelEditorSource("m2")).thenReturn(null);
mvc.perform(get("/api/flow/models/m2"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.found").value(false));
}
@Test
void 建草稿_合法XML落库返modelId() throws Exception {
Model m = Mockito.mock(Model.class);
when(m.getId()).thenReturn("newid");
when(repositoryService.newModel()).thenReturn(m);
String body = "{\"name\":\"新流程\",\"key\":\"newproc\",\"bpmnXml\":"
+ jsonString(VALID_BPMN) + ",\"metaInfo\":\"{}\"}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isOk())
.andExpect(jsonPath("$.modelId").value("newid"));
verify(m).setName("新流程");
verify(m).setKey("newproc");
verify(m).setCategory("eip4"); // 建草稿打 EIP4 分类,供 list() 过滤隔离存量
verify(repositoryService).saveModel(m);
ArgumentCaptor<byte[]> src = ArgumentCaptor.forClass(byte[].class);
verify(repositoryService).addModelEditorSource(eq("newid"), src.capture());
org.junit.jupiter.api.Assertions.assertTrue(
new String(src.getValue(), StandardCharsets.UTF_8).contains("<process id=\"p1\""));
}
@Test
void 建草稿_空白name或key返422且不落库() throws Exception {
// key 是 T3.1 部署资源名/中文原 key 还原的依赖:空白一律拒,在解析守卫之前拦。
String body = "{\"name\":\" \",\"key\":\"\",\"bpmnXml\":" + jsonString(VALID_BPMN) + "}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.msg").isNotEmpty());
verify(repositoryService, never()).newModel();
verify(repositoryService, never()).saveModel(any());
}
@Test
void 建草稿_坏XML返422且不落库() throws Exception {
String body = "{\"name\":\"坏流程\",\"key\":\"bad\",\"bpmnXml\":"
+ jsonString("<definitions><broken") + "}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.msg").isNotEmpty());
// 解析守卫先于任何写:坏 XML 一律不落库
verify(repositoryService, never()).newModel();
verify(repositoryService, never()).saveModel(any());
verify(repositoryService, never()).addModelEditorSource(anyString(), any());
}
@Test
void 建草稿_bpmnJs默认命名空间输出_关严格XSD后200落库() throws Exception {
// 回归锚点:bpmn-js saveXML 默认命名空间输出被严格 XSD 拒(改前必红=422)。草稿保存不该做完整 XSD 校验
// (完整校验属部署时 ProcessValidator,非 XSD)→ 关 validateSchema 后良构解析通过 → 200 建草稿成功。
Model m = Mockito.mock(Model.class);
when(m.getId()).thenReturn("draft-js");
when(repositoryService.newModel()).thenReturn(m);
String body = "{\"name\":\"新流程\",\"key\":\"newproc\",\"bpmnXml\":" + jsonString(BPMN_JS_STYLE) + "}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isOk())
.andExpect(jsonPath("$.modelId").value("draft-js"));
verify(repositoryService).saveModel(m);
verify(repositoryService).addModelEditorSource(eq("draft-js"), any());
}
@Test
void 建草稿_含DOCTYPE声明_字节级XXE守卫返422不落库() throws Exception {
// 正文良构(关 XSD 后本可解析),但 DOCTYPE 声明是 XXE 面 → 解析前字节级守卫拒,不依赖 flowable 内部实现。
String body = "{\"name\":\"x\",\"key\":\"k\",\"bpmnXml\":" + jsonString(DOCTYPE_XML) + "}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).saveModel(any());
verify(repositoryService, never()).addModelEditorSource(anyString(), any());
}
@Test
void 建草稿_非良构XML_关严格XSD后仍返422不落库() throws Exception {
// 关 validateSchema=false 仅关严格 XSD,仍解析:标签不匹配是非良构 XML,解析必抛 → 422。
String body = "{\"name\":\"x\",\"key\":\"k\",\"bpmnXml\":"
+ jsonString("<definitions><process></definitions>") + "}";
mvc.perform(post("/api/flow/models").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).saveModel(any());
}
@Test
void 更新_草稿不存在返404() throws Exception {
when(repositoryService.getModel("nope")).thenReturn(null);
String body = "{\"name\":\"x\",\"bpmnXml\":" + jsonString(VALID_BPMN) + "}";
mvc.perform(put("/api/flow/models/nope").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).saveModel(any());
}
@Test
void 更新_合法XML更新name与editorSource返status0() throws Exception {
Model m = Mockito.mock(Model.class);
when(repositoryService.getModel("m1")).thenReturn(m);
String body = "{\"name\":\"改名\",\"bpmnXml\":" + jsonString(VALID_BPMN) + ",\"metaInfo\":\"{}\"}";
mvc.perform(put("/api/flow/models/m1").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0));
verify(m).setName("改名");
verify(m).setMetaInfo("{}");
verify(repositoryService).saveModel(m);
verify(repositoryService).addModelEditorSource(eq("m1"), any());
}
@Test
void 更新_只带name不带metaInfo时不改metaInfo() throws Exception {
// 草稿的 eip4IdMap 存于 metaInfo,普通保存草稿只发 name+XML 不重发 metaInfo:此时绝不能 setMetaInfo(null)
// 抹掉它——这是 T3.1 发布逆向还原原 key 的命根契约。
Model m = Mockito.mock(Model.class);
when(repositoryService.getModel("m1")).thenReturn(m);
String body = "{\"name\":\"只改名\",\"bpmnXml\":" + jsonString(VALID_BPMN) + "}";
mvc.perform(put("/api/flow/models/m1").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0));
verify(m).setName("只改名");
verify(m, never()).setMetaInfo(any());
verify(repositoryService).saveModel(m);
verify(repositoryService).addModelEditorSource(eq("m1"), any());
}
@Test
void 更新_坏XML返422且不落库() throws Exception {
Model m = Mockito.mock(Model.class);
when(repositoryService.getModel("m1")).thenReturn(m);
String body = "{\"name\":\"x\",\"bpmnXml\":" + jsonString("<nope") + "}";
mvc.perform(put("/api/flow/models/m1").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).saveModel(any());
verify(repositoryService, never()).addModelEditorSource(anyString(), any());
}
@Test
void 删草稿_存在则删除返status0() throws Exception {
Model m = Mockito.mock(Model.class);
when(repositoryService.getModel("m1")).thenReturn(m);
mvc.perform(delete("/api/flow/models/m1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0));
verify(repositoryService).deleteModel("m1");
}
@Test
void 删草稿_不存在返404不删除() throws Exception {
when(repositoryService.getModel("nope")).thenReturn(null);
mvc.perform(delete("/api/flow/models/nope"))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).deleteModel(anyString());
}
@Test
void fromProcDef_净化XML与idMap落metaInfo() throws Exception {
// 存量流程 process id 为中文,from-procdef 净化后建草稿:editorSource 无中文 id,metaInfo JSON 含
// eip4IdMap + sourceProcDefId + 中文 originalKey(发布时逆向还原原 key)。
ProcessDefinition def = Mockito.mock(ProcessDefinition.class);
when(def.getName()).thenReturn("总包合同交底");
when(def.getKey()).thenReturn("总包合同交底");
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.processDefinitionId("def-1")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(def);
String xml = "<definitions>"
+ "<process id=\"总包合同交底\" name=\"总包合同交底\">"
+ "<userTask id=\"sid-A\"/>"
+ "<sequenceFlow id=\"f1\" sourceRef=\"总包合同交底\" targetRef=\"sid-A\"/>"
+ "</process></definitions>";
when(repositoryService.getProcessModel("def-1"))
.thenReturn(new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8)));
Model m = Mockito.mock(Model.class);
when(m.getId()).thenReturn("draft-1");
when(repositoryService.newModel()).thenReturn(m);
String body = "{\"procDefId\":\"def-1\"}";
mvc.perform(post("/api/flow/models/from-procdef").contentType(MediaType.APPLICATION_JSON).content(body))
.andExpect(status().isOk())
.andExpect(jsonPath("$.modelId").value("draft-1"));
verify(m).setName("总包合同交底");
verify(m).setKey("总包合同交底");
verify(m).setCategory("eip4"); // from-procdef 建的草稿同样打 EIP4 分类
// metaInfo:JSON 含 eip4IdMap + sourceProcDefId + 中文 originalKey
ArgumentCaptor<String> meta = ArgumentCaptor.forClass(String.class);
verify(m).setMetaInfo(meta.capture());
String metaJson = meta.getValue();
org.junit.jupiter.api.Assertions.assertTrue(metaJson.contains("eip4IdMap"), metaJson);
org.junit.jupiter.api.Assertions.assertTrue(metaJson.contains("\"sourceProcDefId\":\"def-1\""), metaJson);
org.junit.jupiter.api.Assertions.assertTrue(metaJson.contains("\"originalKey\":\"总包合同交底\""), metaJson);
org.junit.jupiter.api.Assertions.assertTrue(metaJson.contains("总包合同交底"), metaJson); // idMap 键含中文原 id
// editorSource:净化后 XML 不再含中文 id(id/ref 属性),name 保留中文
ArgumentCaptor<byte[]> src = ArgumentCaptor.forClass(byte[].class);
verify(repositoryService).addModelEditorSource(eq("draft-1"), src.capture());
String savedXml = new String(src.getValue(), StandardCharsets.UTF_8);
org.junit.jupiter.api.Assertions.assertFalse(savedXml.contains("id=\"总包合同交底\""), savedXml);
org.junit.jupiter.api.Assertions.assertFalse(savedXml.contains("sourceRef=\"总包合同交底\""), savedXml);
org.junit.jupiter.api.Assertions.assertTrue(savedXml.contains("name=\"总包合同交底\""), savedXml);
}
@Test
void fromProcDef_procDef不存在返found_false不落库() throws Exception {
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.processDefinitionId("nope")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(null);
mvc.perform(post("/api/flow/models/from-procdef")
.contentType(MediaType.APPLICATION_JSON).content("{\"procDefId\":\"nope\"}"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.found").value(false));
verify(repositoryService, never()).newModel();
}
@Test
void fromProcDef_BPMN读取为空返found_false不落库() throws Exception {
// procDef 存在但部署 BPMN 资源读不出(getProcessModel 返 null)→ 降级 found:false,不建空草稿。
ProcessDefinition def = Mockito.mock(ProcessDefinition.class);
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.processDefinitionId("def-empty")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(def);
when(repositoryService.getProcessModel("def-empty")).thenReturn(null);
mvc.perform(post("/api/flow/models/from-procdef")
.contentType(MediaType.APPLICATION_JSON).content("{\"procDefId\":\"def-empty\"}"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.found").value(false));
verify(repositoryService, never()).newModel();
}
// ===== T3.1 发布(deploy)/ 影响摘要(impact) =====
/** 建带 mock ProcessValidator + RuntimeService 的控制器与 MockMvc(发布/影响端点专用,校验器须可 mock)。 */
private MockMvc deployMvc(RuntimeService runtimeService, ProcessValidator validator) {
return MockMvcBuilders.standaloneSetup(
new ProcessModelController(repositoryService, runtimeService, validator)).build();
}
@Test
void 发布_还原中文原key与剥除incoming_outgoing后部署XML无残留净化id且disableSchemaValidation() throws Exception {
Model m = Mockito.mock(Model.class);
when(m.getName()).thenReturn("总包合同交底");
when(m.getKey()).thenReturn("总包合同交底"); // 中文原 key(from-procdef 时存,发布资源名/还原目标)
when(m.getMetaInfo()).thenReturn(DRAFT_META_INFO);
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DRAFT_SANITIZED_XML.getBytes(StandardCharsets.UTF_8));
// 校验器无 ERROR → 放行部署。
ProcessValidator validator = Mockito.mock(ProcessValidator.class);
when(validator.validate(any())).thenReturn(List.of());
// 部署链 mock:disableSchemaValidation().name().addString().deploy()。
DeploymentBuilder db = Mockito.mock(DeploymentBuilder.class);
when(repositoryService.createDeployment()).thenReturn(db);
when(db.disableSchemaValidation()).thenReturn(db);
when(db.name(any())).thenReturn(db);
when(db.addString(anyString(), anyString())).thenReturn(db);
Deployment dep = Mockito.mock(Deployment.class);
when(dep.getId()).thenReturn("dep-1");
when(db.deploy()).thenReturn(dep);
ProcessDefinition deployed = Mockito.mock(ProcessDefinition.class);
when(deployed.getKey()).thenReturn("总包合同交底");
when(deployed.getVersion()).thenReturn(2);
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.deploymentId("dep-1")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(deployed);
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), validator);
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0))
.andExpect(jsonPath("$.deploymentId").value("dep-1"))
.andExpect(jsonPath("$.processKey").value("总包合同交底"))
.andExpect(jsonPath("$.newVersion").value(2));
// disableSchemaValidation 必被调用(防有人回退成严格 XSD,咬 bpmn-js 默认命名空间输出→cvc-complex-type)。
verify(db).disableSchemaValidation();
// 捕获部署 XML:属性位还原为中文原 key/流 id,incoming/outgoing 文本引用剥除 → 全程无残留净化 id。
ArgumentCaptor<String> deployXml = ArgumentCaptor.forClass(String.class);
verify(db).addString(eq("总包合同交底.bpmn20.xml"), deployXml.capture());
String xml = deployXml.getValue();
org.junit.jupiter.api.Assertions.assertTrue(xml.contains("id=\"总包合同交底\""), xml);
org.junit.jupiter.api.Assertions.assertTrue(xml.contains("id=\"流转1\""), xml);
org.junit.jupiter.api.Assertions.assertTrue(xml.contains("id=\"流转2\""), xml);
org.junit.jupiter.api.Assertions.assertFalse(xml.contains("n1a2b3c"), "残留净化 process id: " + xml);
org.junit.jupiter.api.Assertions.assertFalse(xml.contains("nflow1"), "残留净化流 id(incoming/outgoing 未剥除): " + xml);
org.junit.jupiter.api.Assertions.assertFalse(xml.contains("nflow2"), "残留净化流 id(incoming/outgoing 未剥除): " + xml);
org.junit.jupiter.api.Assertions.assertFalse(xml.contains("<incoming>"), "incoming 元素未剥除: " + xml);
org.junit.jupiter.api.Assertions.assertFalse(xml.contains("<outgoing>"), "outgoing 元素未剥除: " + xml);
}
@Test
void 发布_ProcessValidator_ERROR级返422带明细且不部署() throws Exception {
Model m = Mockito.mock(Model.class);
// metaInfo 默认 null → 无 idMap(新建流程分支,不还原);getKey 在 ERROR 返回前不会被读,不 stub 免 strict-stub。
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(VALID_BPMN.getBytes(StandardCharsets.UTF_8));
ValidationError err = new ValidationError();
err.setActivityId("taskA");
err.setProblem("flowable-usertask-no-assignment");
err.setDefaultDescription("用户任务无办理人");
err.setWarning(false);
ProcessValidator validator = Mockito.mock(ProcessValidator.class);
when(validator.validate(any())).thenReturn(List.of(err));
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), validator);
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.errors[0].activityId").value("taskA"))
.andExpect(jsonPath("$.errors[0].problem").value("flowable-usertask-no-assignment"))
.andExpect(jsonPath("$.errors[0].defaultDescription").value("用户任务无办理人"));
// ERROR 级校验失败 → 绝不部署。
verify(repositoryService, never()).createDeployment();
}
@Test
void 发布_ProcessValidator仅WARNING放行部署() throws Exception {
Model m = Mockito.mock(Model.class);
when(m.getName()).thenReturn("新流程");
when(m.getKey()).thenReturn("newproc");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(VALID_BPMN.getBytes(StandardCharsets.UTF_8));
ValidationError warn = new ValidationError();
warn.setActivityId("taskA");
warn.setProblem("some-warning");
warn.setWarning(true);
ProcessValidator validator = Mockito.mock(ProcessValidator.class);
when(validator.validate(any())).thenReturn(List.of(warn));
DeploymentBuilder db = Mockito.mock(DeploymentBuilder.class);
when(repositoryService.createDeployment()).thenReturn(db);
when(db.disableSchemaValidation()).thenReturn(db);
when(db.name(any())).thenReturn(db);
when(db.addString(anyString(), anyString())).thenReturn(db);
Deployment dep = Mockito.mock(Deployment.class);
when(dep.getId()).thenReturn("dep-2");
when(db.deploy()).thenReturn(dep);
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.deploymentId("dep-2")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(null); // 查不到也不炸:回退 model.key/0
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), validator);
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0))
.andExpect(jsonPath("$.deploymentId").value("dep-2"))
.andExpect(jsonPath("$.processKey").value("newproc"))
.andExpect(jsonPath("$.newVersion").value(0));
// 仅 WARNING → 放行:部署照常发生。
verify(db).deploy();
}
@Test
void 发布_草稿不存在返404不部署() throws Exception {
when(repositoryService.getModel("nope")).thenReturn(null);
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(post("/api/flow/models/nope/deploy"))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).createDeployment();
}
@Test
void 影响摘要_还原后解析processKey返当前版本与运行实例数() throws Exception {
Model m = Mockito.mock(Model.class);
// processKey 取自还原后 XML 的 <process id>(=总包合同交底),不读 model.getKey → 不 stub 免 strict-stub。
when(m.getMetaInfo()).thenReturn(DRAFT_META_INFO);
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DRAFT_SANITIZED_XML.getBytes(StandardCharsets.UTF_8));
ProcessDefinition latest = Mockito.mock(ProcessDefinition.class);
when(latest.getVersion()).thenReturn(3);
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.processDefinitionKey("总包合同交底")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.latestVersion()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(latest);
RuntimeService runtimeService = Mockito.mock(RuntimeService.class);
ProcessInstanceQuery piq = Mockito.mock(ProcessInstanceQuery.class);
when(runtimeService.createProcessInstanceQuery()).thenReturn(piq);
when(piq.processDefinitionKey("总包合同交底")).thenReturn(piq);
when(piq.count()).thenReturn(5L);
MockMvc localMvc = deployMvc(runtimeService, Mockito.mock(ProcessValidator.class));
localMvc.perform(get("/api/flow/models/m1/impact"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.processKey").value("总包合同交底"))
.andExpect(jsonPath("$.currentVersion").value(3))
.andExpect(jsonPath("$.runningInstances").value(5));
}
@Test
void 影响摘要_草稿不存在返404() throws Exception {
when(repositoryService.getModel("nope")).thenReturn(null);
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(get("/api/flow/models/nope/impact"))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.status").value(1));
}
@Test
void 发布_非双射idMap_restore_fail_fast返422不部署() throws Exception {
// metaInfo 的 eip4IdMap 两个中文原 id 映射到同一净化 id(n1)→restore 反转检测到非双射抛 IllegalArgumentException
// →deploy catch→422,绝不部署(损坏映射还原会指错 key)。
Model m = Mockito.mock(Model.class);
when(m.getMetaInfo()).thenReturn("{\"eip4IdMap\":{\"总包合同交底\":\"n1\",\"其他流程\":\"n1\"}}");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DRAFT_SANITIZED_XML.getBytes(StandardCharsets.UTF_8));
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.msg").isNotEmpty());
verify(repositoryService, never()).createDeployment();
}
@Test
void 发布_存量草稿metaInfo缺eip4IdMap_fail_fast返422不部署() throws Exception {
// I1 坏 key 地雷:from-procdef 标记(sourceProcDefId/originalKey)在但 eip4IdMap 键丢了→editorSource 是净化 nXXX
// 却无从还原→绝不能静默塌成「空 idMap 跳过还原」部署出 key=nXXX(违 D7)→resolveIdMap fail-fast→422 不部署。
Model m = Mockito.mock(Model.class);
when(m.getMetaInfo()).thenReturn("{\"sourceProcDefId\":\"def-1\",\"originalKey\":\"总包合同交底\"}");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DRAFT_SANITIZED_XML.getBytes(StandardCharsets.UTF_8));
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.msg").isNotEmpty());
verify(repositoryService, never()).createDeployment();
}
@Test
void 发布_metaInfo解析失败_fail_fast返422不部署() throws Exception {
// 非空 metaInfo 却是坏 JSON:无从确认是不是存量草稿→宁拒不发(可能的坏 key)→resolveIdMap fail-fast→422 不部署。
Model m = Mockito.mock(Model.class);
when(m.getMetaInfo()).thenReturn("{坏JSON不可解析");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DRAFT_SANITIZED_XML.getBytes(StandardCharsets.UTF_8));
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).createDeployment();
}
@Test
void 发布_存量草稿eip4IdMap为空_全ASCII流程不误拒正常部署() throws Exception {
// 防 I1 修过头:from-procdef 的全 ASCII 存量流程 sanitize 出空 eip4IdMap {}(present),editorSource 本就是 ASCII key,
// 无需还原→eip4IdMap 存在(空)即「可用」,不该被 fail-fast 误拒→正常部署。
Model m = Mockito.mock(Model.class);
when(m.getName()).thenReturn("ascii流程");
when(m.getKey()).thenReturn("asciiKey");
when(m.getMetaInfo())
.thenReturn("{\"eip4IdMap\":{},\"sourceProcDefId\":\"def-1\",\"originalKey\":\"asciiKey\"}");
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(VALID_BPMN.getBytes(StandardCharsets.UTF_8));
ProcessValidator validator = Mockito.mock(ProcessValidator.class);
when(validator.validate(any())).thenReturn(List.of());
DeploymentBuilder db = Mockito.mock(DeploymentBuilder.class);
when(repositoryService.createDeployment()).thenReturn(db);
when(db.disableSchemaValidation()).thenReturn(db);
when(db.name(any())).thenReturn(db);
when(db.addString(anyString(), anyString())).thenReturn(db);
Deployment dep = Mockito.mock(Deployment.class);
when(dep.getId()).thenReturn("dep-3");
when(db.deploy()).thenReturn(dep);
ProcessDefinition deployed = Mockito.mock(ProcessDefinition.class);
when(deployed.getKey()).thenReturn("p1");
when(deployed.getVersion()).thenReturn(1);
when(repositoryService.createProcessDefinitionQuery()).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.deploymentId("dep-3")).thenReturn(processDefinitionQuery);
when(processDefinitionQuery.singleResult()).thenReturn(deployed);
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), validator);
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0))
.andExpect(jsonPath("$.processKey").value("p1"));
verify(db).deploy();
}
@Test
void 发布_editorSource含DOCTYPE_字节级XXE守卫返422不部署() throws Exception {
// deploy 路径自带的字节级 DOCTYPE 守卫(还原后 XML 再过一道):即便存储的 editorSource 含 DOCTYPE(理论不该,
// 因写入端已拒),部署也在解析前拒,绝不部署。
Model m = Mockito.mock(Model.class);
// metaInfo 默认 null→真·新建分支,resolveIdMap 返空,prepareDeployXml 剥除+空还原=原样→deployXml 仍含 DOCTYPE。
when(repositoryService.getModel("m1")).thenReturn(m);
when(repositoryService.getModelEditorSource("m1"))
.thenReturn(DOCTYPE_XML.getBytes(StandardCharsets.UTF_8));
MockMvc localMvc = deployMvc(Mockito.mock(RuntimeService.class), Mockito.mock(ProcessValidator.class));
localMvc.perform(post("/api/flow/models/m1/deploy"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1));
verify(repositoryService, never()).createDeployment();
}
/** 把任意字符串编成 JSON 字符串字面量(转义引号/反斜杠/换行),用于拼请求体。 */
private static String jsonString(String s) {
StringBuilder sb = new StringBuilder("\"");
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '"' -> sb.append("\\\"");
case '\\' -> sb.append("\\\\");
case '\n' -> sb.append("\\n");
case '\r' -> sb.append("\\r");
case '\t' -> sb.append("\\t");
default -> sb.append(c);
}
}
return sb.append("\"").toString();
}
}

View File

@@ -0,0 +1,18 @@
-- Flyway 迁移 V4:在线流程 Modeler 发布审计表(sys_flow_deploy_audit)。
-- 记录每次草稿→流程定义部署:谁(operator)/何时(deployed_at)/发布了哪个草稿(model_id)/产生的部署(deployment_id)/
-- 流程 key(可能中文,如「总包合同交底」)+新版本号。供合规审计与发布追溯(D2 同人确认部署的审计要求)。
-- 平台表(非引擎表 act_re_*),走 Flyway;写入收口网关 FlowDeployAuditService。
-- 幂等:配合 baseline-on-migrate,既有库已有此表也安全。
CREATE TABLE IF NOT EXISTS sys_flow_deploy_audit (
id bigserial NOT NULL,
model_id varchar(64),
deployment_id varchar(64),
process_key varchar(255),
new_version integer,
operator varchar(64),
deployed_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT pk_sys_flow_deploy_audit PRIMARY KEY (id)
);
-- 按流程 key + 时间倒查发布历史(某流程被谁何时发布过哪些版本)。
CREATE INDEX IF NOT EXISTS idx_sys_flow_deploy_audit_key ON sys_flow_deploy_audit (process_key, deployed_at);

View File

@@ -0,0 +1,66 @@
package com.eip4.platform.flowgateway.aggregate;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
/**
* 流程发布审计:每次草稿→流程定义部署成功后,记一行 {@code sys_flow_deploy_audit}
* (谁 operator / 何时 deployed_at / 发布了哪个草稿 model_id / 产生的 deployment_id / 流程 key + 新版本号),
* 供合规审计与发布追溯(D2 同人确认部署的审计要求)。表由 Flyway V4 建(平台表,非引擎表)。
*
* <p><b>为何是 @Service 而非控制器直查</b>:{@code @RestController} 直持 {@link JdbcTemplate} 触架构棘轮
* ({@code 控制器不得新增直用JdbcTemplate}),审计 INSERT 与字段抽取收口到本 Service。</p>
*
* <p><b>旁路写、不反噬部署</b>:本记录发生在下游部署<b>已成功</b>之后。写审计失败(如库抖动)绝不能让整个
* 发布请求变 500——那会误导用户以为发布失败而重试,产生重复部署。故 {@link #record} 就地吞异常记 error,
* 不上抛。审计缺失可事后追查,重复部署不可逆。</p>
*/
@Service
public class FlowDeployAuditService {
private static final Logger log = LoggerFactory.getLogger(FlowDeployAuditService.class);
static final String INSERT_SQL =
"INSERT INTO sys_flow_deploy_audit (model_id, deployment_id, process_key, new_version, operator) "
+ "VALUES (?, ?, ?, ?, ?)";
private final JdbcTemplate jdbcTemplate;
public FlowDeployAuditService(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/**
* 从下游 deploy 结果 Map 抽 {@code deploymentId/processKey/newVersion} 落审计行。
*
* @param modelId 被发布的草稿 id
* @param deployResult flowable-service deploy 返回体({status,deploymentId,processKey,newVersion})
* @param operator 操作者(= principal.userId(),超管门已保证非空)
*/
public void record(String modelId, Map<String, Object> deployResult, String operator) {
String deploymentId = str(deployResult, "deploymentId");
String processKey = str(deployResult, "processKey");
Integer newVersion = intOf(deployResult, "newVersion");
try {
jdbcTemplate.update(INSERT_SQL, modelId, deploymentId, processKey, newVersion, operator);
} catch (RuntimeException e) {
// 部署已成功,审计是旁路记录:写失败不回滚不上抛(否则用户误判发布失败→重试→重复部署)。
log.error("[发布审计] 写入 sys_flow_deploy_audit 失败(部署已成功,不回滚) modelId={} operator={}: {}",
modelId, operator, e.toString());
}
}
private static String str(Map<String, Object> m, String key) {
Object v = m == null ? null : m.get(key);
return v == null ? null : String.valueOf(v);
}
private static Integer intOf(Map<String, Object> m, String key) {
Object v = m == null ? null : m.get(key);
return v instanceof Number n ? n.intValue() : null;
}
}

View File

@@ -0,0 +1,290 @@
package com.eip4.platform.flowgateway.aggregate;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* 发布门 EIP4 <b>语义</b>校验(网关层):flowable-service 的 {@code ProcessValidator} 只做引擎<b>结构</b>校验
* (节点连通/网关/多实例配置),本校验器补 EIP4 特有的三项运行期正确性约束,返回 {@code List<String>} 错误清单
* (空=通过),供网关 deploy 端点 fail-fast 返 422 且<b>不部署</b>。
*
* <ol>
* <li><b>办理人 / 会签内嵌 JSON</b>:userTask 的 {@code activiti:candidateUsers} 与多实例
* {@code activiti:collection}——凡以 EIP4 handler 前缀
* ({@code candidateUsersHandler.getCandidateUsers} / {@code multiInstanceUsersHandler.getUsers})开头者,
* 内容段花括号全角【】→半角后必须 <b>JSON 可解析</b>、{@code items} <b>非空</b>({@code items:[]} 的 MI
* collection 运行期会炸——仅「JSON 可解析 + type 白名单」不够,T2.4 评审补充)、且每个
* {@code items[].type} ∈ {@link #TYPE_WHITELIST}。非 handler 前缀的裸值(如 {@code ${var}} / 逗号分隔用户)
* 非 EIP4 codec 产物,放行不套 JSON 白名单(避免误拒合法 Flowable 裸值)。</li>
* <li><b>formKey 存在性</b>:userTask 的 {@code activiti:formKey}(= view_wftemplate_id)若存在,必须命中
* {@code view_wftemplate}({@link JdbcTemplate} count 查询);读库异常按全站降级惯例<b>放行</b>该项
* (不因基础设施抖动阻断部署,引用完整性检查跳过并记告警)。</li>
* <li><b>会签完成条件</b>:{@code completionCondition} 允许「三预设 或 保留的自定义非空表达式」
* (T2.4 已实现自定义保留态,别把存量自定义条件拒了)——匹配预设正则则通过,非预设但<b>非空</b>放行
* (仅记 info 告警不阻断),仅<b>空白</b>视为错误。</li>
* </ol>
*
* <p><b>XML 解析</b>:照 {@link WfTemplateService#parseXml} 钉 JDK 内置解析器
* (防 platform-report 带入的上古 xerces 击穿 JAXP 1.4),禁 DOCTYPE / 外部实体(XXE 门)。非命名空间感知,
* 按<b>本地名</b>匹配元素/属性(兼容 bpmn-js 默认命名空间输出与 {@code activiti:}/{@code flowable:} 前缀)。</p>
*
* <p><b>为何是 @Service 而非控制器直查</b>:{@code @RestController} 直持 {@link JdbcTemplate} 触架构棘轮
* ({@code 控制器不得新增直用JdbcTemplate});且 XML 解析 + JSON 白名单逻辑本就该收口成可独立单测的领域件。</p>
*/
@Service
public class ModelSemanticValidator {
private static final Logger log = LoggerFactory.getLogger(ModelSemanticValidator.class);
/** 办理人 handler 表达式前缀,逐字对齐 {@code BasePropertiesConverter} CANDIDATESERVICE(:34)。 */
private static final String CANDIDATE_PREFIX = "${candidateUsersHandler.getCandidateUsers(execution,'";
/** 会签 handler 表达式前缀,逐字对齐 {@code BasePropertiesConverter} MULTIINSTANCESERVICE(:35)。 */
private static final String MULTI_PREFIX = "${multiInstanceUsersHandler.getUsers(execution,'";
private static final String SUFFIX = "')}";
/**
* 办理人/会签项合法 type。<b>权威集 = flowable-service {@code WfTypes} 的 16 个配置类型 + {@code OrgDirectoryJdbc}
* 运行期分派</b>(非 BasePropertiesConverter——它只 setType,不做白名单)。网关不依赖 flowable-service 故此处复刻
* 常量值;<b>WfTypes 新增类型时两处必须同步</b>。此前只列 10 种会 422 误拒含 {@code initiatorDepartManager}
* (实测 24 文档)/{@code fixedDimension}(12 文档)等运行期完全支持的存量流程(from-procdef 载入→编辑无关节点→发布)。
*/
static final Set<String> TYPE_WHITELIST = Set.of(
"user", "roles", "depart", "position", "initiator",
"initiatorDepartManager", "initiatorLeader", "initiatorSubordinate", "initiatorDepart",
"sameToTask", "beforeTaskLeader", "beforeTaskDepartManager",
"fixedDimension", "formSpecifiedDimension", "projectRoleType", "scriptUser");
/** 会签完成条件三预设(与 Eip4Panel.tsx:60-77 逐字一致):全票 / 过半 / 指定数。 */
private static final Pattern COMPLETION_ALL =
Pattern.compile("^\\$\\{nrOfCompletedInstances/nrOfInstances==1\\}$");
private static final Pattern COMPLETION_MAJORITY =
Pattern.compile("^\\$\\{nrOfCompletedInstances/nrOfInstances>0\\.5\\}$");
private static final Pattern COMPLETION_COUNT =
Pattern.compile("^\\$\\{nrOfCompletedInstances>=\\d+\\}$");
/** formKey 存在性查询(bpchar 列比较忽略尾部补白,传裸 UUID 即可,对齐 WfTemplateService.readXml)。 */
static final String FORMKEY_EXISTS_SQL =
"SELECT count(*) FROM view_wftemplate WHERE view_wftemplate_id = ?";
private final JdbcTemplate jdbcTemplate;
private final ObjectMapper objectMapper = new ObjectMapper();
public ModelSemanticValidator(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/** 校验 bpmn XML,返回错误清单(空=通过)。任何解析异常归一为一条「解析失败」错误,不抛。 */
public List<String> validate(String bpmnXml) {
List<String> errors = new ArrayList<>();
if (bpmnXml == null || bpmnXml.isBlank()) {
errors.add("BPMN 源为空,无法校验");
return errors;
}
Document doc;
try {
doc = parse(bpmnXml);
} catch (Exception e) {
// 含 DOCTYPE(XXE 门 disallow-doctype-decl 抛)/非良构 XML → 统一拒;细节仅进日志,不回显。
log.warn("[发布语义] BPMN 解析失败: {}", e.toString());
errors.add("BPMN 解析失败,无法校验语义");
return errors;
}
for (Element userTask : elementsByLocalName(doc, "userTask")) {
String label = nodeLabel(userTask);
validateHandlerJson(attrByLocalName(userTask, "candidateUsers"), CANDIDATE_PREFIX,
label, "办理人", errors);
validateFormKey(attrByLocalName(userTask, "formKey"), label, errors);
}
for (Element mi : elementsByLocalName(doc, "multiInstanceLoopCharacteristics")) {
String label = enclosingUserTaskLabel(mi);
validateHandlerJson(attrByLocalName(mi, "collection"), MULTI_PREFIX, label, "会签人员", errors);
validateCompletionCondition(mi, label, errors);
}
return errors;
}
// ---------------------------------------------------------------- 校验分项
/**
* 办理人/会签内嵌 JSON 校验:仅当值以 {@code prefix}(EIP4 handler)开头才校验;解析失败/items 空/type 非白名单
* 各追加一条错误(type 逐项报,一个节点多个坏 type 出多条)。
*/
private void validateHandlerJson(String value, String prefix, String label, String role, List<String> errors) {
if (value == null || value.isBlank() || !value.startsWith(prefix)) {
return; // 无配置 或 非 EIP4 handler 裸值:非本校验器职责
}
if (!value.endsWith(SUFFIX)) {
errors.add("节点『" + label + "』的" + role + "表达式格式错误(缺尾部 " + SUFFIX + ")");
return;
}
String content = value.substring(prefix.length(), value.length() - SUFFIX.length());
// 全角【】→半角(对齐 CandidateUsersHandler:54 运行期还原),再 JSON 解析。
String json = content.replace("【", "{").replace("】", "}");
JsonNode root;
try {
root = objectMapper.readTree(json);
} catch (Exception e) {
errors.add("节点『" + label + "』的" + role + "配置 JSON 无法解析");
return;
}
JsonNode items = root.get("items");
if (items == null || !items.isArray() || items.isEmpty()) {
errors.add("节点『" + label + "』的" + role + "为空(items 为空),运行期会异常");
return;
}
for (JsonNode item : items) {
JsonNode type = item.get("type");
if (type == null || !type.isTextual() || !TYPE_WHITELIST.contains(type.asText())) {
errors.add("节点『" + label + "』的" + role + "含非法 type:"
+ (type == null || type.isNull() ? "(缺失)" : type.asText()));
}
}
}
/** formKey 存在性:非空则查 view_wftemplate;不存在报错,读库异常降级放行(记告警)。 */
private void validateFormKey(String formKey, String label, List<String> errors) {
if (formKey == null || formKey.isBlank()) {
return;
}
String key = formKey.trim();
try {
Integer c = jdbcTemplate.queryForObject(FORMKEY_EXISTS_SQL, Integer.class, key);
if (c == null || c == 0) {
errors.add("节点『" + label + "』的表单 formKey 不存在于模板库(view_wftemplate):" + key);
}
} catch (RuntimeException e) {
// 读库抖动不阻断发布(全站降级惯例);该项引用完整性检查跳过并记告警。
log.warn("[发布语义] formKey 存在性校验读库降级(跳过该项) formKey={}: {}", key, e.toString());
}
}
/** 会签完成条件:present+空白=错误;非空放行(非预设仅记 info 告警,保留 T2.4 自定义态)。 */
private void validateCompletionCondition(Element mi, String label, List<String> errors) {
Element cc = firstChildByLocalName(mi, "completionCondition");
if (cc == null) {
return; // 无完成条件:多实例全部完成才结束,合法。
}
String body = cc.getTextContent();
if (body == null || body.isBlank()) {
errors.add("节点『" + label + "』的会签完成条件为空");
return;
}
String trimmed = body.trim();
if (!isPresetCompletion(trimmed)) {
log.info("[发布语义] 节点『{}』会签完成条件为自定义表达式(放行,保留 T2.4 自定义态): {}", label, trimmed);
}
}
private static boolean isPresetCompletion(String body) {
return COMPLETION_ALL.matcher(body).matches()
|| COMPLETION_MAJORITY.matcher(body).matches()
|| COMPLETION_COUNT.matcher(body).matches();
}
// ---------------------------------------------------------------- DOM 小工具(按本地名,兼容前缀/默认命名空间)
private static Document parse(String xml) throws Exception {
DocumentBuilderFactory f = newJdkDbf();
f.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
f.setFeature("http://xml.org/sax/features/external-general-entities", false);
f.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
f.setExpandEntityReferences(false);
DocumentBuilder b = f.newDocumentBuilder();
return b.parse(new InputSource(new StringReader(xml)));
}
/** JDK 内置 DocumentBuilderFactory(钉实现类,防 platform-report 上古 xerces 击穿;对齐 WfTemplateService)。 */
private static DocumentBuilderFactory newJdkDbf() {
try {
return DocumentBuilderFactory.newInstance(
"com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl", null);
} catch (Throwable t) {
return DocumentBuilderFactory.newInstance();
}
}
private static List<Element> elementsByLocalName(Document doc, String localName) {
NodeList all = doc.getElementsByTagName("*");
List<Element> out = new ArrayList<>();
for (int i = 0; i < all.getLength(); i++) {
Node n = all.item(i);
if (n.getNodeType() == Node.ELEMENT_NODE && localName.equals(localName(n.getNodeName()))) {
out.add((Element) n);
}
}
return out;
}
/** 取元素下第一个指定本地名的直接子元素。 */
private static Element firstChildByLocalName(Element parent, String localName) {
NodeList children = parent.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node n = children.item(i);
if (n.getNodeType() == Node.ELEMENT_NODE && localName.equals(localName(n.getNodeName()))) {
return (Element) n;
}
}
return null;
}
/** 按本地名取属性值(兼容 {@code activiti:}/{@code flowable:} 前缀与无前缀),无则 null。 */
private static String attrByLocalName(Element e, String localName) {
NamedNodeMap attrs = e.getAttributes();
for (int i = 0; i < attrs.getLength(); i++) {
Node a = attrs.item(i);
if (localName.equals(localName(a.getNodeName()))) {
String v = a.getNodeValue();
return v == null || v.isEmpty() ? null : v;
}
}
return null;
}
/** 上溯到最近的 userTask 祖先取其名(会签 collection/完成条件的节点上下文)。 */
private static String enclosingUserTaskLabel(Element mi) {
Node p = mi.getParentNode();
while (p != null && p.getNodeType() == Node.ELEMENT_NODE) {
if ("userTask".equals(localName(p.getNodeName()))) {
return nodeLabel((Element) p);
}
p = p.getParentNode();
}
return "会签节点";
}
private static String nodeLabel(Element e) {
String name = attrByLocalName(e, "name");
if (name != null && !name.isBlank()) {
return name;
}
String id = attrByLocalName(e, "id");
return id != null && !id.isBlank() ? id : "(未命名节点)";
}
private static String localName(String qname) {
int c = qname.indexOf(':');
return c < 0 ? qname : qname.substring(c + 1);
}
}

View File

@@ -0,0 +1,80 @@
package com.eip4.platform.flowgateway.aggregate;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
/**
* wftemplate 选择器数据源:为在线流程 Modeler 的办理人/会签 formKey 下拉提供 {@code {id,name}} 列表。
*
* <p><b>为何是 Service 而非控制器直查</b>:{@code @RestController} 直持 {@link JdbcTemplate} 拼 SQL 会让
* 现代层退化成第二个「SQL 散落层」(架构棘轮 {@code 控制器不得新增直用JdbcTemplate} 禁止新增此类),
* 故 SQL 收口到本 Service,控制器只保留超管门 + 透传。</p>
*
* <p><b>名称来源实证(information_schema)</b>:{@code view_wftemplate}(1016 行已迁移)<b>无独立名称列</b>
* (仅 {@code view_wftemplate_id CHAR + xml + isactive + 审计列}),{@code <form>} 根标签也无 title/name
* 属性(0/1016);唯一人类可读名来自 XML 的 {@code entityid} → {@code sys_entity.name}(378 模板带 entityid,
* 339 解析出中文名,如「通知管理」)。故 name = 解析出的实体名,无则回退 id;{@code view_wftemplate_id} 是
* CHAR 补白列 → RowMapper 内 trim。读库异常降级({@code degraded:true}),不 500 阻断设计器。</p>
*/
@Service
public class WfTemplatePickerService {
private static final Logger log = LoggerFactory.getLogger(WfTemplatePickerService.class);
/** 选择器 SQL:view_wftemplate_id + entityid→sys_entity.name(LEFT JOIN + 正则抽 entityid),isactive=1,名称升序。 */
static final String WFTEMPLATES_SQL =
"SELECT t.view_wftemplate_id AS id, se.name AS name "
+ "FROM view_wftemplate t "
+ "LEFT JOIN sys_entity se "
+ " ON se.sys_entity_id = substring(CAST(t.xml AS text) FROM 'entityid=\"([0-9a-fA-F-]+)\"') "
+ "WHERE t.isactive = 1 "
+ "ORDER BY se.name NULLS LAST, t.view_wftemplate_id";
/** 单行 → {@code {id(trim 补白),name(实体名,空则回退 id)}}。 */
static final RowMapper<Map<String, Object>> WFTEMPLATE_ROW = (rs, rowNum) -> {
String id = rs.getString("id");
if (id != null) {
id = id.trim();
}
String name = rs.getString("name");
Map<String, Object> row = new LinkedHashMap<>();
row.put("id", id);
row.put("name", (name != null && !name.isBlank()) ? name : id);
return row;
};
private final JdbcTemplate jdbcTemplate;
public WfTemplatePickerService(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/**
* 选择器列表。正常 → {@code {templates:[{id,name}]}};读库异常降级 → {@code {templates:[], degraded:true}}
* (正常路径<b>不带</b> degraded 键,前端可据此区分「真无模板」与「读库失败」并提示重试)。
*/
public Map<String, Object> listTemplates() {
List<Map<String, Object>> templates;
boolean degraded = false;
try {
templates = jdbcTemplate.query(WFTEMPLATES_SQL, WFTEMPLATE_ROW);
} catch (RuntimeException e) {
log.warn("view_wftemplate 选择器读取降级为空列表: {}", e.toString());
templates = List.of();
degraded = true;
}
Map<String, Object> resp = new LinkedHashMap<>();
resp.put("templates", templates);
if (degraded) {
resp.put("degraded", true);
}
return resp;
}
}

View File

@@ -8,17 +8,33 @@ import org.springframework.http.HttpStatusCode;
* <p>与 {@link FlowServiceUnavailableException} 区分:那个是"引擎进程不可达"(→ 503); * <p>与 {@link FlowServiceUnavailableException} 区分:那个是"引擎进程不可达"(→ 503);
* 这个是"引擎在线但拒绝了这次操作"(原状态码透传给调用方,保留 Flowable 语义, * 这个是"引擎在线但拒绝了这次操作"(原状态码透传给调用方,保留 Flowable 语义,
* 如挂起拒办 409、参数错 400)。 * 如挂起拒办 409、参数错 400)。
*
* <p><b>responseBody(可空)</b>:携带下游原始响应体,供 {@code FlowGatewayExceptionHandler} 透传结构化错误
* ——如流程发布下游 422 的 {@code {errors:[{activityId,problem,defaultDescription}]}}(引擎 ProcessValidator 结构校验)
* 需并入网关响应,与网关语义校验 422 的顶层 {@code errors} 契约统一(T3.2 评审 I-2:此前只留状态码丢体,
* 结构化错误到不了前端)。旧两参构造(无体)保留,非发布路径不受影响。
*/ */
public class FlowRemoteException extends RuntimeException { public class FlowRemoteException extends RuntimeException {
private final HttpStatusCode status; private final HttpStatusCode status;
private final String responseBody;
public FlowRemoteException(HttpStatusCode status, String message) { public FlowRemoteException(HttpStatusCode status, String message) {
this(status, message, null);
}
public FlowRemoteException(HttpStatusCode status, String message, String responseBody) {
super(message); super(message);
this.status = status; this.status = status;
this.responseBody = responseBody;
} }
public HttpStatusCode getStatus() { public HttpStatusCode getStatus() {
return status; return status;
} }
/** 下游原始响应体(可空);供 handler 解析并透传结构化 errors。 */
public String getResponseBody() {
return responseBody;
}
} }

View File

@@ -260,6 +260,103 @@ public class FlowableClient {
.body(Map.class)); .body(Map.class));
} }
// ---------------------------------------------------------------- 草稿 Model API 转发(T2.2)
/**
* 草稿列表。对应 flowable-service {@code GET /api/flow/models},返回体
* {@code {models:[{id,name,key,lastUpdateTime}]}} 原样透传(flowable-service 已按 EIP4 分类过滤)。
*/
@SuppressWarnings("unchecked")
public Map<String, Object> listModels() {
return execute("草稿列表", () -> restClient.get()
.uri("/api/flow/models")
.retrieve()
.body(Map.class));
}
/**
* 取草稿(editorSource + metaInfo)。对应 flowable-service {@code GET /api/flow/models/{id}},返回体
* {@code {found,id,name,key,bpmnXml,metaInfo}} 原样透传;草稿不存在下游返 {@code found:false}。
*
* <p>{@code id} 走 uri 模板变量严格编码(禁字符串拼接)。</p>
*/
@SuppressWarnings("unchecked")
public Map<String, Object> getModel(String id) {
return execute("取草稿", () -> restClient.get()
.uri("/api/flow/models/{id}", id)
.retrieve()
.body(Map.class));
}
/**
* 建草稿。对应 flowable-service {@code POST /api/flow/models},请求体 {@code {name,key,bpmnXml,metaInfo?}}
* 经 Jackson 序列化转发,返回 {@code {modelId}};坏 XML 下游 422 → {@link FlowRemoteException} 透传。
*/
@SuppressWarnings("unchecked")
public Map<String, Object> createModel(Object body) {
return post("建草稿", "/api/flow/models", body, Map.class);
}
/**
* 更新草稿。对应 flowable-service {@code PUT /api/flow/models/{id}},请求体 {@code {name?,bpmnXml,metaInfo?}}
* 经 Jackson 序列化转发,返回 {@code {status:0}};草稿不存在下游 404 / 坏 XML 422 → {@link FlowRemoteException} 透传。
*
* <p>{@code id} 走 uri 模板变量严格编码(禁字符串拼接)。</p>
*/
@SuppressWarnings("unchecked")
public Map<String, Object> updateModel(String id, Object body) {
return put("更新草稿", "/api/flow/models/{id}", body, Map.class, id);
}
/**
* 从流程定义建草稿。对应 flowable-service {@code POST /api/flow/models/from-procdef},请求体
* {@code {procDefId}} 经 Jackson 序列化转发,返回 {@code {modelId}};procDef 不存在下游返 {@code found:false}。
*/
@SuppressWarnings("unchecked")
public Map<String, Object> modelFromProcDef(Object body) {
return post("从流程定义建草稿", "/api/flow/models/from-procdef", body, Map.class);
}
/**
* 删草稿。对应 flowable-service {@code DELETE /api/flow/models/{id}},返回 {@code {status:0}};
* 草稿不存在下游 404 → {@link FlowRemoteException} 透传。
*
* <p>{@code id} 走 uri 模板变量严格编码(禁字符串拼接)。DELETE 幂等——{@link #execute} 连接级重试安全
* (重放同一 DELETE 落到同一 id,删已删=下游 404,不产生额外副作用)。</p>
*/
@SuppressWarnings("unchecked")
public Map<String, Object> deleteModel(String id) {
return delete("删草稿", "/api/flow/models/{id}", Map.class, id);
}
/**
* 发布草稿为流程定义(T3.2)。对应 flowable-service {@code POST /api/flow/models/{id}/deploy},无请求体,
* 返回 {@code {status:0,deploymentId,processKey,newVersion}};下游 ProcessValidator 拒 → 422 /
* 草稿不存在 → 404 → {@link FlowRemoteException} 透传。{@code id} 走 uri 模板变量严格编码(禁字符串拼接)。
*
* <p><b>幂等性</b>:部署<b>非幂等</b>(每次 deploy 产生新版本)——{@link #execute} 的连接级重试存在重复部署窗口
* (产生 vN 与 vN+1 内容相同的冗余版本)。接受该风险:①网关↔flowable-service 同机链路,连接级瞬时故障概率极低;
* ②冗余新版本无害(运行中实例留旧版本,新起用 latest);③语义级 4xx/5xx(校验拒)由 {@link #execute} 保证
* <b>绝不</b>重试,故校验失败无重复窗口。发布前网关 {@code ModelSemanticValidator} 已挡住绝大多数坏草稿。</p>
*/
@SuppressWarnings("unchecked")
public Map<String, Object> deployModel(String id) {
return post("发布草稿", "/api/flow/models/{id}/deploy", Map.of(), Map.class, id);
}
/**
* 发布影响摘要(T3.2)。对应 flowable-service {@code GET /api/flow/models/{id}/impact},返回
* {@code {processKey,currentVersion,runningInstances}};草稿不存在 → 404 {@link FlowRemoteException} 透传。
* {@code id} 走 uri 模板变量严格编码(禁字符串拼接)。
*/
@SuppressWarnings("unchecked")
public Map<String, Object> modelImpact(String id) {
return execute("发布影响", () -> restClient.get()
.uri("/api/flow/models/{id}/impact", id)
.retrieve()
.body(Map.class));
}
/** 按发起人查询历史流程实例。对应 flowable-service {@code GET /api/flow/process/started}。 */ /** 按发起人查询历史流程实例。对应 flowable-service {@code GET /api/flow/process/started}。 */
public List<ProcessInstanceDto> started(String startedBy, int firstResult, int maxResults) { public List<ProcessInstanceDto> started(String startedBy, int firstResult, int maxResults) {
return execute("发起流程列表", () -> restClient.get() return execute("发起流程列表", () -> restClient.get()
@@ -311,6 +408,12 @@ public class FlowableClient {
.body(TASK_LIST)); .body(TASK_LIST));
} }
/**
* POST 转发。<b>幂等性</b>:POST 非幂等——{@link #execute} 的<b>连接级</b>重试(连不上/读超时后重放)
* 存在重复创建窗口。接受该风险的理由:①草稿创建廉价且可覆盖(重复草稿人工删即可,非扣款类不可逆副作用);
* ②本地网关↔flowable-service 同机链路,连接级瞬时故障概率极低。语义级 4xx/5xx 由 {@link #execute} 保证
* <b>绝不</b>重试,故业务错无重复窗口。对比 {@link #put}(覆盖写幂等,重试安全)。
*/
private <T> T post(String op, String path, Object body, Class<T> respType) { private <T> T post(String op, String path, Object body, Class<T> respType) {
return execute(op, () -> restClient.post() return execute(op, () -> restClient.post()
.uri(path) .uri(path)
@@ -327,6 +430,46 @@ public class FlowableClient {
.body(respType)); .body(respType));
} }
/**
* POST 转发(uri 模板 + 变量版):{@code uriTemplate}+{@code uriVars} 走 RestClient 严格编码
* ({@code id} 作 uri 变量,禁字符串拼接)。谓词固定 POST 但路径含变量段(如 {@code /models/{id}/deploy})。
* 幂等性/重试语义与四参 {@link #post(String, String, Object, Class)} 一致(非幂等,连接级重试有重复窗口);
* 具体端点的重复风险由调用方 javadoc 声明。四参调用因固定元数优先绑定,不与本重载歧义。
*/
private <T> T post(String op, String uriTemplate, Object body, Class<T> respType, Object... uriVars) {
return execute(op, () -> restClient.post()
.uri(uriTemplate, uriVars)
.body(body == null ? Map.of() : body)
.retrieve()
.body(respType));
}
/**
* PUT 转发(RestClient 无既有封装 → 照 {@link #post} 补)。{@code uriTemplate}+{@code uriVars} 走 RestClient
* 严格编码({@code id} 作 uri 变量,禁字符串拼接);连接级重试 + 4xx/5xx 透传语义与 post 一致。
*
* <p><b>幂等性</b>:PUT 是覆盖写、天然幂等 → {@link #execute} 的连接级重试<b>安全</b>(重放同一 PUT 落到同一
* 草稿 id,不产生额外副作用),无 {@link #post} 那种重复创建窗口。</p>
*/
private <T> T put(String op, String uriTemplate, Object body, Class<T> respType, Object... uriVars) {
return execute(op, () -> restClient.put()
.uri(uriTemplate, uriVars)
.body(body == null ? Map.of() : body)
.retrieve()
.body(respType));
}
/**
* DELETE 转发(RestClient 无既有封装 → 照 {@link #put} 补)。{@code uriTemplate}+{@code uriVars} 走 RestClient
* 严格编码({@code id} 作 uri 变量,禁字符串拼接);无请求体;连接级重试 + 4xx/5xx 透传语义与 put 一致(幂等)。
*/
private <T> T delete(String op, String uriTemplate, Class<T> respType, Object... uriVars) {
return execute(op, () -> restClient.delete()
.uri(uriTemplate, uriVars)
.retrieve()
.body(respType));
}
/** /**
* 统一执行:连接级故障带退避重试 maxRetries 次,耗尽 → 503 语义;业务错(4xx/5xx)立即透传不重试。 * 统一执行:连接级故障带退避重试 maxRetries 次,耗尽 → 503 语义;业务错(4xx/5xx)立即透传不重试。
*/ */
@@ -347,10 +490,12 @@ public class FlowableClient {
sleepBackoff(); sleepBackoff();
} }
} catch (RestClientResponseException e) { } catch (RestClientResponseException e) {
// 业务级:引擎在线但返回 4xx/5xx(如挂起拒办 409)——透传原状态码,绝不重试 // 业务级:引擎在线但返回 4xx/5xx(如挂起拒办 409)——透传原状态码,绝不重试。
// 携带原始响应体:发布下游 422 的结构化 errors(activityId/problem) 交 handler 并入网关响应(评审 I-2)。
HttpStatusCode status = e.getStatusCode(); HttpStatusCode status = e.getStatusCode();
log.debug("flowable-service {}调用返回业务状态 {}: {}", op, status, e.getMessage()); log.debug("flowable-service {}调用返回业务状态 {}: {}", op, status, e.getMessage());
throw new FlowRemoteException(status, "flowable-service " + op + "返回 " + status.value()); throw new FlowRemoteException(status, "flowable-service " + op + "返回 " + status.value(),
e.getResponseBodyAsString());
} }
} }
// 重试耗尽仍连不上 —— 熔断降级为 503 语义 // 重试耗尽仍连不上 —— 熔断降级为 503 语义

View File

@@ -1,7 +1,10 @@
package com.eip4.platform.flowgateway.web; package com.eip4.platform.flowgateway.web;
import java.util.LinkedHashMap;
import java.util.Map; import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler;
@@ -9,6 +12,8 @@ import org.springframework.web.bind.annotation.RestControllerAdvice;
import com.eip4.platform.flowgateway.client.FlowRemoteException; import com.eip4.platform.flowgateway.client.FlowRemoteException;
import com.eip4.platform.flowgateway.client.FlowServiceUnavailableException; import com.eip4.platform.flowgateway.client.FlowServiceUnavailableException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
/** /**
* 流程网关异常 → 干净 HTTP 语义(只管本网关 client 抛出的两类异常,不拦其他)。 * 流程网关异常 → 干净 HTTP 语义(只管本网关 client 抛出的两类异常,不拦其他)。
@@ -17,12 +22,17 @@ import com.eip4.platform.flowgateway.client.FlowServiceUnavailableException;
* <li>{@link FlowServiceUnavailableException}(引擎进程不可达,重试耗尽)→ <b>503</b> * <li>{@link FlowServiceUnavailableException}(引擎进程不可达,重试耗尽)→ <b>503</b>
* Service Unavailable —— 待办聚合在引擎宕机/网络分区时返回明确的服务不可用语义,而非 500 堆栈。</li> * Service Unavailable —— 待办聚合在引擎宕机/网络分区时返回明确的服务不可用语义,而非 500 堆栈。</li>
* <li>{@link FlowRemoteException}(引擎在线但拒绝,如挂起拒办 409)→ <b>透传原状态码</b>, * <li>{@link FlowRemoteException}(引擎在线但拒绝,如挂起拒办 409)→ <b>透传原状态码</b>,
* 保留 Flowable 语义。</li> * 保留 Flowable 语义;若下游响应体带结构化 {@code errors} 数组(如发布 422 的引擎结构校验错误
* {@code [{activityId,problem,defaultDescription}]}),<b>并入</b>网关响应顶层 {@code errors},
* 与网关语义校验 422 的顶层 {@code errors} 契约统一(评审 I-2)。</li>
* </ul> * </ul>
*/ */
@RestControllerAdvice(basePackages = "com.eip4.platform.flowgateway") @RestControllerAdvice(basePackages = "com.eip4.platform.flowgateway")
public class FlowGatewayExceptionHandler { public class FlowGatewayExceptionHandler {
private static final Logger log = LoggerFactory.getLogger(FlowGatewayExceptionHandler.class);
private static final ObjectMapper MAPPER = new ObjectMapper();
@ExceptionHandler(FlowServiceUnavailableException.class) @ExceptionHandler(FlowServiceUnavailableException.class)
public ResponseEntity<Map<String, Object>> onUnavailable(FlowServiceUnavailableException e) { public ResponseEntity<Map<String, Object>> onUnavailable(FlowServiceUnavailableException e) {
return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE) return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
@@ -34,10 +44,33 @@ public class FlowGatewayExceptionHandler {
@ExceptionHandler(FlowRemoteException.class) @ExceptionHandler(FlowRemoteException.class)
public ResponseEntity<Map<String, Object>> onRemote(FlowRemoteException e) { public ResponseEntity<Map<String, Object>> onRemote(FlowRemoteException e) {
return ResponseEntity.status(e.getStatus()) Map<String, Object> body = new LinkedHashMap<>();
.body(Map.of( body.put("status", e.getStatus().value());
"status", e.getStatus().value(), body.put("error", "FLOW_REMOTE_ERROR");
"error", "FLOW_REMOTE_ERROR", body.put("message", e.getMessage());
"message", e.getMessage())); Object errors = extractErrors(e.getResponseBody());
if (errors != null) {
body.put("errors", errors);
}
return ResponseEntity.status(e.getStatus()).body(body);
}
/**
* 从下游原始响应体抽结构化 {@code errors} 数组(非空才返回)。下游体非 JSON / 无 errors / 空数组 → null
* (回原 FLOW_REMOTE_ERROR 信封,不加 errors 键)。防御性:解析失败静默降级,不让异常翻译再抛异常。
*/
private static Object extractErrors(String responseBody) {
if (responseBody == null || responseBody.isBlank()) {
return null;
}
try {
JsonNode errors = MAPPER.readTree(responseBody).get("errors");
if (errors != null && errors.isArray() && !errors.isEmpty()) {
return MAPPER.convertValue(errors, Object.class);
}
} catch (Exception ex) {
log.debug("下游响应体非 JSON 或无 errors,回原信封: {}", ex.toString());
}
return null;
} }
} }

View File

@@ -1,18 +1,26 @@
package com.eip4.platform.flowgateway.web; package com.eip4.platform.flowgateway.web;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal; import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.eip4.platform.auth.security.AuthPrincipal; import com.eip4.platform.auth.security.AuthPrincipal;
import com.eip4.platform.auth.security.EngineContextBinder; import com.eip4.platform.auth.security.EngineContextBinder;
import com.eip4.platform.flowgateway.aggregate.FlowDeployAuditService;
import com.eip4.platform.flowgateway.aggregate.ModelSemanticValidator;
import com.eip4.platform.flowgateway.aggregate.WfTemplatePickerService;
import com.eip4.platform.flowgateway.client.FlowableClient; import com.eip4.platform.flowgateway.client.FlowableClient;
import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Operation;
@@ -22,10 +30,12 @@ import io.swagger.v3.oas.annotations.tags.Tag;
* 在线流程 Modeler 网关门面:把 flowable-service 的流程定义/草稿能力经<b>超管门</b>暴露给设计器前端。 * 在线流程 Modeler 网关门面:把 flowable-service 的流程定义/草稿能力经<b>超管门</b>暴露给设计器前端。
* *
* <p>flowable-service 裸 8089 无 Spring Security → 流程编辑/部署面的鉴权唯一落点在本网关层。 * <p>flowable-service 裸 8089 无 Spring Security → 流程编辑/部署面的鉴权唯一落点在本网关层。
* 本控制器所有端点先过超管门({@link EngineContextBinder#isSystemAdmin},与全站 {@code requireAdmin} * 本控制器所有端点先过超管门({@link #requireSuperAdmin},委托 {@link EngineContextBinder#isSystemAdmin},
* 逐口径对齐),非超管返回 403,过门后转发 {@link FlowableClient},返回体原样透传。 * 与全站 {@code requireAdmin} 逐口径对齐),非超管返回 403,过门后转发 {@link FlowableClient},返回体原样透传。
* *
* <p>阶段 1(T1.6):只读载入存量流程源 XML。草稿 CRUD / 发布门在后续阶段接入本控制器。 * <p>阶段 1(T1.6):只读载入存量流程源 XML。阶段 2(T2.2):草稿 CRUD 五端点转发(list/get/create/update/
* from-procdef,对齐 flowable-service {@code ProcessModelController} 契约)+ 办理人/会签 formKey 选择器数据源
* {@code /wftemplates}(读业务库 {@code view_wftemplate})。发布门在阶段 3 接入。</p>
*/ */
@Tag(name = "流程 Modeler 网关", description = "流程设计器:超管门 + flowable-service 转发(存量源载入/草稿/发布)") @Tag(name = "流程 Modeler 网关", description = "流程设计器:超管门 + flowable-service 转发(存量源载入/草稿/发布)")
@RestController @RestController
@@ -33,11 +43,22 @@ import io.swagger.v3.oas.annotations.tags.Tag;
public class ProcessModelerController { public class ProcessModelerController {
private final FlowableClient flowableClient; private final FlowableClient flowableClient;
private final WfTemplatePickerService wfTemplatePickerService;
private final ModelSemanticValidator semanticValidator;
private final FlowDeployAuditService deployAuditService;
public ProcessModelerController(FlowableClient flowableClient) { public ProcessModelerController(FlowableClient flowableClient,
WfTemplatePickerService wfTemplatePickerService,
ModelSemanticValidator semanticValidator,
FlowDeployAuditService deployAuditService) {
this.flowableClient = flowableClient; this.flowableClient = flowableClient;
this.wfTemplatePickerService = wfTemplatePickerService;
this.semanticValidator = semanticValidator;
this.deployAuditService = deployAuditService;
} }
// ---------------------------------------------------------------- 存量流程源载入(T1.6)
@Operation(summary = "按流程定义 id 取净化源 XML(超管)", @Operation(summary = "按流程定义 id 取净化源 XML(超管)",
description = "超管门后转发 flowable-service /api/flow/process-definitions/{procDefId}/source," description = "超管门后转发 flowable-service /api/flow/process-definitions/{procDefId}/source,"
+ "返回 {procDefId, found, bpmnXml(净化后), idMap, procDefKey, version} 供 bpmn-js Modeler 载入。" + "返回 {procDefId, found, bpmnXml(净化后), idMap, procDefKey, version} 供 bpmn-js Modeler 载入。"
@@ -45,8 +66,9 @@ public class ProcessModelerController {
@GetMapping("/process-definitions/{procDefId}/source") @GetMapping("/process-definitions/{procDefId}/source")
public ResponseEntity<Map<String, Object>> source(@AuthenticationPrincipal AuthPrincipal principal, public ResponseEntity<Map<String, Object>> source(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String procDefId) { @PathVariable String procDefId) {
if (!EngineContextBinder.isSystemAdmin(principal)) { ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
return forbidden(); if (denied != null) {
return denied;
} }
return ResponseEntity.ok(flowableClient.procDefSource(procDefId)); return ResponseEntity.ok(flowableClient.procDefSource(procDefId));
} }
@@ -59,17 +81,186 @@ public class ProcessModelerController {
@GetMapping("/process-definitions/by-key/{key}/source") @GetMapping("/process-definitions/by-key/{key}/source")
public ResponseEntity<Map<String, Object>> sourceByKey(@AuthenticationPrincipal AuthPrincipal principal, public ResponseEntity<Map<String, Object>> sourceByKey(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String key) { @PathVariable String key) {
if (!EngineContextBinder.isSystemAdmin(principal)) { ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
return forbidden(); if (denied != null) {
return denied;
} }
return ResponseEntity.ok(flowableClient.procDefSourceByKey(key)); return ResponseEntity.ok(flowableClient.procDefSourceByKey(key));
} }
/** 超管门未过:403 + {status:1,msg} 风格对齐既有网关端点。 */ // ---------------------------------------------------------------- 草稿 CRUD 转发(T2.2)
private static ResponseEntity<Map<String, Object>> forbidden() {
@Operation(summary = "草稿列表(超管)",
description = "超管门后转发 flowable-service GET /api/flow/models,返回 {models:[{id,name,key,lastUpdateTime}]}。")
@GetMapping("/models")
public ResponseEntity<Map<String, Object>> listModels(@AuthenticationPrincipal AuthPrincipal principal) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.listModels());
}
@Operation(summary = "取草稿(超管)",
description = "超管门后转发 flowable-service GET /api/flow/models/{id},返回 {found,id,name,key,bpmnXml,metaInfo}。"
+ "id 由 FlowableClient 以 uri 变量严格编码转发。")
@GetMapping("/models/{id}")
public ResponseEntity<Map<String, Object>> getModel(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String id) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.getModel(id));
}
@Operation(summary = "建草稿(超管)",
description = "超管门后转发 flowable-service POST /api/flow/models,body {name,key,bpmnXml,metaInfo?},"
+ "返回 {modelId}。坏 XML 下游 422 经既有 handler 透传。")
@PostMapping("/models")
public ResponseEntity<Map<String, Object>> createModel(@AuthenticationPrincipal AuthPrincipal principal,
@RequestBody Map<String, Object> body) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.createModel(body));
}
@Operation(summary = "更新草稿(超管)",
description = "超管门后转发 flowable-service PUT /api/flow/models/{id},body {name?,bpmnXml,metaInfo?},"
+ "返回 {status:0}。草稿不存在 404 / 坏 XML 422 经既有 handler 透传。id 以 uri 变量严格编码转发。")
@PutMapping("/models/{id}")
public ResponseEntity<Map<String, Object>> updateModel(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String id,
@RequestBody Map<String, Object> body) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.updateModel(id, body));
}
@Operation(summary = "从流程定义建草稿(超管)",
description = "超管门后转发 flowable-service POST /api/flow/models/from-procdef,body {procDefId},"
+ "返回 {modelId}(净化 id 映射落 metaInfo)。procDef 不存在下游返 {found:false}。")
@PostMapping("/models/from-procdef")
public ResponseEntity<Map<String, Object>> modelFromProcDef(@AuthenticationPrincipal AuthPrincipal principal,
@RequestBody Map<String, Object> body) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.modelFromProcDef(body));
}
@Operation(summary = "删草稿(超管)",
description = "超管门后转发 flowable-service DELETE /api/flow/models/{id},返回 {status:0}。"
+ "草稿不存在 404 经既有 handler 透传。id 以 uri 变量严格编码转发。")
@DeleteMapping("/models/{id}")
public ResponseEntity<Map<String, Object>> deleteModel(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String id) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.deleteModel(id));
}
// ---------------------------------------------------------------- 发布门(T3.2)
/**
* <b>TOCTOU 已接受风险(评审 I-3)</b>:本端点先 {@link FlowableClient#getModel} 读草稿源做语义校验,再由下游
* deploy 重新读 editorSource 部署——两次读之间存在并发 PUT 改写草稿的窗口(校验的是旧内容、部署的是新内容)。
* v1 <b>接受</b>该风险,不做 content-hash 乐观锁 409:①发布是超管手动、低频、通常单人操作,并发改写窗口极窄;
* ②非安全洞(超管门已限定调用者,下游 deploy 仍过引擎 ProcessValidator 结构校验兜底);③content-hash 409
* 对 v1 过重(需前端拿版本号回传+冲突重试 UI)。与 {@link FlowableClient} 幂等段同风格声明,v2 有多人协同编辑
* 需求再引入乐观锁。
*/
@Operation(summary = "发布草稿为流程定义(超管 + 语义校验门 + 审计)",
description = "超管门 → 取草稿源 XML(FlowableClient.getModel)→ EIP4 语义校验"
+ "(ModelSemanticValidator:办理人/会签内嵌 JSON items 非空+type 白名单、formKey 存在于 view_wftemplate、"
+ "completionCondition 预设∪自定义)→ 有错返 422 {status:1,msg,errors} <b>不部署</b>;过则转发 flowable-service "
+ "POST /api/flow/models/{id}/deploy(引擎 ProcessValidator 结构校验+id 还原中文原 key+部署)→ 成功后写"
+ " sys_flow_deploy_audit(operator=principal.userId())→ 透传下游 {status,deploymentId,processKey,newVersion}。"
+ "草稿不存在/源为空 → 404。非超管 403。")
@PostMapping("/models/{id}/deploy")
public ResponseEntity<Map<String, Object>> deploy(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String id) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
// 取草稿源 XML 供语义校验(办理人/会签 JSON、formKey 在草稿态即定,与部署时 id 还原无关)。
Map<String, Object> model = flowableClient.getModel(id);
String bpmnXml = (model != null && Boolean.TRUE.equals(model.get("found"))
&& model.get("bpmnXml") instanceof String s) ? s : null;
if (bpmnXml == null || bpmnXml.isBlank()) {
return error(HttpStatus.NOT_FOUND, "草稿不存在或源为空: " + id);
}
// EIP4 语义校验门:非空错误清单 → 422 不部署(引擎结构校验在下游 deploy,二者互补)。
List<String> errors = semanticValidator.validate(bpmnXml);
if (!errors.isEmpty()) {
Map<String, Object> body = new LinkedHashMap<>(); Map<String, Object> body = new LinkedHashMap<>();
body.put("status", 1); body.put("status", 1);
body.put("msg", "仅系统管理员可用"); body.put("msg", "流程语义校验未通过");
return ResponseEntity.status(HttpStatus.FORBIDDEN).body(body); body.put("errors", errors);
return ResponseEntity.status(HttpStatus.UNPROCESSABLE_ENTITY).body(body);
}
// 转发部署(下游还原中文原 key + ProcessValidator 结构校验 + deploy)。
Map<String, Object> result = flowableClient.deployModel(id);
// 部署成功后旁路写审计(收口 @Service,避免 @RestController 直用 JdbcTemplate 触架构棘轮);写失败不反噬部署。
deployAuditService.record(id, result, principal.userId());
return ResponseEntity.ok(result);
}
@Operation(summary = "发布影响摘要(超管)",
description = "超管门后转发 flowable-service GET /api/flow/models/{id}/impact,返回"
+ " {processKey,currentVersion,runningInstances} 供同人确认弹窗展示。草稿不存在 → 下游 404 透传。非超管 403。")
@GetMapping("/models/{id}/impact")
public ResponseEntity<Map<String, Object>> impact(@AuthenticationPrincipal AuthPrincipal principal,
@PathVariable String id) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
return ResponseEntity.ok(flowableClient.modelImpact(id));
}
// ---------------------------------------------------------------- formKey 选择器数据源(T2.2)
@Operation(summary = "wftemplate 选择器数据源(超管)",
description = "超管门后经 WfTemplatePickerService 读业务库 view_wftemplate(isactive=1) → {templates:[{id,name}]},"
+ "供办理人/会签 formKey 下拉选择。name 取 XML entityid→sys_entity.name(无则回退 id),"
+ "view_wftemplate_id 去 CHAR 补白。读库异常降级 {templates:[], degraded:true}(不 500 阻断设计器)。")
@GetMapping("/wftemplates")
public ResponseEntity<Map<String, Object>> wftemplates(@AuthenticationPrincipal AuthPrincipal principal) {
ResponseEntity<Map<String, Object>> denied = requireSuperAdmin(principal);
if (denied != null) {
return denied;
}
// SQL 收口 WfTemplatePickerService(@Service):@RestController 不得直用 JdbcTemplate(架构棘轮)。
return ResponseEntity.ok(wfTemplatePickerService.listTemplates());
}
// ---------------------------------------------------------------- 超管门
/**
* 统一超管门:超管返回 {@code null}(放行),非超管/无身份返回 403 ResponseEntity({status:1,msg})。
* 所有端点入口调用,防漏门(T1.6 评审 M-3)。403 信封与既有网关端点逐字对齐。
*/
private static ResponseEntity<Map<String, Object>> requireSuperAdmin(AuthPrincipal principal) {
if (EngineContextBinder.isSystemAdmin(principal)) {
return null;
}
return error(HttpStatus.FORBIDDEN, "仅系统管理员可用");
}
/** 统一错误信封 {status:1,msg}(与全站网关端点逐字对齐)。 */
private static ResponseEntity<Map<String, Object>> error(HttpStatus httpStatus, String msg) {
Map<String, Object> body = new LinkedHashMap<>();
body.put("status", 1);
body.put("msg", msg);
return ResponseEntity.status(httpStatus).body(body);
} }
} }

View File

@@ -0,0 +1,63 @@
package com.eip4.platform.flowgateway;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.jdbc.core.JdbcTemplate;
import com.eip4.platform.flowgateway.aggregate.FlowDeployAuditService;
/**
* 部署审计 Service 单测:从 deploy 下游结果抽字段 INSERT sys_flow_deploy_audit;写库异常吞掉不反噬已成功的部署。
* SQL 收口到本 @Service(@RestController 不得直用 JdbcTemplate,架构棘轮)。
*/
class FlowDeployAuditServiceTest {
private final JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
private final FlowDeployAuditService service = new FlowDeployAuditService(jdbcTemplate);
@Test
void record_从下游结果抽全字段INSERT() {
Map<String, Object> result = new LinkedHashMap<>();
result.put("status", 0);
result.put("deploymentId", "dep-9");
result.put("processKey", "总包合同交底");
result.put("newVersion", 4);
service.record("m1", result, "ADMIN");
// SQL 用 anyString()(照 WfTemplatePickerServiceTest 惯例,不耦合具体语句);断言抽出的字段值与顺序。
verify(jdbcTemplate).update(anyString(),
eq("m1"), eq("dep-9"), eq("总包合同交底"), eq(4), eq("ADMIN"));
}
@Test
void record_newVersion数字归一为Integer_processKey缺失传null() {
Map<String, Object> result = new LinkedHashMap<>();
result.put("deploymentId", "dep-1");
// 无 processKey/newVersion:抽为 null,不炸
service.record("m2", result, "ADMIN");
verify(jdbcTemplate).update(anyString(),
eq("m2"), eq("dep-1"), eq((Object) null), eq((Object) null), eq("ADMIN"));
}
@Test
void record_写库异常被吞不抛_部署已成功不回滚() {
when(jdbcTemplate.update(anyString(), any(), any(), any(), any(), any()))
.thenThrow(new DataAccessResourceFailureException("db down"));
Map<String, Object> result = Map.of("deploymentId", "d", "processKey", "k", "newVersion", 1);
assertThatCode(() -> service.record("m3", result, "ADMIN")).doesNotThrowAnyException();
}
}

View File

@@ -278,4 +278,237 @@ class FlowableClientTest {
.satisfies(e -> assertThat(((FlowRemoteException) e).getStatus().value()).isEqualTo(400)); .satisfies(e -> assertThat(((FlowRemoteException) e).getStatus().value()).isEqualTo(400));
server.verify(); server.verify();
} }
// ---- 草稿 Model API 转发(T2.2):list/get/create/update/from-procdef ----
// flowable-service ProcessModelController(T2.1) 契约:GET/POST/PUT /api/flow/models[/{id}]
// + POST /api/flow/models/from-procdef。全部返 Map 原样透传;POST/PUT body 经 Jackson 序列化转发;
// {id} 走 uri 模板变量严格编码(禁拼接);下游 4xx 透传 FlowRemoteException。
@Test
void 草稿列表_GET_models解析models数组() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models"))
.andExpect(method(HttpMethod.GET))
.andRespond(withSuccess(
"{\"models\":[{\"id\":\"m1\",\"name\":\"总包合同交底\",\"key\":\"总包合同交底\"}]}",
MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.listModels();
@SuppressWarnings("unchecked")
List<Map<String, Object>> models = (List<Map<String, Object>>) resp.get("models");
assertThat(models).hasSize(1);
assertThat(models.get(0)).containsEntry("id", "m1").containsEntry("name", "总包合同交底");
server.verify();
}
@Test
void 取草稿_GET_models按id透传() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1"))
.andExpect(method(HttpMethod.GET))
.andRespond(withSuccess("{\"found\":true,\"id\":\"m1\",\"bpmnXml\":\"<definitions/>\"}",
MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.getModel("m1");
assertThat(resp).containsEntry("found", true).containsEntry("bpmnXml", "<definitions/>");
server.verify();
}
@Test
void 建草稿_POST_models_body原样透传() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models"))
.andExpect(method(HttpMethod.POST))
.andExpect(jsonPath("$.name").value("总包合同交底"))
.andExpect(jsonPath("$.key").value("总包合同交底"))
.andExpect(jsonPath("$.bpmnXml").value("<definitions/>"))
.andRespond(withSuccess("{\"modelId\":\"m9\"}", MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> body = new java.util.LinkedHashMap<>();
body.put("name", "总包合同交底");
body.put("key", "总包合同交底");
body.put("bpmnXml", "<definitions/>");
Map<String, Object> resp = client.createModel(body);
assertThat(resp).containsEntry("modelId", "m9");
server.verify();
}
@Test
void 更新草稿_PUT_models按id_body原样透传() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1"))
.andExpect(method(HttpMethod.PUT))
.andExpect(jsonPath("$.bpmnXml").value("<definitions id=\"a\"/>"))
.andRespond(withSuccess("{\"status\":0}", MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> body = new java.util.LinkedHashMap<>();
body.put("bpmnXml", "<definitions id=\"a\"/>");
Map<String, Object> resp = client.updateModel("m1", body);
assertThat(resp).containsEntry("status", 0);
server.verify();
}
@Test
void 从流程定义建草稿_POST_from_procdef_body原样透传() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/from-procdef"))
.andExpect(method(HttpMethod.POST))
.andExpect(jsonPath("$.procDefId").value("总包合同交底:3:abc123"))
.andRespond(withSuccess("{\"modelId\":\"m7\"}", MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.modelFromProcDef(Map.of("procDefId", "总包合同交底:3:abc123"));
assertThat(resp).containsEntry("modelId", "m7");
server.verify();
}
@Test
void 草稿转发_下游4xx透传FlowRemote且不重试() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), // 业务错不重试
requestTo("http://localhost:8089/api/flow/models"))
.andExpect(method(HttpMethod.POST))
.andRespond(withStatus(HttpStatus.UNPROCESSABLE_ENTITY).body("BPMN 解析失败"));
FlowableClient client = new FlowableClient(builder.build(), p);
assertThatThrownBy(() -> client.createModel(Map.of("bpmnXml", "<bad>")))
.isInstanceOf(FlowRemoteException.class)
.satisfies(e -> assertThat(((FlowRemoteException) e).getStatus().value()).isEqualTo(422));
server.verify();
}
@Test
void 删草稿_DELETE_models按id透传() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1"))
.andExpect(method(HttpMethod.DELETE))
.andRespond(withSuccess("{\"status\":0}", MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.deleteModel("m1");
assertThat(resp).containsEntry("status", 0);
server.verify();
}
@Test
void 删草稿_下游404透传FlowRemote且不重试() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), // 业务错不重试
requestTo("http://localhost:8089/api/flow/models/nope"))
.andExpect(method(HttpMethod.DELETE))
.andRespond(withStatus(HttpStatus.NOT_FOUND).body("草稿不存在"));
FlowableClient client = new FlowableClient(builder.build(), p);
assertThatThrownBy(() -> client.deleteModel("nope"))
.isInstanceOf(FlowRemoteException.class)
.satisfies(e -> assertThat(((FlowRemoteException) e).getStatus().value()).isEqualTo(404));
server.verify();
}
// ---- 发布/影响转发(T3.2):POST /api/flow/models/{id}/deploy、GET /api/flow/models/{id}/impact ----
@Test
void 发布草稿_POST_models_id_deploy_透传下游结果() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1/deploy"))
.andExpect(method(HttpMethod.POST))
.andRespond(withSuccess(
"{\"status\":0,\"deploymentId\":\"dep-9\",\"processKey\":\"总包合同交底\",\"newVersion\":4}",
MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.deployModel("m1");
assertThat(resp).containsEntry("deploymentId", "dep-9").containsEntry("processKey", "总包合同交底")
.containsEntry("newVersion", 4);
server.verify();
}
@Test
void 发布草稿_下游422透传FlowRemote且不重试() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), // 业务错不重试(引擎 ProcessValidator 拒)
requestTo("http://localhost:8089/api/flow/models/m1/deploy"))
.andExpect(method(HttpMethod.POST))
.andRespond(withStatus(HttpStatus.UNPROCESSABLE_ENTITY).body("流程校验未通过"));
FlowableClient client = new FlowableClient(builder.build(), p);
assertThatThrownBy(() -> client.deployModel("m1"))
.isInstanceOf(FlowRemoteException.class)
.satisfies(e -> assertThat(((FlowRemoteException) e).getStatus().value()).isEqualTo(422));
server.verify();
}
@Test
void 发布_下游422结构化errors体被FlowRemoteException携带_不丢弃() {
// 评审 I-2:execute 曾只留状态码丢响应体,引擎结构校验 errors 到不了前端。现携带原始体供 handler 透传。
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
String engineBody = "{\"status\":1,\"msg\":\"流程校验未通过\",\"errors\":"
+ "[{\"activityId\":\"t1\",\"problem\":\"flowable-noOutgoingSeq\",\"defaultDescription\":\"节点未连出边\"}]}";
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1/deploy"))
.andExpect(method(HttpMethod.POST))
.andRespond(withStatus(HttpStatus.UNPROCESSABLE_ENTITY)
.body(engineBody).contentType(MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
assertThatThrownBy(() -> client.deployModel("m1"))
.isInstanceOf(FlowRemoteException.class)
.satisfies(e -> {
FlowRemoteException fre = (FlowRemoteException) e;
assertThat(fre.getStatus().value()).isEqualTo(422);
assertThat(fre.getResponseBody()).contains("activityId").contains("节点未连出边");
});
server.verify();
}
@Test
void 发布影响_GET_models_id_impact_透传下游结果() {
FlowGatewayProperties p = props();
RestClient.Builder builder = RestClient.builder().baseUrl(p.getBaseUrl());
MockRestServiceServer server = MockRestServiceServer.bindTo(builder).build();
server.expect(ExpectedCount.once(), requestTo("http://localhost:8089/api/flow/models/m1/impact"))
.andExpect(method(HttpMethod.GET))
.andRespond(withSuccess(
"{\"processKey\":\"总包合同交底\",\"currentVersion\":3,\"runningInstances\":7}",
MediaType.APPLICATION_JSON));
FlowableClient client = new FlowableClient(builder.build(), p);
Map<String, Object> resp = client.modelImpact("m1");
assertThat(resp).containsEntry("processKey", "总包合同交底").containsEntry("currentVersion", 3)
.containsEntry("runningInstances", 7);
server.verify();
}
} }

View File

@@ -0,0 +1,265 @@
package com.eip4.platform.flowgateway;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.jdbc.core.JdbcTemplate;
import com.eip4.platform.flowgateway.aggregate.ModelSemanticValidator;
/**
* 发布语义校验器单测:办理人/会签内嵌 JSON(全角【】)items 非空 + type 白名单、formKey 存在于
* view_wftemplate、completionCondition 预设∪自定义(自定义不阻断)。返回 {@code List<String>} 空=通过。
*
* <p>fixture 逐字复刻 §0 真实形态:candidateUsers/collection 值是引擎 handler 表达式,内容段花括号全角【】、
* XML 属性内引号 {@code &quot;}(DOM 解码回真引号后 validator 再 replace 全角→半角 JSON.parse)。
*/
class ModelSemanticValidatorTest {
private final JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
private final ModelSemanticValidator validator = new ModelSemanticValidator(jdbcTemplate);
private static final String CANDIDATE_PREFIX = "${candidateUsersHandler.getCandidateUsers(execution,'";
private static final String MULTI_PREFIX = "${multiInstanceUsersHandler.getUsers(execution,'";
private static final String SUFFIX = "')}";
/** formKey 存在性查询恒返回给定 count(一次 stub 覆盖所有 formKey)。 */
private void formKeyCount(int count) {
when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), any())).thenReturn(count);
}
/** 办理人/会签内容段:半角 JSON → 花括号全角【】(方括号保持半角,逐字对齐存储态)。 */
private static String toStored(String halfWidthJson) {
return halfWidthJson.replace("{", "【").replace("}", "】");
}
private static String candidateExpr(String itemsJson) {
return CANDIDATE_PREFIX + toStored("{\"items\":" + itemsJson + "}") + SUFFIX;
}
private static String multiExpr(String itemsJson) {
return MULTI_PREFIX + toStored("{\"items\":" + itemsJson + "}") + SUFFIX;
}
/** XML 属性值转义(内嵌 JSON 双引号 → &quot;)。 */
private static String attr(String s) {
return s.replace("&", "&amp;").replace("\"", "&quot;").replace("<", "&lt;");
}
private static String bpmn(String processInner) {
return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" "
+ "xmlns:activiti=\"http://activiti.org/bpmn\" targetNamespace=\"n\">"
+ "<process id=\"p1\" name=\"流程\">" + processInner + "</process></definitions>";
}
private static String userTaskWithCandidate(String name, String candidateExpr) {
return "<userTask id=\"t1\" name=\"" + name + "\" activiti:candidateUsers=\""
+ attr(candidateExpr) + "\"/>";
}
private static String cosignUserTask(String name, String collectionExpr, String completion) {
String cc = completion == null ? ""
: "<completionCondition>" + attr(completion) + "</completionCondition>";
return "<userTask id=\"t2\" name=\"" + name + "\">"
+ "<multiInstanceLoopCharacteristics isSequential=\"false\" activiti:collection=\""
+ attr(collectionExpr) + "\" activiti:elementVariable=\"assignee\">" + cc
+ "</multiInstanceLoopCharacteristics></userTask>";
}
// ---------------------------------------------------------------- 通过
@Test
void 合法流程_办理人items非空白名单_formKey存在_预设完成条件_零错误() {
formKeyCount(1);
String xml = bpmn(
"<userTask id=\"t1\" name=\"审批\" activiti:formKey=\"wft-1\" activiti:candidateUsers=\""
+ attr(candidateExpr("[{\"type\":\"user\",\"content\":\"u1,u2\",\"isCandidate\":true}]"))
+ "\"/>"
+ cosignUserTask("会签", multiExpr("[{\"type\":\"depart\",\"content\":\"d1\"}]"),
"${nrOfCompletedInstances/nrOfInstances==1}"));
assertThat(validator.validate(xml)).isEmpty();
}
@Test
void 裸userTask无办理人无formKey_不属本校验器职责_零错误() {
String xml = bpmn("<userTask id=\"t1\" name=\"纯节点\"/>");
assertThat(validator.validate(xml)).isEmpty();
// 无 formKey → 不查库
verify(jdbcTemplate, never()).queryForObject(anyString(), eq(Integer.class), any());
}
@Test
void 非handler裸候选值_非EIP4codec产物_放行不校验JSON() {
// 直接写 ${someVar} 等裸表达式:非 EIP4 办理人 handler 形态,不套 JSON 白名单(避免误拒合法 Flowable 裸值)
String xml = bpmn("<userTask id=\"t1\" name=\"节点\" activiti:candidateUsers=\"${someVar}\"/>");
assertThat(validator.validate(xml)).isEmpty();
}
@Test
void M1_flowable前缀candidateUsers_按本地名匹配同样校验() {
// 语料有 flowable 命名空间文档(3docs);按本地名匹配,flowable:candidateUsers 与 activiti: 同样被校验。
String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\" "
+ "xmlns:flowable=\"http://flowable.org/bpmn\" targetNamespace=\"n\">"
+ "<process id=\"p1\" name=\"流程\">"
+ "<userTask id=\"t1\" name=\"flowable节点\" flowable:candidateUsers=\""
+ attr(candidateExpr("[{\"type\":\"bogusType\",\"content\":\"x\"}]")) + "\"/>"
+ "</process></definitions>";
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("flowable节点").contains("bogusType");
}
@Test
void M2_新增4种type放行_锁I1白名单对齐WfTypes() {
// roles/initiatorLeader/initiatorDepartManager/fixedDimension:WfTypes 配置类型、OrgDirectoryJdbc 运行期支持,
// 但旧 10 种白名单缺失。实测 initiatorDepartManager(24 文档)/fixedDimension(12 文档)真存量命中→曾会 422 误拒。
for (String type : new String[]{"roles", "initiatorLeader", "initiatorDepartManager", "fixedDimension",
"initiatorSubordinate", "initiatorDepart"}) {
String xml = bpmn(userTaskWithCandidate("节点",
candidateExpr("[{\"type\":\"" + type + "\",\"content\":\"x\"}]")));
assertThat(validator.validate(xml)).as("type=%s 应放行", type).isEmpty();
}
}
// ---------------------------------------------------------------- 办理人 JSON 错误
@Test
void 办理人items为空数组_error() {
String xml = bpmn(userTaskWithCandidate("空办理人", candidateExpr("[]")));
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("空办理人").contains("为空");
}
@Test
void 办理人type非白名单_error() {
String xml = bpmn(userTaskWithCandidate("坏type",
candidateExpr("[{\"type\":\"bogusType\",\"content\":\"x\"}]")));
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("坏type").contains("bogusType");
}
@Test
void 办理人JSON无法解析_error() {
// 内容段坏 JSON(缺闭合)——全角还原后仍非法
String bad = CANDIDATE_PREFIX + toStored("{\"items\":[{\"type\":") + SUFFIX;
String xml = bpmn("<userTask id=\"t1\" name=\"坏JSON\" activiti:candidateUsers=\""
+ attr(bad) + "\"/>");
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("坏JSON").contains("JSON");
}
@Test
void 办理人多个type_逐项报非法() {
String xml = bpmn(userTaskWithCandidate("多项",
candidateExpr("[{\"type\":\"user\",\"content\":\"a\"},"
+ "{\"type\":\"bad1\",\"content\":\"b\"},{\"type\":\"bad2\",\"content\":\"c\"}]")));
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(2);
assertThat(errors).anyMatch(e -> e.contains("bad1")).anyMatch(e -> e.contains("bad2"));
}
// ---------------------------------------------------------------- 会签 collection + 完成条件
@Test
void 会签collection的items为空_error() {
formKeyCount(1);
String xml = bpmn(cosignUserTask("空会签", multiExpr("[]"),
"${nrOfCompletedInstances/nrOfInstances==1}"));
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("空会签").contains("为空");
}
@Test
void 会签自定义完成条件_不阻断_零错误() {
// T2.4 保留自定义完成条件态:非三预设的合法表达式必须放行(别把存量自定义条件拒了)
String xml = bpmn(cosignUserTask("过六成会签",
multiExpr("[{\"type\":\"user\",\"content\":\"u1\"}]"),
"${nrOfCompletedInstances/nrOfInstances>0.6}"));
assertThat(validator.validate(xml)).isEmpty();
}
@Test
void 会签过半预设_不阻断_零错误() {
String xml = bpmn(cosignUserTask("过半会签",
multiExpr("[{\"type\":\"user\",\"content\":\"u1\"}]"),
"${nrOfCompletedInstances/nrOfInstances>0.5}"));
assertThat(validator.validate(xml)).isEmpty();
}
@Test
void 会签指定数预设_不阻断_零错误() {
String xml = bpmn(cosignUserTask("三票会签",
multiExpr("[{\"type\":\"user\",\"content\":\"u1\"}]"),
"${nrOfCompletedInstances>=3}"));
assertThat(validator.validate(xml)).isEmpty();
}
@Test
void 会签完成条件空白_error() {
String xml = bpmn(cosignUserTask("空条件会签",
multiExpr("[{\"type\":\"user\",\"content\":\"u1\"}]"), " "));
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("空条件会签").contains("完成条件");
}
// ---------------------------------------------------------------- formKey 存在性
@Test
void formKey不存在于模板库_error() {
formKeyCount(0);
String xml = bpmn("<userTask id=\"t1\" name=\"带表单\" activiti:formKey=\"ghost-uuid\"/>");
List<String> errors = validator.validate(xml);
assertThat(errors).hasSize(1);
assertThat(errors.get(0)).contains("带表单").contains("ghost-uuid").contains("view_wftemplate");
}
@Test
void formKey读库异常_降级放行不阻断部署() {
when(jdbcTemplate.queryForObject(anyString(), eq(Integer.class), any()))
.thenThrow(new DataAccessResourceFailureException("db down"));
String xml = bpmn("<userTask id=\"t1\" name=\"带表单\" activiti:formKey=\"wft-1\"/>");
// 读库抖动不因基础设施问题阻断发布(全站降级惯例),该项引用完整性检查跳过
assertThat(validator.validate(xml)).isEmpty();
}
// ---------------------------------------------------------------- XML 层防御
@Test
void 坏XML_error不抛() {
List<String> errors = validator.validate("<definitions><process</bad>");
assertThat(errors).isNotEmpty();
assertThat(errors.get(0)).contains("解析");
}
@Test
void 含DOCTYPE_XXE防御_error() {
String evil = "<?xml version=\"1.0\"?><!DOCTYPE foo [<!ENTITY x \"y\">]>"
+ "<definitions xmlns=\"http://www.omg.org/spec/BPMN/20100524/MODEL\"><process id=\"p\"/></definitions>";
List<String> errors = validator.validate(evil);
assertThat(errors).isNotEmpty();
}
@Test
void 空XML_error() {
assertThat(validator.validate(" ")).isNotEmpty();
assertThat(validator.validate(null)).isNotEmpty();
}
}

View File

@@ -2,12 +2,17 @@ package com.eip4.platform.flowgateway;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never; import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@@ -17,6 +22,7 @@ import java.util.Map;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.core.MethodParameter; import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders; import org.springframework.test.web.servlet.setup.MockMvcBuilders;
@@ -26,6 +32,10 @@ import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer; import org.springframework.web.method.support.ModelAndViewContainer;
import com.eip4.platform.auth.security.AuthPrincipal; import com.eip4.platform.auth.security.AuthPrincipal;
import com.eip4.platform.flowgateway.aggregate.FlowDeployAuditService;
import com.eip4.platform.flowgateway.aggregate.ModelSemanticValidator;
import com.eip4.platform.flowgateway.aggregate.WfTemplatePickerService;
import com.eip4.platform.flowgateway.client.FlowRemoteException;
import com.eip4.platform.flowgateway.client.FlowServiceUnavailableException; import com.eip4.platform.flowgateway.client.FlowServiceUnavailableException;
import com.eip4.platform.flowgateway.client.FlowableClient; import com.eip4.platform.flowgateway.client.FlowableClient;
import com.eip4.platform.flowgateway.web.FlowGatewayExceptionHandler; import com.eip4.platform.flowgateway.web.FlowGatewayExceptionHandler;
@@ -38,7 +48,11 @@ import com.eip4.platform.flowgateway.web.ProcessModelerController;
class ProcessModelerControllerTest { class ProcessModelerControllerTest {
private final FlowableClient flowableClient = mock(FlowableClient.class); private final FlowableClient flowableClient = mock(FlowableClient.class);
private final ProcessModelerController controller = new ProcessModelerController(flowableClient); private final WfTemplatePickerService wfTemplatePickerService = mock(WfTemplatePickerService.class);
private final ModelSemanticValidator semanticValidator = mock(ModelSemanticValidator.class);
private final FlowDeployAuditService deployAuditService = mock(FlowDeployAuditService.class);
private final ProcessModelerController controller = new ProcessModelerController(
flowableClient, wfTemplatePickerService, semanticValidator, deployAuditService);
/** 真实形态:中文 key + 冒号分隔的 procDefId。 */ /** 真实形态:中文 key + 冒号分隔的 procDefId。 */
private static final String CN_PROCDEF = "总包合同交底:3:abc123"; private static final String CN_PROCDEF = "总包合同交底:3:abc123";
@@ -191,4 +205,291 @@ class ProcessModelerControllerTest {
.andExpect(status().isServiceUnavailable()) .andExpect(status().isServiceUnavailable())
.andExpect(jsonPath("$.error").value("FLOW_SERVICE_UNAVAILABLE")); .andExpect(jsonPath("$.error").value("FLOW_SERVICE_UNAVAILABLE"));
} }
// ---- 草稿 CRUD 五端点转发(T2.2):每端点 admin 200 透传 + 非超管 403。
// 两次调用(admin+非超管同参)后 verify 下游恰调 1 次 → 证明门确实拦下了非超管调用(若漏门会是 2 次)。----
@Test
void 草稿列表_超管透传200_非超管403门拦下游() {
Map<String, Object> downstream = Map.of("models", List.of(Map.of("id", "m1", "name", "总包合同交底")));
when(flowableClient.listModels()).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.listModels(admin());
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.listModels(normalUser());
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(denied.getBody()).containsEntry("status", 1).containsEntry("msg", "仅系统管理员可用");
verify(flowableClient).listModels(); // 恰 1 次(仅超管):非超管被门拦,未落下游
}
@Test
void 取草稿_超管透传200_非超管403门拦下游() {
Map<String, Object> downstream = Map.of("found", true, "id", "m1", "bpmnXml", "<definitions/>");
when(flowableClient.getModel("m1")).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.getModel(admin(), "m1");
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.getModel(normalUser(), "m1");
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
verify(flowableClient).getModel("m1"); // 恰 1 次(仅超管)
}
@Test
void 建草稿_超管透传200_非超管403门拦下游() {
Map<String, Object> req = Map.of("name", "总包合同交底", "key", "总包合同交底", "bpmnXml", "<definitions/>");
Map<String, Object> downstream = Map.of("modelId", "m9");
when(flowableClient.createModel(req)).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.createModel(admin(), req);
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.createModel(normalUser(), req);
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
verify(flowableClient).createModel(req); // 恰 1 次(仅超管):漏门会是 2 次
}
@Test
void 更新草稿_超管透传200_非超管403门拦下游() {
Map<String, Object> req = Map.of("bpmnXml", "<definitions id=\"a\"/>");
Map<String, Object> downstream = Map.of("status", 0);
when(flowableClient.updateModel("m1", req)).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.updateModel(admin(), "m1", req);
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.updateModel(normalUser(), "m1", req);
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
verify(flowableClient).updateModel("m1", req); // 恰 1 次(仅超管)
}
@Test
void 从流程定义建草稿_超管透传200_非超管403门拦下游() {
Map<String, Object> req = Map.of("procDefId", CN_PROCDEF);
Map<String, Object> downstream = Map.of("modelId", "m7");
when(flowableClient.modelFromProcDef(req)).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.modelFromProcDef(admin(), req);
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.modelFromProcDef(normalUser(), req);
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
verify(flowableClient).modelFromProcDef(req); // 恰 1 次(仅超管)
}
@Test
void 无身份_建草稿403且不触发下游() {
ResponseEntity<Map<String, Object>> resp = controller.createModel(null, Map.of("name", "x"));
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(resp.getBody()).containsEntry("status", 1);
verify(flowableClient, never()).createModel(any());
}
@Test
void 删草稿_超管透传200_非超管403门拦下游() {
Map<String, Object> downstream = Map.of("status", 0);
when(flowableClient.deleteModel("m1")).thenReturn(downstream);
ResponseEntity<Map<String, Object>> ok = controller.deleteModel(admin(), "m1");
assertThat(ok.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(ok.getBody()).isEqualTo(downstream);
ResponseEntity<Map<String, Object>> denied = controller.deleteModel(normalUser(), "m1");
assertThat(denied.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(denied.getBody()).containsEntry("status", 1).containsEntry("msg", "仅系统管理员可用");
verify(flowableClient).deleteModel("m1"); // 恰 1 次(仅超管):非超管被门拦,未落下游
}
@Test
void 胶水_删草稿_下游404经handler透传() throws Exception {
when(flowableClient.deleteModel("nope"))
.thenThrow(new FlowRemoteException(HttpStatus.NOT_FOUND, "flowable-service 删草稿返回 404"));
glueMvc().perform(delete("/api/workflow/models/{id}", "nope"))
.andExpect(status().isNotFound())
.andExpect(jsonPath("$.status").value(404))
.andExpect(jsonPath("$.error").value("FLOW_REMOTE_ERROR"));
}
// ---- 422 胶水透传:下游坏 XML 422 经既有 FlowGatewayExceptionHandler 出 FLOW_REMOTE_ERROR 信封 ----
@Test
void 胶水_建草稿_下游422经handler透传() throws Exception {
when(flowableClient.createModel(any()))
.thenThrow(new FlowRemoteException(HttpStatus.UNPROCESSABLE_ENTITY, "flowable-service 建草稿返回 422"));
glueMvc().perform(post("/api/workflow/models")
.contentType(MediaType.APPLICATION_JSON)
.content("{\"name\":\"x\",\"key\":\"k\",\"bpmnXml\":\"<bad>\"}"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(422))
.andExpect(jsonPath("$.error").value("FLOW_REMOTE_ERROR"));
}
// ---- wftemplates 选择器:控制器只验门 + 透传 WfTemplatePickerService 结果(SQL/trim/降级细节在 WfTemplatePickerServiceTest)----
@Test
void wftemplates_超管_透传service结果200() {
Map<String, Object> downstream = Map.of("templates",
List.of(Map.of("id", "wft-0001", "name", "通知管理")));
when(wfTemplatePickerService.listTemplates()).thenReturn(downstream);
ResponseEntity<Map<String, Object>> resp = controller.wftemplates(admin());
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(resp.getBody()).isEqualTo(downstream);
verify(wfTemplatePickerService).listTemplates();
}
@Test
void wftemplates_非超管_403且不调service() {
ResponseEntity<Map<String, Object>> resp = controller.wftemplates(normalUser());
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(resp.getBody()).containsEntry("status", 1).containsEntry("msg", "仅系统管理员可用");
verify(wfTemplatePickerService, never()).listTemplates();
}
// ---- PUT 路由胶水(M-3):MockMvc 真走 PUT /api/workflow/models/{id},验路径匹配 + @PathVariable 绑定 + 200 透传 ----
@Test
void 胶水_更新草稿_PUT路由绑定pathVar并200透传() throws Exception {
Map<String, Object> downstream = Map.of("status", 0);
when(flowableClient.updateModel(eq("m1"), any())).thenReturn(downstream);
glueMvc().perform(put("/api/workflow/models/{id}", "m1")
.contentType(MediaType.APPLICATION_JSON)
.content("{\"bpmnXml\":\"<definitions/>\"}"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value(0));
// 路由匹配 PUT 谓词 + {id} 绑定到 "m1" 交给控制器
verify(flowableClient).updateModel(eq("m1"), any());
}
// ---- 发布门(T3.2):超管门 → 语义校验 → 转发部署 → 审计 INSERT。语义 fail 零转发零审计;非超管零触达。----
@Test
void 发布_超管语义通过_转发部署并写审计_operator为userId() {
when(flowableClient.getModel("m1"))
.thenReturn(Map.of("found", true, "bpmnXml", "<definitions/>"));
when(semanticValidator.validate("<definitions/>")).thenReturn(List.of());
Map<String, Object> deployed = Map.of("status", 0, "deploymentId", "dep-9",
"processKey", "总包合同交底", "newVersion", 4);
when(flowableClient.deployModel("m1")).thenReturn(deployed);
ResponseEntity<Map<String, Object>> resp = controller.deploy(admin(), "m1");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(resp.getBody()).isEqualTo(deployed);
verify(flowableClient).deployModel("m1");
// 审计收口到 @Service,operator=principal.userId()="ADMIN"(超管门已保证 principal 非空)
verify(deployAuditService).record("m1", deployed, "ADMIN");
}
@Test
void 发布_语义校验失败_422带明细_零转发零审计() {
when(flowableClient.getModel("m1"))
.thenReturn(Map.of("found", true, "bpmnXml", "<definitions/>"));
when(semanticValidator.validate("<definitions/>"))
.thenReturn(List.of("节点『会签』的办理人为空(items 为空)"));
ResponseEntity<Map<String, Object>> resp = controller.deploy(admin(), "m1");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
assertThat(resp.getBody()).containsEntry("status", 1);
assertThat(resp.getBody().get("errors")).isEqualTo(List.of("节点『会签』的办理人为空(items 为空)"));
verify(flowableClient, never()).deployModel(anyString()); // 校验拦截:绝不部署
verify(deployAuditService, never()).record(anyString(), any(), anyString()); // 未部署不写审计
}
@Test
void 发布_非超管_403_零触达下游与校验() {
ResponseEntity<Map<String, Object>> resp = controller.deploy(normalUser(), "m1");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(resp.getBody()).containsEntry("status", 1).containsEntry("msg", "仅系统管理员可用");
verify(flowableClient, never()).getModel(anyString());
verify(flowableClient, never()).deployModel(anyString());
verify(semanticValidator, never()).validate(anyString());
verify(deployAuditService, never()).record(anyString(), any(), anyString());
}
@Test
void 发布_草稿不存在_404_不校验不部署() {
when(flowableClient.getModel("nope")).thenReturn(Map.of("found", false));
ResponseEntity<Map<String, Object>> resp = controller.deploy(admin(), "nope");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(resp.getBody()).containsEntry("status", 1);
verify(semanticValidator, never()).validate(anyString());
verify(flowableClient, never()).deployModel(anyString());
verify(deployAuditService, never()).record(anyString(), any(), anyString());
}
@Test
void 影响摘要_超管_透传下游200() {
Map<String, Object> downstream = Map.of("processKey", "总包合同交底",
"currentVersion", 3, "runningInstances", 7);
when(flowableClient.modelImpact("m1")).thenReturn(downstream);
ResponseEntity<Map<String, Object>> resp = controller.impact(admin(), "m1");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(resp.getBody()).isEqualTo(downstream);
verify(flowableClient).modelImpact("m1");
}
@Test
void 影响摘要_非超管_403_零触达下游() {
ResponseEntity<Map<String, Object>> resp = controller.impact(normalUser(), "m1");
assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
verify(flowableClient, never()).modelImpact(anyString());
}
// ---- 胶水:发布 422 语义信封经 MVC 出(status:1 + errors 数组);发布路由 POST /{id}/deploy 绑定 ----
@Test
void 胶水_发布_语义422信封含errors数组() throws Exception {
when(flowableClient.getModel("m1"))
.thenReturn(Map.of("found", true, "bpmnXml", "<definitions/>"));
when(semanticValidator.validate("<definitions/>"))
.thenReturn(List.of("节点『审批』的表单 formKey 不存在于模板库(view_wftemplate):ghost"));
glueMvc().perform(post("/api/workflow/models/{id}/deploy", "m1"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.status").value(1))
.andExpect(jsonPath("$.errors[0]").value(
"节点『审批』的表单 formKey 不存在于模板库(view_wftemplate):ghost"));
verify(flowableClient, never()).deployModel(anyString());
}
@Test
void 胶水_发布_语义过但下游引擎422结构化errors经handler并入顶层() throws Exception {
// I-2:语义门放行 → 转发 deploy → 下游引擎 ProcessValidator 结构校验 422(对象式 errors) → handler 并入网关响应。
// 两条 422 契约统一:顶层 errors(语义=字符串数组 / 引擎=对象数组),前端 T3.3 同一渲染。
when(flowableClient.getModel("m1"))
.thenReturn(Map.of("found", true, "bpmnXml", "<definitions/>"));
when(semanticValidator.validate("<definitions/>")).thenReturn(List.of()); // 语义过
String engineBody = "{\"status\":1,\"msg\":\"流程校验未通过\",\"errors\":"
+ "[{\"activityId\":\"t1\",\"problem\":\"noOutgoing\",\"defaultDescription\":\"节点未连出边\"}]}";
when(flowableClient.deployModel("m1")).thenThrow(
new FlowRemoteException(HttpStatus.UNPROCESSABLE_ENTITY,
"flowable-service 发布草稿返回 422", engineBody));
glueMvc().perform(post("/api/workflow/models/{id}/deploy", "m1"))
.andExpect(status().isUnprocessableEntity())
.andExpect(jsonPath("$.error").value("FLOW_REMOTE_ERROR"))
.andExpect(jsonPath("$.errors[0].activityId").value("t1"))
.andExpect(jsonPath("$.errors[0].defaultDescription").value("节点未连出边"));
}
} }

View File

@@ -0,0 +1,65 @@
package com.eip4.platform.flowgateway;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.ResultSet;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import com.eip4.platform.flowgateway.aggregate.WfTemplatePickerService;
/**
* wftemplate 选择器 Service 单测:RowMapper trim CHAR 补白 + 无实体名回退 id + 读库异常降级。
* SQL 收口到本 Service(@RestController 不得直用 JdbcTemplate,架构棘轮),故这些细节从控制器测试搬到这里。
*/
class WfTemplatePickerServiceTest {
private final JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
private final WfTemplatePickerService service = new WfTemplatePickerService(jdbcTemplate);
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
void listTemplates_trim补白并回退id_正常不带degraded() {
// mock JdbcTemplate 反射调真实 RowMapper:第一行有实体名(取名+trim补白),第二行无名(回退 trim 后的 id)
when(jdbcTemplate.query(anyString(), any(RowMapper.class))).thenAnswer(inv -> {
RowMapper<Map<String, Object>> rm = inv.getArgument(1);
ResultSet named = mock(ResultSet.class);
when(named.getString("id")).thenReturn("wft-0001 "); // CHAR(36) 补白
when(named.getString("name")).thenReturn("通知管理");
ResultSet unnamed = mock(ResultSet.class);
when(unnamed.getString("id")).thenReturn("wft-0002 ");
when(unnamed.getString("name")).thenReturn(null); // 无 entityid/实体名 → 回退 id
return List.of(rm.mapRow(named, 0), rm.mapRow(unnamed, 1));
});
Map<String, Object> resp = service.listTemplates();
List<Map<String, Object>> templates = (List<Map<String, Object>>) resp.get("templates");
assertThat(templates).hasSize(2);
assertThat(templates.get(0)).containsEntry("id", "wft-0001").containsEntry("name", "通知管理");
assertThat(templates.get(1)).containsEntry("id", "wft-0002").containsEntry("name", "wft-0002");
assertThat(resp).doesNotContainKey("degraded"); // 正常路径不带 degraded 键
}
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
void listTemplates_读库异常_降级空列表带degraded不抛() {
when(jdbcTemplate.query(anyString(), any(RowMapper.class)))
.thenThrow(new DataAccessResourceFailureException("db down"));
Map<String, Object> resp = service.listTemplates();
List<Map<String, Object>> templates = (List<Map<String, Object>>) resp.get("templates");
assertThat(templates).isEmpty();
assertThat(resp).containsEntry("degraded", true); // 降级分支带标记(正常路径无此键)
}
}