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