unis-oa/backend/scripts/check_writeback_goback.py

550 lines
29 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
"""「本环节被退回时」再按**退落到哪一环**(goBackTo)与**这一退是谁按的**(goBackVia)筛一遍。
PYTHONPATH=. python3 scripts/check_writeback_goback.py
口径见 ``docs/goback-target-writeback-design.md``。这一份跑真流程,为的是钉住那些"配置看着
都对、运行期一声不响"的账:
1. **落点筛子**:勾了 ``@starter`` 的规则只在退回到发起人那一刻发;勾了 ``@prev`` 的只在
退到引擎默认那一个落点(候选清单第一个)时发;勾了环节 id 的只在那个落点上发;
**两格都不写的存量规则仍旧任何退回都发**(零迁移);
2. **来源筛子**:``via`` 就是引擎那四条通道。第三方调 ``/open/tasks/{id}/execute``、
``/open/nodes/…/decide`` 退回来的那一单,走的正是 ``execute_task → go_back`` 这一条,
与待办页那颗按钮汇进同一个钩子——所以筛子对两边一视同仁,只认通道不认人;
3. **两格是 AND**:先过来源、再过落点,任一没过就"这条规则这一刻不存在";
4. **报文取得到落点与来源**:``{action.target}`` / ``{action.target_name}`` /
``{action.via}`` / ``{action.via_name}``;人工重推回放的是入队那一刻那一份;
5. **默认幂等键不分落点**:一张单退两次仍旧只发一条;要各发一条就自定义键里写 ``{target}``
(按来源分开写 ``{via}``);
6. **死配置保存流程时就挡**:环节不存在、这一环退不到、勾了落点却没勾那一刻、``[]``、
通道名不认识、两条规则的落点桶(或来源桶)相交才算撞键——桶不相交那叫分流。
跑在 backend 目录下。数据源开影子模式(报文照渲染照留档,不打出去),跑完连数据源、
模板、流程、单据、报文一起删干净。
"""
from __future__ import annotations
import time
from datetime import datetime
from types import SimpleNamespace
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"wbg_src_{int(time.time())}"
#: 只勾「退回到发起人」
T_STARTER = f"wbg_starter_{STAMP}"
#: 只勾「退到上一环节」(= 候选清单第一个,人不挑时引擎自己选的那一个)
T_PREV = f"wbg_prev_{STAMP}"
#: 什么筛子都不写:存量配置的口径,任何退回都发
T_ANY = f"wbg_any_{STAMP}"
#: 指定环节那一档(落点 = 部门经理)
T_DEPT = f"wbg_dept_{STAMP}"
#: 只发外部按的退回(open / embed)
T_EXTERNAL = f"wbg_external_{STAMP}"
#: 只发 OA 界面按的退回
T_OA = f"wbg_oa_{STAMP}"
#: 落点 + 来源两格都勾:验 AND
T_BOTH = f"wbg_both_{STAMP}"
#: 自定义幂等键里写了 {target}:退到不同环节各发一条
T_TARGET = f"wbg_target_{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 next_second() -> None:
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 payload_of(row: models.OutboundMessage) -> dict:
return dict(row.payload or {})
def latest(db, code: str, job: str, phase: str = "goBack") -> dict:
rows = rows_of(db, code, job, phase)
return payload_of(max(rows, key=lambda row: row.id)) if rows else {}
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 pending(db, job: str, activity_name: str):
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 task
def to_review(db, actor, job: str):
"""把这张单从部门经理办到财务复核(重新提交那一路要再走一遍同一段)。"""
task = pending(db, job, "部门经理")
engine.execute_task(db, task_id=task.id, actor=actor, route_name="通过",
opinion="部门同意", data={"amount": 100})
db.commit()
return pending(db, job, "财务复核")
def build(db, approver_ref: str) -> dict:
"""发起 → 部门经理 → 财务复核 → 总监审批 → 结束。
落点在图纸上说不算数,所以复核环节画了一条「退回发起人」(``decision=goBack``,线终点写
的就是发起环节),并在环节配置上用 ``goBackTarget`` 把这条线的落点钉死——第三方回一句
「不同意」就会走它。要验的是**引擎算出来的那一个落点**,不是画布上那条线自己怎么说。
"""
form = models.FormElement(name=f"退回落点校验表单 {STAMP}", content={"fields": [
{"key": "amount", "label": "金额", "type": "number"},
]})
db.add(form)
db.flush()
begin = models.Activity(process="", type="begin", name="发起申请", order_number=0, form=form.id)
dept = models.Activity(process="", type="manual", name="部门经理", order_number=1, form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}]})
review = models.Activity(process="", type="manual", name="财务复核", order_number=2, form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}],
"allowGoBack": True})
boss = models.Activity(process="", type="manual", name="总监审批", order_number=3, form=form.id,
config={"mode": "any",
"taskValues": [{"type": "person", "data": [approver_ref]}]})
end = models.Activity(process="", type="end", name="结束", order_number=4)
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, dept, review, boss, end):
row.process = process.id
db.add_all([begin, dept, review, boss, end])
db.flush()
db.add_all([
models.Route(process=process.id, name="提交", from_activity=begin.id, to_activity=dept.id),
models.Route(process=process.id, name="通过", from_activity=dept.id, to_activity=review.id),
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": "nodeId", "from": "{activity.id}"},
{"to": "moment", "from": "{action.phase}"},
{"to": "button", "from": "{action.route}"},
{"to": "to", "from": "{action.target}"},
{"to": "toName", "from": "{action.target_name}"},
{"to": "via", "from": "{action.via}"},
{"to": "viaName", "from": "{action.via_name}"},
]}
rules = {T_TARGET: "{source}:{code}:{job}:{event}:{event_key}:{target}"}
for code in (T_STARTER, T_PREV, T_ANY, T_DEPT, T_EXTERNAL, T_OA, T_BOTH, T_TARGET):
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=False, idem_rule=rules.get(code, ""),
payload=dict(body)))
db.commit()
CLEAN.update(form=form.id, process=process.id, jobs=[])
ids = {"form": form.id, "process": process.id, "begin": begin.id, "dept": dept.id,
"review": review.id, "boss": boss.id}
mount_on_review(db, ids)
return ids
def mount_on_review(db, ids: dict) -> None:
"""把八份规则挂到复核环节上:一条规则一个筛子,好一条条数清谁发了谁没发。"""
row = db.get(models.Activity, ids["review"])
# 这条线的落点钉死在发起环节(id 要到 flush 之后才有,所以这一格在这儿补):
# 第三方回一句「不同意」走的就是它,落点是钉的那一环而不是候选第一个
row.config = {**(row.config or {}), "goBackTarget": {"退回发起人": ids["begin"]},
"writeback": {"blocks": [
{"integrations": [T_STARTER], "trigger": "goBack", "goBackTo": ["@starter"]},
{"integrations": [T_PREV], "trigger": "goBack", "goBackTo": ["@prev"]},
{"integrations": [T_ANY], "trigger": "goBack"},
{"integrations": [T_DEPT], "trigger": "goBack", "goBackTo": [ids["dept"]]},
{"integrations": [T_EXTERNAL], "trigger": "goBack", "goBackVia": ["open", "embed"]},
{"integrations": [T_OA], "trigger": "goBack", "go_back_via": ["oa"]},
{"integrations": [T_BOTH], "trigger": "goBack", "goBackTo": ["@starter"],
"goBackVia": ["open"]},
{"integrations": [T_TARGET], "trigger": "goBack"},
]}}
db.commit()
outbox.invalidate_node_triggers()
def drive(db, actor, ids: dict, note: str) -> str:
"""开一张新单,一路办到财务复核手上(每个场景一张单,幂等键互不干扰)。"""
result = engine.create_job(db, process_id=ids["process"], actor=actor,
data={"amount": 100}, title=f"退回落点校验单 {STAMP}{note}")
db.commit()
CLEAN["jobs"].append(str(result.work.job))
job = str(result.work.job)
to_review(db, actor, job)
return job
def activities_with(db, ids: dict, writeback: dict, **flags) -> list[SimpleNamespace]:
"""整条流程的环节行 + 把复核环节那份挂载换成要校的这一份。
必须把**全部**环节交给那把尺子:保存流程时调用方给的就是整份画布,落点指的环节存不存在
是按这份名单判的。只给一个环节会把"部门经理"判成"这一环不存在"。
"""
out: list[SimpleNamespace] = []
for row in db.scalars(select(models.Activity).where(
models.Activity.process == ids["process"])).all():
config = dict(row.config or {})
if row.id == ids["review"]:
config.update(flags)
config["writeback"] = writeback
out.append(SimpleNamespace(id=row.id, name=row.name, type=row.type,
process=row.process, form=row.form, config=config))
return out
def problems_for(db, ids: dict, universe: dict, writeback: dict, **flags) -> list[str]:
return mapping.mount_problems(
db, activities_with(db, ids, writeback, **flags),
["提交", "通过", "通过", "退回发起人", "通过"], goback=universe)
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)
# ---------------------------------- 1. OA 里点退回,退到发起人
job = drive(db, actor, ids, "A")
task = pending(db, job, "财务复核")
check("单子在财务复核手上", task is not None, job)
if task is None:
return 1
engine.go_back(db, task_id=task.id, actor=actor, target=ids["begin"], opinion="金额再改一下")
db.commit()
deliver(db, job)
check("勾了 @starter 的规则命中一条(退回到发起人)",
len(rows_of(db, T_STARTER, job, "goBack")) == 1,
[(r.phase, r.idem) for r in rows_of(db, T_STARTER, job, "goBack")])
check("勾了 @prev 的规则不命中——落点不是候选第一个",
not rows_of(db, T_PREV, job, "goBack"))
check("勾了指定环节(部门经理)的规则不命中", not rows_of(db, T_DEPT, job, "goBack"))
check("两格都没写的存量规则仍旧发(任何退回都发,零迁移)",
len(rows_of(db, T_ANY, job, "goBack")) == 1)
check("来源筛子认 OA 这一档:goBackVia=[oa] 命中",
len(rows_of(db, T_OA, job, "goBack")) == 1)
check("第三方那一条不命中:这一退是 OA 里点的,不是接口退的",
not rows_of(db, T_EXTERNAL, job, "goBack"))
check("落点与来源两格是 AND:落点过了、来源没过,这一条不发",
not rows_of(db, T_BOTH, job, "goBack"))
one = latest(db, T_STARTER, job)
check("报文里 {action.target} / {action.target_name} 就是引擎算出来的那个落点",
one.get("to") == ids["begin"] and one.get("toName") == "发起申请", one)
check("报文里 {action.via} / {action.via_name} 说清这一退是 OA 界面按的",
one.get("via") == "oa" and one.get("viaName") == "OA 界面", one)
check("报文挂在按退回的这一环上,不是挂在落点上",
one.get("nodeId") == ids["review"]
and rows_of(db, T_STARTER, job, "goBack")[0].event_key == ids["review"], one)
check("退回这一刻不触发「通过后」", not rows_of(db, T_ANY, job, "leave"))
# ---------------------------------- 2. 人不挑:落点 = 候选第一个(上一环节)
job = drive(db, actor, ids, "B")
task = pending(db, job, "财务复核")
engine.go_back(db, task_id=task.id, actor=actor, opinion="票据再看一下")
db.commit()
deliver(db, job)
two = latest(db, T_PREV, job)
check("退到上一环节(候选第一个 = 部门经理)时,@prev 那一条命中",
len(rows_of(db, T_PREV, job, "goBack")) == 1 and two.get("to") == ids["dept"], two)
check("指定环节那一档按 id 命中同一个落点(与 @prev 各自独立判)",
len(rows_of(db, T_DEPT, job, "goBack")) == 1)
check("退到上一环节时 @starter 那条不发", not rows_of(db, T_STARTER, job, "goBack"))
check("引擎自己选的落点也写进报文:退到哪一环、谁按的",
two.get("toName") == "部门经理" and two.get("via") == "oa", two)
check("待办确实落在部门经理手上(筛子改不了流转,只改发不发)",
pending(db, job, "部门经理") is not None, job)
# ---------------------------------- 3. 第三方调开放接口退回(走画布那条 goBack 线)
job = drive(db, actor, ids, "C")
task = pending(db, job, "财务复核")
engine.execute_task(db, task_id=task.id, actor=actor, route_name="退回发起人",
opinion="发票不对", data={"amount": 100}, via=engine.VIA_OPEN)
db.commit()
deliver(db, job)
three = latest(db, T_EXTERNAL, job)
check("第三方调 /open/* 退回来这一单,落点与来源两道钩子照样生效",
len(rows_of(db, T_EXTERNAL, job, "goBack")) == 1 and three.get("to") == ids["begin"],
three)
check("报文里写的是这条通道的名字:第三方开放接口",
three.get("via") == "open" and three.get("viaName") == "第三方开放接口", three)
check("报文里那颗钮仍是画布上那条线的名字(第三方不例外)",
three.get("button") == "退回发起人", three)
check("这一退不该被记成 OA 界面点的:goBackVia=[oa] 那条不发",
not rows_of(db, T_OA, job, "goBack"))
check("落点 + 来源两格都过了,AND 那一条命中",
len(rows_of(db, T_BOTH, job, "goBack")) == 1)
check("落点认的是 goBackTarget 钉死的那一环,不是候选第一个",
three.get("toName") == "发起申请", three)
# ---------------------------------- 4. 第三方退回,但落点是上一环:AND 挡住
job = drive(db, actor, ids, "D")
task = pending(db, job, "财务复核")
engine.go_back(db, task_id=task.id, actor=actor, opinion="先补个附件", via=engine.VIA_OPEN)
db.commit()
deliver(db, job)
check("来源过了、落点没过:@starter + 外部 那一条仍旧不发",
not rows_of(db, T_BOTH, job, "goBack"))
check("只勾来源那一条命中(第三方退的、退给上一环节)",
len(rows_of(db, T_EXTERNAL, job, "goBack")) == 1
and latest(db, T_EXTERNAL, job).get("to") == ids["dept"])
# ---------------------------------- 5. 幂等键:默认不分落点,{target} 才分
job = drive(db, actor, ids, "E")
task = pending(db, job, "财务复核")
engine.go_back(db, task_id=task.id, actor=actor, target=ids["begin"], opinion="第一退")
db.commit()
deliver(db, job)
task = pending(db, job, "发起申请")
engine.execute_task(db, task_id=task.id, actor=actor, route_name="提交",
opinion="改好了", data={"amount": 100})
db.commit()
task = to_review(db, actor, job)
check("重新提交后又回到财务复核", task is not None, job)
if task is None:
return 1
engine.go_back(db, task_id=task.id, actor=actor, opinion="第二退")
db.commit()
deliver(db, job)
any_rows = rows_of(db, T_ANY, job, "goBack")
target_rows = rows_of(db, T_TARGET, job, "goBack")
check("默认键不看落点:一张单退两次仍旧只发一条",
len(any_rows) == 1, [(r.revision, r.idem) for r in any_rows])
check("自定义键里写了 {target}:退到两个不同环节各发一条",
len(target_rows) == 2, [(r.revision, r.idem) for r in target_rows])
check("两条的分量差在落点那一段", len({row.idem for row in target_rows}) == 2
and {payload_of(row).get("to") for row in target_rows} == {ids["begin"], ids["dept"]},
[row.idem for row in target_rows])
# ---------------------------------- 6. 人工重推回放当初那一刻
row = rows_of(db, T_STARTER, job, "goBack") or rows_of(db, T_STARTER, CLEAN["jobs"][0], "goBack")
check("有一条退回报文可以重推", bool(row))
if row:
first = row[0]
snapshot = payload_of(first)
#: 重推是就地改这一行(修订版 +1),拿 old 那份修订版要比就先抄下来
was_revision = int(first.revision or 1)
outbox.replay(db, first.id, actor=actor, reason="校验重推")
db.commit()
again = db.get(models.OutboundMessage, first.id)
back = payload_of(again)
check("重推仍按入队那一刻的落点与来源渲染(不回头看单据现在停在哪儿)",
again.phase == "goBack" and back.get("to") == snapshot.get("to")
and back.get("toName") == snapshot.get("toName")
and back.get("via") == snapshot.get("via")
and back.get("viaName") == snapshot.get("viaName")
and int(again.revision) == was_revision + 1,
(again.phase, back, again.revision))
check("重推只换修订版,不换幂等键里那一截时刻与落点",
f":activity:goBack:{first.event_key}:" in again.idem, again.idem)
deliver(db, again.job)
return _design_checks(db, ids)
def _design_checks(db, ids: dict) -> int:
universe = engine.goback_universe_for(db, ids["process"])
lands = set(universe.get(ids["review"]) or [])
check("引擎那一份落点全集:复核环节退得到部门经理与发起人",
{ids["dept"], ids["begin"]} <= lands, sorted(lands))
check("下游环节不在落点全集里(退回不能把单据往前送)",
ids["boss"] not in lands and ids["review"] not in lands, sorted(lands))
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack"})
check("什么筛子都不写:过得了保存这把尺子", not problems, problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackTo": [ids["dept"], "@starter", "@prev"]})
check("勾中退得到的落点 + 两个语义档:过得了", not problems, problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackTo": [ids["boss"]]})
check("勾了一个这一环永远退不到的落点 → 保存流程点名",
any("退不到它" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackTo": ["act_ghost_" + STAMP]})
check("落点指的环节在本流程不存在 → 点名",
any("在这条流程里不存在" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "leave",
"goBackTo": ["@starter"]})
check("写了落点却没勾「被退回时」→ 点名这一格是白配的",
any("落点那一格是白配的" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackTo": []})
check("goBackTo 写成空清单 → 点名(运行期等于任何退回都发)",
any("一个都没选" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackVia": ["open", "embed"]})
check("来源勾外部两条通道:过得了保存这把尺子", not problems, problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackVia": ["third"]})
check("别名(third)归一成 open:过得了", not problems, problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackVia": ["wechat"]})
check("通道名不认识 → 点名并给出可选项",
any("退回来源不认识:wechat" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackVia": []})
check("goBackVia 写成空清单 → 点名", any("谁按的都发" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "leave",
"goBackVia": ["open"]})
check("写了来源却没勾「被退回时」→ 点名这一格是白配的",
any("来源那一格是白配的" in item for item in problems), problems)
problems = problems_for(db, ids, universe, {"integrations": [T_ANY], "trigger": "goBack",
"goBackTo": ["@prev"]},
goBackConfig={"type": "prev"})
check("勾了 @prev 而这一环 goBackConfig.type=prev:后端不吵(只在面板提示)",
not problems, problems)
# 撞键:桶相交才算撞;桶不相交是分流
clash = {"blocks": [
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter"]},
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter", "@prev"]},
]}
problems = problems_for(db, ids, universe, clash)
check("两条规则同模板、落点桶相交 → 点名重复,并说要加 {target}",
any("重复" in item and "{target}" in item for item in problems), problems)
split = {"blocks": [
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter"]},
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@prev"]},
]}
problems = problems_for(db, ids, universe, split)
check("落点桶不相交(一个发起人、一个上一环)→ 那是分流,不算重复",
not problems, problems)
via_clash = {"blocks": [
{"integrations": [T_ANY], "trigger": "goBack", "goBackVia": ["open"]},
{"integrations": [T_ANY], "trigger": "goBack", "goBackVia": ["open", "embed"]},
]}
problems = problems_for(db, ids, universe, via_clash)
check("同模板、来源桶相交 → 点名,并说要加 {via}",
any("重复" in item and "{via}" in item for item in problems), problems)
via_split = {"blocks": [
{"integrations": [T_ANY], "trigger": "goBack", "goBackVia": ["open"]},
{"integrations": [T_ANY], "trigger": "goBack", "goBackVia": ["oa"]},
]}
problems = problems_for(db, ids, universe, via_split)
check("来源桶不相交(第三方退的 / OA 退的各一条)→ 不算重复", not problems, problems)
both_split = {"blocks": [
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter"],
"goBackVia": ["oa"]},
{"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter"],
"goBackVia": ["open"]},
]}
problems = problems_for(db, ids, universe, both_split)
check("落点相同但来源分开 → 也不算重复", not problems, problems)
# 判据只有一份:同一份事实,筛不筛得中在两处是同一个答案
block = {"integrations": [T_ANY], "trigger": "goBack", "goBackTo": ["@starter"],
"goBackVia": ["open"]}
check("判据:退给发起人 + 第三方 = 命中",
mapping.goback_hit(block, {"target": ids["begin"], "is_starter": True,
"is_prev": False, "via": "open"}))
check("判据:退给上一环 + 第三方 = 不命中(落点没过)",
not mapping.goback_hit(block, {"target": ids["dept"], "is_starter": False,
"is_prev": True, "via": "open"}))
check("判据:退给发起人 + OA 里点的 = 不命中(来源没过)",
not mapping.goback_hit(block, {"target": ids["begin"], "is_starter": True,
"is_prev": False, "via": "oa"}))
check("判据:老报文重推没有 via 这一格时按没筛处理,不白白少一条",
mapping.goback_hit({"integrations": [T_ANY], "trigger": "goBack",
"goBackVia": ["open"]}, {"target": ids["begin"]}))
check("回显文案念得出人话",
mapping.goback_text(["@starter", ids["dept"]], {ids["dept"]: "部门经理"})
== "退回给发起人 / 部门经理"
and mapping.goback_via_text(["open"]) == "第三方调开放接口退回",
mapping.goback_text(["@starter", ids["dept"]], {ids["dept"]: "部门经理"}))
return 0
def main() -> int:
db = SessionLocal()
try:
code = _run(db)
finally:
cleanup(db)
print()
if FAILS:
print(f"{len(FAILS)} 条没对上:")
for item in FAILS:
print(f" - {item}")
return 1
print(f"全部 {PASSED} 条对上。")
return code
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("wbg_%")))
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())