421 lines
24 KiB
Python
421 lines
24 KiB
Python
#!/usr/bin/env python3
|
||
"""流程中间环节写回:字段改了要不要再发、退回 / 撤回后还能不能发——跑真流程验整条链。
|
||
|
||
PYTHONPATH=. python3 scripts/check_writeback_revisit.py
|
||
|
||
回答的是配写回时最容易被"发件箱干干净净"骗到的四个真问题:
|
||
|
||
1. **发起那一刻**(发起环节挂「提交单据时」)把发起人编辑过的字段回写出去;
|
||
2. **退回后改了字段再提交**:勾了「重复到达时重发」的模板修订版 +1、真再发一条,
|
||
报文取的是**改后的新值**;没勾的照老口径每张单只成功一次(这是设计,不是坏了);
|
||
3. **走到某个环节**(到达时 / 审批通过后)把该环节审批人改过的字段回写出去;
|
||
4. **已办被撤回、处理人再办一次**:这一环的写回同样修订版 +1 再发一条。
|
||
|
||
数据源开影子模式(报文照渲染照留档,不打出去),跑完连数据源、模板、流程、单据、
|
||
报文一起删干净。
|
||
|
||
顺带钉住「第二次命中撞上一条还在途」那一档的口径:请求仍只有一次(幂等键与修订版都不动),
|
||
但那条还没出门的报文按当下最新的字段值重渲染——并回不是发旧值的理由。
|
||
已成功的报文是"对面已经收到过什么"的事实,不回改。
|
||
|
||
这一档要的是"第一条此刻确实还在途"。本机常驻的 dev 服务会在报文入队当场被叫醒、
|
||
把它直接投成功(影子模式也算成功),于是第二次命中合法地另起一条——那是有人在旁边
|
||
替我们投递,不是幂等并回坏了,所以这一档四条按「跳过」记。要一份干净结论:停掉常驻
|
||
服务再跑,或先抢走 ``scheduler`` 租约(见 ``app/service/leader.py``)。
|
||
"""
|
||
|
||
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"wb_src_{int(time.time())}"
|
||
T_SUBMIT_REFIRE = f"wb_submit_refire_{STAMP}"
|
||
T_SUBMIT_ONCE = f"wb_submit_once_{STAMP}"
|
||
T_ARRIVE = f"wb_arrive_{STAMP}"
|
||
T_LEAVE = f"wb_leave_{STAMP}"
|
||
T_DECLARE_ELSEWHERE = f"wb_declare_elsewhere_{STAMP}"
|
||
|
||
FAILS: list[str] = []
|
||
PASSED = 0
|
||
SKIPPED: list[str] = []
|
||
CLEAN: dict = {}
|
||
|
||
|
||
def check(label: str, condition, detail: str = "", *, soft: bool = False) -> None:
|
||
global PASSED
|
||
if condition:
|
||
PASSED += 1
|
||
print(f"[通过] {label}")
|
||
elif soft:
|
||
# 断言的前置条件被环境抢走了(见第 6 段那句"第一条还在途"),不是行为变了
|
||
SKIPPED.append(label)
|
||
print(f"[跳过] {label}{f' -> {detail}' if detail else ''}")
|
||
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`` 只存到秒。
|
||
|
||
``reset_task`` 问的是"这一环之后有没有人办过"(``completed_time >= 那一刻``),
|
||
脚本几步挤在同一秒里跑完,前面那些环节就会被算成"后续环节已处理,无法撤回"——
|
||
报出来的是时钟,不是撤回口径。真实审批隔了几小时,撞不上这一档。
|
||
"""
|
||
time.sleep(max(0.0, 1.02 - datetime.now().microsecond / 1_000_000))
|
||
|
||
|
||
def rows_of(db, code: str, job: str) -> list[models.OutboundMessage]:
|
||
"""这张单在这个模板上的全部报文,按修订版排(重发一次多一条,肉眼可数)。"""
|
||
return list(db.execute(
|
||
select(models.OutboundMessage)
|
||
.where(models.OutboundMessage.integration == code, models.OutboundMessage.job == job)
|
||
.order_by(models.OutboundMessage.revision, models.OutboundMessage.id)
|
||
).scalars().all())
|
||
|
||
|
||
def deliver(db, job: str = "") -> None:
|
||
"""把入队的报文投干净(影子模式:照渲染照记成功,不打真接口)。
|
||
|
||
``due()`` 对**同一张单每轮只取队首一条**(办结写回必须排在冻结写回后面,不并发抢发),
|
||
所以要一轮一轮跑到没有待发为止——线上是后台线程 15/60 秒一醒,这里连着跑几轮。
|
||
不等干净就断言重发,会撞上"上一条还在途 → 幂等键并回那一条",测出来的是假结论。
|
||
"""
|
||
for _ in range(20):
|
||
waiting = db.execute(
|
||
select(models.OutboundMessage.id)
|
||
.where(models.OutboundMessage.status.in_(models.OutboundMessage.STATUS_OPEN),
|
||
*( [models.OutboundMessage.job == job] if job else [] ))
|
||
.limit(1)
|
||
).scalars().first()
|
||
if waiting is None:
|
||
return
|
||
outbox.run_due(db)
|
||
|
||
|
||
def build(db, approver_ref: str, starter_ref: str) -> dict:
|
||
"""begin(提交时回写两个模板)→ 财务复核(到达 / 通过后各回写一个)→ 总监 → end。
|
||
|
||
总监那一环是故意留的:办结归档的单不允许撤回已办,要验"撤回后再办一次还能不能写回",
|
||
被撤回的那一步后面必须还有一环。
|
||
"""
|
||
form = models.FormElement(name=f"写回重发校验表单 {STAMP}", content={"fields": [
|
||
{"key": "amount", "label": "金额", "type": "number"},
|
||
{"key": "payWay", "label": "结算方式", "type": "text"},
|
||
]})
|
||
db.add(form)
|
||
db.flush()
|
||
|
||
begin = models.Activity(process="", type="begin", name="发起申请", order_number=0, form=form.id,
|
||
config={"writeback": {
|
||
"integrations": [T_SUBMIT_REFIRE, T_SUBMIT_ONCE, T_DECLARE_ELSEWHERE],
|
||
"trigger": "leave"}})
|
||
review = models.Activity(process="", type="manual", name="财务复核", order_number=1, form=form.id,
|
||
config={"mode": "any",
|
||
"taskValues": [{"type": "person", "data": [approver_ref]}],
|
||
"writeback": {"blocks": [
|
||
{"integrations": [T_ARRIVE], "trigger": "arrive"},
|
||
{"integrations": [T_LEAVE], "trigger": "leave"},
|
||
]}})
|
||
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),
|
||
models.Route(process=process.id, name="通过", from_activity=review.id, to_activity=boss.id),
|
||
models.Route(process=process.id, name="退回修改", from_activity=review.id, to_activity=begin.id),
|
||
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}"},
|
||
# 报文里想说明"这是哪一环"。两格一起配正好看出口径差:{work.activity_name} 读的是
|
||
# 单据游标此刻指到哪一环(到达那一刻还没翻过来,于是读到上一环),
|
||
# {activity.id} 读的是**触发这条报文的那一环**,与幂等键里的 event_key 同一个环节。
|
||
{"to": "atNode", "from": "{work.activity_name}"},
|
||
{"to": "nodeId", "from": "{activity.id}"},
|
||
]}
|
||
for code, key, refire in ((T_SUBMIT_REFIRE, begin.id, True), (T_SUBMIT_ONCE, begin.id, False),
|
||
(T_ARRIVE, review.id, True), (T_LEAVE, review.id, True),
|
||
# 声明"到达总监时发"、却挂在发起人身上按「提交时」发:
|
||
# 挂载管时机,声明那条仍会在真的到达总监时再发一次(幂等键不同)
|
||
(T_DECLARE_ELSEWHERE, boss.id, False)):
|
||
db.add(models.Integration(code=code, name=f"写回重发 {code}", source=SRC, biz_form=form.id,
|
||
trigger_event=models.Integration.EVENT_ACTIVITY, event_key=key,
|
||
refire_revisit=refire, 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}
|
||
|
||
|
||
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 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("发起后单据走到财务复核(开始环节已提交)", result.work.activity_type != "begin",
|
||
str(result.work.activity_type))
|
||
|
||
submit_rows = rows_of(db, T_SUBMIT_REFIRE, job)
|
||
check("发起环节「提交单据时」当场入队一条写回(不用等办结)",
|
||
len(submit_rows) == 1 and submit_rows[0].revision == 1, f"{len(submit_rows)} 条")
|
||
check("这条报文取的就是提交那一刻编辑过的字段值",
|
||
submit_rows and str(payload_of(submit_rows[0]).get("amount")) == "100",
|
||
payload_of(submit_rows[0]) if submit_rows else "")
|
||
check("没勾重发的同一个写回点也照常入队(先别谈重发)",
|
||
len(rows_of(db, T_SUBMIT_ONCE, job)) == 1)
|
||
check("「提交单据时」的报文里 {activity.id} 就是发起环节这一环",
|
||
payload_of(submit_rows[0]).get("nodeId") == ids["begin"], payload_of(submit_rows[0]))
|
||
check("到达财务复核那一刻「到达时」那条也入队了", len(rows_of(db, T_ARRIVE, job)) == 1)
|
||
deliver(db, job)
|
||
check("投递成功(影子模式:报文已渲染留档)",
|
||
all(r.status == models.OutboundMessage.STATUS_SUCCESS for r in rows_of(db, T_SUBMIT_REFIRE, job)),
|
||
[r.last_error for r in rows_of(db, T_SUBMIT_REFIRE, job)])
|
||
|
||
# ------------------------------------------------ 2. 退回:goBack 不算审批完成
|
||
_work, review_task = pending(db, job, "财务复核")
|
||
check("财务复核有待办", review_task is not None, job)
|
||
if review_task is None:
|
||
return 1
|
||
engine.go_back(db, task_id=review_task.id, actor=actor, target=ids["begin"], opinion="金额再改一下")
|
||
db.commit()
|
||
deliver(db, job)
|
||
check("退回(goBack)不触发「本环节审批通过后」那条写回",
|
||
len(rows_of(db, T_LEAVE, job)) == 0, f"{len(rows_of(db, T_LEAVE, job))} 条")
|
||
check("退回时到达开始环节,不会把「提交时」那两条再发一遍",
|
||
len(rows_of(db, T_SUBMIT_REFIRE, job)) == 1 and len(rows_of(db, T_SUBMIT_ONCE, job)) == 1,
|
||
f"{len(rows_of(db, T_SUBMIT_REFIRE, job))}/{len(rows_of(db, T_SUBMIT_ONCE, job))}")
|
||
_work2, begin_task = pending(db, job, "发起申请")
|
||
check("退回后待办回到发起人手上", begin_task is not None, job)
|
||
if begin_task is None:
|
||
return 1
|
||
|
||
# ------------------------------------------------ 3. 改了金额再提交:勾了重发的才再发
|
||
engine.execute_task(db, task_id=begin_task.id, actor=actor, route_name="提交",
|
||
opinion="改成 888 重新提交", data={"amount": 888, "payWay": "对公"})
|
||
db.commit()
|
||
deliver(db, job)
|
||
again = rows_of(db, T_SUBMIT_REFIRE, job)
|
||
check("勾了「重复到达时重发」:再提交真的多入一条,修订版 +1",
|
||
len(again) == 2 and again[1].revision == 2, f"{[(r.revision, r.status) for r in again]}")
|
||
check("重发那条取的是**改后的新值**(对面按单号更新才同步得动)",
|
||
len(again) == 2 and str(payload_of(again[1]).get("amount")) == "888",
|
||
payload_of(again[1]) if len(again) > 1 else "")
|
||
check("两条报文幂等键不同(对面能认出是同一张单的新版本)",
|
||
len(again) == 2 and again[0].idem != again[1].idem, getattr(again[1], "idem", "") if len(again) > 1 else "")
|
||
once = rows_of(db, T_SUBMIT_ONCE, job)
|
||
check("没勾重发的:第二次提交被幂等键并回第一条,发件箱不留新记录(老口径)",
|
||
len(once) == 1 and str(payload_of(once[0]).get("amount")) == "100", f"{len(once)} 条")
|
||
# 成功过的报文是**已发出的那一次的事实**:在途刷新只管还没出门的,已成功的原文不回改
|
||
check("已经成功的那条不回改成新值(对面收到过什么,台账就写着什么)",
|
||
len(once) == 1 and "值已刷新" not in (once[0].response or {}), f"{len(once)} 条")
|
||
arrive_again = rows_of(db, T_ARRIVE, job)
|
||
check("退回重走再到达财务复核:到达时那条也修订版 +1 重发",
|
||
len(arrive_again) == 2 and arrive_again[1].revision == 2, f"{len(arrive_again)} 条")
|
||
|
||
# ------------------------------------------------ 4. 复核批完:把这一环改过的值回写出去
|
||
_work3, review_task2 = pending(db, job, "财务复核")
|
||
check("重新提交后又回到财务复核", review_task2 is not None, job)
|
||
if review_task2 is None:
|
||
return 1
|
||
# 这一次办完的结果待会儿要被撤回,而撤回的判据是"这一环之后有没有人办过"——
|
||
# 秒级精度下"之前那一环"与"这一环"落在同一秒就会被当成之后。跨过一秒再办,
|
||
# 量出来的才是口径而不是时钟。
|
||
next_second()
|
||
engine.execute_task(db, task_id=review_task2.id, actor=actor, route_name="通过",
|
||
opinion="核过了,改成 999", data={"amount": 999, "payWay": "对公"})
|
||
db.commit()
|
||
deliver(db, job)
|
||
leave_rows = rows_of(db, T_LEAVE, job)
|
||
check("「本环节审批通过后」入队一条,取的是本环节审批人刚改的值",
|
||
len(leave_rows) == 1 and str(payload_of(leave_rows[0]).get("amount")) == "999",
|
||
payload_of(leave_rows[0]) if leave_rows else "")
|
||
|
||
submit_latest = rows_of(db, T_SUBMIT_REFIRE, job)[1]
|
||
check("发起环节「提交时」的报文里环节名是本环节(发起申请)",
|
||
payload_of(submit_latest).get("atNode") == "发起申请", payload_of(submit_latest))
|
||
arrive_latest = rows_of(db, T_ARRIVE, job)[-1]
|
||
check("「到达时」的报文带的是**当前最新**的字段值(前面环节改过就带新值)",
|
||
str(payload_of(arrive_latest).get("amount")) == "888", payload_of(arrive_latest))
|
||
# 当前口径:到达那一刻 work.activity 还没翻到本环节(_arrive_manual 在入队之后才落),
|
||
# 所以「到达时」的报文里 {work.activity_name} 读到的是上一环。别拿它当"这是哪一环"。
|
||
check("「到达时」的报文里环节名还是上一环(当前口径:到达那一刻游标没翻过来)",
|
||
payload_of(arrive_latest).get("atNode") == "发起申请", payload_of(arrive_latest))
|
||
arrive_node = payload_of(arrive_latest).get("nodeId")
|
||
check("「到达时」的报文里 {activity.id} 就是到达的那一环(环节名那格读的是上一环,这格不会)",
|
||
arrive_node == ids["review"], f"{arrive_node} / {payload_of(arrive_latest)}")
|
||
declare = rows_of(db, T_DECLARE_ELSEWHERE, job)
|
||
check("声明的环节与挂载的环节不是同一个:两处各发一次,幂等键不同(上游会收到两笔)",
|
||
len(declare) == 2 and declare[0].event_key != declare[1].event_key,
|
||
[(r.event_key, r.revision) for r in declare])
|
||
|
||
leave_now = rows_of(db, T_LEAVE, job)[0]
|
||
check("「审批通过后」的报文里环节名是本环节(财务复核)",
|
||
payload_of(leave_now).get("atNode") == "财务复核", payload_of(leave_now))
|
||
check("「审批通过后」的报文里 {activity.id} 也是本环节,且与幂等键里那一环同一个",
|
||
payload_of(leave_now).get("nodeId") == leave_now.event_key == ids["review"],
|
||
f"{payload_of(leave_now).get('nodeId')} / {leave_now.event_key}")
|
||
check("两条「声明在别处 + 挂在发起环节」的报文各带自己那一环的 id(对方照报文调接口不会调错环节)",
|
||
len(declare) == 2 and all(payload_of(r).get("nodeId") == r.event_key for r in declare)
|
||
and payload_of(declare[0]).get("nodeId") != payload_of(declare[1]).get("nodeId"),
|
||
[(r.event_key, payload_of(r).get("nodeId")) for r in declare])
|
||
check("终态那一刻没有触发环节:{activity.id} 渲染成空串,不报也不卡办理",
|
||
mapping.render_template(db, {"method": "POST", "fields": [{"to": "n", "from": "{activity.id}"}]},
|
||
data={}, work=None) == {"n": ""})
|
||
|
||
# ------------------------------------------------ 5. 撤回已办再办一次:照样能回写
|
||
done = db.execute(
|
||
select(models.TaskCompleted).where(models.TaskCompleted.task == review_task2.id)
|
||
).scalars().first()
|
||
check("财务复核这条已办在台账里", done is not None, str(review_task2.id))
|
||
if done is None:
|
||
return 1
|
||
next_second() # 让它前面的环节确实落在"上一秒",撤回判据才量得准
|
||
engine.reset_task(db, task_completed_id=done.id, actor=actor, opinion="ERP 说还要改")
|
||
db.commit()
|
||
_work4, review_task3 = pending(db, job, "财务复核")
|
||
check("撤回后待办重新落回处理人手上", review_task3 is not None, job)
|
||
if review_task3 is None:
|
||
return 1
|
||
engine.execute_task(db, task_id=review_task3.id, actor=actor, route_name="通过",
|
||
opinion="确认 999", data={"amount": 999, "payWay": "对公"})
|
||
db.commit()
|
||
deliver(db, job)
|
||
leave_again = rows_of(db, T_LEAVE, job)
|
||
check("撤回后重新办理:这一环的写回修订版 +1 又发一条(第三方拿得到这一次)",
|
||
len(leave_again) == 2 and leave_again[1].revision == 2,
|
||
f"{[(r.revision, r.status) for r in leave_again]}")
|
||
check("重发仍是同一条幂等族(同单同环节,只有修订版在跳)",
|
||
len(leave_again) == 2 and leave_again[0].idem.rsplit(":", 1)[0] == leave_again[1].idem.rsplit(":", 1)[0],
|
||
f"{getattr(leave_again[0], 'idem', '')} / {getattr(leave_again[1], 'idem', '')}"
|
||
if len(leave_again) > 1 else "")
|
||
|
||
# ------------------------------------------------ 6. 还在途不补发:这是"两张凭证"的防线
|
||
result2 = engine.create_job(db, process_id=ids["process"], actor=actor,
|
||
data={"amount": 200, "payWay": "现金"}, title=f"写回重发校验单 {STAMP} 二号")
|
||
db.commit()
|
||
job2 = str(result2.work.job)
|
||
CLEAN["jobs"].append(job2)
|
||
_w5, review5 = pending(db, job2, "财务复核")
|
||
engine.go_back(db, task_id=review5.id, actor=actor, target=ids["begin"], opinion="先退一下")
|
||
db.commit()
|
||
_w6, begin6 = pending(db, job2, "发起申请")
|
||
# 故意不投递:第一条还在途,第二次命中就不该另起一条(自动补发就是两张凭证)
|
||
engine.execute_task(db, task_id=begin6.id, actor=actor, route_name="提交",
|
||
opinion="改成 777 再提交", data={"amount": 777, "payWay": "现金"})
|
||
db.commit()
|
||
in_flight = rows_of(db, T_SUBMIT_REFIRE, job2)
|
||
# 这一段四条都要求"第一条此刻还在途"。本机常驻的 dev 服务(或任何拿着调度租约的副本)
|
||
# 会在入队当场被叫醒,把这条影子报文直接投成功——第二次命中于是合法地另起修订版 2。
|
||
# 那是有人在一旁替我们投递,不是并回逻辑坏了:整段按"跳过"记,别报成回归。
|
||
# 想要一次安静的验证:停掉常驻服务再跑,或先把 scheduler 租约抢过来(scripts 里没有现成的,
|
||
# 照着 app/service/leader.py 抢一把即可)。
|
||
raced = (len(in_flight) != 1
|
||
or in_flight[0].status not in models.OutboundMessage.STATUS_OPEN)
|
||
check("上一条还在途:第二次命中并回那一条,不另起一条(勾了重发也不补发)",
|
||
len(in_flight) == 1 and in_flight[0].status in models.OutboundMessage.STATUS_OPEN,
|
||
[(r.revision, r.status) for r in in_flight], soft=raced)
|
||
check("并回的那条按当下最新值重渲染:报文带的是改后的 777,界面上留一句「值已刷新」",
|
||
len(in_flight) == 1 and str(payload_of(in_flight[0]).get("amount")) == "777"
|
||
and "值已刷新" in (in_flight[0].response or {}),
|
||
[(str(payload_of(r).get("amount")), list(r.response or {})) for r in in_flight], soft=raced)
|
||
merged_idem = in_flight[0].idem if in_flight else ""
|
||
deliver(db, job2)
|
||
after = rows_of(db, T_SUBMIT_REFIRE, job2)
|
||
check("请求仍只有一次:幂等键与修订版都没变,发件箱没多行(两张凭证那条防线不动)",
|
||
len(after) == 1 and after[0].idem == merged_idem and int(after[0].revision) == 1,
|
||
[(r.revision, r.idem) for r in after], soft=raced)
|
||
check("真发出去的就是那份新值:还没出门的报文不该抱着旧金额上路",
|
||
len(after) == 1 and str(payload_of(after[0]).get("amount")) == "777",
|
||
[(r.revision, str(payload_of(r).get("amount"))) for r in after], soft=raced)
|
||
|
||
print()
|
||
if FAILS:
|
||
print(f"{len(FAILS)} 条没对上:")
|
||
for item in FAILS:
|
||
print(f" - {item}")
|
||
else:
|
||
quiet = f"(另有 {len(SKIPPED)} 条被跳过:常驻服务的后台投递抢先,不是行为变了)" if SKIPPED else ""
|
||
print(f"全部 {PASSED} 条对上{quiet}。")
|
||
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)))
|
||
if jobs:
|
||
db.execute(delete(models.Work).where(models.Work.job.in_(jobs)))
|
||
db.execute(delete(models.WorkCompleted).where(models.WorkCompleted.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"]))
|
||
for code in (T_SUBMIT_REFIRE, T_SUBMIT_ONCE, T_ARRIVE, T_LEAVE, T_DECLARE_ELSEWHERE):
|
||
db.execute(delete(models.Integration).where(models.Integration.code == code))
|
||
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())
|