unis-oa/docs/node-oa-lock-design.md

29 KiB
Raw Permalink Blame History

OA 按钮锁定:环节把表态交给外部系统之后,OA 这边那几颗钮还点不点得动

真问题是这样一句话:「财务复核这一环已经接了 ERP 的审批接口,可我们部门的审批人打开 OA 还是能点同意——两边都批了一遍,第三方那条 bizKey 回来撞上 alreadyHandled,两边的账 从此对不上。」反过来也一样:ERP 那边批完了,OA 里的审批人以为自己漏办,又点了一次退回。

落地状态

本文已实现。判据在 backend/app/service/node_approve.py(lock_of / lock_enabled / locked_actions / lock_where / lock_text / lock_view / lock_block / check / lock_problems / lock_flags),通道闸在 engine._lock_guard,界面那一侧读的是环节简报里 的 oa_lock。与设计稿有四处出入,都是有意的:

  • 四个 VIA_* 常量落在 engine 那一侧(node_approve 只留同名的一份 OA_VIAS)。 node_approve 模块级就引了 embed_session,而 embed_session 又模块级引 engine; 让引擎反过来在模块级引本模块会绕成一个环,而 via 是函数签名的默认值,必须在 def 那一刻就有值。两处同名由 check_node_approve.py 钉住,漂了就红。
  • check() 回的是那句话,不抛异常。抛什么交给调用方:引擎收成 EngineError(→ 400), 待办列表与已办列表把同一句摆成灰按钮的悬浮说明。这样本模块保持"纯判定层、不连库也能测"。
  • 连库验收另起一份 backend/scripts/check_oa_lock_api.py(37 条),没有塞进 check_node_approve_api.py:那一份已经 90 条、跑一张流程要建一整套夹具,锁这一层 的验收自成一组更好读。§9 里"混一条锁住的批量办理""干预路不被挡""超时不代办只发待阅" 都在这一份里。
  • start 也管发起页那颗「发起」(生产第一撞就撞在这儿:开始环节锁着,人从发起页 一点,单子建出来就当场提交出去流转了,外部系统一条表态都没收到)。发起那一刻做的 就是「建单 + 提交」,与停在开始环节那一单的「提交」是同一颗钮,闸写在 engine.create_job 开头(_lock_guard(..., "start", via, starting=True),排在冻快照与 排号之前,挡下时库里不留半张单)。starting 只换那句说法:对着一个还没建出来的单说 "这张单还停在开始环节",听话的人只会回头去找那张单。第三方那两条建单路 (/open/works、开始环节那句代发起)显式改口 via="open",照旧不受影响。
  • 开始环节上 handle 与 start 是同一颗「提交」(BEGIN_SUBMIT_ACTIONS):勾了任一颗 就算两颗都锁上,lock_view 报给界面的那一格也跟着补齐。只挡一条的锁最坑人——退回发起人 那一单走 handle、发起页走 start,同一颗钮一条点不动一条点得动,人只会觉得锁时灵时不灵。 别的环节两条各管各的,不跟着并。

顺手记一条现场最容易问的一句:开锁那一刻已经在路上的单据不受这把锁管(引擎按发起那一刻 冻住的那一版图判,check(..., process=definition)),只有之后新发起的单才认这把锁;界面那一侧 读的是实库此刻那一行,所以旧单看着是灰的、真从外部通道或老页面打进来仍然办得动。要旧单也当场 吃锁,就把 check 那一处的 process 交回 None(回库读当前设计),代价是"改图不影响在途单" 这一条对锁不再成立。

/admin/task/processing(流程监控那份全部待办)暂未逐行标 oa_locked:监控页上管理员 本来就能改道终止,那一行标不标不影响他动手。要加就在 runtime.py 复用 node_approve.lock_flags(),一句 payload["oa_locked"] = ... 的事。

下面正文是最初的设计稿,读它时按上面那几处校正。

openApprove 那一层(见 node-open-approve-design.md) 解决的是「第三方按得动 OA 的审批按钮」,它没有回答另一侧:既然表态交出去了, OA 界面里那几颗钮(提交、审批 / 驳回、退回、撤回)就该点不动。本文定的就是这一层, 配在设计器同一个页签里,叫 OA 按钮锁定。

三条贯穿全文的分寸,与外部审批那一层同源:

  • 锁是通道闸,不是能力开关。第三方那三条路(/open/nodes/…/decide、 /open/tasks/{id}/execute、嵌入页面里的 decide)一律不受锁影响——它们本来就是 交出去的那一半表态。锁只管 OA 自己那几颗按钮。
  • 判据在引擎一处,界面只是提前说一遍。与 suspend(_ensure_active)、提交闸门 (gate.check)同一姿态:靠界面少放一个按钮不叫闸。
  • 锁不制造死角。每一处挡住的地方都要说清「去哪儿办」,并且留一条管理员用得上的兜底路 (干预面板),别让人对着一片灰按钮猜。

0. 一页看完

要做的事 配在哪儿 谁还能办
这一环的表态只在外部发生 流程设计器 → 选中那一环 → 「外部审批」页签 → OA 按钮锁定 第三方(三条外部通道照旧)
只锁其中几颗钮 同处 → 勾要锁的钮(默认锁 提交 / 审批 / 退回 / 撤回) 未勾的照旧
第三方备好的表态还要不要在 OA 里点头 同处 → 「外部表态仍可在 OA 确认」(allowConfirm) 默认要(confirm 模式本来就靠它落地)
审批人打开待办时看见什么 不用配,后端把那句说明算好一起回 一句「这一环的审批在 ERP 合同系统里进行」
外部系统怎么知道 OA 里没人会点 不用配:接口卡片 / task.arrived 信封 / locate 里多一个 oaLocked —
外部系统迟迟不表态,谁救 不用配:流程监控的干预面板(改道 / 终止 / 改派 / 修正 / 催办) 管理员,不看环节开关

1. 为什么得单独一层:现成那几样都差一段

现成的东西 为什么不够
环节上的 allowGoBack / allowAddTask / allowTransfer / allowRecall 那一组 它们是这一环本来有没有这个能力,与外部审批无关。把「表态归 ERP」拆成四个 allow_* 关掉,改图的人看见的是四个不相干的开关,看不出它们其实是一句话;而且它们没有「去哪儿办」那句说明,也没有分通道。
挂起(suspend / _ensure_active) 挂起冻的是整张单,execute_task 撞上就抛,不分通道——第三方那条 decide 也一起办不动。用它当锁,等于把唯一还能表态的那条路也堵了。
表单字段权限(form_perms)全设只读 只挡改格子,不挡流转:格子一格不能改,出口按钮照样点得下去。
不给这一环派待办 人在 OA 里再也看不见自己的单:批注、附件、知情全没了,auto 模式下那条已办也没了挂靠的地方。锁的是动作,不该顺手把可见性一起收掉。

差的那一段就是「按通道关掉 OA 侧的表态动作,同时把话说清楚」。

2. 配置长什么样

挂在外部审批那一段底下,不新起一个环节级配置键:

// oa_activity.config(财务复核这一环)
{
  "mode": "any",
  "openApprove": {
    "enabled": true,
    "confirm": "auto",
    "note": "ERP 合同系统",
    // ↓ 本文新增的这一段
    "oaLock": {
      "enabled": true,
      // 锁哪几颗:空 = 默认那一组(handle / start / goBack / recall),不是六颗全锁
      "actions": ["handle", "goBack", "recall"],
      // 第三方备好的表态还能不能在 OA 里点头(confirm 模式靠它落地)
      "allowConfirm": true,
      // 界面横幅;空 = 按 where 自动拼
      "text": "这一环的审批在 ERP 合同系统里进行,OA 里只读。"
    }
  }
}

继承:流程默认档 oa_process.open_approve 里同样能放 oaLock,环节显式配置逐键覆盖, 走的就是 node_approve.effective_config() 那一句,不新写合并逻辑。设计器上提供 「应用到本流程全部环节」的批量动作(与外部审批同一处入口)。

逐栏的判据:

  • enabled 默认关,且只在 openApprove.enabled 为真时有意义。没开外部审批就把锁打开, 等于这一环既没人能办、也没外部通道——发布时点名挡下(§6)。设计器页签在开关关着时 整段不显示,不给配一个永远不会生效的死配置(与开始环节收起同意 / 驳回两行同一做法)。
  • actions 是黑名单,空 = 默认那一组,不是「空 = 一颗都不锁」,也不是「六颗全锁」。 理由:勾这个开关的人要说的是「这一环交给外部了」,默认就该把表态那几颗一起锁掉; 而加签 / 转办不改表态,默认不锁。设计器上的勾选框永远把六颗摆全、默认前四颗勾上, 落库时把勾了的显式写出来——空值只可能来自手改 JSON 或 API 直配。
  • allowConfirm(默认 true)管的是那条横幅,不是审批按钮。第三方在 confirm 模式下 备好的表态,是要处理人替他点头才落引擎的;把它一起锁掉,confirm 模式的表态就永远 停在 staged 里等到过期。所以默认留着,想全交给机器就关掉——但那时确认模式必须是 auto,否则就是 §6 那条死锁。名字不跟着父级叫 confirm:父级那一格是 "confirm" | "auto" 的字符串,同名两种类型在设计器和 JSON 里来回看错。
  • text 空就自动拼:取词顺序是 text → 「这一环的审批在 {note} 里进行,OA 里不能表态」, {note} 没有就退到 apps 白名单里那个应用的名字,再没有就是「外部系统」。这一句由后端 算好放进接口响应(§4),前端不再拼第二遍——gate 那两处为了逐字对齐要盯着两个文件, 这里一份口径就够。
  • 形状不对一律当没配(dict 以外、actions 不是数组这类),与 node_config() 读 openApprove 那句同口径:脏配置不该把整条审批页拖崩。

为什么不叫 allowLocal / 再补四个 allow_*:那一组是环节的能力开关,本文这一层是 「表态权归哪一侧」,两件事挤在四个 allow_* 里,改图的人会看见四个开关却读不出因果关系, 也没有地方写那句「去哪儿办」。放在 openApprove 底下还白得两样:流程默认档的继承, 以及 problems() 那一趟发布体检顺路把锁一起验了。

3. 锁的范围:六颗钮,各对着哪个入口

actions 认这六个值。左列是 OA 界面上的动作,中列是它真正打的端点,右列是默认。

值 界面上是什么 端点 默认锁吗
handle 处理面板上按出口提交那几颗(同意 / 驳回 / 提交本环节 / 退回修改…) POST /task/{id}/execute、POST /task/batch-execute 锁
start 停在开始环节那一单的「提交」,以及发起页那颗「发起」(按下去就是建单 + 提交) POST /job/{job}/start、POST /job 锁
goBack 「退回」按钮(引擎合成线那条,不是设计器画的出口) POST /task/{id}/goback 锁
recall 已办列表与审批记录上的「撤回」 POST /taskcompleted/{id}/reset 锁
addTask 更多 → 加签 POST /task/{id}/addtask 不锁
transfer 更多 → 转办 POST /task/{id}/transfer 不锁

加签 / 转办默认不锁,是因为它们不表态:只把待办挪到别人手上。真要把「这一环的人也不许换」 写死,勾上就是;但那一档勾上之后,人请假、离职就只剩管理员改派一条路,界面上要说明白。

handle 与 goBack 各管一条路,互不重叠:设计器画的「退回修改」是一条真出口线, 从处理面板上按下去归 handle;界面上那颗「退回」按钮走 engine.go_back 的合成线,归 goBack。 分工与 node-open-approve-design.md §3 末尾那一段(「退回修改要单拉一条线,会不会撞原本 流程的退回」)一字不差:那颗按钮走的合成线既不读也不写设计器画的出口。

永远不锁的动作(不是漏了,是有意不管):

动作 为什么不锁
催办 press 催的是「去外部系统办」,正是锁上之后最需要做的事
抄送 / 分享 / 批注 / 附件 都不动流转;批注常常是两边沟通的唯一地方
终止 外部系统那边作废这张单时,OA 这边总得能落;且 work.terminated 事件本来就是对账通路
外部核验闸门的送审 / 撤回 / 重新核验 那是闸门(gate)不是表态,ExternalCheckPanel 照旧
干预面板五个动作(挂起 / 改道 / 整单催办 / 整单改派 / 修正表单)、POST /admin/task/{id}/transfer 干预层不看环节开关,这条口径早就写在 process-intervention-design.md §3:管理员存在的意义就是把卡住的单子救活。engine.transfer(admin=True) 那条路照旧。

4. 判据落在哪儿:一个 via,六处调用

引擎是所有通道的同一条路(node-open-approve-design.md §8 就靠这一点保证「外部表态也要过 字段权限、必填、公式、额度、闸门」)。所以锁不能无条件塞进 execute_task——那样第三方 也办不动了。补法是给引擎入口加一个关键字:

# engine.py:谁来按这颗钮。默认 "oa" = OA 界面,认锁;外部通道显式改口
VIA_OA = "oa"                  # OA 界面(默认:fail-safe,新调用方漏传就是「锁住」这一边)
VIA_OA_CONFIRM = "oa_confirm"  # OA 界面里替第三方点头那条横幅,认 oaLock.allowConfirm
VIA_OPEN = "open"              # /open/nodes/…/decide 与 /open/tasks/{id}/execute:不锁
VIA_EMBED = "embed"            # 嵌入页面里那一次 decide:不锁(第三方页面就在屏幕前)

判定本体放 service/node_approve.py 里新增一段(纯函数部分与现有那些同处):

def lock_of(config) -> dict          # effective config 里的 oaLock,形状不对当没配
def lock_enabled(config) -> bool     # openApprove.enabled 且 oaLock.enabled 才算开
def locked_actions(config) -> tuple  # 显式清单 / 默认那一组
def lock_where(config) -> str        # note → 应用名 → 「外部系统」
def lock_text(config) -> str         # 给人看那一句
def check(db, activity, *, action, via, actor) -> None   # 挡不住就 EngineError

check() 的位置照 _ensure_active() 那一处的姿态写:在 get_task / _ensure_active 之后、_resolve_route 之前(engine.execute_task 里)。挂起先看、再看锁、最后才轮到路由、 闸门与写回卡控——顺序要说得出理由:锁与点的是哪条出口无关,越早说越省事,也不必为一张 注定办不动的单去跑一遍公式和外部核验外呼。

六个引擎入口 × 四条通道的总表,实现与验收都照着它核:

引擎入口 via 调用方 受哪一栏管
execute_task oa runtime.py /task/{id}/execute、/task/batch-execute actions 里的 handle
execute_task oa_confirm runtime.py /task/{id}/node-decision/{id}/confirm allowConfirm
execute_task open openapi.py /open/nodes/…/decide(auto)、/open/tasks/{id}/execute 不锁
execute_task embed embed_session.decide 不锁
start_from_begin oa runtime.py /job/{job}/start actions 里的 start
start_from_begin oa_confirm runtime.py /job/{job}/node-decision/{id}/confirm allowConfirm
start_from_begin open openapi.py 停在开始环节的第三方提交 不锁
create_job oa runtime.py /job(发起页那颗「发起」,含从草稿提交) actions 里的 start
create_job open openapi.py /open/works、开始环节那句代发起 不锁
create_job embed engine._run_invoke 替父单开的调用子流程 不锁(没人按按钮)
go_back oa runtime.py /task/{id}/goback goBack
add_task oa runtime.py /task/{id}/addtask addTask
transfer oa runtime.py /task/{id}/transfer transfer
transfer 不经此闸 /admin/task/{id}/transfer(admin=True) 干预层,不锁
reset_task oa runtime.py /taskcompleted/{id}/reset recall
reset_task open /open/tasks/completed/{id}/recall 不锁

挡下来的那一句走 EngineError(→ 400),句子只在一处拼:

这一环「财务复核」的审批已交给外部系统(ERP 合同系统),OA 里不能表态。
请到 ERP 合同系统里审批;需要 OA 这边改动,请到流程监控里干预。

recall / goBack 那几颗换成各自的动词,start 那句改成「这张单还没提交出去,请到 X 里提交」。 _run_engine 会把 EngineError 收成 400 ENGINE_ERROR,/task/batch-execute 那一条 「一次事务一条」的既有承诺不变:一批里混进一条锁住的,只失败那一条并带回这句话, 其余照常办结(check_action_surface.py 早就钉着这个行为)。

5. 界面上怎么表现:口径后端算完,前端只摆

后端把「这一环锁没锁、锁了哪几颗、那句说明」在一处算好,随环节简报一起回, 前端不再推一遍继承规则(与 serializers_activity_brief() 里 skip_starter / repeat_policy 同一句承诺:前端拿到的就是运行时口径):

// serializers_activity_brief() 多一块;/job/{job}、/task/{id} 都跟着带上
"oa_lock": {
  "locked": true,
  "actions": ["handle", "goBack", "recall"],
  "allowConfirm": true,
  "where": "ERP 合同系统",
  "text": "这一环的审批在 ERP 合同系统里进行,OA 里只读。"
}

各处的表现:

位置 怎么改
TaskDetailView.vue 处理面板 现在有三档:frozen(挂起)→ 说明、!canProcess → 只读、否则处理面板。锁上时插进第四档,按钮照旧摆着但置灰,title 与横幅都写 oa_lock.text。置灰而不是摘掉,是因为审批人最需要知道的是「我本来能点什么、为什么现在不行」;挂起那种是整单冻结,语义不同,摘掉说得通。
确认横幅 外部表态那条横幅(node_decisions)不受 handle 影响,只在 oaLock.allowConfirm=false 时整段收起。那种场合发布校验保证了确认模式只能是 auto(§6 第二条),本来就不会再有 staged 表态等着人点头。
开始环节那一单的详情页 can_start 为真但 start 被锁时,「提交」置灰 + 同一句横幅;allowConfirm 开着时发起人仍能给第三方备好的表态点头。
TodoListView.vue 行上挂一个「外部审批」标签(/task/processing 每行加 oa_locked,逐行判据复用 _recall_flags() 那一套带缓存的读法);批量办理默认不勾这些行,硬勾上也能提交,逐条失败原因里就是那句 EngineError。
DoneListView.vue / 审批记录 锁了 recall 时,_recall_flags() 里加一条 blocker(现有那句「环节『X』不允许撤回」旁边一句「这一环的审批在外部系统,OA 里不能撤回」),界面上那颗撤回按钮自动变成灰 + 悬浮原因。
移动端 PWA 同一批接口,自动跟着,不需要另写一套。
待办通知 / 企微推送 可选加一句 where;不加也不算错——待办标题与详情页都会说。

前端要动的那几处:OpenApprovePanel.vue 加一块「OA 按钮锁定」(开关 + 六个勾选 + allowConfirm 开关 + 一句 text),types/index.ts 的 OpenApproveConfig 加 oaLock, utils/nodeConfig.ts 的 openApproveDigest() 在「已开放」那句后面加「OA 已锁 N 颗钮」, i18n/locales/zh.ts 与 en.ts 同步加 openApprove.lock* 与 task.oaLock* 两组词条。

6. 什么时候点名挡下

node_approve.problems() 已经在保存与发布两处逐环节跑(api/design.py),锁的体检并进去, 免费拿到那两条现成的调用点。

发布挡下(配了等于把自己锁死,不能让这种图上线):

  1. 开了 oaLock 但 openApprove.enabled 是关的 → 「这一环没开外部审批,锁上之后没人办得动」;
  2. 锁了 handle(或开始环节的 start)、确认模式是 confirm、又关掉了 oaLock.allowConfirm → 「第三方备好的表态在 OA 里没人能点头:要么把确认模式改成自动, 要么留着那句确认」;
  3. 锁了 handle 却一个决策词都没配(decisions 空)→ 「这一环没有任何表态通路」。 设计器在打开锁的当场就该报这句(与外部审批打开时那句「决策词表为空」同一处逻辑)。

面板红字,不挡发布(两种都成立,只是要知道后果):

  • 配了 timeoutAction=autoPass/autoReject 又锁了 handle → 红字写明「这一环超时不会 自动办,只提醒」。运行时的口径见 §7。
  • 锁了 goBack 且这一环唯一的纠偏出路是退回 → 提示「退不回去了,只能等外部系统重新表态 或管理员改道」。

API 直配要记得的一处:流程默认档那条写入路 design._clean_open_approve() 是逐键挑着抄的, 不认识 oaLock 就会把它悄悄丢掉——环节上那份 activity.config 是原样落库的,不受影响。 新增这一段时那一处必须一起补。

7. 外部系统不回调时,谁把这单救出来

锁上一之后,OA 侧没人能办、外部迟迟不表态,单子就会停在那一环。这不是缺陷,是锁的语义, 但兜底路必须预先说清:

  • 超时照常计时,但只提醒不代办。mark_expired() 里 timeoutAction=autoPass/autoReject 撞上锁时跳过自动办理,改成给处理人与流程管理员各发一条待阅(「这一环的审批已交给 X, 超时不自动办」)。让定时器绕过自己的锁去表态,等于把刚关上的那扇门从后面踹开。
  • 催办照发,文案点名「请到 X 里表态」——锁上之后催办唯一还有意义的方向。
  • 干预面板是兜底:改道(engine.move)、终止、整单改派、修正表单都不看环节开关; 监控里的替处理人改派走 engine.transfer(admin=True),同样不锁。真要救到「就在这一环办掉它」, 用改道绕过,而不是给锁开一个管理员后门。
  • 给第三方一个硬约束:接口卡片、task.arrived 信封、locate 响应里都加一个 oaLocked: true (与 interface / apis 同处生成,constants/openApproveApis.ts 那份跟着改, check_node_approve.py 钉住卡片键清单)。对方看到这一格就该明白:OA 里不会有人点, 必须回调,confirm 模式那条横幅也不会有人来点头。这一格比文案有用——它是给对方程序读的。

8. 边界

  • 对在途单据即时生效:引擎读的是实库那行环节配置,与 skipStarter 等一切环节配置同口径; 发布快照只作审计。中途打开锁,正在审批页上开着的那一屏会在下一次提交时撞上一句红字, 不会静默办成。
  • 挂起优先于锁:_ensure_active() 先判。两张闸叠着时,人先听见「这张单被谁挂了」。
  • 会签 / 加签:锁不改派工规则,只改点不点得动。auto 模式下第三方按 identity 点名替 哪一条待办办,与 OA 侧锁不锁无关;会签里一条被外部办了、其余人手上那条被锁住,是正常结局, 界面上那句说明要能解释它。
  • 已归档的单据不受影响:oa_work_completed 那一份行读不到环节配置,一律当「没锁」, 查看、打印、导出照常。
  • 不改权限:谁能看这一环、谁进得去详情页,照 permissions 与数据范围那套走。锁的是动作, 不是可见性。
  • allow* 与锁各说各话时以锁为准:allowGoBack=false 的环节再勾 goBack,行为不变 (本来就不能退),但设计器里那句摘要要说得清是哪一个在起作用(digest 上分开写)。
  • 锁不做审批委托 / 代理:empower_from_identity 那条代理链上的人照样被锁——他代理的是 「处理人」这个位置,那个位置此刻没有表态权。

9. 验收

  • backend/scripts/check_node_approve.py(纯函数,不连库):lock_of 的形状兜底与 流程默认 → 环节覆盖的逐键继承;actions 空值落默认那一组;lock_where 三级取词; check() 的通道判定表(同一份锁配置 × 四种 via 该挡哪几个);§6 那三条死锁判据。
  • backend/scripts/check_node_approve_api.py(连真库真服务,跑真单据):
    1. auto 模式 + 锁 → 第三方 decide 办掉这一环;另起一张同流程的单停在同一环时, OA 侧 /task/{id}/execute 被挡回 400,句子里有 where 那个系统名;
    2. confirm 模式 + 锁 + allowConfirm=true → 横幅确认成事;allowConfirm=false 时那条横幅不该出现, 直接调确认端点回 400 且句子里点名是配置关的;
    3. 锁 handle 时 /task/{id}/execute、/task/batch-execute(混一条锁住的,只失败那一条)、 /task/{id}/goback、/task/{id}/addtask、/task/{id}/transfer、 /taskcompleted/{id}/reset 各自按清单成 / 挡,挡回来的句子里有 where 那句系统名;
    4. 外部三条通道在锁着的时候全部照成:/open/tasks/{id}/execute、 /open/nodes/…/decide、嵌入 decide;/open/tasks/completed/{id}/recall 照成;
    5. 开始环节:hold 建的那一单,/job/{job}/start 被挡,第三方 decide 提交成, allowConfirm 开着时发起人的确认横幅照成;
    6. 干预路不被锁挡:monitor:work 的改派、engine.move、终止;
    7. 卡片 / 事件信封 / locate 里的 oaLocked 在,值为真。
  • backend/scripts/check_action_surface.py:批量处理逐条成事那一条在锁场景下照样成立。
  • 超时那一段:配 autoPass + 锁,跑一次监控页那个手动触发口,断言待办没被办掉、待阅发出去了。
  • 发布校验:§6 那三条各自被点名,且改对之后能发布。
  • 前端:设计器面板勾选与 openApproveDigest 那句摘要的单元测试;TaskDetailView 三档(未锁 / 锁且无横幅 / 锁且有横幅)的路径测试;TodoListView 批量选择默认不含锁行。

10. 已知边界

  • 锁不改变「第三方以待办处理人名义办」这条既有前提;它只是把 OA 这一侧的表态权收走, 不给外部系统加新身份。
  • 锁着的时候第三方反复 decide、把同一环办成 alreadyHandled,与今天一模一样:幂等台账 与已办判定都不因锁而变。
  • handle 锁不住「审批人已经在外部系统批了、又回到 OA 想把话补一句」这种需求——请走批注, 批注永远不锁。
  • 这一层不提供「按人放开」:同一环里给某个人留一颗钮,得回去用环节 / 分支拆图。按身份配 解锁条件听着灵活,实际会退化成「谁都能问一句为什么他有我没有」,与这一层要一句话讲清 的目标相反。

11. 改动清单:一次实现要碰哪些文件

文件 碰它做什么
backend/app/service/node_approve.py 新增 lock_of / lock_enabled / locked_actions / lock_where / lock_text / check;problems() 里并进去 §6 那三条
backend/app/engine/engine.py VIA_* 四个常量;六个入口(execute_task / start_from_begin / go_back / add_task / transfer / reset_task)加 via 形参并调 check();mark_expired() 撞上锁只发待阅不代办
backend/app/api/runtime.py 六个 OA 端点显式传 via(oa / oa_confirm);serializers_activity_brief() 与 /job/{job}、/task/{id} 载荷带 oa_lock;/task/processing 每行带 oa_locked;_recall_flags() 补一句 blocker
backend/app/api/openapi.py decide、/open/tasks/{id}/execute、start_from_begin、recall 传 via="open";card() 出来的那份带 oaLocked
backend/app/service/embed_session.py decide 传 via="embed"
backend/app/api/design.py _clean_open_approve() 认 oaLock 这一段(否则流程默认档会把它悄悄丢掉)
frontend/src/components/oa/design/OpenApprovePanel.vue 「OA 按钮锁定」那一块:开关 + 六个勾选 + allowConfirm + text
frontend/src/types/index.ts、utils/nodeConfig.ts、i18n/locales/{zh,en}.ts OpenApproveConfig.oaLock;digest 那句「OA 已锁 N 颗钮」;两组词条
frontend/src/views/oa/{TaskDetailView,TodoListView,DoneListView}.vue 处理面板第四档与置灰、批量选择默认排除、撤回那颗钮的 blocker 文案
frontend/src/constants/openApproveApis.ts 卡片上那份跟着带 oaLocked 的说明
backend/scripts/check_{node_approve,node_approve_api,action_surface}.py §9 那些断言