unis-oa/backend/scripts/check_intervention_move.py

615 lines
32 KiB
Python
Raw 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
"""钉住「干预改道之后,被干预那一环还剩什么」与「已经推出去的消息各自什么下场」。
两个问题来自 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())