unis-oa/backend/scripts/check_writeback_revisit.py

421 lines
24 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_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())