unis-oa/backend/scripts/check_oa_lock_api.py

473 lines
27 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

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

#!/usr/bin/env python3
"""OA 按钮锁定的连库验收:锁上之后 OA 点不动、外部那三条通道一点都没被误伤。
PYTHONPATH=. python3 scripts/check_oa_lock_api.py
判据本身(继承、四通道判定表、那三条死锁、卡片那一格)由 ``check_node_approve.py`` 钉住;
这一份跑真单据,验的是"该挡的真挡住了、该成的真没被连带挡掉"。
设计见 ``docs/node-oa-lock-design.md`` §9 第二组。
跑完连自己造的应用、流程、单据与表态一起删干净。
"""
from __future__ import annotations
import sys
import time
from datetime import datetime, timedelta
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 node_approve, personref
STAMP = datetime.now().strftime("%m%d%H%M%S")
APP_CODE = f"oa_lock_{int(time.time())}"
APP_NAME = f"ERP 合同系统 {STAMP}"
FAILS: list[str] = []
PASSED = 0
CLEANUP: dict = {"processes": [], "jobs": []}
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 open_approve(*, confirm: str, lock: dict | None,
decisions: dict | None = None) -> dict:
config = {
"enabled": True,
"apps": [APP_CODE],
"confirm": confirm,
"decisions": decisions or {"APPROVED": "agree", "REJECTED": "refuse"},
"routes": {"refuse": "退回修改"},
}
if lock is not None:
config["oaLock"] = lock
return config
def build_process(db, approver_ref: str, *, label: str, manual_lock: dict | None,
confirm: str = "auto", timeout: bool = False,
begin_lock: dict | None = None) -> str:
"""begin →(可锁)财务复核 → 总监审批 → end。
「总监审批」那一环**不开**外部审批,专门用来当对照组:批量办理里混一条锁住的、
一条没锁的,只有前者该失败。开始环节另配一份(第三方替发起人按提交那颗钮)。
"""
form = models.FormElement(name=f"OA 按钮锁定校验表单 {STAMP} {label}", content={"fields": []})
db.add(form)
db.flush()
process = models.Process(name=f"OA 按钮锁定流程 {STAMP} {label}", 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": open_approve(
confirm="auto", lock=begin_lock,
decisions={"SUBMITTED": "submit"})}
if begin_lock is not None 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]}],
# 超时动作挂在环节配置上,不在 openApprove 里:锁上之后
# 定时器要绕开的正是自己这一环的自动办理
**({"timeoutAction": "autoPass"} if timeout else {}),
"openApprove": open_approve(confirm=confirm, lock=manual_lock)})
tail = 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)
db.add_all([begin, manual, tail, 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=begin.id),
models.Route(process=process.id, name="通过", from_activity=manual.id, to_activity=tail.id),
models.Route(process=process.id, name="通过", from_activity=tail.id, to_activity=end.id),
])
db.commit()
CLEANUP["processes"].append(process.id)
return process.id
def start_work(db, process_id: str, actor: engine.Actor, title: str, *, hold: bool = False,
via: str = "") -> str:
"""建一张单。``hold=True`` 那一档按外部通道建(与 ``POST /open/works`` 同一条路)。
停在开始环节的这一单在产品里只有第三方那条通道建得出来:开始环节锁了 ``start``
时 OA 侧发起本来就该被挡(``create_job`` 那一道 ``starting=True`` 的闸),
拿默认 ``via`` 建单会先撞在那句话上,测不到后面想测的东西。
"""
result = engine.create_job(db, process_id=process_id, actor=actor, data={}, title=title,
hold_at_begin=hold,
via=via or (engine.VIA_OPEN if hold else engine.VIA_OA))
db.commit()
CLEANUP["jobs"].append(str(result.work.job))
return str(result.work.job)
def task_of(db, job: str, activity_name: str):
work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_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 message_of(response) -> str:
body = response.json() or {}
return str(body.get("message") or body.get("detail") or response.text)[:300]
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": APP_NAME,
"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
CLEANUP["app"] = APP_CODE
data = created.json().get("data") or {}
got = client.post("/api/v1/open/token", json={
"appKey": data.get("appKey", ""), "appSecret": data.get("appSecret", "")})
open_token = str((got.json() or {}).get("data", {}).get("accessToken") or "")
check("换到了开放平台访问令牌", bool(open_token), got.text[:160])
open_headers = {"Authorization": f"Bearer {open_token}"}
# ============================================ 主场景:auto 模式 + 默认那一组锁
process_a = build_process(db, approver_ref, label="主", confirm="auto",
manual_lock={"enabled": True})
job1 = start_work(db, process_a, actor, f"OA 锁定校验 {STAMP} 一号")
work1, task1 = task_of(db, job1, "财务复核")
check("单据走到了锁着的那一环", task1 is not None, job1)
if task1 is None:
return 1
task_id1, activity_id1, title1 = str(task1.id), str(task1.activity), str(work1.title)
detail = client.get(f"/api/v1/task/{task_id1}", headers=headers).json().get("data") or {}
brief = (detail.get("activity_nodes") or {}).get(activity_id1) or {}
lock = brief.get("oa_lock") or {}
check("任务详情随环节简报带回 oa_lock(锁了哪几颗、去哪儿办、那句说明)",
lock.get("locked") is True
and lock.get("actions") == list(node_approve.LOCK_ACTIONS_DEFAULT)
and APP_NAME in str(lock.get("text") or "")
and lock.get("allowConfirm") is True, str(lock)[:220])
rows = client.get("/api/v1/task/processing", headers=headers,
params={"keyword": title1}).json().get("data") or {}
line = next((item for item in rows.get("items") or [] if item.get("id") == task_id1), {})
check("待办列表这一行标了 oa_locked(界面挂标签、批量默认不勾)",
line.get("oa_locked") is True, str(line)[:160])
blocked = client.post(f"/api/v1/task/{task_id1}/execute", headers=headers,
json={"route_name": "通过", "opinion": "OA 里点一下"})
text = message_of(blocked)
check("锁上之后 OA 里那颗「同意」点不动:400 + 点名去哪儿办 + 给出路",
blocked.status_code == 400 and APP_NAME in text and "流程监控" in text, text)
back = client.post(f"/api/v1/task/{task_id1}/goback", headers=headers, json={"opinion": "退回去"})
check("锁了 goBack:那颗「退回」同样点不动",
back.status_code == 400 and "退回" in message_of(back), message_of(back))
locate = client.post("/api/v1/open/nodes/locate", headers=open_headers,
json={"work": job1, "detail": "full"})
card = ((locate.json() or {}).get("data") or {}).get("openApprove") or {}
check("接口卡片 / locate 带 oaLocked=true(给对方程序读的硬约束:OA 里没人会点)",
card.get("oaLocked") is True and (card.get("oaLock") or {}).get("where") == APP_NAME,
str(card)[:200])
decided = client.post(f"/api/v1/open/nodes/{job1}/{activity_id1}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"LOCK-{STAMP}-1"})
check("外部那条 decide 不受锁影响:当场把这一环办掉",
decided.status_code == 200 and ((decided.json() or {}).get("data") or {}).get("handled") is True,
message_of(decided))
db.rollback()
done1 = db.execute(select(models.TaskCompleted).where(
models.TaskCompleted.task == task_id1)).scalars().first()
# ------------------------------- 撤回:OA 撤不回(锁),外部那条撤得回(不关锁的事)
if done1 is not None:
recalled = client.post(f"/api/v1/taskcompleted/{done1.id}/reset", headers=headers,
json={"opinion": "OA 里想撤回"})
check("锁了 recall:已办那条在 OA 里撤不回,句子点名外部系统",
recalled.status_code == 400 and APP_NAME in message_of(recalled), message_of(recalled))
db.rollback()
items = (client.get("/api/v1/task/completed", headers=headers,
params={"keyword": title1}).json().get("data") or {}).get("items") or []
mine = next((item for item in items if item.get("id") == done1.id), {})
check("已办列表那一行把撤回置灰并带上同一句原因",
mine.get("recallable") is False and APP_NAME in str(mine.get("recall_blocker") or ""),
str(mine)[:220])
open_recall = client.post(f"/api/v1/open/tasks/completed/{done1.id}/recall", headers=open_headers,
json={"opinion": "外部系统自己收回"})
check("外部那条撤回照成:锁只管 OA 那几颗钮,不关外部通道的事",
open_recall.status_code == 200, message_of(open_recall))
# ================================== 批量办理:只失败锁住的那一条,其余照常办结
job2 = start_work(db, process_a, actor, f"OA 锁定校验 {STAMP} 二号")
client.post(f"/api/v1/open/nodes/{job2}/{activity_id1}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"LOCK-{STAMP}-2"})
db.rollback()
_, open_task = task_of(db, job2, "总监审批")
check("二号单已被外部办到「总监审批」(这一环没开锁,是对照组)", open_task is not None, job2)
job3 = start_work(db, process_a, actor, f"OA 锁定校验 {STAMP} 三号")
_, locked_task = task_of(db, job3, "财务复核")
check("三号单停在锁着的那一环", locked_task is not None, job3)
if open_task is not None and locked_task is not None:
batch = client.post("/api/v1/task/batch-execute", headers=headers, json={
"task_ids": [str(open_task.id), str(locked_task.id)],
"route_name": "通过", "opinion": "批量同意"})
batch_data = (batch.json() or {}).get("data") or {}
errors = batch_data.get("errors") or []
check("批量办理里混一条锁住的:只失败那一条,带回来的还是那一句",
batch.status_code == 200 and int(batch_data.get("succeeded") or 0) == 1
and int(batch_data.get("failed") or 0) == 1
and len(errors) == 1 and errors[0].get("id") == str(locked_task.id)
and APP_NAME in str(errors[0].get("message") or ""), str(batch_data)[:260])
# ------------------------------- 加签 / 转办:默认不锁(不表态,只是挪待办)
added = client.post(f"/api/v1/task/{locked_task.id}/addtask", headers=headers,
json={"identities": [approver_ref], "way": "after", "opinion": "加个人看看"})
check("加签默认不锁:不表态的动作照旧点得动", added.status_code == 200, message_of(added))
moved = client.post(f"/api/v1/task/{locked_task.id}/transfer", headers=headers,
json={"identities": [approver_ref], "opinion": "挪给别人看看"})
check("转办默认不锁:把待办挪个人手不算表态", moved.status_code == 200, message_of(moved))
# ======================================== 勾上 transfer 之后:本人换不动,管理员换得动
process_b = build_process(db, approver_ref, label="转办锁", confirm="auto",
manual_lock={"enabled": True, "actions": ["handle", "transfer"]})
job4 = start_work(db, process_b, actor, f"OA 锁定校验 {STAMP} 四号")
_, task4 = task_of(db, job4, "财务复核")
check("只锁 handle + transfer 的那一环也建起来了", task4 is not None, job4)
if task4 is not None:
refused = client.post(f"/api/v1/task/{task4.id}/transfer", headers=headers,
json={"identities": [approver_ref], "opinion": "换人"})
check("勾上 transfer 之后本人换不动人了:句子说清这一环归外部",
refused.status_code == 400 and "转办" in message_of(refused), message_of(refused))
helped = client.post(f"/api/v1/admin/task/{task4.id}/transfer", headers=headers,
json={"identities": [approver_ref], "opinion": "管理员替他把人换好"})
check("流程监控里的改派不看环节开关:干预层是这条闸的兜底",
helped.status_code == 200, message_of(helped))
# ================================ confirm 模式:横幅那条路认 allowConfirm,不认 handle
process_c = build_process(db, approver_ref, label="点头", confirm="confirm",
manual_lock={"enabled": True})
job5 = start_work(db, process_c, actor, f"OA 锁定校验 {STAMP} 五号")
_, task5 = task_of(db, job5, "财务复核")
if task5 is None:
check("五号单停在财务复核", False, job5)
else:
staged = client.post(f"/api/v1/open/nodes/{job5}/{task5.activity}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"LOCK-{STAMP}-5"})
decision5 = str(((staged.json() or {}).get("data") or {}).get("decisionId") or "")
check("锁着 + confirm 模式:第三方备好的表态照旧停着等人点头",
staged.status_code == 200 and bool(decision5), message_of(staged))
nodded = client.post(f"/api/v1/task/{task5.id}/node-decision/{decision5}/confirm", headers=headers)
check("allowConfirm 开着(默认):横幅那条路走得通,锁不挡它",
nodded.status_code == 200, message_of(nodded))
process_d = build_process(db, approver_ref, label="不点头", confirm="confirm",
manual_lock={"enabled": True, "allowConfirm": False})
job6 = start_work(db, process_d, actor, f"OA 锁定校验 {STAMP} 六号")
_, task6 = task_of(db, job6, "财务复核")
if task6 is None:
check("六号单停在财务复核", False, job6)
else:
staged6 = client.post(f"/api/v1/open/nodes/{job6}/{task6.activity}/decide", headers=open_headers,
json={"result": "APPROVED", "bizKey": f"LOCK-{STAMP}-6"})
decision6 = str(((staged6.json() or {}).get("data") or {}).get("decisionId") or "")
detail6 = client.get(f"/api/v1/task/{task6.id}", headers=headers).json().get("data") or {}
lock6 = ((detail6.get("activity_nodes") or {}).get(str(task6.activity)) or {}).get("oa_lock") or {}
check("简报把 allowConfirm=false 也带给界面(横幅该整段收起,不是按钮置灰)",
lock6.get("allowConfirm") is False and lock6.get("locked") is True, str(lock6)[:200])
forced = client.post(f"/api/v1/task/{task6.id}/node-decision/{decision6}/confirm", headers=headers)
check("关掉点头之后硬要确认:400 且句子里点名是配置关的",
forced.status_code == 400 and "外部表态仍可在 OA 确认" in message_of(forced),
message_of(forced))
# ================================================== 开始环节:那颗「提交」归第三方按
process_e = build_process(db, approver_ref, label="开始环节", manual_lock=None,
begin_lock={"enabled": True, "actions": ["start"]})
job7 = start_work(db, process_e, actor, f"OA 锁定校验 {STAMP} 七号", hold=True)
db.rollback()
oa_start_blocked = None
try:
engine.create_job(db, process_id=process_e, actor=actor, data={},
title=f"OA 锁定校验 {STAMP} 七号·OA 侧发起", hold_at_begin=True)
db.rollback()
except engine.EngineError as exc:
oa_start_blocked = str(exc)
db.rollback()
check("锁了 start 的开始环节:OA 侧连发起都建不出单,句子说清该去外部系统发起",
oa_start_blocked is not None and "提交已交给外部系统" in oa_start_blocked
and "发起" in oa_start_blocked, str(oa_start_blocked)[:220])
work7 = db.execute(select(models.Work).where(models.Work.job == job7)).scalar_one_or_none()
check("hold 建的那一单停在开始环节", work7 is not None and work7.activity_type == "begin", job7)
start_blocked = client.post(f"/api/v1/job/{job7}/start", headers=headers, json={"route": "提交"})
check("开始环节锁了 start:发起人自己按不动那颗「提交」",
start_blocked.status_code == 400 and "提交" in message_of(start_blocked),
message_of(start_blocked))
begin_activity = db.execute(select(models.Activity).where(
models.Activity.process == process_e, models.Activity.type == "begin")).scalars().first()
detail7 = client.get(f"/api/v1/job/{job7}", headers=headers).json().get("data") or {}
lock7 = ((detail7.get("activity_nodes") or {}).get(str(begin_activity.id)) or {}).get("oa_lock") or {}
check("单据详情也带着开始环节那份锁(详情页那颗提交要置灰)",
lock7.get("locked") is True and "start" in (lock7.get("actions") or []), str(lock7)[:200])
submitted = client.post(f"/api/v1/open/nodes/{job7}/{begin_activity.id}/decide", headers=open_headers,
json={"result": "SUBMITTED", "bizKey": f"LOCK-{STAMP}-7"})
check("第三方替发起人按那颗「提交」不受锁影响",
submitted.status_code == 200 and ((submitted.json() or {}).get("data") or {}).get("handled") is True,
message_of(submitted))
# ---------- 发起页那颗「发起」=开始环节那颗「提交」:锁上之后 OA 侧发不起这条流程
# 界面这一侧读的是流程定义报文里那一格锁(发起页任何登录用户可读),引擎那一句才是闸。
brief_e = client.get(f"/api/v1/process/processes/{process_e}", headers=headers).json().get("data") or {}
begin_brief = next((item for item in brief_e.get("activities") or []
if str(item.get("type") or "") == "begin"), {})
begin_lock_view = begin_brief.get("oa_lock") or {}
check("流程定义报文带着开始环节那份锁(发起页那颗「发起」据此置灰)",
begin_lock_view.get("locked") is True
and "start" in (begin_lock_view.get("actions") or [])
and APP_NAME in str(begin_lock_view.get("text") or ""), str(begin_lock_view)[:200])
start_locked_9 = client.post("/api/v1/job", headers=headers,
json={"process": process_e, "title": f"OA 锁定校验 {STAMP} 九号"})
text9 = message_of(start_locked_9)
check("锁了 start 的流程:OA 里连发起都点不动,400 说清去哪儿发起、这一趟没建出单",
start_locked_9.status_code == 400 and APP_NAME in text9 and "发起" in text9
and db.execute(select(models.Work).where(
models.Work.title == f"OA 锁定校验 {STAMP} 九号")).scalar_one_or_none() is None,
text9)
# 只勾 handle 的那一环也算:开始环节上这两颗就是同一颗「提交」,挡一条漏一条最坑人
process_g = build_process(db, approver_ref, label="只勾提交", manual_lock=None,
begin_lock={"enabled": True, "actions": ["handle"]})
handle_only = client.post("/api/v1/job", headers=headers,
json={"process": process_g, "title": f"OA 锁定校验 {STAMP} 十号"})
check("开始环节只勾 handle:那颗「提交」照样锁着(这一环上两颗是同一颗)",
handle_only.status_code == 400 and "提交" in message_of(handle_only),
message_of(handle_only))
brief_g = client.get(f"/api/v1/process/processes/{process_g}", headers=headers).json().get("data") or {}
lock_g = next((item.get("oa_lock") or {} for item in brief_g.get("activities") or []
if str(item.get("type") or "") == "begin"), {})
check("简报把这一环上的两颗一起报出去(界面不用自己补另一半)",
{"handle", "start"} <= set(lock_g.get("actions") or []), str(lock_g)[:200])
# 对照组:锁开着但没勾提交的那一环,OA 该发得起——闸只锁它认得的那一颗
process_h = build_process(db, approver_ref, label="没勾提交", manual_lock=None,
begin_lock={"enabled": True, "actions": ["recall"]})
started_h = client.post("/api/v1/job", headers=headers,
json={"process": process_h, "title": f"OA 锁定校验 {STAMP} 十一号"})
job11 = str(((started_h.json() or {}).get("data") or {}).get("job") or "")
if job11:
CLEANUP["jobs"].append(job11)
check("开始环节锁着但没勾提交:OA 照样发得起(没勾的那颗照旧点得动)",
started_h.status_code == 200 and bool(job11), message_of(started_h))
# 外部那条建单路不受影响:锁只管 OA 那几颗钮,代发起与开放平台建单照旧
open_created = client.post("/api/v1/open/works", headers=open_headers, json={
"process": process_e, "identity": approver_ref,
"title": f"OA 锁定校验 {STAMP} 十二号", "data": {}})
job12 = str((((open_created.json() or {}).get("data") or {}).get("work") or {}).get("job") or "")
if job12:
CLEANUP["jobs"].append(job12)
check("第三方那条建单不受锁影响:锁着 start 的开始环节照样建得出、也提交得出去",
open_created.status_code == 200 and bool(job12), message_of(open_created))
# ==================================== 超时:锁上之后定时器不绕过自己的锁,只发提醒
process_f = build_process(db, approver_ref, label="超时", confirm="auto",
manual_lock={"enabled": True}, timeout=True)
job8 = start_work(db, process_f, actor, f"OA 锁定校验 {STAMP} 八号")
_, task8 = task_of(db, job8, "财务复核")
check("八号单停在配了超时自动通过的那一环", task8 is not None, job8)
if task8 is not None:
task8.expire_time = datetime.now() - timedelta(minutes=5)
db.commit()
engine.mark_expired(db)
db.commit()
db.rollback()
again = db.get(models.Task, task8.id)
notes = db.execute(select(models.Notification).where(
models.Notification.task == str(task8.id))).scalars().all()
check("锁上之后超时不代办:待办还压在第三方那一环上,没被定时器办掉",
again is not None and again.status == "pending", getattr(again, "status", ""))
check("超时改成发一条待阅,说清这一环归外部、不自动办",
any(APP_NAME in f"{row.title}{row.body}" for row in notes),
" / ".join(row.title for row in notes)[:200])
print()
if FAILS:
print(f"{len(FAILS)} 条没对上:")
for item in FAILS:
print(f" - {item}")
return 1
print(f"全部 {PASSED} 条对上。")
return 0
def cleanup(db) -> None:
try:
for pid in CLEANUP["processes"]:
db.execute(delete(models.Route).where(models.Route.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.name.like(f"OA 按钮锁定校验表单 {STAMP}%")))
for job in CLEANUP["jobs"]:
db.execute(delete(models.Notification).where(models.Notification.job == job))
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("app"):
db.execute(delete(models.OpenToken).where(models.OpenToken.app == CLEANUP["app"]))
db.execute(delete(models.OpenApp).where(models.OpenApp.code == CLEANUP["app"]))
db.commit()
print("[清理] 应用、流程、单据与表态台账已删干净")
except Exception as exc: # noqa: BLE001 - 清场失败不盖住验收结论
db.rollback()
print(f"[清理] 没删干净:{exc}")
if __name__ == "__main__":
sys.exit(main())