unis-oa/backend/scripts/check_writeback_action.py

496 lines
28 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
"""环节写回的第三、第四个时刻:本环节被退回时、本环节被撤回时——跑真流程验整条链。
PYTHONPATH=. python3 scripts/check_writeback_action.py
为什么有这一份(口径见 ``docs/node-writeback-config.md`` §1 §1.5 §13):「到达本环节」与
「本环节通过后」这两个时刻写在 ``_advance`` 里,而**退回与撤回根本不经过** ``_advance``
(``go_back`` / ``reset_task`` 自己清 token、自己派待办)。所以在补这两个钩子之前,
一张单被退回、被撤回,上游一个字都收不到——不是被幂等键并掉了,是压根没入过队。
钉住十四件事:
1. **「本环节通过后」= 同意那一刻**:入队一条,``phase=leave``,报文里 ``{action.route}``
是按下去的那颗钮(``通过``)、``{action.decision}`` 是这条线的语义(``agree``)、
``{action.opinion}`` 是审批人刚填的意见;
2. **「本环节被退回时」**:点「退回」入队一条 ``phase=goBack``,挂在**按退回的这一环**上;
3. 退回**不**触发「通过后」,也**不**触发被退回到的那一环的「到达时」(口径没被放宽);
4. 设计器里 ``decision=goBack`` 那条线按下去时,报文写的是那条线的名字(``退回修改``),
不是引擎合成的那颗「退回」;
5. **「本环节被撤回时」**:撤回那条已办入队一条 ``phase=recall``,带的是撤回人填的理由;
6. **一份模板管三个时刻**:同一条规则勾 ``["leave","goBack","recall"]``,各刻各入一条、
幂等键互不相同——状态回写这类"同一个接口、只有状态值不同"不用再复制三份模板;
7. 到达 / 通过这两个时刻的幂等键**一个字节都没变**(存量单子升级后第二次命中仍并回那条);
8. 撤回后重新办一次:默认口径仍旧并回第一条(每张单每个写回点只成功一次);
9. 报文落库的时刻与按钮快照:人工重推回放原那一刻,不回头看单据现在停在哪儿;
10. 三条终态那一刻没有按钮,``{action.x}`` 渲染成空串,不报错也不卡办理;
11. 死配置在保存流程时就被挡:非人工环节配这两个时刻、环节把那颗按钮关了、
时刻名字认不得、同一模板两个时刻在幂等键里分不开——四种都是"配得挺对、永不发作";
12. ``{action.不存在的字段}`` 保存模板时点名;
13. 勾了「本环节被退回时」的模板停用了 / 不存在时,仍按既有的那句点名(这把尺子没被换掉);
14. 前端那份镜像(``utils/formWriteback.ts``)与后端同一把尺子:同一份配置,判出的毛病一样。
跑在 backend 目录下。数据源开影子模式(报文照渲染照留档,不打出去),跑完连数据源、
模板、流程、单据、报文一起删干净。
"""
from __future__ import annotations
import time
from datetime import datetime
from sqlalchemy import delete, select
from app import models
from app.db import SessionLocal
from app.engine import engine
from app.service import mapping, outbox, personref
STAMP = datetime.now().strftime("%m%d%H%M%S")
SRC = f"wba_src_{int(time.time())}"
#: 一份模板管三个时刻(状态回写那一类)
T_STATE = f"wba_state_{STAMP}"
#: 只勾「到达时」,用来验退回落到这一环时不会把它带出去
T_BEGIN_ARRIVE = f"wba_begin_arrive_{STAMP}"
#: 同一份配置,但**没勾**「重复到达时重发」:同一个时刻第二次命中仍旧并回那一条
T_ONCE = f"wba_once_{STAMP}"
#: 自定义幂等键里既没有 {event} 也没有 {phase}:同环节挂两个时刻只会发一条
T_MERGED = f"wba_merged_{STAMP}"
FAILS: list[str] = []
PASSED = 0
CLEAN: 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 payload_of(row: models.OutboundMessage) -> dict:
return dict(row.payload or {})
def next_second() -> None:
"""跨过一秒的边界再往下走:``completed_time`` 只存到秒。
撤回问的是"这一环之后有没有人办过",脚本几步挤在同一秒里跑完,前面那些环节会被算成
之后(量出来的是时钟,不是口径)。真实审批隔了几小时,撞不上这一档。
"""
time.sleep(max(0.0, 1.02 - datetime.now().microsecond / 1_000_000))
def rows_of(db, code: str, job: str, phase: str | None = None) -> list[models.OutboundMessage]:
stmt = select(models.OutboundMessage).where(
models.OutboundMessage.integration == code, models.OutboundMessage.job == job)
if phase is not None:
stmt = stmt.where(models.OutboundMessage.phase == phase)
return list(db.execute(stmt.order_by(models.OutboundMessage.revision,
models.OutboundMessage.id)).scalars().all())
def deliver(db, job: str) -> None:
"""把这张单排着的报文投干净(影子模式:照渲染照记成功,不打真接口)。"""
for _ in range(20):
waiting = db.execute(
select(models.OutboundMessage.id)
.where(models.OutboundMessage.status.in_(models.OutboundMessage.STATUS_OPEN),
models.OutboundMessage.job == job)
.limit(1)
).scalars().first()
if waiting is None:
return
outbox.run_due(db)
def mount_of(db, activity_id: str) -> dict:
row = db.get(models.Activity, activity_id)
return dict((row.config or {}).get("writeback") or {}) if row is not None else {}
def build(db, approver_ref: str, starter_ref: str) -> dict:
"""begin(只挂「到达时」)→ 财务复核(一份模板管三个时刻)→ 总监 → end。
总监那一环是故意留的:办结归档之后不许撤回已办,要验「被撤回时」,被撤回的那一步
后面必须还有一环。复核环节画两条往回走的线(一颗引擎合成的「退回」+ 一条设计器里
标了 ``decision=goBack`` 的「退回修改」),正好把两种退回入口都跑一遍。
"""
form = models.FormElement(name=f"按钮写回校验表单 {STAMP}", content={"fields": [
{"key": "amount", "label": "金额", "type": "number"},
{"key": "payWay", "label": "结算方式", "type": "text"},
]})
review_mount = {"blocks": [
# 一份模板管三个时刻:状态回写那一类"同一个接口、只有状态值不同"的写法
{"integrations": [T_STATE, T_ONCE], "trigger": ["leave", "goBack", "recall"]},
]}
db.add(form)
db.flush()
begin = models.Activity(process="", type="begin", name="发起申请", order_number=0, form=form.id,
config={"writeback": {"integrations": [T_BEGIN_ARRIVE],
"trigger": "arrive"}})
review = models.Activity(process="", type="manual", name="财务复核", order_number=1, form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}],
"allowGoBack": True, "allowRecall": True,
"writeback": review_mount})
boss = models.Activity(process="", type="manual", name="总监审批", order_number=2, form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}]})
end = models.Activity(process="", type="end", name="结束", order_number=3)
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()
for row in (begin, review, boss, end):
row.process = process.id
db.add_all([begin, review, boss, end])
db.flush()
db.add_all([
models.Route(process=process.id, name="提交", from_activity=begin.id, to_activity=review.id),
# 同意这条线在图纸上就写着"这是个同意的决定":报文里的 {action.decision} 该读到它
models.Route(process=process.id, name="通过", from_activity=review.id, to_activity=boss.id,
decision="agree"),
models.Route(process=process.id, name="退回修改", from_activity=review.id,
to_activity=begin.id, decision="goBack"),
models.Route(process=process.id, name="通过", from_activity=boss.id, to_activity=end.id),
])
db.add(models.DataSource(code=SRC, name=f"按钮写回校验数据源 {STAMP}",
direction=models.DataSource.DIRECTION_OUT,
provider=models.DataSource.PROVIDER_HTTP,
url="https://erp.invalid/api/update", shadow=True, enabled=True))
body = {"method": "POST", "path": "/api/update", "fields": [
{"to": "flowNo", "from": "{work.serial}"},
{"to": "amount", "from": "{form.amount}"},
{"to": "nodeId", "from": "{activity.id}"},
{"to": "moment", "from": "{action.phase}"},
{"to": "momentName", "from": "{action.phase_name}"},
{"to": "button", "from": "{action.route}"},
{"to": "decision", "from": "{action.decision}"},
{"to": "say", "from": "{action.opinion}"},
]}
for code, rule, refire in ((T_STATE, "", True), (T_ONCE, "", False),
(T_BEGIN_ARRIVE, "", False),
(T_MERGED, "{source}:{code}:{job}:{event_key}", False)):
db.add(models.Integration(code=code, name=f"按钮写回 {code}", source=SRC, biz_form=form.id,
# 模板自己一个触发点都不勾:这一刻发不发,全听环节挂载的
trigger_event=models.Integration.EVENT_MANUAL, event_key="",
refire_revisit=refire, idem_rule=rule, payload=dict(body)))
db.commit()
outbox.invalidate_node_triggers()
CLEAN.update(form=form.id, process=process.id)
return {"form": form.id, "process": process.id, "begin": begin.id,
"review": review.id, "boss": boss.id}
def pending(db, job: str, activity_name: str):
work = db.execute(select(models.Work).where(models.Work.job == job)).scalar_one_or_none()
task = 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().first()
return work, task
def activity_probe(*, writeback: dict, node_type: str = "manual", **flags):
"""拿一份环节配置去过保存流程时那把尺子(``mount_problems`` 只看配置,不读库里的环节)。"""
from types import SimpleNamespace
config = {"mode": "any", "taskValues": [{"type": "person", "data": ["x"]}],
"writeback": writeback}
config.update(flags)
return SimpleNamespace(id=f"act_{STAMP}", name="校验环节", type=node_type,
process="p", form=CLEAN["form"], config=config)
def route_refs() -> list[str]:
return ["提交", "通过", "退回修改"]
def main() -> int:
db = SessionLocal()
try:
return _run(db)
finally:
cleanup(db)
def _run(db) -> int:
user = db.get(models.User, 1)
if user is None:
print("[跳过] 库里没有 1 号用户,这一项校不了")
return 0
approver_ref = personref.ref_of(user)
actor = engine.Actor.from_ref(db, user, approver_ref)
ids = build(db, approver_ref, approver_ref)
# ------------------------------------------------ 1. 提交:开始环节不会被「走到」
result = engine.create_job(db, process_id=ids["process"], actor=actor,
data={"amount": 100, "payWay": "对公"}, title=f"按钮写回校验单 {STAMP}")
db.commit()
job = str(result.work.job)
CLEAN["jobs"] = [job]
check("发起那一刻不算「到达发起环节」(开始环节只会被提交)",
not rows_of(db, T_BEGIN_ARRIVE, job))
_work, review_task = pending(db, job, "财务复核")
check("走到财务复核", review_task is not None, job)
if review_task is None:
return 1
# ------------------------------------------------ 2. 同意 = 本环节通过后
next_second()
engine.execute_task(db, task_id=review_task.id, actor=actor, route_name="通过",
opinion="金额核过了,可以走", data={"amount": 100, "payWay": "对公"})
db.commit()
deliver(db, job)
leave_rows = rows_of(db, T_STATE, job, "leave")
check("「本环节审批通过后」入队一条,报文行上 phase 写着 leave",
len(leave_rows) == 1 and leave_rows[0].phase == "leave",
[(r.phase, r.status) for r in leave_rows])
one = payload_of(leave_rows[0]) if leave_rows else {}
check("报文里 {action.phase} / {action.phase_name} 说的就是「通过后」这一档",
one.get("moment") == "leave" and one.get("momentName") == "本环节审批通过后", one)
check("报文里 {action.route} 是按下去的那颗钮(通过),{action.decision} 是这条线的语义(agree)",
one.get("button") == "通过" and one.get("decision") == "agree", one)
check("报文里 {action.opinion} 是审批人刚填的那句意见(同意回写意见,不用再往表单里塞一格)",
one.get("say") == "金额核过了,可以走", one)
check("报文里 {activity.id} 与幂等键里的环节仍是本环节",
one.get("nodeId") == leave_rows[0].event_key == ids["review"],
f"{one.get('nodeId')} / {leave_rows[0].event_key}" if leave_rows else "")
# ------------------------------------------------ 3. 撤回这一步:「本环节被撤回时」
done = db.execute(
select(models.TaskCompleted).where(models.TaskCompleted.task == review_task.id)
).scalars().first()
check("财务复核这条已办在台账里", done is not None, str(review_task.id))
if done is None:
return 1
next_second()
engine.reset_task(db, task_completed_id=done.id, actor=actor, opinion="ERP 说要先改一下")
db.commit()
deliver(db, job)
recall_rows = rows_of(db, T_STATE, job, "recall")
check("「本环节被撤回时」入队一条(补这两个钩子之前,这一刻上游一个字都收不到)",
len(recall_rows) == 1 and payload_of(recall_rows[0]).get("moment") == "recall",
[(r.phase, r.idem) for r in recall_rows])
recall_payload = payload_of(recall_rows[0]) if recall_rows else {}
check("撤回那条报文里那颗钮叫「撤回」,{action.opinion} 是撤回人填的理由",
recall_payload.get("button") == "撤回"
and recall_payload.get("say") == "ERP 说要先改一下", recall_payload)
check("撤回与通过是两条报文、两个幂等键:同一份模板挂两个时刻各发一条",
len(recall_rows) == 1 and len(leave_rows) == 1
and recall_rows[0].idem != leave_rows[0].idem,
f"{getattr(recall_rows[0], 'idem', '')} / {getattr(leave_rows[0], 'idem', '')}")
check("幂等键里只有退回 / 撤回补了一截时刻;通过那一条仍是老形状(存量键一个字节都没变)",
len(leave_rows) == 1 and f":activity:{leave_rows[0].event_key}:" in leave_rows[0].idem
and ":activity:leave:" not in leave_rows[0].idem
and f":activity:recall:{recall_rows[0].event_key}:" in recall_rows[0].idem,
f"{getattr(leave_rows[0], 'idem', '')} / {getattr(recall_rows[0], 'idem', '')}"
if recall_rows and leave_rows else "")
_w2, review_task2 = pending(db, job, "财务复核")
check("撤回后待办重新落回处理人手上", review_task2 is not None, job)
if review_task2 is None:
return 1
# ------------------------------------------------ 4. 再同意一次:勾没勾「重复到达时重发」各走各的
next_second()
engine.execute_task(db, task_id=review_task2.id, actor=actor, route_name="通过",
opinion="确认 100", data={"amount": 100, "payWay": "对公"})
db.commit()
deliver(db, job)
leave_again = rows_of(db, T_STATE, job, "leave")
check("勾了「重复到达时重发」:撤回后重新办一次,同一时刻修订版 +1 再发一条",
len(leave_again) == 2 and int(leave_again[-1].revision) == 2,
[(r.revision, r.status) for r in leave_again])
once_leave = rows_of(db, T_ONCE, job, "leave")
check("没勾重发的那一份照旧口径:第二次命中并回那一条,发件箱不多行",
len(once_leave) == 1, [(r.revision, r.status) for r in once_leave])
# ------------------------------------------------ 5. 退回:时刻归"按退回的那一环"
_w3, boss_task = pending(db, job, "总监审批")
check("单子走到总监审批", boss_task is not None, job)
if boss_task is None:
return 1
engine.go_back(db, task_id=boss_task.id, actor=actor, target=ids["review"], opinion="票据少一张")
db.commit()
deliver(db, job)
check("总监那一环没挂写回:它按的退回不会牵连到复核环节身上那份 goBack",
not rows_of(db, T_STATE, job, "goBack"),
[(r.event_key, r.phase) for r in rows_of(db, T_STATE, job, "goBack")])
check("退回不触发「本环节审批通过后」",
len(rows_of(db, T_STATE, job, "leave")) == 2,
len(rows_of(db, T_STATE, job, "leave")))
# 复核环节自己按退回:这一刻才该发,而且发的就是这一环那一份配置
_w4, review_task3 = pending(db, job, "财务复核")
check("退回后待办回到财务复核", review_task3 is not None, job)
if review_task3 is None:
return 1
engine.go_back(db, task_id=review_task3.id, actor=actor, target=ids["begin"], opinion="金额再改一下")
db.commit()
deliver(db, job)
back_rows = rows_of(db, T_STATE, job, "goBack")
check("「本环节被退回时」入队一条,挂在按退回的这一环上",
len(back_rows) == 1 and back_rows[0].event_key == ids["review"],
[(r.event_key, r.phase) for r in back_rows])
back_payload = payload_of(back_rows[0]) if back_rows else {}
check("报文里那颗钮是引擎合成的「退回」(decision=goBack),{action.opinion} 是退回理由",
back_payload.get("button") == "退回" and back_payload.get("decision") == "goBack"
and back_payload.get("say") == "金额再改一下", back_payload)
check("退回到发起环节也不算「到达本环节」:那一环挂的「到达时」一条都没发",
not rows_of(db, T_BEGIN_ARRIVE, job), f"{len(rows_of(db, T_BEGIN_ARRIVE, job))} 条")
replay_row = back_rows[0]
# ------------------------------------------------ 6. 人工重推回放"当初那一刻"
outbox.replay(db, replay_row.id, actor=actor, reason="校验重推")
db.commit()
pushed = db.get(models.OutboundMessage, replay_row.id)
check("人工重推仍按入队那一刻的时刻与按钮渲染(不回头看单据现在停在哪儿)",
pushed.phase == "goBack" and payload_of(pushed).get("moment") == "goBack"
and payload_of(pushed).get("button") == "退回" and int(pushed.revision) == 2,
(pushed.phase, payload_of(pushed), pushed.revision))
check("重推只换修订版,不换幂等键里那一截时刻",
f":activity:goBack:{replay_row.event_key}:2" in pushed.idem, pushed.idem)
deliver(db, job)
# ------------------------------------------------ 7. 设计器里那条 goBack 线也要点名
_w5, begin_task = pending(db, job, "发起申请")
check("退回后待办回到发起人手上", begin_task is not None, job)
if begin_task is None:
return 1
engine.execute_task(db, task_id=begin_task.id, actor=actor, route_name="提交",
opinion="改成 888 重新提交", data={"amount": 888, "payWay": "对公"})
db.commit()
deliver(db, job)
_w6, review_task4 = pending(db, job, "财务复核")
check("重新提交后又回到财务复核", review_task4 is not None, job)
if review_task4 is None:
return 1
# 这一次按的是图纸上那条「退回修改」(decision=goBack),报文写的该是它自己的名字
engine.execute_task(db, task_id=review_task4.id, actor=actor, route_name="退回修改",
opinion="缺发票,退回补", data={"amount": 888, "payWay": "对公"})
db.commit()
deliver(db, job)
back_again = rows_of(db, T_STATE, job, "goBack")
check("同一时刻的第二次命中:勾了重发就再发一条",
len(back_again) == 2, [(r.revision, r.status) for r in back_again])
# 取"最新入队的那一条"要按 id 排(``new_time_id`` 等于入队先后):上面那次人工重推把
# 老那一行的修订版顶到了 2,新入队这条反而拿到修订版 1,按修订版排会挑到旧的那一份
named = payload_of(max(back_again, key=lambda row: row.id)) if back_again else {}
check("报文里写的是那条线的名字「退回修改」,不是引擎合成的那颗「退回」",
named.get("button") == "退回修改" and named.get("decision") == "goBack"
and named.get("say") == "缺发票,退回补", named)
check("退回那一刻的报文取的是这一环最新的字段值",
str(named.get("amount")) == "888", named)
check("没勾重发的那一份:第二次退回仍旧并回第一条(同一个时刻只成功一次)",
len(rows_of(db, T_ONCE, job, "goBack")) == 1,
[(r.revision, r.status) for r in rows_of(db, T_ONCE, job, "goBack")])
check("三个时刻各自成行:通过后 / 被撤回 / 被退回互不吞掉",
len({row.phase for row in rows_of(db, T_STATE, job)}) == 3,
[(r.phase, r.revision) for r in rows_of(db, T_STATE, job)])
# ------------------------------------------------ 8. 三条终态那一刻没有按钮
blank = mapping.render_template(
db, {"method": "POST", "fields": [{"to": "m", "from": "{action.phase}"},
{"to": "s", "from": "{action.opinion}"},
{"to": "n", "from": "{activity.id}"}]},
data={}, work=None)
check("终态那一刻没有环节也没有按钮:{action.*} 与 {activity.*} 都渲染成空串,不报错",
blank == {"m": "", "s": "", "n": ""}, blank)
# ------------------------------------------------ 9. 死配置:保存流程时就挡下来
problems = mapping.mount_problems(db, [activity_probe(node_type="choice", writeback={"integrations": [T_STATE],
"trigger": "goBack"})], route_refs())
check("分支环节配「本环节被退回时」被挡(这一环没人按按钮,配了就是不发)",
any("不会有这一刻" in item for item in problems), problems)
problems = mapping.mount_problems(db, [activity_probe(writeback={"integrations": [T_STATE],
"trigger": "recall"})],
route_refs())
check("「本环节被撤回时」在开着撤回的审批环节上过得了这把尺子", not problems, problems)
problems = mapping.mount_problems(db, [activity_probe(allowRecall=False, writeback={"integrations": [T_STATE],
"trigger": "recall"})], route_refs())
check("环节把「撤回」按钮关了还配这个时刻 → 保存流程点名",
any("把「撤回」按钮关了" in item for item in problems), problems)
problems = mapping.mount_problems(db, [activity_probe(allowGoBack=False, writeback={"integrations": [T_STATE],
"trigger": "goBack"})], route_refs())
check("环节把「退回」按钮关了还配这个时刻 → 同样点名",
any("把「退回」按钮关了" in item for item in problems), problems)
problems = mapping.mount_problems(db, [activity_probe(writeback={"integrations": [T_STATE],
"trigger": "onSubmit"})], route_refs())
check("时刻名字认不得时点名,并给出可选项", any("的触发时机不支持:onSubmit" in item
for item in problems), problems)
problems = mapping.mount_problems(db, [activity_probe(writeback={"integrations": [T_STATE],
"trigger": "go_back"})], route_refs())
check("下划线写法(go_back)归一成 goBack:不被判成不认识", not problems, problems)
# 同一模板挂两个时刻:默认幂等键分得开,不挡;自定义键里既没 {event} 也没 {phase} 就挡
probe = activity_probe(writeback={"blocks": [
{"integrations": [T_STATE], "trigger": "leave"},
{"integrations": [T_STATE], "trigger": "goBack"},
]})
problems = mapping.mount_problems(db, [probe], route_refs())
check("同一份模板挂「通过后」+「被退回时」不再算撞键(这正是三个时刻共用一份模板的用法)",
not problems, problems)
probe = activity_probe(writeback={"blocks": [
{"integrations": [T_MERGED], "trigger": "leave"},
{"integrations": [T_MERGED], "trigger": "goBack"},
]})
problems = mapping.mount_problems(db, [probe], route_refs())
check("自定义幂等键里既没 {event} 也没 {phase}:两个时刻挂同一个模板被挡,并说要加 {phase}",
any("{phase}" in item for item in problems), problems)
probe = activity_probe(writeback={"blocks": [
{"integrations": [T_STATE], "trigger": "arrive"},
{"integrations": [T_STATE], "trigger": "leave"},
]})
problems = mapping.mount_problems(db, [probe], route_refs())
check("「到达时」与「通过后」挂同一个模板仍旧撞(这两个时刻的键里都没时刻段)",
any("重复" in item for item in problems), problems)
# ------------------------------------------------ 10. 模板那一层的写法校验
bad = {"code": f"wba_bad_{STAMP}", "name": "写坏的按钮取值", "source": SRC,
"bizForm": CLEAN["form"], "triggerEvents": [], "triggerEvent": "manual",
"payload": {"method": "POST", "path": "/x",
"fields": [{"to": "a", "from": "{action.notAField}"}]}}
problems = mapping.problems(db, bad)
check("``{action.不存在的字段}`` 保存模板时点名(与 {activity.*} 同一把尺子)",
any("action.notAField" in item for item in problems), problems)
print()
if FAILS:
print(f"{len(FAILS)} 条没对上:")
for item in FAILS:
print(f" - {item}")
else:
print(f"全部 {PASSED} 条对上。")
return 1 if FAILS else 0
def cleanup(db) -> None:
jobs = CLEAN.get("jobs") or []
if jobs:
db.execute(delete(models.OutboundMessage).where(models.OutboundMessage.job.in_(jobs)))
db.execute(delete(models.Task).where(models.Task.job.in_(jobs)))
db.execute(delete(models.TaskCompleted).where(models.TaskCompleted.job.in_(jobs)))
db.execute(delete(models.Work).where(models.Work.job.in_(jobs)))
db.execute(delete(models.WorkCompleted).where(models.WorkCompleted.job.in_(jobs)))
db.execute(delete(models.WorkLog).where(models.WorkLog.job.in_(jobs)))
if CLEAN.get("process"):
db.execute(delete(models.Route).where(models.Route.process == CLEAN["process"]))
db.execute(delete(models.Activity).where(models.Activity.process == CLEAN["process"]))
db.execute(delete(models.Process).where(models.Process.id == CLEAN["process"]))
db.execute(delete(models.Integration).where(models.Integration.code.like("wba_%")))
db.execute(delete(models.DataSource).where(models.DataSource.code == SRC))
if CLEAN.get("form"):
db.execute(delete(models.FormElement).where(models.FormElement.id == CLEAN["form"]))
db.commit()
outbox.invalidate_node_triggers()
print("[清理] 数据源、写回模板、流程、单据与发件箱报文已删干净")
if __name__ == "__main__":
raise SystemExit(main())