unis-oa/backend/scripts/check_node_approve_api.py

1778 lines
118 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

#!/usr/bin/env python3
"""第三方按设计器「定义的接口」调 OA 的审批按钮:跑一张真流程验整条链。
PYTHONPATH=. python3 scripts/check_node_approve_api.py
``check_node_approve.py`` 只能验到判据本身;这一份验"该成的真成了、该对上账的真的对上了":
1. **confirm 模式**:第三方表态停着,审批页(任务详情)亮出这条表态,处理人点头才走引擎那条路;
2. **bizKey 幂等**:同一趟两次表态只办一次,第二次原样回第一份;
3. **驳回表态**:处理人不认,表态作废,第三方再调只会收到「已驳回」,待办还留在手上;
4. **出口钉配**:钉了 refuse → 「退回修改」,第三方说「驳回」就必然回到发起环节;
5. **会签不点名回候选**:多条待办没带 identity,不猜;
6. **状态同步**:单据终止的那一刻,还停着的表态同事务作废;
7. **撤回已办**:第三方从对账接口拿到那条已办的号,撤自己办过的那一步,待办重新落回处理人手上;
8. **事件信封**:task.arrived 的载荷里带着待办号与接口卡片,对方收到通知就能动手;
9. **主写法点名环节**:``/open/nodes/{单号}/{环节id}/decide``,卡片、事件信封、``locate``
递出去的 ``interface`` 就是这一条,两个号都替对方填好了;结论那一格叫 ``result``
(老名 ``status`` / ``decision`` 继续认——改名不该把已经接上的人当场停摆),回显那一格
与请求同名,表态自身的生命周期叫 ``state``,与 ``work.status``(单据在不在跑)分得开;
10. **结论词翻不出来时把认得的词念回去**:默认那份定位不带 ``decisions`` 那张表了,
报错里就得补上,不然对方要多一次往返才知道自己该发什么;
11. **定位默认只回那几块**:``/open/nodes/locate`` 默认回瘦的那份(哪张单、停在哪个流程哪个
环节、还能不能表态),带 ``detail=full`` 才连那张接口卡片与全套清单一起回;
11. **省掉环节那一段也能按那颗钮**(``/open/nodes/{单号}/decide``):环节由 OA 认当前该表
态的那一环,给图简单、调用即时的对接方。认不出唯一一环就回候选:并行分支同时停在两环
上点名,停着的环节没开接口回笼统话,开了没对这个应用开口回 403;认出环节之后与点名那条
走的是同一段代码(同一本幂等账);
10. **地址里那一段是流程编号**:第三方手里只有单子上那个号与 job 号,流程定义的内部 id
不再是入场券——同号撞车、地址与报文各说一张单、只写 id 不带 work、单不归这条流程,
一条条点名;老卡片那种写法(id + 报文 work)继续认。
跑完连自己造的应用、订阅、流程、单据、表态一起删干净。
"""
from __future__ import annotations
import sys
import time
from datetime import datetime, timedelta
import json
from sqlalchemy import delete, select
from starlette.testclient import TestClient
from app import models
from app.db import SessionLocal
from app.engine import engine
from app.main import app
from app.security import create_access_token
from app.service import autofill, embed_session, numbering, personref
STAMP = datetime.now().strftime("%m%d%H%M%S")
APP_CODE = f"node_approve_{int(time.time())}"
HOOK_CODE = f"node_approve_hook_{int(time.time())}"
PROCESS_NAME = f"外部审批校验流程 {STAMP}"
FAILS: list[str] = []
PASSED = 0
CLEANUP: dict = {}
def check(label: str, condition, detail: str = "") -> None:
global PASSED
if condition:
PASSED += 1
print(f"[通过] {label}")
else:
FAILS.append(label)
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
def build_process(db, approver_ref: str, *, confirm: str, tail: bool = False, lookup: list[str] | None = None) -> str:
"""begin → 人工审批(开了外部审批)→ [tail: 还有一环] → end;驳回那条线钉回 begin。
撤回的验收要拿 tail 版:办结归档的单不允许撤回(撤回最后一步等于改归档记录),
得让被撤回的那一步后面还有一环,撤得动才验得出。
"""
form = models.FormElement(name=f"外部审批校验表单 {STAMP}", content={"fields": []})
db.add(form)
db.flush()
process = models.Process(name=PROCESS_NAME, category="check", enabled=True, published=True,
latest_form=form.id, latest_form_name=form.name)
db.add(process)
db.flush()
begin = models.Activity(process=process.id, type="begin", name="发起申请", order_number=0)
manual = models.Activity(process=process.id, type="manual", name="财务复核", order_number=1,
form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}],
"openApprove": {
"enabled": True,
"apps": [APP_CODE],
"confirm": confirm,
"decisions": {"APPROVED": "agree", "REJECTED": "refuse"},
"routes": {"refuse": "退回修改"},
"fields": [],
"opinion": {"agree": "经 ERP 对账核验一致,同意。{serial}"},
**({"lookup": lookup} if lookup else {}),
}})
activities = [begin, manual]
if tail:
next_manual = models.Activity(process=process.id, type="manual", name="总监审批", order_number=2,
form=form.id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}]})
end = models.Activity(process=process.id, type="end", name="结束", order_number=3)
activities = [begin, manual, next_manual, end]
else:
end = models.Activity(process=process.id, type="end", name="结束", order_number=2)
activities = [begin, manual, end]
db.add_all(activities)
db.flush()
routes = [
models.Route(process=process.id, name="提交", from_activity=begin.id, to_activity=manual.id),
models.Route(process=process.id, name="重新提交", from_activity=begin.id, to_activity=manual.id, order_number=1),
models.Route(process=process.id, name="退回修改", from_activity=manual.id, to_activity=begin.id),
models.Route(process=process.id, name="通过", from_activity=manual.id,
to_activity=(next_manual.id if tail else end.id)),
]
if tail:
routes.append(models.Route(process=process.id, name="通过", from_activity=next_manual.id, to_activity=end.id))
db.add_all(routes)
db.commit()
return process.id
def build_process_begin(db, approver_ref: str, *, confirm: str, auto_start: bool = False,
serial_prefix: str = "", begin_lock: dict | None = None,
require_field: bool = False, with_applicant: bool = False) -> str:
"""begin(开了外部审批,只认提交)→ 人工审批 → end。
``auto_start`` 那一档是给"没有单据时代为发起"用的:勾上之后第三方一句 decide 就该把
这张单发起来并提交掉,不必先调一次建单。
``serial_prefix`` 给这张表单配一个真编号格:占号那一条要看"这个号是不是 OA 自己排出去的"
(按排号那本账认回流程),没有前缀的号认不出归属,那一档就只能靠 bizKey 认趟。
"""
fields = ([{"key": "processNo", "type": "auto", "auto": "serial", "label": "流程编号",
"autoRule": {"prefix": serial_prefix, "date": "YYYYMMDD", "length": 4, "period": "day"}}]
if serial_prefix else [])
# 代发要把整张单发起来,就躲不开发起那一步的必填校验:给这一档配一格必填,
# 验的是"缺必填时回得清缺哪一格、且库里不会留下半张单"
if require_field:
fields = fields + [{"key": "reason", "type": "text", "label": "申请事由", "required": True}]
# 生产那张费用报销单的「申请人」就是 ``auto: creator`` 的选人格:这一格要用来验
# "拼给人看的那句参数值不许占住系统带出格",占住了落库会是一个字符串而不是一串人员引用
if with_applicant:
fields = fields + [{"key": "applicant", "type": "user", "auto": "creator",
"label": "申请人", "required": True}]
form = models.FormElement(name=f"开始环节审批表单 {STAMP}", content={"fields": fields})
db.add(form)
db.flush()
process = models.Process(name=f"开始环节外部审批流程 {STAMP}", category="check", enabled=True,
published=True, latest_form=form.id, latest_form_name=form.name)
db.add(process)
db.flush()
begin = models.Activity(process=process.id, type="begin", name="发起申请", order_number=0,
config={"openApprove": {
"enabled": True,
"apps": [APP_CODE],
"confirm": confirm,
**({"autoStart": True} if auto_start else {}),
# AGREE 是内置三词之一:第三方那一套词不肯改时,
# 靠这张表把它改判成提交(表里配的排在内置词前面)
"decisions": {"SUBMITTED": "submit", "PASSED": "agree", "AGREE": "submit"},
"opinion": {"submit": "经 ERP 核验,提交。{serial}"},
**({"oaLock": begin_lock} if begin_lock else {}),
}})
manual = models.Activity(process=process.id, type="manual", name="财务复核", order_number=1,
form=form.id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}]})
end = models.Activity(process=process.id, type="end", name="结束", order_number=2)
db.add_all([begin, manual, end])
db.flush()
db.add_all([
models.Route(process=process.id, name="提交", from_activity=begin.id, to_activity=manual.id),
models.Route(process=process.id, name="通过", from_activity=manual.id, to_activity=end.id),
])
db.commit()
return process.id
def build_process_parallel(db, approver_ref: str) -> str:
"""begin → 并行 → 两条分支各开外部审批 → 汇总 → end。
验的是"认不出唯一一环就不猜":这张单同时停在两环上,两条都开着接口,
短地址赌哪一条都可能办到另一条线上去,得回候选让对方点名。
"""
form = models.FormElement(name=f"并行外部审批表单 {STAMP}", content={"fields": []})
db.add(form)
db.flush()
process = models.Process(name=f"并行外部审批流程 {STAMP}", category="check", enabled=True,
published=True, latest_form=form.id, latest_form_name=form.name)
db.add(process)
db.flush()
begin = models.Activity(process=process.id, type="begin", name="发起申请", order_number=0)
fork = models.Activity(process=process.id, type="parallel", name="并行审批", order_number=1)
open_cfg = {"enabled": True, "apps": [APP_CODE], "confirm": "confirm",
"decisions": {"APPROVED": "agree", "REJECTED": "refuse"}}
line_a = models.Activity(process=process.id, type="manual", name="部门复核", order_number=2, form=form.id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}],
"openApprove": dict(open_cfg)})
line_b = models.Activity(process=process.id, type="manual", name="财务复核", order_number=2, form=form.id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}],
"openApprove": dict(open_cfg)})
join = models.Activity(process=process.id, type="merge", name="汇总", order_number=3)
end = models.Activity(process=process.id, type="end", name="结束", order_number=4)
db.add_all([begin, fork, line_a, line_b, join, end])
db.flush()
db.add_all([
models.Route(process=process.id, name="提交", from_activity=begin.id, to_activity=fork.id),
models.Route(process=process.id, name="部门线", from_activity=fork.id, to_activity=line_a.id),
models.Route(process=process.id, name="财务线", from_activity=fork.id, to_activity=line_b.id,
order_number=1),
models.Route(process=process.id, name="部门完成", from_activity=line_a.id, to_activity=join.id),
models.Route(process=process.id, name="财务完成", from_activity=line_b.id, to_activity=join.id,
order_number=1),
models.Route(process=process.id, name="汇总", from_activity=join.id, to_activity=end.id),
])
db.commit()
return process.id
def start_work(db, process_id: str, actor: engine.Actor, title: str, data: dict | None = None) -> str:
result = engine.create_job(db, process_id=process_id, actor=actor, data=dict(data or {}), title=title)
db.commit()
return str(result.work.job)
def pending_task_of(db, job: str, activity_name: str):
work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_none()
if work is None:
return None, None
rows = db.execute(
select(models.Task).where(models.Task.job == job, models.Task.status == "pending",
models.Task.activity_name == activity_name)
.order_by(models.Task.id)
).scalars().all()
return work, (rows[0] if rows else None)
def main() -> int:
db = SessionLocal()
client = TestClient(app, raise_server_exceptions=False)
user = db.get(models.User, 1)
if user is None:
print("[跳过] 库里没有 1 号用户,这一项校不了")
return 0
try:
return _run_body(db, client, user)
finally:
cleanup(db)
def _run_body(db, client, user) -> int:
approver_ref = personref.ref_of(user)
token, _ = create_access_token(str(user.id))
headers = {"Authorization": f"Bearer {token}"}
actor = engine.Actor.from_ref(db, user, approver_ref)
# ------------------------------------------------------------- 应用与令牌
created = client.post("/api/v1/design/open/apps", headers=headers, json={
"code": APP_CODE, "name": f"外部审批校验 {STAMP}",
"scopes": ["process:read", "work:read", "task:read", "task:write", "work:write"],
})
if created.status_code >= 400:
print(f"[跳过] 建开放应用失败({created.status_code}):{created.text[:160]}")
return 0
app_data = created.json().get("data") or {}
CLEANUP["app"] = APP_CODE
got_token = client.post("/api/v1/open/token", json={
"appKey": app_data.get("appKey", ""), "appSecret": app_data.get("appSecret", "")})
open_token = str((got_token.json() or {}).get("data", {}).get("accessToken") or "")
check("换到了开放平台访问令牌", bool(open_token), got_token.text[:160])
open_headers = {"Authorization": f"Bearer {open_token}"}
# ------------------------------------------------------------- 事件订阅(信封验卡)
hook = client.post("/api/v1/design/open/webhooks", headers=headers, json={
"code": HOOK_CODE, "name": f"外部审批校验订阅 {STAMP}",
"url": "https://erp.invalid/hooks", "events": ["task.arrived"],
"processes": [], "sendData": False,
})
check("建好了事件订阅", hook.status_code < 400, hook.text[:160])
if hook.status_code < 400:
CLEANUP["hook"] = HOOK_CODE
# ------------------------------------------------------------- 单据一:confirm 模式 + 人确认
process_id = build_process(db, approver_ref, confirm="confirm")
CLEANUP["process"] = process_id
job1 = start_work(db, process_id, actor, f"外部审批校验单 {STAMP} 一号")
CLEANUP["jobs"] = [job1]
work, task = pending_task_of(db, job1, "财务复核")
check("单据走到了开了外部审批的那一环", task is not None, job1)
if task is None:
return 1
task_id1 = str(task.id)
serial1 = str(work.serial or "")
# 信封:task.arrived 的载荷里得有待办号与接口卡片
db.rollback()
event = db.execute(
select(models.OpenEvent).where(models.OpenEvent.event == "task.arrived",
models.OpenEvent.job == job1)
.order_by(models.OpenEvent.id.desc())
).scalars().first()
payload = (event.payload or {}) if event is not None else {}
check("task.arrived 信封带了待办号与处理人", str((payload.get("task") or {}).get("id") or "") == task_id1,
str(payload.get("task"))[:120])
card1 = payload.get("openApprove") or {}
check("task.arrived 信封带了接口卡片(主地址把单号与当前环节 id 都填好了,照抄就能调)",
str(card1.get("interface") or "")
== f"POST /api/v1/open/nodes/{serial1 or job1}/{task.activity}/decide"
and str(card1.get("interfaceCurrent") or "") == f"POST /api/v1/open/nodes/{serial1 or job1}/decide"
and card1.get("routes") == {"refuse": "退回修改"},
str(card1)[:200])
check("信封那张卡片把全套对接接口一并递出(对方不必再要一份会漂的文档)",
[str(item.get("path") or "") for item in card1.get("apis") or []][:3]
== ["/api/v1/open/token", "/api/v1/open/nodes/locate",
f"/api/v1/open/nodes/{serial1 or job1}/{task.activity}/decide"]
and str(((card1.get("apis") or [{}])[2]).get("alt") or "")
== f"/api/v1/open/nodes/{serial1 or job1}/decide",
str(card1.get("apis"))[:220])
decided = client.post(f"/api/v1/open/nodes/{process_id}/{task.activity}/decide",
headers=open_headers,
json={"work": serial1, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-1"})
payload = (decided.json() or {}).get("data") or {}
check("confirm 模式:表态停着等确认,没有直接办掉",
decided.status_code == 200 and payload.get("staged") is True, f"{decided.status_code} {str(decided.text)[:160]}")
decision_id1 = str(payload.get("decisionId") or "")
detail = client.get(f"/api/v1/task/{task_id1}", headers=headers).json().get("data") or {}
banners = detail.get("node_decisions") or []
check("审批页(任务详情)亮出了这条表态",
len(banners) == 1 and str(banners[0].get("id") or "") == decision_id1, str(banners)[:160])
# 上一条没成时这里得**接着跑**:整段验收里有二十来条各自独立的判据,一条没落到
# 就 IndexError 收场,等于把后面那些还没验的东西一起赔进去
check("意见模板按 {serial} 渲染好了",
bool(banners) and str(banners[0].get("opinion") or "").endswith(serial1),
str((banners[0] if banners else {}).get("opinion")))
replay = client.post(f"/api/v1/open/nodes/{process_id}/{task.activity}/decide",
headers=open_headers,
json={"work": serial1, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-1"})
replay_payload = (replay.json() or {}).get("data") or {}
check("同一 bizKey 再调:原样回那份停着的表态", replay.status_code == 200 and replay_payload.get("alreadyStaged") is True,
f"{replay.status_code} {str(replay.text)[:160]}")
# 这一格如今叫 result,老卡片上叫过 status 与 decision:三个名字都收,认的是同一本账
legacy_ok, legacy_detail = True, ""
for label, words in (("result", {"result": "APPROVED"}),
("status", {"status": "APPROVED"}),
("decision", {"decision": "APPROVED"}),
("空的 status + 有值的 decision", {"status": "", "decision": "APPROVED"}),
("空的 result + 有值的 status", {"result": "", "status": "APPROVED"})):
again = client.post(f"/api/v1/open/nodes/{process_id}/{task.activity}/decide",
headers=open_headers,
json={"work": serial1, "bizKey": f"BIZ-{STAMP}-1", **words})
got = (again.json() or {}).get("data") or {}
if not (again.status_code == 200 and got.get("alreadyStaged") is True
and str(got.get("decisionId") or "") == decision_id1):
legacy_ok = False
legacy_detail = f"{label}: {again.status_code} {str(again.text)[:120]}"
break
check("result 与两个老名都认(含老名留空那种写法):回的始终是第一次那一份",
legacy_ok, legacy_detail)
# 默认的 locate 不再每次带那张词表:翻不出来时,报错里就得把认得的词念回去
bogus = client.post(f"/api/v1/open/nodes/{process_id}/{task.activity}/decide",
headers=open_headers,
json={"work": serial1, "result": "PASSED", "bizKey": f"BIZ-{STAMP}-1b"})
bg = str((bogus.json() or {}).get("message", ""))
check("结论词翻不出来:400 里把这一环认得的词一并念回去(不必再调一次 full 问)",
bogus.status_code == 400 and "APPROVED" in bg and "REJECTED" in bg, bg[:200])
confirmed = client.post(f"/api/v1/task/{task_id1}/node-decision/{decision_id1}/confirm",
headers=headers)
check("处理人点头:走引擎那条路办掉了", confirmed.status_code == 200, f"{confirmed.status_code} {str(confirmed.text)[:160]}")
db.rollback()
done_row = db.execute(select(models.TaskCompleted).where(models.TaskCompleted.task == task_id1)).scalars().first()
check("已办台账里的办理人就是处理人本人", done_row is not None and done_row.identity == approver_ref,
getattr(done_row, "identity", ""))
check("走的是钉配之外按名匹到的「通过」出口", str(getattr(done_row, "route_name", "") or "") == "通过",
getattr(done_row, "route_name", ""))
# ------------------------------------------------------------- 单据二:驳回表态
job2 = start_work(db, process_id, actor, f"外部审批校验单 {STAMP} 二号")
CLEANUP["jobs"].append(job2)
work2, task2 = pending_task_of(db, job2, "财务复核")
task_id2 = str(task2.id)
decided2 = client.post(f"/api/v1/open/nodes/{process_id}/{task2.activity}/decide",
headers=open_headers,
json={"work": job2, "result": "REJECTED", "bizKey": f"BIZ-{STAMP}-2"})
decision_id2 = str(((decided2.json() or {}).get("data") or {}).get("decisionId") or "")
check("驳回也停在等确认,出口已按钉配落到「退回修改」",
decided2.status_code == 200 and str(((decided2.json() or {}).get("data") or {}).get("route") or "") == "退回修改",
str(decided2.text)[:160])
rejected = client.post(f"/api/v1/task/{task_id2}/node-decision/{decision_id2}/reject",
headers=headers, json={"opinion": "这单我得自己看"})
check("处理人驳回:表态作废,待办留在手上",
rejected.status_code == 200 and db.get(models.Task, task_id2) is not None, str(rejected.text)[:160])
db.rollback()
again = client.post(f"/api/v1/open/nodes/{process_id}/{task2.activity}/decide",
headers=open_headers,
json={"work": str(work2.serial or ""), "result": "REJECTED", "bizKey": f"BIZ-{STAMP}-2"})
ar2 = (again.json() or {}).get("data") or {}
check("处理人驳回之后第三方拿同一个 bizKey 再推:重新停一条等确认(那个号换不掉,挡死就等于卡住)",
again.status_code == 200 and ar2.get("staged") is True and bool(str(ar2.get("decisionId") or "")),
f"{again.status_code} {str(again.text)[:200]}")
check("重停那一句要说清上一次是谁驳回的",
"驳回" in str(ar2.get("note") or "") and "bizKey" in str(ar2.get("note") or ""),
str(ar2.get("note"))[:200])
db.rollback()
rows2 = db.execute(select(models.NodeDecision).where(
models.NodeDecision.biz_key == f"BIZ-{STAMP}-2")).scalars().all()
check("驳回后重推仍只有一行台账,且回到等确认(唯一键就地改写,确认痕迹跟着清掉)",
len(rows2) == 1 and rows2[0].status == "staged" and not rows2[0].confirm_name,
f"{len(rows2)} 行 / {[(getattr(r, 'status', ''), getattr(r, 'confirm_name', '')) for r in rows2]}")
# ------------------------------------------------------------- 单据三:auto 模式 + 撤回
process_auto = build_process(db, approver_ref, confirm="auto", tail=True)
CLEANUP["process_auto"] = process_auto
job3 = start_work(db, process_auto, actor, f"外部审批校验单 {STAMP} 三号")
CLEANUP["jobs"].append(job3)
work3, task3 = pending_task_of(db, job3, "财务复核")
task_id3 = str(task3.id)
# 这一段起改成新写法:号在地址里(流程编号或 job 号都行),报文不再带 work——
# 上面那几条走的是老卡片那种「地址放流程 id + 报文带 work」,两种写法都得一直是通的
auto_decided = client.post(f"/api/v1/open/nodes/{job3}/{task3.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-3"})
auto_payload = (auto_decided.json() or {}).get("data") or {}
check("auto 模式:当场办掉,不等人",
auto_decided.status_code == 200 and auto_payload.get("handled") is True, str(auto_decided.text)[:160])
db.rollback()
auto_done = db.execute(select(models.TaskCompleted).where(models.TaskCompleted.task == task_id3)).scalars().first()
check("auto 办理的留痕署名是「经节点审批接口(自动)」那一路",
auto_done is not None and str(auto_done.opinion or "").startswith("经 ERP 对账核验一致"),
getattr(auto_done, "opinion", ""))
if auto_done is None:
check("撤回段:没有可撤的已办(前面 auto 没办成)", False, "auto_done 为空")
else:
# 撤回要点名一条已办。这一份从**开放接口**里拿(不是从库里捞):对方收尾时
# 手上只有这一份响应,响应里没有这个号,那条 recall 就等于开着却没人用得上
ledger = client.get(f"/api/v1/open/works/{job3}", headers=open_headers)
lp = (ledger.json() or {}).get("data") or {}
mine = [item for item in (lp.get("handled") or [])
if str(item.get("id") or "") == str(auto_done.id)]
check("对账接口带出已办台账:撤回要点名的那个号就在 handled[].id 里",
ledger.status_code == 200 and len(mine) == 1
and str(mine[0].get("activity") or "") == "财务复核",
str(lp.get("handled"))[:200])
recall_id = str(mine[0]["id"]) if mine else str(auto_done.id)
stranger = client.post(f"/api/v1/open/tasks/completed/{recall_id}/recall",
headers=open_headers, json={"identity": "nobody@unisoa"})
check("换个人来撤:引擎那句「只能撤回本人处理的待办」照旧挡",
stranger.status_code == 400, str(stranger.text)[:160])
recalled = client.post(f"/api/v1/open/tasks/completed/{recall_id}/recall",
headers=open_headers, json={"identity": approver_ref})
check("第三方撤回自己办的那一步:撤得动", recalled.status_code == 200, str(recalled.text)[:160])
db.rollback()
back_rows = db.execute(
select(models.Task).where(models.Task.job == job3, models.Task.status == "pending")
).scalars().all()
back = next((t for t in back_rows if t.activity_name == "财务复核"), None)
check("撤回后待办重新落回处理人手上,后续环节收掉了",
back is not None and back.identity == approver_ref
and all(t.activity_name != "总监审批" for t in back_rows),
f"{[(t.activity_name, t.identity) for t in back_rows]}")
# ------------------------------------------------------------- 状态同步:终止那一刻表态作废
job4 = start_work(db, process_id, actor, f"外部审批校验单 {STAMP} 四号")
CLEANUP["jobs"].append(job4)
work4, task4 = pending_task_of(db, job4, "财务复核")
task4_id = str(task4.id)
decided4 = client.post(f"/api/v1/open/nodes/{job4}/{task4.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-4"})
check("第四张单的表态也停着等确认", decided4.status_code == 200, str(decided4.text)[:120])
terminated = client.post(f"/api/v1/open/works/{job4}/terminate",
headers=open_headers, json={"identity": approver_ref, "opinion": "ERP 那边作废了"})
check("第三方把这张单终止了", terminated.status_code == 200, str(terminated.text)[:160])
db.rollback()
staged_left = db.execute(
select(models.NodeDecision).where(models.NodeDecision.job == job4)
).scalars().all()
check("单据终止的那一刻,还停着的表态同事务作废",
len(staged_left) == 1 and staged_left[0].status == models.NodeDecision.STATUS_EXPIRED
and "终止" in str(staged_left[0].confirm_note or ""),
f"{[(str(r.status), str(r.confirm_note)) for r in staged_left]}")
detail4 = client.get(f"/api/v1/task/{task4_id}", headers=headers).json().get("data") or {}
check("审批页不再亮死人单据的横幅", not (detail4.get("node_decisions") or []), str(detail4.get("node_decisions"))[:120])
# ------------------------------------------------------------- 关着的环节 / 没权限的应用
off = client.post(f"/api/v1/open/nodes/{process_id}/{begin_id_of(db, process_id)}/decide",
headers=open_headers, json={"work": serial1, "result": "APPROVED"})
check("没开外部审批的环节回笼统话(不作探针)", off.status_code in (400, 404), str(off.text)[:120])
# ------------------------------------------------------------- 拉取式定位:不订阅事件,自己来问参数
erp_no = f"ERP-{STAMP}-LOCATE"
process_locate = build_process(db, approver_ref, confirm="auto", lookup=["erpNo"])
CLEANUP["process_locate"] = process_locate
job5 = start_work(db, process_locate, actor, f"外部审批校验单 {STAMP} 五号", data={"erpNo": erp_no})
CLEANUP["jobs"].append(job5)
work5, task5 = pending_task_of(db, job5, "财务复核")
check("五号单走到了开了外部审批的那一环", task5 is not None, job5)
serial5 = str(work5.serial or "")
task5_id = str(task5.id)
loc_manual = str(task5.activity)
by_key = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"keys": {"erpNo": erp_no}, "detail": "full"})
lk = (by_key.json() or {}).get("data") or {}
check("按查找字段定位:回的是这张单", by_key.status_code == 200 and str(lk.get("work", {}).get("job")) == job5,
f"{by_key.status_code} {str(by_key.text)[:160]}")
check("定位带回当前环节的 processId / activityId",
str(lk.get("process", {}).get("id")) == process_locate and str(lk.get("activity", {}).get("id")) == loc_manual,
f"{lk.get('process')} {lk.get('activity')}")
check("定位带回这条待办与出口", str((lk.get("task") or {}).get("id")) == task5_id
and (lk.get("task") or {}).get("routes") == ["退回修改", "通过"], str(lk.get("task")))
check("定位带回的接口卡片把单号与当前环节 id 都填好了(照抄这一条,环节 id 不必自己拼)",
str((lk.get("openApprove") or {}).get("interface"))
== f"POST /api/v1/open/nodes/{serial5 or job5}/{loc_manual}/decide"
and str((lk.get("openApprove") or {}).get("interfaceCurrent"))
== f"POST /api/v1/open/nodes/{serial5 or job5}/decide",
str(lk.get("openApprove"))[:200])
check("定位带回的卡片同样带全套接口,第一条就是换令牌(对方从零也能起步)",
str((((lk.get("openApprove") or {}).get("apis") or [{}])[0]).get("path") or "")
== "/api/v1/open/token", str((lk.get("openApprove") or {}).get("apis"))[:200])
by_work = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"work": job5})
lw = (by_work.json() or {}).get("data") or {}
check("按单号(job 号)定位:同一套参数(与查找字段同口径)",
by_work.status_code == 200 and str(lw.get("activity", {}).get("id")) == loc_manual
and str(lw.get("process", {}).get("id")) == process_locate, f"{by_work.status_code} {str(by_work.text)[:160]}")
# 定位是每次表态前都要调的,默认这份只留「是哪张单、停在哪个环节、还能不能表态」
check("定位默认回瘦的那份:卡片与待办都不带,拼地址要的两个号照样齐",
lw.get("openApprove") is None and lw.get("task") is None
and sorted((lw.get("work") or {}).keys()) == ["job", "serial", "status"]
and lw.get("pending") is True and lw.get("activity", {}).get("id") == loc_manual,
str(lw)[:200])
lwf = (client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": job5, "detail": "full"}).json() or {}).get("data") or {}
check("detail=full 才把那张卡片与待办一并带回(决策词、可写字段那几样配一次看一次的东西)",
bool((lwf.get("openApprove") or {}).get("interface"))
and str((lwf.get("task") or {}).get("id")) == task5_id, str(lwf)[:200])
by_serial = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"work": serial5})
check("单号撞了不止一张单:回歧义让报 job 号,不抛 500、不赌哪张",
by_serial.status_code == 400 and "job" in str((by_serial.json() or {}).get("message", "")), str(by_serial.text)[:160])
bad_field = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"keys": {"noSuchField": "x"}})
check("没配成查找键的字段点名挡下", bad_field.status_code == 400
and "noSuchField" in str((bad_field.json() or {}).get("message", "")), str(bad_field.text)[:160])
empty = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={})
check("单号与查找字段一个都不带 = 点名要补", empty.status_code == 400, str(empty.text)[:120])
# 第三方最常踩的一坑:拿自己那套单号来表态,而 OA 这头这张单还没建起来。
# 这句不能只说"不在跑"——那会让人去翻一张根本不存在的单的归档记录
ghost = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": f"BX-{STAMP}-从没发起过"})
gm = str((ghost.json() or {}).get("message", ""))
check("OA 没发出过的那个号:说清「先建单再来」,不含糊成「已办结 / 终止」",
ghost.status_code == 400 and "open/works" in gm and "hold" in gm, gm[:240])
no_key = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"keys": {"erpNo": f"ERP-{STAMP}-对不上"}})
km = str((no_key.json() or {}).get("message", ""))
check("查找字段配过但值对不上:回的是「值没对上」,不是「这个号 OA 没用过」",
no_key.status_code == 400 and "查找字段" in km and "open/works" not in km, km[:240])
done5 = client.post(f"/api/v1/open/nodes/{process_locate}/{loc_manual}/decide",
headers=open_headers,
json={"work": job5, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-5"})
check("把五号单按卡办掉(auto 当场办结),验办结后再定位",
done5.status_code == 200 and ((done5.json() or {}).get("data") or {}).get("handled") is True, str(done5.text)[:160])
after = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": job5, "detail": "full"})
la = (after.json() or {}).get("data") or {}
check("办结后再定位:回「已归档不用再表态」,不硬造卡片",
after.status_code == 200 and la.get("pending") is False and not (la.get("openApprove"))
and "归档" in str(la.get("note", "")), str(after.text)[:160])
# ------------------------------------------------------------- 开始环节的第三方审批
# 语义:开始环节的「审批按钮」就是那颗提交钮。hold 建的单停在开始环节,
# 第三方 decide 表态(confirm 等发起人点头 / auto 当场提交),或发起人自己提交。
process_begin = build_process_begin(db, approver_ref, confirm="confirm")
CLEANUP["process_begin"] = process_begin
begin_id = begin_id_of(db, process_begin)
held = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 六号", "data": {}, "hold": True})
hp = (held.json() or {}).get("data") or {}
job6 = str((hp.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job6)
check("hold 建单:单建出来了,停在开始环节",
held.status_code == 200 and str((hp.get("work") or {}).get("status")) == "running", str(held.text)[:160])
db.rollback()
work6 = db.execute(select(models.Work).where(models.Work.job == job6)).scalar_one_or_none()
check("停在开始环节:没流转、没待办、还没提交出去",
work6 is not None and work6.activity == begin_id and work6.activity_type == "begin"
and db.execute(select(models.Task).where(models.Task.job == job6)).scalars().first() is None,
f"{getattr(work6, 'activity', None)} {getattr(work6, 'activity_type', None)}")
events6 = db.execute(select(models.OpenEvent).where(
models.OpenEvent.job == job6, models.OpenEvent.event == "work.submitted")).scalars().all()
check("停着的单不算提交:work.submitted 事件没发", len(events6) == 0, f"{len(events6)}")
lk6 = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": job6, "detail": "full"})
l6 = (lk6.json() or {}).get("data") or {}
serial6 = str(getattr(work6, "serial", "") or "") if work6 is not None else ""
check("locate 停在开始环节的单:回 pending、回接口卡片(端点里填的是这张单的号)",
lk6.status_code == 200 and l6.get("pending") is True
and str((l6.get("openApprove") or {}).get("interface"))
== f"POST /api/v1/open/nodes/{serial6 or job6}/{begin_id}/decide"
and "开始环节" in str(l6.get("note", "")), str(l6.get("note")))
card6 = (l6.get("openApprove") or {})
works6 = next((row for row in (card6.get("apis") or [])
if str(row.get("path") or "") == "/api/v1/open/works"), {})
# 卡片自洽这件事才是重点:样例里那个词必须在卡片自己那份 decisions 里,
# 且翻出来是提交——对方照卡片抄,抄出来一次 400 就是我们自己的文档在骗人
sample6 = str((card6.get("sample") or {}).get("result") or "")
check("停在开始环节那张单递出去的卡片:样例照抄就能用(那个词翻出来就是提交),建单那条教了先带 hold",
str((card6.get("decisions") or {}).get(sample6.casefold()) or "") == "submit"
and "hold" in str(works6.get("when") or ""), f"{card6.get('sample')} {str(works6)[:120]}")
d6 = client.get(f"/api/v1/job/{job6}", headers=headers).json().get("data") or {}
check("单据详情把「停在开始环节 / 可以提交」递给了界面",
d6.get("at_begin") is True and d6.get("can_start") is True,
f"{d6.get('at_begin')} {d6.get('can_start')}")
wrong = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job6, "result": "PASSED", "bizKey": f"BIZ-{STAMP}-6w"})
wm = str((wrong.json() or {}).get("message", ""))
check("开始环节只认提交:映到同意的词当场挡下",
wrong.status_code == 400 and "提交" in wm, str(wrong.text)[:160])
check("挡下那句把要补的那一行念出来(第三方不肯改词时,这是唯一出路)",
"PASSED → 提交" in wm and "决策词表" in wm, wm[:220])
st6 = client.post(f"/api/v1/open/nodes/{job6}/{begin_id}/decide", headers=open_headers,
json={"result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-6",
"opinion": "ERP 对账一致,提交"})
sp = (st6.json() or {}).get("data") or {}
decision_id6 = str(sp.get("decisionId") or "")
check("confirm 模式:提交表态停着,单还停在开始环节",
st6.status_code == 200 and sp.get("staged") is True, str(st6.text)[:160])
db.rollback()
work6b = db.execute(select(models.Work).where(models.Work.job == job6)).scalar_one_or_none()
check("表态停着的那刻,单确实还没流转", work6b is not None and work6b.activity == begin_id,
getattr(work6b, "activity", ""))
d6b = client.get(f"/api/v1/job/{job6}", headers=headers).json().get("data") or {}
banners6 = d6b.get("node_decisions") or []
check("单据详情页亮出了这条表态",
len(banners6) == 1 and str(banners6[0].get("id") or "") == decision_id6, str(banners6)[:160])
check("显式给的意见原样落账(不走模板)",
str(banners6[0].get("opinion") or "") == "ERP 对账一致,提交", str(banners6[0].get("opinion")))
replay6 = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job6, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-6"})
check("同一 bizKey 再调:原样回那份停着的表态",
replay6.status_code == 200 and (replay6.json().get("data") or {}).get("alreadyStaged") is True,
str(replay6.text)[:120])
started6 = client.post(f"/api/v1/job/{job6}/start", headers=headers, json={"opinion": "我自己交"})
check("发起人亲按提交钮:单流转出去了", started6.status_code == 200, str(started6.text)[:160])
db.rollback()
work6c = db.execute(select(models.Work).where(models.Work.job == job6)).scalar_one_or_none()
check("提交之后单已离开开始环节", work6c is not None and work6c.activity != begin_id,
getattr(work6c, "activity", ""))
past = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job6, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-6p"})
check("已离开开始环节的单再 decide:说清楚,不静默重提",
past.status_code == 400 and "开始环节" in str((past.json() or {}).get("message", "")), str(past.text)[:160])
held7 = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 七号", "hold": True})
job7 = str(((held7.json() or {}).get("data") or {}).get("work", {}).get("job") or "")
CLEANUP["jobs"].append(job7)
st7 = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job7, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-7"})
decision_id7 = str(((st7.json() or {}).get("data") or {}).get("decisionId") or "")
rej7 = client.post(f"/api/v1/job/{job7}/node-decision/{decision_id7}/reject",
headers=headers, json={"opinion": "金额不对,重填"})
check("发起人驳回表态:表态作废,单还停在开始环节",
rej7.status_code == 200, str(rej7.text)[:120])
db.rollback()
work7 = db.execute(select(models.Work).where(models.Work.job == job7)).scalar_one_or_none()
check("被驳回的单仍在开始环节等提交", work7 is not None and work7.activity == begin_id,
getattr(work7, "activity", ""))
# 开始环节上没有待办行(这一单是 hold 建的,还没提交过),"有没有人等"只能看它停在哪儿:
# 停在起点就是等提交。这一条判据若只看待办,第三方那个换不掉的 bizKey 会把单永久锁死
re7 = client.post(f"/api/v1/open/nodes/{job7}/{begin_id}/decide", headers=open_headers,
json={"work": job7, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-7"})
r7 = (re7.json() or {}).get("data") or {}
check("驳回之后同一个 bizKey 再推(单还停在起点):重新停一条,不 400 锁死",
re7.status_code == 200 and r7.get("staged") is True, str(re7.text)[:200])
db.rollback()
rows7 = db.execute(select(models.NodeDecision).where(
models.NodeDecision.biz_key == f"BIZ-{STAMP}-7")).scalars().all()
check("重停的那一条仍是同一行台账(等确认,驳回痕迹已清)",
len(rows7) == 1 and rows7[0].status == "staged" and not rows7[0].confirm_name,
f"{len(rows7)} 行 / {[(getattr(r, 'status', ''), getattr(r, 'confirm_name', '')) for r in rows7]}")
again7 = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job7, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-7"})
check("重停的那一条还等点头时同一个 bizKey 再调:原样回那一条,不叠第二条横幅",
again7.status_code == 200 and (again7.json().get("data") or {}).get("alreadyStaged") is True,
str(again7.text)[:160])
held8 = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 八号", "hold": True})
job8 = str(((held8.json() or {}).get("data") or {}).get("work", {}).get("job") or "")
CLEANUP["jobs"].append(job8)
st8 = client.post(f"/api/v1/open/nodes/{process_begin}/{begin_id}/decide", headers=open_headers,
json={"work": job8, "result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-8"})
decision_id8 = str(((st8.json() or {}).get("data") or {}).get("decisionId") or "")
conf8 = client.post(f"/api/v1/job/{job8}/node-decision/{decision_id8}/confirm", headers=headers)
check("发起人点头:单据提交出去开始流转", conf8.status_code == 200, str(conf8.text)[:160])
db.rollback()
row8 = db.execute(select(models.NodeDecision).where(models.NodeDecision.id == decision_id8)).scalar_one_or_none()
work8 = db.execute(select(models.Work).where(models.Work.job == job8)).scalar_one_or_none()
check("表态台账:发起人确认、单已离开开始环节",
row8 is not None and row8.status == models.NodeDecision.STATUS_HANDLED
and row8.confirm_by == str(user.id)
and work8 is not None and work8.activity != begin_id,
f"{getattr(row8, 'status', None)} {getattr(row8, 'confirm_by', None)} {getattr(work8, 'activity', None)}")
process_begin_auto = build_process_begin(db, approver_ref, confirm="auto")
CLEANUP["process_begin_auto"] = process_begin_auto
begin_id_a = begin_id_of(db, process_begin_auto)
held9 = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin_auto, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 九号", "hold": True})
job9 = str(((held9.json() or {}).get("data") or {}).get("work", {}).get("job") or "")
CLEANUP["jobs"].append(job9)
st9 = client.post(f"/api/v1/open/nodes/{job9}/{begin_id_a}/decide", headers=open_headers,
json={"result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-9"})
check("auto 模式:表态当场提交,不等人",
st9.status_code == 200 and (st9.json().get("data") or {}).get("handled") is True, str(st9.text)[:160])
db.rollback()
work9 = db.execute(select(models.Work).where(models.Work.job == job9)).scalar_one_or_none()
check("auto 提交之后单已在流转", work9 is not None and work9.activity_type != "begin",
getattr(work9, "activity_type", ""))
# 第三方只回自己那套状态词、一个字不改(真实来路:报销单回 AGREE):
# 环节上的决策词表把内置词改判成提交,这一趟就该当场提交出去
held9b = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin_auto, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} AGREE 号", "hold": True})
job9b = str(((held9b.json() or {}).get("data") or {}).get("work", {}).get("job") or "")
CLEANUP["jobs"].append(job9b)
st9b = client.post(f"/api/v1/open/nodes/{job9b}/{begin_id_a}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"BIZ-{STAMP}-9b"})
check("决策词表把 AGREE 配成提交:开始环节照样当场提交,不再回 400",
st9b.status_code == 200 and (st9b.json().get("data") or {}).get("handled") is True,
str(st9b.text)[:200])
db.rollback()
work9b = db.execute(select(models.Work).where(models.Work.job == job9b)).scalar_one_or_none()
check("AGREE 改判的那一单真走起了流转", work9b is not None and work9b.activity_type != "begin",
f"{getattr(work9b, 'activity_type', None)} {getattr(work9b, 'activity', None)}")
row9b = db.execute(select(models.NodeDecision).where(
models.NodeDecision.biz_key == f"BIZ-{STAMP}-9b")).scalars().first()
check("落的账两头都留:他们说的 AGREE 与我们办的提交,各看一眼才查得出台阶在哪",
row9b is not None and str(getattr(row9b, "decision", "")) == "AGREE"
and str(getattr(row9b, "kind", "")) == "submit"
and str(getattr(row9b, "route", "")) == "提交",
f"{getattr(row9b, 'decision', None)} / {getattr(row9b, 'kind', None)} / {getattr(row9b, 'route', None)}")
# 第三方手里那个号有一条完全正当的来路:发起页每开一页,OA 就替这一趟占一个正式号
# (对面按它建自己的草稿)。那一页没提交时这个号既不在途也不归档,而第三方从自己
# 服务端补发时如果另排一个新号,它记的那个号还会当场作废——这就是这次联调的现场
reserved = f"RESERVED{STAMP}-1"
prekey = f"PRE{STAMP}RES"
db.add(models.EmbedSession(
token_hash=f"th_{STAMP}_reserved", prekey=prekey, source="reimb", person=str(user.id),
serial=reserved, scopes=["start"], status="open",
expires_at=datetime.now() + timedelta(hours=1)))
db.commit()
CLEANUP["prekeys"] = [prekey]
lk_res = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"work": reserved})
rm = str((lk_res.json() or {}).get("message", ""))
check("发起页占下、还没发起的那个号:不说「OA 没用过这个号」,而是说清这一趟该怎么发起",
lk_res.status_code == 400 and prekey in rm and "open/works" in rm, rm[:260])
start_res = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin_auto, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 预留号单", "hold": True, "bizKey": prekey})
sr = (start_res.json() or {}).get("data") or {}
CLEANUP["jobs"].append(str((sr.get("work") or {}).get("job") or ""))
check("第三方拿这一趟的预受理号补发:建出来就是它手里那个号,不另排一个新号",
start_res.status_code == 200 and str((sr.get("work") or {}).get("serial") or "") == reserved,
f"{start_res.status_code} {str(start_res.text)[:200]}")
decide_res = client.post(f"/api/v1/open/nodes/{reserved}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"BIZ-{STAMP}-res"})
check("从此第三方手上那个号就是能用的地址:定位、表态一路通,不必回头再问一次号",
decide_res.status_code == 200 and (decide_res.json().get("data") or {}).get("handled") is True,
str(decide_res.text)[:200])
again_res = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_begin_auto, "identity": approver_ref,
"title": f"开始环节审批单 {STAMP} 预留号单", "bizKey": prekey})
ar = (again_res.json() or {}).get("data") or {}
check("同一趟再发一次:不建第二张,把原来那张连号一起回(对方重试不会生出重复单)",
again_res.status_code == 200 and ar.get("alreadyStarted") is True
and str((ar.get("work") or {}).get("serial") or "") == reserved, str(again_res.text)[:200])
# ------------------------------------ 没有单据时由这次表态代发(开始环节那一档的开关)
# 地址里点名的就是开始环节,"没有活动流程"于是只剩一个意思:这一趟还没人发起。
# 勾上这一档,第三方一句 decide 就该把流程提交起来,而不是先被要求去建单
process_begin_start = build_process_begin(db, approver_ref, confirm="auto", auto_start=True)
CLEANUP["process_begin_start"] = process_begin_start
begin_id_s = begin_id_of(db, process_begin_start)
their_flow = f"RE-{STAMP}-他们那边的号"
one_shot = client.post(f"/api/v1/open/nodes/{their_flow}/{begin_id_s}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE",
"bizKey": f"BIZ-{STAMP}-one", "data": {}})
os_d = (one_shot.json() or {}).get("data") or {}
job_ones = str((os_d.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_ones)
check("没有活动流程时一句 decide 就把流程提交起来(回包说清代发了、单号给出来)",
one_shot.status_code == 200 and os_d.get("handled") is True
and os_d.get("startedFromDecision") is True and bool((os_d.get("work") or {}).get("serial")),
f"{one_shot.status_code} {str(one_shot.text)[:220]}")
db.rollback()
work_ones = db.execute(select(models.Work).where(models.Work.job == job_ones)).scalar_one_or_none()
check("代发的这一张真的离开了开始环节(走的是引擎那一步,不是记了个账)",
work_ones is not None and work_ones.activity != begin_id_s,
f"{getattr(work_ones, 'activity', None)} {getattr(work_ones, 'activity_type', None)}")
row_ones = db.execute(select(models.NodeDecision).where(
models.NodeDecision.biz_key == f"BIZ-{STAMP}-one")).scalars().first()
check("代发的账记的是他们说的 AGREE 与我们办的提交(与人工环节同一本账)",
row_ones is not None and str(row_ones.decision) == "AGREE" and str(row_ones.kind) == "submit",
f"{getattr(row_ones, 'decision', None)} / {getattr(row_ones, 'kind', None)}")
again_one = client.post(f"/api/v1/open/nodes/{their_flow}/{begin_id_s}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE",
"bizKey": f"BIZ-{STAMP}-one"})
check("同一趟重试不建第二张:对方自己编的号认不出归属,那种场合只认 (应用, 环节, bizKey)",
again_one.status_code == 200
and str(((again_one.json() or {}).get("data") or {}).get("work", {}).get("job") or "") == job_ones,
str(again_one.text)[:200])
db.rollback()
counted = db.execute(select(models.Work).where(models.Work.process == process_begin_start)).scalars().all()
check("这一趟从头到尾只留下一张单", len(counted) == 1, f"{len(counted)} 张")
# 地址里那个号是对方自己编的(OA 排号那本账认不出归属),按号分不出趟。这时那一张
# 被退回到开始环节,这一句就该复用那一张——再建一张只多出一个他们手上没有的号,
# 库里还留下一张没人认领的单
back_task_o = db.execute(select(models.Task).where(
models.Task.job == job_ones, models.Task.status == "pending")).scalars().first()
back_o_error = ""
if back_task_o is not None:
try:
engine.go_back(db, task_id=str(back_task_o.id),
actor=engine.Actor.from_ref(db, user, str(back_task_o.identity or approver_ref)),
opinion="再补一张发票")
db.commit()
except engine.EngineError as exc:
db.rollback()
back_o_error = str(exc)
db.rollback()
reuse_o = client.post(f"/api/v1/open/nodes/{their_flow}/{begin_id_s}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE",
"bizKey": f"BIZ-{STAMP}-one"})
ro = (reuse_o.json() or {}).get("data") or {}
check("号认不出归属、那一张又被退回开始环节:复用那一张重新提交,不另起一张",
reuse_o.status_code == 200 and ro.get("handled") is True
and str((ro.get("work") or {}).get("job") or "") == job_ones
and not back_o_error, f"{reuse_o.status_code} {back_o_error} {str(reuse_o.text)[:200]}")
db.rollback()
counted_o = db.execute(select(models.Work).where(models.Work.process == process_begin_start)).scalars().all()
check("复用之后库里仍只有一张单", len(counted_o) == 1, f"{len(counted_o)} 张")
# 上面那条用的是对方自己编的号。OA 自己排出去的号是另一回事:对方那套流水号按**报销记录**
# 编,同一条记录他们可以把发起页重开一次(OA 一页占一个号)再回写一次,那是**两趟**。
# 2026-10-27 生产上撞的就是这一条:FYBX202610270023 那句裸 AGREE 命中十分钟前
# FYBX202610270020 那条已办的记录,OA 回 200 加 alreadyHandled,对方日志写着
# "writeback succeeded",而 OA 里那张新单压根没建。这一档只有拿**真号**才验得出来。
process_dup = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"DP{STAMP}")
CLEANUP["process_begin_dup"] = process_dup
begin_dup = begin_id_of(db, process_dup)
dup_rule = numbering.serial_rule_of(autofill.form_fields(
db, str(db.get(models.Process, process_dup).latest_form or ""), None))
dup_biz = f"BIZ-{STAMP}-dup"
dup_serials = []
for tag in ("A", "B"):
got = numbering.reserve(db, process_dup, dup_rule)
dup_serials.append((str(got["serial"]), f"PRE{STAMP}DUP{tag}"))
for serial_value, prekey_value in dup_serials:
db.add(models.EmbedSession(
token_hash=f"th_{STAMP}_dup_{prekey_value}", prekey=prekey_value, source="reimb",
person=str(user.id), serial=serial_value, scopes=["start"], status="open",
expires_at=datetime.now() + timedelta(hours=1)))
CLEANUP["prekeys"].append(prekey_value)
db.commit()
serial_a, _ = dup_serials[0]
serial_b, _ = dup_serials[1]
dup_a = client.post(f"/api/v1/open/nodes/{serial_a}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
da = (dup_a.json() or {}).get("data") or {}
job_dup_a = str((da.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_dup_a)
check("拿发起页那个真号回写:建的单就是那个号",
dup_a.status_code == 200 and str((da.get("work") or {}).get("serial") or "") == serial_a
and da.get("handled") is True, str(dup_a.text)[:220])
retry_a = client.post(f"/api/v1/open/nodes/{serial_a}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
ra = (retry_a.json() or {}).get("data") or {}
check("同一个号再回写一次:幂等照旧,原样回那一张",
retry_a.status_code == 200 and ra.get("alreadyHandled") is True
and str((ra.get("work") or {}).get("job") or "") == job_dup_a, str(retry_a.text)[:200])
dup_b = client.post(f"/api/v1/open/nodes/{serial_b}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
dbb = (dup_b.json() or {}).get("data") or {}
job_dup_b = str((dbb.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_dup_b)
check("同一个 bizKey 点名另一个真号:按另一趟代发,不被幂等吞掉(生产那句 succeeded 而没单)",
dup_b.status_code == 200 and dbb.get("handled") is True and bool(job_dup_b)
and job_dup_b != job_dup_a
and str((dbb.get("work") or {}).get("serial") or "") == serial_b, str(dup_b.text)[:220])
check("多发那一张把「这个 bizKey 之前在哪个号上办过」写进回包,不让人事后猜",
serial_a in str(dbb.get("note") or "") and "bizKey" in str(dbb.get("note") or ""),
str(dbb.get("note"))[:220])
retry_b = client.post(f"/api/v1/open/nodes/{serial_b}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
rb = (retry_b.json() or {}).get("data") or {}
check("换到新那个号上重试:认的是这一趟,不多建第三张",
retry_b.status_code == 200 and rb.get("alreadyHandled") is True
and str((rb.get("work") or {}).get("job") or "") == job_dup_b, str(retry_b.text)[:200])
db.rollback()
dup_count = db.execute(select(models.Work).where(models.Work.process == process_dup)).scalars().all()
check("两趟留下两张单,一张不多一张不少", len(dup_count) == 2, f"{len(dup_count)} 张")
# 生产上撞的第二步:15:44 代发提交、15:48 被发起人退回、16:26 对方拿同一个 bizKey
# 再推一次。对方那个号是按报销记录编的,改完材料重推用的还是它——这一句必须真的把
# 这张单重新提交出去。只回一句 alreadyHandled,那张单就永远停在开始环节,
# 而对方日志写着 writeback succeeded。
back_task = db.execute(select(models.Task).where(
models.Task.job == job_dup_a, models.Task.status == "pending")).scalars().first()
went_back = False
if back_task is not None:
try:
engine.go_back(db, task_id=str(back_task.id),
actor=engine.Actor.from_ref(db, user, str(back_task.identity or approver_ref)),
opinion="发票再补一张")
db.commit()
went_back = True
except engine.EngineError as exc:
db.rollback()
went_back = False
dup_back_error = str(exc)
db.rollback()
check("先制造出「那张单被退回到开始环节」这一步(生产上就是这个状态)", went_back,
locals().get("dup_back_error", ""))
back_res = client.post(f"/api/v1/open/nodes/{serial_a}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
br = (back_res.json() or {}).get("data") or {}
check("退回到开始环节后同一 bizKey 再推:按新表态重新提交,不再吃幂等回放",
back_res.status_code == 200 and br.get("handled") is True
and str((br.get("work") or {}).get("job") or "") == job_dup_a,
f"{back_res.status_code} {str(back_res.text)[:240]}")
check("重办那一句要如实交代:这个 bizKey 之前办过、那张单被退回来过",
"bizKey" in str(br.get("note") or "") and "退回" in str(br.get("note") or ""),
str(br.get("note"))[:240])
check("重办的这一张不是新单:没替它另起一趟代发",
br.get("startedFromDecision") is not True, str(br.get("note"))[:200])
db.rollback()
work_back = db.execute(select(models.Work).where(models.Work.job == job_dup_a)).scalar_one_or_none()
check("重办这一张真的又离开了开始环节(走的还是引擎那一步,不是只记了个账)",
work_back is not None and work_back.activity != begin_dup,
str(getattr(work_back, "activity", None)))
rows_back = db.execute(select(models.NodeDecision).where(
models.NodeDecision.biz_key == dup_biz,
models.NodeDecision.work == str(getattr(work_back, "id", "")))).scalars().all()
check("同一张单同一环上这个 bizKey 只留一行台账(唯一键就地改写,插第二行会 500)",
len(rows_back) == 1 and rows_back[0].status == "handled",
f"{len(rows_back)} 行 / {[getattr(r, 'status', '') for r in rows_back]}")
# 第三次再推:单已经在下一环,翻篇不成立 → 回 200 与那一份快照,
# 但那句得说清那张单**现在**在哪一环(那份快照是上一次办的时候拍的,拿它当"现在"会骗人)
hint_res = client.post(f"/api/v1/open/nodes/{serial_a}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
hr = (hint_res.json() or {}).get("data") or {}
check("单已经走到下一环了再推同一个 bizKey:回放照旧 200,但那句得说清它现在停在哪",
hint_res.status_code == 200 and hr.get("alreadyHandled") is True
and "现在在「财务复核」" in str(hr.get("note") or ""),
f"{hint_res.status_code} {str(hr.get('note'))[:240]}")
# 再退一次回开始环节,然后按"重开发起页"那种来路回写:号是这一趟新占的那一个
# (OA 排出去的,只是还没变成单),单却是早先那一张。2026-10-27 16:53 生产上就是在
# 这里建出了第二张单——原本那张还停在发起人手里,对方手里只剩这个新号
reopen_task = db.execute(select(models.Task).where(
models.Task.job == job_dup_b, models.Task.status == "pending")).scalars().first()
reopen_error = ""
if reopen_task is not None:
try:
engine.go_back(db, task_id=str(reopen_task.id),
actor=engine.Actor.from_ref(db, user, str(reopen_task.identity or approver_ref)),
opinion="金额再改一下")
db.commit()
except engine.EngineError as exc:
db.rollback()
reopen_error = str(exc)
db.rollback()
got_c = numbering.reserve(db, process_dup, dup_rule)
serial_c = str(got_c["serial"])
prekey_c = f"PRE{STAMP}DUPC"
CLEANUP["prekeys"].append(prekey_c)
db.add(models.EmbedSession(
token_hash=f"th_{STAMP}_dup_{prekey_c}", prekey=prekey_c, source="reimb",
person=str(user.id), serial=serial_c, scopes=["start"], status="open",
expires_at=datetime.now() + timedelta(hours=1)))
db.commit()
reopen = client.post(f"/api/v1/open/nodes/{serial_c}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
rc = (reopen.json() or {}).get("data") or {}
check("重开发起页换了新号回写:提的还是原本那一张,不另起一张",
reopen.status_code == 200 and rc.get("handled") is True
and str((rc.get("work") or {}).get("job") or "") == job_dup_b and not reopen_error,
f"{reopen.status_code} {reopen_error} {str(reopen.text)[:200]}")
check("那一句要说清号跟着这一趟换了、指的还是早先那一张",
serial_c in str(rc.get("note") or "") and serial_b in str(rc.get("note") or "")
and str((rc.get("work") or {}).get("serial") or "") == serial_c,
str(rc.get("note"))[:220])
db.rollback()
counted_c = db.execute(select(models.Work).where(models.Work.process == process_dup)).scalars().all()
check("重开发起页这一趟没多出第三张单", len(counted_c) == 2, f"{len(counted_c)} 张")
locate_c = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"work": serial_c})
lc = (locate_c.json() or {}).get("data") or {}
check("新那个号往后也认得这张单(对方手里只剩它了)",
locate_c.status_code == 200 and str(lc.get("work", {}).get("job") or "") == job_dup_b,
f"{locate_c.status_code} {str(locate_c.text)[:180]}")
again_c = client.post(f"/api/v1/open/nodes/{serial_c}/{begin_dup}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": dup_biz})
ac = (again_c.json() or {}).get("data") or {}
check("拿新号再推一次同一个 bizKey:认得那张单,也不再重办一遍",
again_c.status_code == 200 and ac.get("alreadyHandled") is True
and str((ac.get("work") or {}).get("job") or "") == job_dup_b
and "现在在「财务复核」" in str(ac.get("note") or ""),
f"{again_c.status_code} {str(again_c.text)[:220]}")
no_biz = client.post(f"/api/v1/open/nodes/{their_flow}-2/{begin_id_s}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE"})
check("代发不带 bizKey 当场挡下:一次重试就是一张重复单,这个号不能省",
no_biz.status_code == 400 and "bizKey" in str((no_biz.json() or {}).get("message", "")),
str(no_biz.text)[:200])
no_who = client.post(f"/api/v1/open/nodes/{their_flow}-3/{begin_id_s}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"BIZ-{STAMP}-who"})
check("代发没说替谁发起就挡下,并把两条出路念出来(带 identity / 用发起页那趟预受理号)",
no_who.status_code == 400 and "identity" in str((no_who.json() or {}).get("message", ""))
and "PRE" in str((no_who.json() or {}).get("message", "")), str(no_who.text)[:220])
# 这一趟占过的号照旧接得住:第三方拿发起页那个号来代发,建出来的还是那个号
reserved_s = f"RESERVED{STAMP}-2"
prekey_s = f"PRE{STAMP}ASS"
db.add(models.EmbedSession(
token_hash=f"th_{STAMP}_autostart", prekey=prekey_s, source="reimb", person=str(user.id),
serial=reserved_s, scopes=["start"], status="open",
expires_at=datetime.now() + timedelta(hours=1)))
db.commit()
CLEANUP["prekeys"].append(prekey_s)
by_prekey = client.post(f"/api/v1/open/nodes/{reserved_s}/{begin_id_s}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": prekey_s})
bp = (by_prekey.json() or {}).get("data") or {}
CLEANUP["jobs"].append(str((bp.get("work") or {}).get("job") or ""))
check("拿发起页那个号与那趟预受理号来代发:建出来就是那个号,且当场提交掉",
by_prekey.status_code == 200 and str((bp.get("work") or {}).get("serial") or "") == reserved_s
and bp.get("handled") is True, str(by_prekey.text)[:220])
# confirm + 代发:单由这句表态建起来,但提交这一下仍要发起人点头(第三方不越过人去交)
process_begin_start_c = build_process_begin(db, approver_ref, confirm="confirm", auto_start=True)
CLEANUP["process_begin_start_c"] = process_begin_start_c
begin_id_sc = begin_id_of(db, process_begin_start_c)
staged_start = client.post(f"/api/v1/open/nodes/RE-{STAMP}-sc/{begin_id_sc}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE",
"bizKey": f"BIZ-{STAMP}-sc", "data": {}})
ss = (staged_start.json() or {}).get("data") or {}
job_sc = str((ss.get("work") or {}).get("job") or "")
decision_id_sc = str(ss.get("decisionId") or "")
CLEANUP["jobs"].append(job_sc)
check("confirm 模式代发:单建起来了,但这一句仍停在发起人确认(staged + 说清代发)",
staged_start.status_code == 200 and ss.get("staged") is True
and ss.get("startedFromDecision") is True and bool(job_sc) and "代发" in str(ss.get("note") or ""),
f"{staged_start.status_code} {str(staged_start.text)[:220]}")
db.rollback()
work_sc = db.execute(select(models.Work).where(models.Work.job == job_sc)).scalar_one_or_none()
check("发起人还没点头:单确实还停在开始环节",
work_sc is not None and work_sc.activity == begin_id_sc and work_sc.activity_type == "begin",
f"{getattr(work_sc, 'activity', None)} {getattr(work_sc, 'activity_type', None)}")
conf_sc = client.post(f"/api/v1/job/{job_sc}/node-decision/{decision_id_sc}/confirm", headers=headers)
check("发起人点头:代发的那张单这才提交出去", conf_sc.status_code == 200, str(conf_sc.text)[:160])
db.rollback()
work_sc2 = db.execute(select(models.Work).where(models.Work.job == job_sc)).scalar_one_or_none()
check("点头之后单已离开开始环节(代发 + 人工确认这一条路走通)",
work_sc2 is not None and work_sc2.activity != begin_id_sc,
getattr(work_sc2, "activity", None))
# 没勾这一档的环节不越权:还是那句拒绝,但要多说一句开关在哪
off = client.post(f"/api/v1/open/nodes/{their_flow}-9/{begin_id}/decide", headers=open_headers,
json={"identity": approver_ref, "result": "AGREE", "bizKey": f"BIZ-{STAMP}-off"})
om = str((off.json() or {}).get("message", ""))
check("没勾「没有单据时代为发起」:照旧不当代发,但把那一档点名出来",
off.status_code == 400 and "没有单据时代为发起" in om, om[:240])
# ---------------- 占号未发起 + 勾了代发:第三方原样那一句就能把流程发起来
# 线上真实那一条路:号是发起页替这一趟占下的正式号(第三方按它建自己的草稿),
# 他们那套流水线是**先 locate 再 decide**,而 bizKey 填的是自己那套流水号。
# 以前这一趟两头都堵:locate 直接 400(连该把表态发到哪一环都没告诉人家),
# decide 又认不出替谁发起。两边都不肯改,那就得 OA 自己按排号那本账把这一趟认回来。
def reserve_trip(pid: str, prekey: str, person: str, args: dict | None = None,
form: dict | None = None) -> str:
"""走真路占一个号(发起页每开一页就是这么占的),并把那一趟挂上。
``args`` 是"打开那一页时带进来的那几格值"、``form`` 是"那一屏此刻的整份表单值",
两份都走真 :func:`embed_session._stashed` 存进去,与 ``POST /embed/launch``
落库的那一份同一个形状。
"""
rule = numbering.serial_rule_of(autofill.form_fields(db, str(db.get(models.Process, pid).latest_form or "")))
serial = str(numbering.reserve(db, pid, rule)["serial"])
db.add(models.EmbedSession(
token_hash=f"th_{STAMP}_{prekey}", prekey=prekey, source="reimb", person=person,
serial=serial, scopes=["start"], status="open",
result=(embed_session._stashed(None, None, None, args=args, form=form)
if (args or form) else {}),
expires_at=datetime.now() + timedelta(hours=1)))
db.commit()
CLEANUP["prekeys"].append(prekey)
return serial
prefix_live = f"LV{STAMP}"
process_live = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=prefix_live)
CLEANUP["process_live"] = process_live
begin_live = begin_id_of(db, process_live)
reserved_live = reserve_trip(process_live, f"PRE{STAMP}LV1", str(user.id))
check("占下的号能按排号那本账认回是哪条流程的(OA 自己排的号,不是对方照着格式编的)",
numbering.owners_of_serial(db, reserved_live) == [process_live],
f"{reserved_live} -> {numbering.owners_of_serial(db, reserved_live)}")
lk_live = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": reserved_live, "detail": "full"})
lv = (lk_live.json() or {}).get("data") or {}
check("这一趟勾了代发:locate 不再回 400,如实回「还没单,直接 decide 就代发」",
lk_live.status_code == 200 and lv.get("pending") is True
and str((lv.get("work") or {}).get("status") or "") == "not_started"
and str((lv.get("activity") or {}).get("id") or "") == begin_live
and "没有单据时代为发起" in str(lv.get("note") or ""),
f"{lk_live.status_code} {str(lk_live.text)[:240]}")
card_live = (lv.get("openApprove") or {})
check("这一份定位把 decide 的完整地址与 autoStart 一起递出去(对方照抄一条就发得起来)",
str(card_live.get("interface") or "")
== f"POST /api/v1/open/nodes/{reserved_live}/{begin_live}/decide"
and card_live.get("autoStart") is True, str(card_live)[:240])
brief_live = (client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": reserved_live}).json() or {}).get("data") or {}
check("瘦身那份也留得下判决(是哪条流程、哪个环节、还能不能表态)",
brief_live.get("pending") is True
and str((brief_live.get("activity") or {}).get("id") or "") == begin_live
and "openApprove" not in brief_live, str(brief_live)[:220])
# 他们那一句原样回写:结论词 AGREE、bizKey 是自己那套流水号、没带 identity
one_line = client.post(f"/api/v1/open/nodes/{reserved_live}/{begin_live}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-他们那边的流水号"})
ol = (one_line.json() or {}).get("data") or {}
job_live = str((ol.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_live)
check("原样那一句就把流程发起并提交了(不要求第三方改一个字)",
one_line.status_code == 200 and ol.get("handled") is True
and ol.get("startedFromDecision") is True,
f"{one_line.status_code} {str(one_line.text)[:240]}")
check("单号还是他们手里那一个:代发起不许换号",
str((ol.get("work") or {}).get("serial") or "") == reserved_live,
str((ol.get("work") or {}).get("serial")))
db.rollback()
work_live = db.execute(select(models.Work).where(models.Work.job == job_live)).scalar_one_or_none()
check("代发的这一张真的离开了开始环节",
work_live is not None and work_live.activity != begin_live,
f"{getattr(work_live, 'activity', None)} {getattr(work_live, 'activity_type', None)}")
sess_live = db.execute(select(models.EmbedSession).where(
models.EmbedSession.prekey == f"PRE{STAMP}LV1")).scalar_one_or_none()
check("那一趟对上了这张单(发起页刷新时看得见「已发起成单号 X」,不会再生一张)",
str(getattr(sess_live, "claim_job", "") or "") == job_live,
getattr(sess_live, "claim_job", None))
check("发起来之后同一个号定位就回真单了:状态不再是 not_started",
(client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": reserved_live}).json() or {}).get("data", {})
.get("work", {}).get("status") == "running", reserved_live)
# 短地址(省掉环节那一段)也认这颗钮:环节由 OA 按号认回来
process_short = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"LS{STAMP}")
CLEANUP["process_short"] = process_short
begin_short = begin_id_of(db, process_short)
reserved_short = reserve_trip(process_short, f"PRE{STAMP}LS1", str(user.id))
shot = client.post(f"/api/v1/open/nodes/{reserved_short}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-短地址"})
sd = (shot.json() or {}).get("data") or {}
CLEANUP["jobs"].append(str((sd.get("work") or {}).get("job") or ""))
check("短地址也发得起来:环节由 OA 按这个号认回开始环节,不让人去抄环节 id",
shot.status_code == 200 and sd.get("handled") is True
and str((sd.get("work") or {}).get("serial") or "") == reserved_short,
f"{shot.status_code} {str(shot.text)[:220]}")
# 没勾代发:这一趟在这一环真办不成事,locate 照旧回那句「先建单再来」
process_off = build_process_begin(db, approver_ref, confirm="auto", serial_prefix=f"LX{STAMP}")
CLEANUP["process_off"] = process_off
reserved_off = reserve_trip(process_off, f"PRE{STAMP}LX1", str(user.id))
off_lk = client.post("/api/v1/open/nodes/locate", headers=open_headers, json={"work": reserved_off})
check("没勾代发就不越权:定位照旧 400 NODE_WORK_NOT_STARTED,并把那一档点名出来",
off_lk.status_code == 400 and "先建单再来" not in str(off_lk.text)
and str((off_lk.json() or {}).get("reason") or "") == "NODE_WORK_NOT_STARTED"
and "没有单据时代为发起" in str((off_lk.json() or {}).get("message") or ""),
f"{off_lk.status_code} {str(off_lk.text)[:220]}")
# 对方照着格式自己编一个号:认不出那一趟,就说不清替谁发起,绝不蒙着发一张单
invented = f"{prefix_live}{datetime.now().strftime('%Y%m%d')}9999"
check("当期没排到这个值:这个号就不是 OA 排的,认不出流程",
numbering.owners_of_serial(db, invented) == [], invented)
inv = client.post(f"/api/v1/open/nodes/{invented}/{begin_live}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-自排的号"})
check("自己编的号来代发:认不出那一趟就当场问清替谁发起,不会乱建一张没人填的单",
inv.status_code == 400
and str((inv.json() or {}).get("reason") or "") == "NODE_START_IDENTITY_REQUIRED",
f"{inv.status_code} {str(inv.text)[:220]}")
# 生产那一档的真配法:锁了 start 又勾了代发(费用报销的开始环节就是这么配的)。
# 那把锁锁的是 OA 界面里那几颗钮,不该顺手把第三方这一句代发也挡在门外
process_locked = build_process_begin(
db, approver_ref, confirm="auto", auto_start=True, serial_prefix=f"LK{STAMP}",
begin_lock={"enabled": True, "actions": ["handle", "start", "goBack", "recall"]})
CLEANUP["process_locked"] = process_locked
begin_locked = begin_id_of(db, process_locked)
reserved_locked = reserve_trip(process_locked, f"PRE{STAMP}LK1", str(user.id))
locked_decide = client.post(f"/api/v1/open/nodes/{reserved_locked}/{begin_locked}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-锁着也发"})
ld = (locked_decide.json() or {}).get("data") or {}
CLEANUP["jobs"].append(str((ld.get("work") or {}).get("job") or ""))
check("开始环节锁了 start:第三方那一句代发照样发得起来(锁锁的是 OA 那几颗钮)",
locked_decide.status_code == 200 and ld.get("handled") is True
and str((ld.get("work") or {}).get("serial") or "") == reserved_locked,
f"{locked_decide.status_code} {str(locked_decide.text)[:240]}")
reserved_locked2 = reserve_trip(process_locked, f"PRE{STAMP}LK2", str(user.id))
locked_lk = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": reserved_locked2})
check("同一配法下还没发起的那个号照样定位得出来(锁没把定位一起带沟里)",
locked_lk.status_code == 200
and str((((locked_lk.json() or {}).get("data") or {}).get("activity") or {}).get("id") or "")
== begin_locked,
f"{locked_lk.status_code} {str(locked_lk.text)[:200]}")
# 代发把整张单发起来 = 发起那一步的校验一条不少。缺必填要回得清缺哪一格,
# 更不能留下"占了号却从没提交出去"的那半张单(真实报销单有九格必填,全靠这句话自查)
process_form = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"LF{STAMP}", require_field=True)
CLEANUP["process_form"] = process_form
begin_form = begin_id_of(db, process_form)
reserved_form = reserve_trip(process_form, f"PRE{STAMP}LF1", str(user.id))
missing = client.post(f"/api/v1/open/nodes/{reserved_form}/{begin_form}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-缺必填"})
mj = missing.json() or {}
mm = str(mj.get("message") or "")
check("代发缺必填:400 且点名缺哪一格(第三方照着补 data 就行)",
missing.status_code == 400 and "申请事由" in mm, f"{missing.status_code} {mm[:220]}")
check("这句话还教对方怎么补:说清值放在 data 里、库里没留半张单",
str(mj.get("reason") or "") == "NODE_START_DATA_INCOMPLETE"
and "data" in mm and "半张单" in mm, mm[:220])
check("这句话先交代 OA 自己垫了哪几份、并把\"发起人回 OA 那一屏填上\"排在让对方改报文之前",
"发起页那一屏此刻的表单值" in mm and mm.index("让发起人回到 OA 那一屏") < mm.index("data"),
mm[:260])
db.rollback()
half = db.execute(select(models.Work).where(models.Work.process == process_form)).scalars().all()
check("挡下来之后库里干干净净:不会留下占了号又没提交的那半张单", half == [], f"{len(half)} 张")
filled = client.post(f"/api/v1/open/nodes/{reserved_form}/{begin_form}/decide", headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-补齐了",
"data": {"reason": "差旅报销", "processNo": reserved_form}})
fd = (filled.json() or {}).get("data") or {}
CLEANUP["jobs"].append(str((fd.get("work") or {}).get("job") or ""))
check("补上那一格再发一次:同一句 decide 就发起来了,号还是那一个",
filled.status_code == 200 and fd.get("handled") is True
and str((fd.get("work") or {}).get("serial") or "") == reserved_form,
f"{filled.status_code} {str(filled.text)[:200]}")
# 底稿是在「打开那一页」那一步存下来的:这一条钉住 open_session 真把参数值留在了这一趟上
src_trip = models.DataSource(code=f"trip_{STAMP}", name="代发底稿自检源", provider="embed",
enabled=True, url_mode="template",
url="https://trip.test/{arg.processNo}")
db.add(src_trip)
db.flush()
trip_row, _secret = embed_session.open_session(
db, row=src_trip, field_key="embed_x", field={"key": "embed_x", "embed": {"start": True}},
person=str(getattr(user, "person_id", "") or user.id), serial=f"TRIP{STAMP}",
args={"accountProject": "SHFP01", "hide_title": "1"})
db.commit()
check("打开那一页时带进来的参数值留在这一趟上(代发才有底稿,以前只留了个指纹)",
embed_session.trip_args(trip_row) == {"accountProject": "SHFP01", "hide_title": "1"},
json.dumps(embed_session.trip_args(trip_row), ensure_ascii=False))
db.execute(delete(models.EmbedSession).where(models.EmbedSession.id == trip_row.id))
db.delete(src_trip)
db.commit()
# 打开那一页时带进来的那几格值就是这一趟的底稿:第三方回写不必把同一份数送第二遍
process_args = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"LA{STAMP}", require_field=True)
CLEANUP["process_args"] = process_args
begin_args = begin_id_of(db, process_args)
reserved_args = reserve_trip(process_args, f"PRE{STAMP}LA1", str(user.id),
args={"reason": "发起页带进来的事由", "hide_title": "1"})
by_args = client.post(f"/api/v1/open/nodes/{reserved_args}/{begin_args}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-用带进来的值"})
ba = (by_args.json() or {}).get("data") or {}
job_args = str((ba.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_args)
check("没带 data 也发得起来:代发拿这一趟已有的值当底稿",
by_args.status_code == 200 and ba.get("handled") is True
and str((ba.get("work") or {}).get("serial") or "") == reserved_args,
f"{by_args.status_code} {str(by_args.text)[:200]}")
db.rollback()
trip_work = db.execute(select(models.Work).where(models.Work.job == job_args)).scalar_one_or_none()
wdata = dict((trip_work.data if trip_work is not None else None) or {})
check("底稿里只收表单真定义的那几格:展示用的参数不会变成单据数据",
wdata.get("reason") == "发起页带进来的事由" and "hide_title" not in wdata,
json.dumps(wdata, ensure_ascii=False)[:200])
db.rollback()
# 那一趟挂着草稿时,代发用**那个人自己存的那一份**(生产上他们下一步就要用这条)
process_draft = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"DR{STAMP}", require_field=True)
CLEANUP["process_draft"] = process_draft
begin_draft = begin_id_of(db, process_draft)
reserved_draft = reserve_trip(process_draft, f"PRE{STAMP}DR1", str(user.id),
args={"reason": "打开那一页时带的事由"})
dform = str(db.get(models.Process, process_draft).latest_form or "")
trip_draft = models.Draft(title="草稿上改过的事由", process=process_draft, process_name="草稿自检流程",
form=dform, data={"reason": "草稿上改过的事由"},
serial=reserved_draft, person=str(user.id), identity=approver_ref)
db.add(trip_draft)
db.flush()
sess_row = db.execute(select(models.EmbedSession)
.where(models.EmbedSession.prekey == f"PRE{STAMP}DR1")).scalar_one()
sess_row.draft = trip_draft.id
db.commit()
by_draft = client.post(f"/api/v1/open/nodes/{reserved_draft}/{begin_draft}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-拿草稿发起"})
bd = (by_draft.json() or {}).get("data") or {}
job_draft = str((bd.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_draft)
check("那一趟挂着草稿:代发用草稿里那一份值(盖过打开时带的参数)",
by_draft.status_code == 200 and bd.get("handled") is True,
f"{by_draft.status_code} {str(by_draft.text)[:200]}")
db.rollback()
dw = db.execute(select(models.Work).where(models.Work.job == job_draft)).scalar_one_or_none()
check("发起来的单用的是草稿那份,而不是底稿里那一份",
str(((dw.data if dw is not None else None) or {}).get("reason") or "") == "草稿上改过的事由",
json.dumps(dict((dw.data if dw is not None else None) or {}), ensure_ascii=False)[:200])
db.rollback()
db.delete(db.get(models.Draft, trip_draft.id))
db.commit()
# 那一屏上**整张单**的表单值(``form`` 那一路留下的)才是代发最该用的那一份底稿:
# 生产那张费用报销单八格必填,而嵌进去的那一格只引用申请人/单号/核算项目,
# 收款方式这种没被引用的必填格只有这一份接得住(第三方不改一个字)
process_screen = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"SC{STAMP}", require_field=True)
CLEANUP["process_screen"] = process_screen
begin_screen = begin_id_of(db, process_screen)
reserved_screen = reserve_trip(process_screen, f"PRE{STAMP}SC1", str(user.id),
args={"reason": "打开那一页时带的事由"},
form={"reason": "这一屏上刚改过的事由"})
by_screen = client.post(f"/api/v1/open/nodes/{reserved_screen}/{begin_screen}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-用这一屏那份"})
bs = (by_screen.json() or {}).get("data") or {}
job_screen = str((bs.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_screen)
check("发起页那一屏的整份表单值也能撑起代发:一句裸回写就发起来",
by_screen.status_code == 200 and bs.get("handled") is True
and str((bs.get("work") or {}).get("serial") or "") == reserved_screen,
f"{by_screen.status_code} {str(by_screen.text)[:200]}")
db.rollback()
sw = db.execute(select(models.Work).where(models.Work.job == job_screen)).scalar_one_or_none()
check("这一屏那份压过打开时带的参数:它是那个人刚才敲的,那份是他更早带来的",
str(((sw.data if sw is not None else None) or {}).get("reason") or "") == "这一屏上刚改过的事由",
json.dumps(dict((sw.data if sw is not None else None) or {}), ensure_ascii=False)[:200])
db.rollback()
# 对方报文里那几格空值不该把 OA 自己有的值抹掉——"以 OA 中的为准"就是这一句
reserved_blank = reserve_trip(process_screen, f"PRE{STAMP}SC2", str(user.id),
form={"reason": "OA 手里那一份值"})
by_blank = client.post(f"/api/v1/open/nodes/{reserved_blank}/{begin_screen}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-带一串空值",
"data": {"reason": "", "ghost_not_on_form": ""}})
bb = (by_blank.json() or {}).get("data") or {}
job_blank = str((bb.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_blank)
bw = db.execute(select(models.Work).where(
models.Work.job == job_blank)).scalar_one_or_none() if job_blank else None
check("报文里那一格是空串时不算「对方点名要改」:OA 手里那份值照用,不被抹成「请填写」",
by_blank.status_code == 200
and str(dict((bw.data if bw is not None else None) or {}).get("reason") or "")
== "OA 手里那一份值",
f"{by_blank.status_code} {str(by_blank.text)[:200]}")
db.rollback()
# 参数是拼给对方看的一句人话,不是存储形状:它不许占住系统自己带出的那几格
process_shape = build_process_begin(db, approver_ref, confirm="auto", auto_start=True,
serial_prefix=f"SH{STAMP}", with_applicant=True)
CLEANUP["process_shape"] = process_shape
begin_shape = begin_id_of(db, process_shape)
reserved_shape = reserve_trip(process_shape, f"PRE{STAMP}SH1", str(user.id),
args={"applicant": "kangwenjing", "processNo": "编出来的号"})
by_shape = client.post(f"/api/v1/open/nodes/{reserved_shape}/{begin_shape}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-申请人形状"})
bsh = (by_shape.json() or {}).get("data") or {}
job_shape = str((bsh.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_shape)
shw = db.execute(select(models.Work).where(
models.Work.job == job_shape)).scalar_one_or_none() if job_shape else None
shdata = dict((shw.data if shw is not None else None) or {})
check("拼给人看的那句参数值不占住系统带出格:申请人落的是一串人员引用,不是账号那句人话",
by_shape.status_code == 200 and isinstance(shdata.get("applicant"), list)
and bool(shdata.get("applicant")),
f"{by_shape.status_code} {json.dumps(shdata, ensure_ascii=False)[:220]}")
check("单据编号那一格也不被参数里那句话占住:用的还是这一趟占下的号",
str(shdata.get("processNo") or "") == reserved_shape,
json.dumps(shdata, ensure_ascii=False)[:220])
db.rollback()
# 那一屏上的值太大没存进底稿时,那句 400 得说得出"其实有过值"
reserved_drop = reserve_trip(process_screen, f"PRE{STAMP}SC4", str(user.id),
form={"reason": "一" * 9000})
by_drop = client.post(f"/api/v1/open/nodes/{reserved_drop}/{begin_screen}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-挤掉的那格"})
md = str(((by_drop.json() or {}).get("message") or ""))
check("被上限挤掉的那一格,400 里要说出来(否则两头都只看见「OA 手里没有」)",
by_drop.status_code == 400 and "申请事由" in md and "本来有值" in md,
f"{by_drop.status_code} {md[:240]}")
db.rollback()
# 「OA 表单中有的字段值以 OA 中的为准」:对方报文里那一格给个假值也盖不掉屏幕上那一份
reserved_hold = reserve_trip(process_screen, f"PRE{STAMP}SC3", str(user.id),
form={"reason": "OA 那一屏上填的事由"})
by_hold = client.post(f"/api/v1/open/nodes/{reserved_hold}/{begin_screen}/decide",
headers=open_headers,
json={"result": "AGREE", "bizKey": f"RE-{STAMP}-报文想改它",
"data": {"reason": "对方报文想改成这个", "amount": 88}})
bh = (by_hold.json() or {}).get("data") or {}
job_hold = str((bh.get("work") or {}).get("job") or "")
CLEANUP["jobs"].append(job_hold)
hw = db.execute(select(models.Work).where(
models.Work.job == job_hold)).scalar_one_or_none() if job_hold else None
hdata = dict((hw.data if hw is not None else None) or {})
check("OA 手里有的那格以 OA 为准:报文 data 盖不掉那一屏上填的事由",
by_hold.status_code == 200 and str(hdata.get("reason") or "") == "OA 那一屏上填的事由",
f"{by_hold.status_code} {json.dumps(hdata, ensure_ascii=False)[:200]}")
check("报文 data 该干的活还在:补 OA 手里没有的那几格",
hdata.get("amount") == 88, json.dumps(hdata, ensure_ascii=False)[:200])
db.rollback()
# ---------------------------------------- 地址里那一段是流程编号:第三方只有这个号与 job 号
job10 = start_work(db, process_id, actor, f"外部审批校验单 {STAMP} 十号")
CLEANUP["jobs"].append(job10)
work10, task10 = pending_task_of(db, job10, "财务复核")
check("十号单走到了开了外部审批的那一环", task10 is not None, job10)
if task10 is not None:
# 这一段要的是一条不会撞号的编号(编号按天流水,同号落在几张单上是常态,
# 撞号那一条下面单独造一张同号单来验,别让上面这几条赌运气)
serial10 = f"NodeApproveNo-{STAMP}-10"
work10.serial = serial10
db.commit()
by_no = client.post(f"/api/v1/open/nodes/{serial10}/{task10.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10a"})
d10 = (by_no.json() or {}).get("data") or {}
check("地址里放流程编号、报文不带 work:照样办得通,回包认得这张单",
by_no.status_code == 200 and d10.get("staged") is True
and str((d10.get("work") or {}).get("serial")) == serial10,
f"{by_no.status_code} {str(by_no.text)[:160]}")
by_job_path = client.post(f"/api/v1/open/nodes/{job10}/{task10.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10b"})
check("地址里放 job 号:同样认(编号没排出来的流程只有这一个号)",
by_job_path.status_code == 200, str(by_job_path.text)[:140])
same_both = client.post(f"/api/v1/open/nodes/{serial10}/{task10.activity}/decide",
headers=open_headers,
json={"work": job10, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10c"})
check("地址与报文都写、指的是同一张单:收下来,不算重复表态",
same_both.status_code == 200, str(same_both.text)[:140])
# 报文那一位要拿另一张**还在跑**的单来对:四号单已终止归档,报它的号只会先撞上
# 「这张单不存在」,验不到「两处各说一张单」这一档
mismatch = client.post(f"/api/v1/open/nodes/{serial10}/{task10.activity}/decide",
headers=open_headers,
json={"work": job9, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10d"})
check("地址与报文各说一张单:当场点名不是同一张,不赌哪张",
mismatch.status_code == 400 and "不是同一张单" in str((mismatch.json() or {}).get("message", "")),
str(mismatch.text)[:160])
only_process = client.post(f"/api/v1/open/nodes/{process_id}/{task10.activity}/decide",
headers=open_headers, json={"result": "APPROVED"})
check("只写流程定义 id 又不带 work:点名要补,不猜是哪张单",
only_process.status_code == 400 and "work" in str((only_process.json() or {}).get("message", "")),
str(only_process.text)[:160])
unknown = client.post(f"/api/v1/open/nodes/{serial10}-NOPE/{task10.activity}/decide",
headers=open_headers, json={"result": "APPROVED"})
check("那一段既不是编号也不是 job 号:说清没认出这张单",
unknown.status_code == 400 and "没认出" in str((unknown.json() or {}).get("message", "")),
str(unknown.text)[:160])
junk = client.post(f"/api/v1/open/nodes/Garbage-{STAMP}/{task10.activity}/decide",
headers=open_headers, json={"work": job10, "result": "APPROVED"})
check("地址里那一段谁也不认得:报文带得再全也点名挡下,不放行",
junk.status_code == 400 and "既不是流程编号" in str((junk.json() or {}).get("message", "")),
str(junk.text)[:160])
other_serial = f"{serial10}-OTHER"
if work9 is not None:
work9.serial = other_serial
db.commit()
foreign = client.post(f"/api/v1/open/nodes/{other_serial}/{task10.activity}/decide",
headers=open_headers, json={"result": "APPROVED"})
check("号对上了但单不归这条流程:当场点名,不办到别的单上",
foreign.status_code == 400 and "不在那条流程里" in str((foreign.json() or {}).get("message", "")),
str(foreign.text)[:160])
# 老写法不回收:卡片上还是流程定义 id 的对方,带上 work 照样调得动
legacy = client.post(f"/api/v1/open/nodes/{process_id}/{task10.activity}/decide",
headers=open_headers,
json={"work": serial10, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10e"})
check("老卡片那种写法(地址里是流程定义 id + 报文带 work)继续认",
legacy.status_code == 200, str(legacy.text)[:140])
# 撞号:再造一张同号的单,编号跨流程不保证唯一,这时候必须让人改报 job 号
job11 = start_work(db, process_id, actor, f"外部审批校验单 {STAMP} 十一号")
CLEANUP["jobs"].append(job11)
work11, _task11 = pending_task_of(db, job11, "财务复核")
if work11 is not None:
work11.serial = serial10
db.commit()
collide = client.post(f"/api/v1/open/nodes/{serial10}/{task10.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-10f"})
check("编号撞了不止一张单:点名让改报 job 号,不赌哪张",
collide.status_code == 400 and "job" in str((collide.json() or {}).get("message", "")),
str(collide.text)[:160])
# 关着的环节排在查单之前:真编号也探不出这张单在不在跑
gate = client.post(f"/api/v1/open/nodes/{serial10}/{begin_id_of(db, process_id)}/decide",
headers=open_headers, json={"result": "APPROVED"})
check("没开的环节先挡探针:地址里放真编号也只回那句笼统话",
gate.status_code == 404 and "没开审批接口" in str((gate.json() or {}).get("message", "")),
str(gate.text)[:160])
# ---------------------------- 不点名环节:地址里只写单号,环节由 OA 认
if task10 is None:
check("不点名环节这一段:十号单没走到那一环,验不了", False, job10)
return 1
short_a = client.post(f"/api/v1/open/nodes/{job10}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12a"})
s12 = (short_a.json() or {}).get("data") or {}
check("只报单号、不带环节那一段:OA 认出当前该表态的那一环,照样停在等确认",
short_a.status_code == 200 and s12.get("staged") is True
and str(s12.get("activity") or "") == "财务复核",
f"{short_a.status_code} {str(short_a.text)[:160]}")
# 两条地址只是"环节谁说了算"不同:认出环节之后落的是同一本账
cross = client.post(f"/api/v1/open/nodes/{job10}/{task10.activity}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12a"})
cp = (cross.json() or {}).get("data") or {}
check("同一 bizKey 换成长地址再调:原样回那份表态,不另起一份",
cross.status_code == 200 and cp.get("alreadyStaged") is True
and str(cp.get("decisionId") or "") == str(s12.get("decisionId") or ""),
f"{cross.status_code} {str(cross.text)[:160]}")
mixed = client.post(f"/api/v1/open/nodes/{job10}/decide", headers=open_headers,
json={"work": job9, "result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12c"})
check("短地址下地址与报文各说一张单:照样点名",
mixed.status_code == 400 and "不是同一张单" in str((mixed.json() or {}).get("message", "")),
str(mixed.text)[:160])
junk12 = client.post(f"/api/v1/open/nodes/Garbage-{STAMP}/decide", headers=open_headers,
json={"result": "APPROVED"})
check("短地址那一段谁也不认得:说清这一条只认单子上印的那个号",
junk12.status_code == 400 and "只认单子上印的那个号" in str((junk12.json() or {}).get("message", "")),
str(junk12.text)[:160])
# 一号单在这一段之前已经办结归档:对一张不在了的单表态,听到的该是"不用再表态",
# 不是"没认出这张单"——后者会让对方的机器人照着「号可能错了」再重试一遍
archived = client.post(f"/api/v1/open/nodes/{job1}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12g"})
check("对已办结归档的单表态:说清不用再表态,不甩一句「没认出这张单」",
archived.status_code == 400 and "归档" in str((archived.json() or {}).get("message", ""))
and str((archived.json() or {}).get("reason") or "") == "NODE_WORK_NOT_RUNNING",
str(archived.text)[:160])
short_auto = client.post(f"/api/v1/open/nodes/{job3}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12d"})
check("auto 模式下短地址也当场办掉,不等人",
short_auto.status_code == 200 and (short_auto.json().get("data") or {}).get("handled") is True,
f"{short_auto.status_code} {str(short_auto.text)[:160]}")
past_open = client.post(f"/api/v1/open/nodes/{job3}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-12e"})
check("单子往下走到没开接口的环节:短地址回同一句笼统话",
past_open.status_code == 404 and "没开审批接口" in str((past_open.json() or {}).get("message", "")),
str(past_open.text)[:160])
short_begin = client.post(f"/api/v1/open/nodes/{job7}/decide", headers=open_headers,
json={"result": "SUBMITTED", "bizKey": f"BIZ-{STAMP}-12f"})
sb = (short_begin.json() or {}).get("data") or {}
check("停在开始环节的那一单:短地址认出的就是那颗提交钮",
short_begin.status_code == 200 and sb.get("staged") is True
and str(sb.get("activity") or "") == "发起申请", str(short_begin.text)[:160])
# 并行分支:这张单同时停在两环上,认不出唯一一环就不猜
process_parallel = build_process_parallel(db, approver_ref)
CLEANUP["process_parallel"] = process_parallel
job13 = start_work(db, process_parallel, actor, f"外部审批校验单 {STAMP} 十三号")
CLEANUP["jobs"].append(job13)
db.rollback()
branches = db.execute(
select(models.Task).where(models.Task.job == job13, models.Task.status == "pending")
.order_by(models.Task.id)
).scalars().all()
branch_ids = sorted({str(row.activity) for row in branches})
check("十三号单同时停在两条分支上(两条都开着外部审批)", len(branch_ids) == 2,
f"{[(row.activity_name, row.status) for row in branches]}")
if len(branch_ids) == 2:
amb = client.post(f"/api/v1/open/nodes/{job13}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-13a"})
am = str((amb.json() or {}).get("message", ""))
check("同时停在两个开了接口的环节:回候选点名,不赌哪一条线",
amb.status_code == 400 and "部门复核" in am and "财务复核" in am, str(amb.text)[:200])
picked_line = next(row for row in branches if row.activity_name == "部门复核")
on_line = client.post(f"/api/v1/open/nodes/{job13}/{picked_line.activity}/decide",
headers=open_headers,
json={"result": "APPROVED", "bizKey": f"BIZ-{STAMP}-13b"})
check("点名那一环的长地址在并行分支下照样办得通",
on_line.status_code == 200
and str(((on_line.json() or {}).get("data") or {}).get("activity") or "") == "部门复核",
str(on_line.text)[:160])
# 开了接口但没对这把钥匙开口:403 说清是哪一档,不与"没开接口"混成一句
other_code = f"{APP_CODE}_b"
other = client.post("/api/v1/design/open/apps", headers=headers, json={
"code": other_code, "name": f"外部审批校验(不在白名单){STAMP}",
"scopes": ["task:read", "task:write"]})
if other.status_code < 400:
CLEANUP["app2"] = other_code
od = other.json().get("data") or {}
ot = client.post("/api/v1/open/token", json={
"appKey": od.get("appKey", ""), "appSecret": od.get("appSecret", "")})
other_headers = {"Authorization": f"Bearer {(ot.json() or {}).get('data', {}).get('accessToken', '')}"}
denied = client.post(f"/api/v1/open/nodes/{job10}/decide", headers=other_headers,
json={"result": "APPROVED"})
check("环节开着但没对这个应用开口:短地址回 403,与「没开接口」分得开",
denied.status_code == 403 and "没对当前应用开审批接口" in str((denied.json() or {}).get("message", "")),
f"{denied.status_code} {str(denied.text)[:160]}")
# 设计器保存时的体检:开始环节的决策词表映到同意 / 钉到同意出口 → 点名挡下
form_d = models.FormElement(name=f"开始环节体检表单 {STAMP}", content={"fields": []})
db.add(form_d)
db.flush()
proc_d = models.Process(name=f"开始环节体检流程 {STAMP}", category="check", enabled=True, published=True,
latest_form=form_d.id, latest_form_name=form_d.name)
db.add(proc_d)
db.flush()
bd = models.Activity(process=proc_d.id, type="begin", name="发起申请", order_number=0)
bm = models.Activity(process=proc_d.id, type="manual", name="复核", order_number=1, form=form_d.id,
config={"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}]})
be = models.Activity(process=proc_d.id, type="end", name="结束", order_number=2)
db.add_all([bd, bm, be])
db.flush()
r1 = models.Route(process=proc_d.id, name="提交", from_activity=bd.id, to_activity=bm.id)
r2 = models.Route(process=proc_d.id, name="通过", from_activity=bm.id, to_activity=be.id)
db.add_all([r1, r2])
db.commit()
CLEANUP["process_begin_design"] = proc_d.id
design_payload = {
"activities": [
{"id": bd.id, "type": "begin", "name": "发起申请", "alias": "发起申请", "x": 0, "y": 0,
"order_number": 0, "form": "",
"config": {"openApprove": {"enabled": True,
"decisions": {"PASSED": "agree", "SUBMITTED": "submit"},
"routes": {"agree": "提交"}}}},
{"id": bm.id, "type": "manual", "name": "复核", "alias": "复核", "x": 0, "y": 0,
"order_number": 1, "form": form_d.id,
"config": {"mode": "any", "taskValues": [{"type": "person", "data": [approver_ref]}]}},
{"id": be.id, "type": "end", "name": "结束", "alias": "结束", "x": 0, "y": 0,
"order_number": 2, "form": "", "config": {}},
],
"routes": [
{"id": r1.id, "name": "提交", "alias": "提交", "from_activity": bd.id, "to_activity": bm.id,
"order_number": 0},
{"id": r2.id, "name": "通过", "alias": "通过", "from_activity": bm.id, "to_activity": be.id,
"order_number": 1},
],
}
bad_design = client.put(f"/api/v1/process/processes/{proc_d.id}/design", headers=headers, json=design_payload)
check("开始环节映到同意 / 钉到同意的配置:保存时点名挡下",
bad_design.status_code == 400 and "开始环节" in str((bad_design.json() or {}).get("message", "")),
str(bad_design.text)[:200])
good_payload = json.loads(json.dumps(design_payload))
good_payload["activities"][0]["config"] = {"openApprove": {"enabled": True, "decisions": {"SUBMITTED": "submit"}}}
good_design = client.put(f"/api/v1/process/processes/{proc_d.id}/design", headers=headers, json=good_payload)
check("只认提交的配置保存得进", good_design.status_code == 200, str(good_design.text)[:160])
print()
if FAILS:
print(f"{len(FAILS)} 条没对上:")
for item in FAILS:
print(f" - {item}")
return 1
print(f"全部 {PASSED} 条对上。")
return 0
def begin_id_of(db, process_id: str) -> str:
row = db.execute(select(models.Activity).where(
models.Activity.process == process_id, models.Activity.type == "begin")).scalars().first()
return str(row.id) if row else ""
def cleanup(db) -> None:
"""连自己造的应用、订阅、流程、单据、表态一起删干净。"""
try:
# 每一条场景各造一张流程,这里按 key 前缀收,不手写名单:从前这份名单是手抄的,
# 抄漏的那几档每跑一次就在库里留一张没人认领的流程,而它行上挂的那张表单已经被
# 下面那一句删掉了——于是 check_job_payload 挨个流程量表单清单时,量出来一句
# 「SQL 那份清单与 form_ids() 不同源」,冤枉的其实是这张没扫干净的流程行。
process_ids = [pid for key, pid in CLEANUP.items() if key.startswith("process") and pid]
for pid in [item for item in process_ids if item]:
db.execute(delete(models.Route).where(models.Route.process == pid))
db.execute(delete(models.SerialNumber).where(models.SerialNumber.process == pid))
db.execute(delete(models.Activity).where(models.Activity.process == pid))
db.execute(delete(models.Process).where(models.Process.id == pid))
db.execute(delete(models.FormElement).where(
(models.FormElement.process == pid)
| models.FormElement.name.like(f"外部审批校验表单 {STAMP}%")
| models.FormElement.name.like(f"并行外部审批表单 {STAMP}%")
| models.FormElement.name.like(f"开始环节审批表单 {STAMP}%")))
for job in CLEANUP.get("jobs") or []:
db.execute(delete(models.NodeDecision).where(models.NodeDecision.job == job))
db.execute(delete(models.TaskCompleted).where(models.TaskCompleted.job == job))
db.execute(delete(models.Task).where(models.Task.job == job))
db.execute(delete(models.WorkLog).where(models.WorkLog.job == job))
db.execute(delete(models.WorkCompleted).where(models.WorkCompleted.job == job))
db.execute(delete(models.Work).where(models.Work.job == job))
db.execute(delete(models.OpenEvent).where(models.OpenEvent.job == job))
if CLEANUP.get("hook"):
db.execute(delete(models.OpenEvent).where(models.OpenEvent.webhook == CLEANUP["hook"]))
db.execute(delete(models.OpenWebhook).where(models.OpenWebhook.code == CLEANUP["hook"]))
for key in CLEANUP.get("prekeys") or []:
db.execute(delete(models.EmbedSession).where(models.EmbedSession.prekey == key))
for code in [CLEANUP.get("app"), CLEANUP.get("app2")]:
if code:
db.execute(delete(models.OpenToken).where(models.OpenToken.app == code))
db.execute(delete(models.OpenApp).where(models.OpenApp.code == code))
db.commit()
print("[清理] 应用、订阅、流程、单据与表态台账已删干净")
except Exception as exc: # noqa: BLE001 - 清场失败不盖住验收结论
db.rollback()
print(f"[清理] 没删干净:{exc}")
if __name__ == "__main__":
sys.exit(main())