1778 lines
118 KiB
Python
1778 lines
118 KiB
Python
#!/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())
|