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