615 lines
32 KiB
Python
615 lines
32 KiB
Python
#!/usr/bin/env python3
|
||
"""钉住「干预改道之后,被干预那一环还剩什么」与「已经推出去的消息各自什么下场」。
|
||
|
||
两个问题来自 2026-11-10 的用户截图:管理员把一张停在「部门主管」的单直接改到「财务审批」,
|
||
审批记录上写着「经营管理中心不需要部门主管审批,故干预到财务审批」。于是两问——
|
||
|
||
1. **被干预之前的那一环还会不会有待办**?
|
||
2. **已经推送出去的那条「您有新的待办」怎么办**?
|
||
|
||
口径以代码为准,这一篇把答案钉成可复跑的判据(设计见 ``docs/process-intervention-design.md``
|
||
与 ``docs/intervention-todo-and-message-settlement-design.md``)::
|
||
|
||
cd backend && PYTHONPATH=. python3 scripts/check_intervention_move.py
|
||
|
||
全程跑在内存 sqlite 上,一条语句都不碰开发库;引擎、站内信、接口、事件订阅都是真代码。
|
||
|
||
分组:
|
||
|
||
A 待办去向 整张单的待办一次收干净、收进已办而非删行、代操作人与原因都留在痕迹上
|
||
B 消息下场 站内信当场收尾(标已读不删行)/ 外发那一路走渠道可勾的 ``rerouted`` /
|
||
事件订阅带 ``processingType``,改道回到走过的环节也推得出**新**待办号
|
||
C 收口 在跑的嵌入子流程默认拒、勾了才一并终止;停在半路的第三方表态作废;
|
||
待阅那份「当前环节」跟着游标走
|
||
D 点开旧卡片 认得出下场就照实回话(去向卡),认不出才还是那句「已被处理」
|
||
|
||
``[现状]`` 打头的是**已经确认、但这一版管不住的行为**:已经发到邮箱 / 群 / 企业微信的
|
||
那条消息收不回来(Hub 的推送接口只有发送与逐人回查,企微自己的撤回没在 Hub 上开)。
|
||
它由 D 组那一屏兜住——消息追不回来,就让它每次点开都落在一个说得出真相的页面上。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
import sys
|
||
from datetime import datetime, timedelta
|
||
|
||
# 设计缓存是跨进程的,脚本里这些固定流程 id 会读到上一趟自己存进去的那一份。
|
||
os.environ["OA_DESIGN_CACHE"] = "off"
|
||
# 只读复用那一层靠挂在 app.db 那台 MySQL 引擎连接上的写钩子作废(见 app/readcache.py)。
|
||
# 本脚本的内存库不在它名下,钩子够不着,写着 oa_task 也作废不掉「本环节有哪些人」那份旧结果。
|
||
# 关掉它不是绕过被测逻辑,是补上内存库缺的那半个前提:判据要的是一次DB一次真读。
|
||
os.environ["OA_READCACHE"] = "off"
|
||
|
||
from sqlalchemy import create_engine, func, select # noqa: E402
|
||
from sqlalchemy.orm import Session # noqa: E402
|
||
from sqlalchemy.pool import StaticPool # noqa: E402
|
||
|
||
from app import envelope, models, presence # noqa: E402
|
||
from app.api import runtime as runtime_api # noqa: E402
|
||
from app.deps import CurrentUser # noqa: E402
|
||
from app.engine import engine # noqa: E402
|
||
from app.service import channels # noqa: E402
|
||
|
||
STARTER = ("1001", "周瑾", "zhoujin") # 发起人
|
||
BOSS = ("2002", "陈鹏", "chenpeng") # 部门主管:被干预的那一环
|
||
FINANCE = ("3003", "张梅", "zhangmei") # 财务经理:改道的落点
|
||
CC_PERSON = ("3004", "黄雪秋", "huangxueqiu") # 部门主管那一环抄送出去的人
|
||
ADMIN = ("9001", "管理员", "admin01")
|
||
OUTSIDER = ("5005", "无关的人", "wairen")
|
||
|
||
REASON = "经营管理中心不需要部门主管审批,故干预到财务审批"
|
||
|
||
PASSED = 0
|
||
FAILS: list[str] = []
|
||
NOTES: list[str] = []
|
||
|
||
|
||
def check(label: str, ok: bool, detail: object = "") -> bool:
|
||
global PASSED
|
||
if ok:
|
||
PASSED += 1
|
||
print(f"[通过] {label}")
|
||
else:
|
||
FAILS.append(label)
|
||
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
|
||
return ok
|
||
|
||
|
||
def observe(label: str, detail: object) -> None:
|
||
"""记一条"这一版管不住、靠后面那一屏兜底"的现状。"""
|
||
NOTES.append(label)
|
||
print(f"[现状] {label} -> {str(detail)[:300]}")
|
||
|
||
|
||
def new_session() -> Session:
|
||
"""内存库。模型里 MySQL 专属的 server_default 在 sqlite 上建不出来,建表前摘掉。"""
|
||
for table in models.Base.metadata.tables.values():
|
||
for column in table.columns:
|
||
if column.server_default is not None:
|
||
column.server_default = None
|
||
bind = create_engine("sqlite://", poolclass=StaticPool,
|
||
connect_args={"check_same_thread": False})
|
||
models.Base.metadata.create_all(bind)
|
||
# presence 那层「这张表有没有值得去问的」记在进程里,作废挂在 app.db 那个引擎的写钩子上;
|
||
# 这一份内存库不在它名下,不清就会拿着上一趟 session「一条渠道都没有」的旧结论。
|
||
presence.clear()
|
||
db = Session(bind)
|
||
for person_id, name, ref in (STARTER, BOSS, FINANCE, CC_PERSON, ADMIN, OUTSIDER):
|
||
db.add(models.User(id=int(person_id), account=ref, display_name=name,
|
||
email=f"{ref}@example.com", password_hash="", status=1))
|
||
db.flush()
|
||
return db
|
||
|
||
|
||
def actor_of(person, *, is_admin: bool = False) -> engine.Actor:
|
||
person_id, name, ref = person
|
||
return engine.Actor(person_id=person_id, person_name=name, ref=ref, is_admin=is_admin)
|
||
|
||
|
||
def user_of(person, *, monitor: bool = True) -> CurrentUser:
|
||
"""接口要的那个登录身份。``monitor=False`` 是"只看得到自己那一份"的普通处理人。"""
|
||
person_id, name, ref = person
|
||
row = models.User(id=int(person_id), account=ref, display_name=name, status=1)
|
||
perms = ("work:profile", "monitor:work") if monitor else ("work:profile",)
|
||
return CurrentUser(person=row, ref=ref, is_admin=False, permissions=perms)
|
||
|
||
|
||
def task_detail(db: Session, task_id: str, user: CurrentUser) -> dict:
|
||
"""调接口那一层取待办详情,并把「不该掉出来」的那几种情况也摊成一个信封。
|
||
|
||
接口出错走的是抛 :class:`ApiError`(FastAPI 那个异常处理器负责换成 ``{"code": ...}``),
|
||
脚本里没有那层处理器,所以自己接一下,判据才能照旧只看 code / message。
|
||
"""
|
||
try:
|
||
return runtime_api.get_task_detail(task_id, db=db, user=user)
|
||
except envelope.ApiError as exc:
|
||
return {"code": exc.api_code, "message": str(exc.detail), "data": None}
|
||
|
||
|
||
def holder(ref: str) -> dict:
|
||
return {"taskValues": [{"type": "identity", "data": [ref]}]}
|
||
|
||
|
||
def make_flow(db: Session, tag: str) -> str:
|
||
"""发起 → 部门主管(到达时抄送黄雪秋)→ 财务经理 → 结束。回流程 id。"""
|
||
pid = f"p-{tag}"
|
||
db.add(models.Process(id=pid, name=f"改道校验流程 {tag}", latest_form="f-shared",
|
||
enabled=True, published=True))
|
||
db.add(models.Activity(id=f"{pid}-begin", process=pid, type="begin", name="发起", config={}))
|
||
db.add(models.Activity(id=f"{pid}-dept", process=pid, type="manual", name="部门主管",
|
||
config={**holder(BOSS[2]),
|
||
"ccRules": [{"when": "arrive",
|
||
"taskValues": [{"type": "identity",
|
||
"data": [CC_PERSON[2]]}]}]}))
|
||
db.add(models.Activity(id=f"{pid}-finance", process=pid, type="manual", name="财务经理",
|
||
config=holder(FINANCE[2])))
|
||
db.add(models.Activity(id=f"{pid}-end", process=pid, type="end", name="结束", config={}))
|
||
db.add(models.Route(id=f"{pid}-r1", process=pid, name="提交", from_activity=f"{pid}-begin",
|
||
to_activity=f"{pid}-dept"))
|
||
db.add(models.Route(id=f"{pid}-r2", process=pid, name="同意", from_activity=f"{pid}-dept",
|
||
to_activity=f"{pid}-finance"))
|
||
db.add(models.Route(id=f"{pid}-r3", process=pid, name="同意", from_activity=f"{pid}-finance",
|
||
to_activity=f"{pid}-end"))
|
||
db.flush()
|
||
return pid
|
||
|
||
|
||
def start_job(db: Session, pid: str, tag: str) -> models.Work:
|
||
result = engine.create_job(
|
||
db, process_id=pid, actor=actor_of(STARTER),
|
||
data={"title": f"改道校验单 {tag}"}, title=f"改道校验单 {tag}",
|
||
)
|
||
db.flush()
|
||
return result.work
|
||
|
||
|
||
def tasks_of(db: Session, work: models.Work) -> list[models.Task]:
|
||
return list(db.execute(
|
||
select(models.Task).where(models.Task.work == work.id).order_by(models.Task.id)
|
||
).scalars().all())
|
||
|
||
|
||
def notices(db: Session, identity: str, *, unread_only: bool = True) -> list[models.Notification]:
|
||
rows = list(db.execute(
|
||
select(models.Notification).where(models.Notification.identity == identity)
|
||
).scalars().all())
|
||
return [row for row in rows if not unread_only or not row.read]
|
||
|
||
|
||
def events_of(db: Session, event: str) -> list[models.OpenEvent]:
|
||
return list(db.execute(
|
||
select(models.OpenEvent).where(models.OpenEvent.event == event)
|
||
).scalars().all())
|
||
|
||
|
||
def deliveries_of(db: Session, identity: str) -> list[models.NotifyDelivery]:
|
||
return list(db.execute(
|
||
select(models.NotifyDelivery).where(models.NotifyDelivery.identity == identity)
|
||
).scalars().all())
|
||
|
||
|
||
def move(db: Session, work: models.Work, activity: str, *, opinion: str = REASON,
|
||
cascade: bool = False) -> engine.StepResult:
|
||
return engine.move(db, job=work.job, actor=actor_of(ADMIN, is_admin=True),
|
||
activity=activity, opinion=opinion, cascade_children=cascade)
|
||
|
||
|
||
def mail_channel(db: Session, code: str, events: list[str]) -> None:
|
||
"""一条邮箱渠道:外发那一路的投递记录由它造,事件勾什么由调用方定。"""
|
||
db.add(models.NotifyChannel(
|
||
id=f"ch-{code}", code=code, name=f"改道校验渠道 {code}",
|
||
kind=models.NotifyChannel.KIND_EMAIL, enabled=True, events=events,
|
||
config={"host": "smtp.invalid", "port": 25, "user": "oa", "password": "p",
|
||
"from": "oa@invalid"},
|
||
))
|
||
db.flush()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# A 待办去向
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def check_todo_after_move() -> None:
|
||
db = new_session()
|
||
pid = make_flow(db, "a")
|
||
work = start_job(db, pid, "a")
|
||
origin = tasks_of(db, work)[0]
|
||
check("A0 前置:改道前这张单的待办压在部门主管手上",
|
||
origin.identity == BOSS[2] and work.activity == f"{pid}-dept")
|
||
|
||
move(db, work, f"{pid}-finance")
|
||
db.flush()
|
||
|
||
left = tasks_of(db, work)
|
||
check("A1 被干预那一环一条待办都不剩:改道收的是整张单的待办,不只当前环节",
|
||
not [row for row in left if row.activity == f"{pid}-dept"],
|
||
[(row.activity_name, row.identity) for row in left])
|
||
check("A2 落点这一环派出了新待办,压在财务经理手上",
|
||
len(left) == 1 and left[0].activity == f"{pid}-finance" and left[0].identity == FINANCE[2],
|
||
[(row.activity_name, row.identity) for row in left])
|
||
|
||
done = db.execute(
|
||
select(models.TaskCompleted).where(models.TaskCompleted.task == origin.id)
|
||
).scalar_one_or_none()
|
||
check("A3 被收走的那条进的是「已办」而不是被删:事后答得出谁手里被拿走了一条",
|
||
done is not None and done.route_name == "干预改道",
|
||
None if done is None else done.route_name)
|
||
check("A4 那条已办分得清不是人签的:processing_type 记 move,不混进正常同意那一堆",
|
||
done is not None and done.processing_type == engine.LOG_MOVE,
|
||
None if done is None else done.processing_type)
|
||
check("A5 代操作人写在已办行上:陈鹏那一行读起来是「管理员替我收的尾」,不是他自己批的"
|
||
"(与终止 operator=actor 同一写法)",
|
||
done is not None and done.operator == ADMIN[2] and done.operator_name == ADMIN[1],
|
||
None if done is None else (done.operator, done.operator_name))
|
||
check("A6 改道的原因跟着那一步走,审批记录里看得见",
|
||
done is not None and REASON in str(done.opinion or ""),
|
||
None if done is None else done.opinion)
|
||
check("A7 单据游标与「当前环节」文案一起落到落点",
|
||
work.activity == f"{pid}-finance" and work.current_activity_names == "财务经理",
|
||
(work.activity, work.current_activity_names))
|
||
check("A8 路上的残余一次清干净:token 只剩落点那一条,票箱与直返约定清空,去重基线写上",
|
||
len(work.tokens or []) == 1 and not work.joins and not work.go_back_store
|
||
and bool((work.variables or {}).get("dedupSince")),
|
||
(work.tokens, work.joins, work.go_back_store))
|
||
log = db.execute(
|
||
select(models.WorkLog).where(models.WorkLog.job == work.job, models.WorkLog.type == "move")
|
||
).scalars().first()
|
||
check("A9 干预在流转记录里是一条真的换环节记录(从部门主管到财务经理,带谁动的)",
|
||
log is not None and log.from_activity == f"{pid}-dept"
|
||
and log.arrived_activity == f"{pid}-finance" and log.from_person_name == ADMIN[1],
|
||
None if log is None else (log.from_activity, log.arrived_activity, log.from_person_name))
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# B 已经推送出去的消息
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def check_messages() -> None:
|
||
db = new_session()
|
||
db.add(models.OpenWebhook(id="hook-1", code="itest", name="改道校验订阅", enabled=True,
|
||
url="https://hook.invalid/cb", secret="s",
|
||
events=["task.arrived", "task.completed"], processes=[]))
|
||
mail_channel(db, "itest-mail", ["task", "rerouted"])
|
||
pid = make_flow(db, "b")
|
||
work = start_job(db, pid, "b")
|
||
origin = tasks_of(db, work)[0]
|
||
|
||
arrived_title = f"您有新的待办:{work.title}"
|
||
queued = [row for row in deliveries_of(db, BOSS[2]) if row.type == "task"]
|
||
check("B1 前置:待办到达那一刻确实排出了外发投递(邮箱一路按人各一条)",
|
||
len(queued) == 1 and queued[0].task == origin.id,
|
||
[(row.channel, row.type, row.task) for row in queued])
|
||
for row in queued: # 模拟"这条已经发出去了"
|
||
row.status = models.NotifyDelivery.STATUS_SUCCESS
|
||
row.sent_at = datetime.now()
|
||
db.flush()
|
||
pushed_id = queued[0].id
|
||
|
||
move(db, work, f"{pid}-finance")
|
||
db.flush()
|
||
|
||
left = [row.title for row in notices(db, BOSS[2])]
|
||
check("B2 站内信当场退场:改道这一步就把那句「您有新的待办」收尾了,"
|
||
"不等他下次点开列表(标已读不删行,投递记录仍回查得到)",
|
||
arrived_title not in left and len(left) == 1 and "改道" in left[0],
|
||
f"未读 {left}")
|
||
retired = [row for row in notices(db, BOSS[2], unread_only=False) if row.title == arrived_title]
|
||
check("B3 收尾是标已读不是删行:那一行还在库里且带着已读时间,"
|
||
"「谁在什么时候收到过什么」查得回来",
|
||
len(retired) == 1 and retired[0].read and bool(retired[0].read_time), retired)
|
||
check("B4 被收走待办的人收到一句为什么:control 站内信点明改道、落点与原因",
|
||
any(row.type == "control" and "改道" in row.title and "财务经理" in row.body
|
||
and REASON in row.body
|
||
for row in notices(db, BOSS[2], unread_only=False)),
|
||
[row.title for row in notices(db, BOSS[2], unread_only=False)])
|
||
check("B5 发起人也被知会了一句「流程被改道」",
|
||
any(row.type == "control" and "改道" in row.title
|
||
for row in notices(db, STARTER[2], unread_only=False)),
|
||
[row.title for row in notices(db, STARTER[2], unread_only=False)])
|
||
check("B6 落点那位收到的是正常的「您有新的待办」,带的是新待办号",
|
||
any(row.type == "task" and row.task and row.task != origin.id
|
||
for row in notices(db, FINANCE[2], unread_only=False)),
|
||
[(row.type, row.task) for row in notices(db, FINANCE[2], unread_only=False)])
|
||
|
||
out = [row for row in deliveries_of(db, BOSS[2]) if row.type == "rerouted"]
|
||
check("B7 外发那一路走的是渠道能单独勾的 rerouted:站内仍叫 control,"
|
||
"深链不再指那条已经不存在的待办",
|
||
len(out) == 1 and out[0].notification and not out[0].task,
|
||
[(row.type, row.task, row.notification) for row in out])
|
||
check("B8 rerouted 是一档可勾的渠道事件(挂在渠道上按人勾,不是干预硬推)",
|
||
"rerouted" in dict(channels.EVENTS), list(dict(channels.EVENTS)))
|
||
again = db.get(models.NotifyDelivery, pushed_id)
|
||
check("B9 已经发出去的那条投递记录原样躺着:改道不回收、不改写",
|
||
again is not None and again.status == models.NotifyDelivery.STATUS_SUCCESS
|
||
and again.task == origin.id,
|
||
None if again is None else (again.status, again.task))
|
||
observe("B9+ 已经落到邮箱 / 群 / 企业微信里的那条卡片收不回来(Hub 9.6 只有发送与逐人回查,"
|
||
"企微自己的撤回没在 Hub 上开);这一条由 D 组那一屏兜住",
|
||
(again.title if again else "", again.status if again else ""))
|
||
|
||
completed = events_of(db, "task.completed")
|
||
payload = completed[0].payload if completed else {}
|
||
check("B10 事件订阅能自愈:task.completed 入队并带上 processingType=move,"
|
||
"订阅方据此就该把手上那条待办收掉",
|
||
bool(completed) and isinstance(payload, dict)
|
||
and payload.get("processingType") == "move",
|
||
payload if isinstance(payload, dict) else str(payload)[:200])
|
||
|
||
|
||
def check_event_dedupe() -> None:
|
||
"""改道回到走过的环节时,幂等键按待办号认,新那条待办号推得出去。"""
|
||
db = new_session()
|
||
db.add(models.OpenWebhook(id="hook-2", code="itest2", name="改道校验订阅2", enabled=True,
|
||
url="https://hook.invalid/cb2", secret="s",
|
||
events=["task.arrived"], processes=[]))
|
||
db.flush()
|
||
pid = make_flow(db, "b2")
|
||
work = start_job(db, pid, "b2")
|
||
origin = tasks_of(db, work)[0]
|
||
first = events_of(db, "task.arrived")
|
||
check("B11 前置:走到部门主管时推过一条 task.arrived,幂等键里带着当时那条待办号",
|
||
len(first) == 1 and first[0].idem.endswith(origin.id),
|
||
[row.idem for row in first])
|
||
|
||
move(db, work, f"{pid}-finance", opinion="先挪去财务")
|
||
move(db, work, f"{pid}-dept", opinion="还得回部门主管看一眼")
|
||
db.flush()
|
||
latest = tasks_of(db, work)[0]
|
||
again = [row for row in events_of(db, "task.arrived") if row.idem.endswith(latest.id)]
|
||
check("B12 改道回到走过的环节时推得出**新**那条待办号(原先按环节名去重,"
|
||
"订阅方手里只剩一条已经废掉的号)",
|
||
len(again) == 1 and again[0].activity == "部门主管",
|
||
{"当前真待办号": latest.id, "按新号入队的事件条数": len(again),
|
||
"已入队的幂等键": [row.idem for row in events_of(db, "task.arrived")]})
|
||
check("B13 同一条待办不会被推两遍:重复表态、重复入队这一头照旧守得住",
|
||
len([row for row in events_of(db, "task.arrived") if row.idem.endswith(origin.id)]) == 1,
|
||
[row.idem for row in events_of(db, "task.arrived")])
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# C 改道收口
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def check_residues() -> None:
|
||
db = new_session()
|
||
pid = make_flow(db, "c")
|
||
work = start_job(db, pid, "c")
|
||
origin = tasks_of(db, work)[0]
|
||
db.add(models.NodeDecision(
|
||
id="nd-1", app="itest-app", app_name="改道校验应用", work=work.id, job=work.job,
|
||
process=pid, process_name=work.process_name, activity=f"{pid}-dept", activity_name="部门主管",
|
||
task=origin.id, task_identity=BOSS[2], task_identity_name=BOSS[1],
|
||
decision="同意", kind="agree", route="同意", opinion="第三方原话",
|
||
biz_key="biz-1", status=models.NodeDecision.STATUS_STAGED,
|
||
expires_at=datetime.now() + timedelta(hours=6),
|
||
))
|
||
db.flush()
|
||
read_before = list(db.execute(
|
||
select(models.Read).where(models.Read.work == work.id)
|
||
).scalars().all())
|
||
|
||
move(db, work, f"{pid}-finance")
|
||
db.flush()
|
||
|
||
check("C1 抄送出去的待阅不随改道回收:它说的是「抄给你看过」,不是要办的事",
|
||
len(read_before) == 1
|
||
and len(list(db.execute(select(models.Read).where(
|
||
models.Read.work == work.id)).scalars().all())) == 1)
|
||
read_now = db.get(models.Read, read_before[0].id)
|
||
check("C2 待阅行上那份「当前环节」跟着游标走:待阅列表不再写着这张单停在部门主管",
|
||
read_now is not None and read_now.current_activity_name == "财务经理",
|
||
None if read_now is None else read_now.current_activity_name)
|
||
|
||
staged = db.get(models.NodeDecision, "nd-1")
|
||
check("C3 停在半路等确认的第三方表态随改道作废:那是改道之前、按改道之前的表单说的,"
|
||
"改道回到同一环时不该再冒出来等人点头",
|
||
staged is not None and staged.status == models.NodeDecision.STATUS_EXPIRED
|
||
and "改道" in str(staged.confirm_note or "") and "财务经理" in str(staged.confirm_note or ""),
|
||
None if staged is None else (staged.status, staged.confirm_note))
|
||
|
||
|
||
def _embed_flows(db: Session) -> tuple[str, str]:
|
||
"""父:发起 → 调用子流程 → 财务经理 → 结束;子:发起 → 子流程经办 → 结束。"""
|
||
child = "p-c-child"
|
||
db.add(models.Process(id=child, name="改道校验子流程", latest_form="f-shared",
|
||
enabled=True, published=True))
|
||
db.add(models.Activity(id=f"{child}-begin", process=child, type="begin", name="发起", config={}))
|
||
db.add(models.Activity(id=f"{child}-step", process=child, type="manual", name="子流程经办",
|
||
config=holder(CC_PERSON[2])))
|
||
db.add(models.Activity(id=f"{child}-end", process=child, type="end", name="结束", config={}))
|
||
db.add(models.Route(id=f"{child}-r1", process=child, name="提交", from_activity=f"{child}-begin",
|
||
to_activity=f"{child}-step"))
|
||
db.add(models.Route(id=f"{child}-r2", process=child, name="同意", from_activity=f"{child}-step",
|
||
to_activity=f"{child}-end"))
|
||
|
||
pid = "p-c-parent"
|
||
db.add(models.Process(id=pid, name="改道校验父流程", latest_form="f-shared",
|
||
enabled=True, published=True))
|
||
db.add(models.Activity(id=f"{pid}-begin", process=pid, type="begin", name="发起", config={}))
|
||
db.add(models.Activity(id=f"{pid}-call", process=pid, type="embed", name="调用子流程",
|
||
config={"process": child}))
|
||
db.add(models.Activity(id=f"{pid}-finance", process=pid, type="manual", name="财务经理",
|
||
config=holder(FINANCE[2])))
|
||
db.add(models.Activity(id=f"{pid}-end", process=pid, type="end", name="结束", config={}))
|
||
db.add(models.Route(id=f"{pid}-r1", process=pid, name="提交", from_activity=f"{pid}-begin",
|
||
to_activity=f"{pid}-call"))
|
||
db.add(models.Route(id=f"{pid}-r2", process=pid, name="同意", from_activity=f"{pid}-call",
|
||
to_activity=f"{pid}-finance"))
|
||
db.add(models.Route(id=f"{pid}-r3", process=pid, name="同意", from_activity=f"{pid}-finance",
|
||
to_activity=f"{pid}-end"))
|
||
db.flush()
|
||
return pid, child
|
||
|
||
|
||
def check_embed_cascade() -> None:
|
||
"""父单停在「调用子流程」时改道:先拒,勾了一并终止才动子单。"""
|
||
db = new_session()
|
||
pid, _child = _embed_flows(db)
|
||
result = engine.create_job(db, process_id=pid, actor=actor_of(STARTER),
|
||
data={"title": "改道校验父子单"}, title="改道校验父子单")
|
||
db.flush()
|
||
parent = result.work
|
||
# 这一组要先验一次"改道被拒",被拒之后会回滚;先落一次库,回滚才只吞掉那次失败的改道,
|
||
# 不会把整张父子单一起抹掉。
|
||
db.commit()
|
||
kids = list(db.execute(
|
||
select(models.Work).where(models.Work.parent_job == parent.job)
|
||
).scalars().all())
|
||
check("C4 前置:父单停在调用环节、自己没有待办,待办压在子单上",
|
||
len(kids) == 1 and not tasks_of(db, parent) and tasks_of(db, kids[0]),
|
||
(len(kids), len(tasks_of(db, parent))))
|
||
child_work = kids[0]
|
||
|
||
message = ""
|
||
try:
|
||
move(db, parent, f"{pid}-finance")
|
||
except engine.EngineError as exc:
|
||
message = str(exc)
|
||
db.rollback()
|
||
check("C5 默认停手:父单改道撞上还在跑的子流程就拒,并把是哪张子单、卡在谁手上说清楚",
|
||
"子流程" in message and child_work.title in message and CC_PERSON[1] in message
|
||
and "一并终止" in message, message)
|
||
check("C6 停手是真的什么都没动:父单还停在调用环节,子单那条待办照旧在",
|
||
db.get(models.Work, parent.id).activity == f"{pid}-call"
|
||
and bool(tasks_of(db, child_work)),
|
||
(db.get(models.Work, parent.id).activity, len(tasks_of(db, child_work))))
|
||
|
||
move(db, parent, f"{pid}-finance", cascade=True)
|
||
db.flush()
|
||
parent_now = db.get(models.Work, parent.id)
|
||
child_now = db.get(models.Work, child_work.id)
|
||
check("C7 勾了一并终止:父单落到落点,子单跟着终止归档,那条没人认领的待办一起收掉",
|
||
parent_now is not None and parent_now.activity == f"{pid}-finance"
|
||
and child_now is None
|
||
and db.execute(select(func.count(models.WorkCompleted.id)).where(
|
||
models.WorkCompleted.id == child_work.id)).scalar() == 1
|
||
and not tasks_of(db, child_work),
|
||
(parent_now.activity if parent_now else None,
|
||
child_now is not None,
|
||
len(tasks_of(db, child_work))))
|
||
cascade_log = db.execute(
|
||
select(models.WorkLog).where(models.WorkLog.job == child_work.job)
|
||
).scalars().all()
|
||
check("C8 子单那句终止原因是「父流程已改道」,读的人知道这张子单是谁为什么收掉的",
|
||
any("改道" in str(row.from_opinion or "") for row in cascade_log),
|
||
[row.from_opinion for row in cascade_log][:4])
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# D 点开一条已经不存在的待办
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def check_dead_link() -> None:
|
||
db = new_session()
|
||
pid = make_flow(db, "d")
|
||
work = start_job(db, pid, "d")
|
||
origin = tasks_of(db, work)[0]
|
||
move(db, work, f"{pid}-finance")
|
||
db.flush()
|
||
|
||
# 引擎那一层照旧认不出这条待办:去向卡是**读出口**那一层补的,不改办事的判据
|
||
message = ""
|
||
try:
|
||
engine.get_task(db, origin.id, actor_of(BOSS))
|
||
except engine.EngineError as exc:
|
||
message = str(exc)
|
||
check("D1 办事那一头照旧挡得住:这条待办已经不是任何人的待办",
|
||
message == "待办不存在或已被处理", message)
|
||
|
||
payload = task_detail(db, origin.id, user_of(BOSS))["data"]
|
||
vanished = payload.get("vanished") or {}
|
||
check("D2 点开旧卡片不再只有一句「已被处理」:认得出下场就照实回话",
|
||
bool(vanished) and vanished.get("kind") == "move",
|
||
list(payload.keys()))
|
||
check("D3 那一屏答得出是谁、什么时候、为什么收走的",
|
||
vanished.get("operator_name") == ADMIN[1]
|
||
and REASON in str(vanished.get("opinion") or "")
|
||
and bool(vanished.get("handled_at")),
|
||
{k: vanished.get(k) for k in ("operator_name", "opinion", "handled_at")})
|
||
check("D4 还答得出这张单现在停在哪个环节、在等谁(处理人真正想知道的是还要不要他管)",
|
||
vanished.get("current_activity_names") == "财务经理"
|
||
and FINANCE[1] in str(vanished.get("current_handlers") or "")
|
||
and vanished.get("work_status") == "running"
|
||
and vanished.get("job") == work.job,
|
||
{k: vanished.get(k) for k in ("current_activity_names", "current_handlers",
|
||
"work_status", "job")})
|
||
check("D5 原环节那一环认得出来:卡片上写的是「部门主管」这一步没了,不是别的环节",
|
||
vanished.get("activity_name") == "部门主管" and bool(vanished.get("title")),
|
||
(vanished.get("activity_name"), vanished.get("title")))
|
||
|
||
unrecognized = db.execute(
|
||
select(models.TaskCompleted).where(models.TaskCompleted.task == origin.id)
|
||
).scalars().first()
|
||
if unrecognized is not None:
|
||
unrecognized.processing_type = "addBefore" # 加签那一档:去向卡没有专门文案
|
||
db.flush()
|
||
odd = (task_detail(db, origin.id, user_of(BOSS)).get("data") or {}).get("vanished") or {}
|
||
check("D6 认不出的收尾方式(加签那一档)不硬套成「有人办完了」:只说这条待办已结束,认得的那几行照说",
|
||
odd.get("kind") == "unknown" and bool(odd.get("title"))
|
||
and odd.get("job") == work.job and bool(odd.get("opinion")),
|
||
{k: odd.get(k) for k in ("kind", "title", "opinion")})
|
||
unrecognized.processing_type = "move"
|
||
db.flush()
|
||
|
||
other = task_detail(db, origin.id, user_of(OUTSIDER, monitor=False))
|
||
check("D6 无关的人拿一个待办号来问,连标题都不该跟着掉出来(照旧 404)",
|
||
other.get("code") != 0 and "已被处理" in str(other.get("message") or ""),
|
||
other)
|
||
monitor = task_detail(db, origin.id, user_of(ADMIN, monitor=True))
|
||
check("D7 看得见监控的人问得动(他就是被找来问的那个)",
|
||
bool((monitor.get("data") or {}).get("vanished")), monitor.get("code"))
|
||
|
||
missing = task_detail(db, "t-压根没这个号", user_of(BOSS))
|
||
check("D8 查无此号还是那句原话,不硬编一个下场给人看",
|
||
missing.get("code") != 0, missing)
|
||
|
||
labels = _frontend_move_labels()
|
||
check("D9 前端那两张「处理方式」表认得 move:已办那一列不会印出裸的 move",
|
||
labels == [], labels)
|
||
|
||
engine.terminate(db, job=work.job, actor=actor_of(ADMIN, is_admin=True),
|
||
opinion="这张单后来被终止了")
|
||
db.flush()
|
||
later = (task_detail(db, origin.id, user_of(BOSS)).get("data") or {}).get("vanished") or {}
|
||
check("D10 那张单后来终止归档了:旧卡片跟着换成「这张单已终止」,不再写着停在哪个环节等谁办",
|
||
later.get("kind") == "move" and later.get("work_status") == "terminated"
|
||
and not later.get("current_handlers") and bool(later.get("title")),
|
||
{k: later.get(k) for k in ("kind", "work_status", "current_handlers")})
|
||
|
||
|
||
def _frontend_move_labels() -> list[str]:
|
||
"""看前端那两张处理方式表认不认得 move。判据口径与 check_notify_settle.py 同一类。"""
|
||
import pathlib as _pathlib
|
||
import re
|
||
|
||
root = _pathlib.Path(__file__).resolve().parents[2] / "frontend" / "src" / "utils"
|
||
out: list[str] = []
|
||
for rel, marker in (("oa.ts", "PROCESSING_TYPE"), ("approvalRecord.ts", "PROCESSING_TYPES")):
|
||
text = (root / rel).read_text(encoding="utf-8")
|
||
block = re.search(marker + r"[^=]*=\s*\{(.*?)\n\}", text, re.S)
|
||
if block is None:
|
||
out.append(f"{rel}:{marker} 没找到")
|
||
elif not re.search(r"^\s*move\s*:", block.group(1), re.M):
|
||
out.append(f"{rel}:{marker} 缺 move")
|
||
return out
|
||
|
||
|
||
def main() -> int:
|
||
for step in (check_todo_after_move, check_messages, check_event_dedupe,
|
||
check_residues, check_embed_cascade, check_dead_link):
|
||
step()
|
||
print(f"\n共 {PASSED + len(FAILS)} 项判据:通过 {PASSED},失败 {len(FAILS)}"
|
||
+ (f";另记现状 {len(NOTES)} 条" if NOTES else ""))
|
||
for item in FAILS:
|
||
print(f" - {item}")
|
||
return 1 if FAILS else 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|