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