unis-oa/backend/scripts/check_notify_settle.py

496 lines
25 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 用户截图):待办全部处理完,右上角铃铛里那叠通知消息还挂着四条
「您有新的待办」,小红点也不灭,只能靠「全部已读」手动清一遍——而清完列表还摆在原处。
根因是 ``oa_notification`` 只在写进去的那一刻有人看:``engine.notify`` 发完就不管,
接口只有「点开算已读」「全部已读」两个手动口子,而待办本身会消失(办结删行、或签
把同级一起结掉、转办与交接换持有人、终止与办结清空整单),每一条都不回头动站内信。
口径与取舍写在 :mod:`app.service.notify_settle`,一句话:**一条提醒值不值得摆着,
看它指向的那件事还在不在收件人自己手上**;收尾落在读出口(列表 / 未读数 / 工作台),
待办消失那七八条路子与升级前的存量数据一起管住。界面上这一屏从此只摆没读过的。
**全程跑在内存 sqlite 上,一条语句都不碰生产库**(引擎、站内信、接口都是真代码)::
cd backend && PYTHONPATH=. python3 scripts/check_notify_settle.py
分组:
A 判据 还在我手上 / 那条待办没了 / 换了持有人 / 没记待办号的老数据 / 空身份
B 不该动的 办结结果、控制类、会议、对接留痕,以及别人的与已读的
C 真流程 转办、或签自动结、终止、待阅登记之后,通知跟着事项一起收尾
D 接口与界面 列表、未读数、工作台三处同一份账;没未读时一趟收尾语句都不许多跑;
前端三个出口都只摆未读
"""
from __future__ import annotations
import os
import sys
from datetime import datetime
# 与 check_terminate_control.py 同一个理由:共享设计缓存是跨进程的,脚本里那些
# 固定流程 id 会读到上一趟自己存进去的设计,症状是"改了配置判据还是旧的"。
os.environ["OA_DESIGN_CACHE"] = "off"
from sqlalchemy import create_engine, event, func, select # noqa: E402
from sqlalchemy.orm import Session # noqa: E402
from sqlalchemy.pool import StaticPool # noqa: E402
from app import models # noqa: E402
from app.api import support as support_api # noqa: E402
from app.deps import CurrentUser # noqa: E402
from app.engine import definition as definition_module # noqa: E402
from app.engine import engine # noqa: E402
from app.service import notify_settle # noqa: E402
STARTER = ("1001", "张锦杰", "zhangjinjie")
HOLDER = ("2002", "陈晟罡", "chenshenggang")
HOLDER2 = ("2003", "贾晨铭", "jiachenming")
OTHER_ORG = ("3003", "黄雪秋", "huangxueqiu")
FAILS: list[str] = []
PASSED = 0
#: 收尾那两条 UPDATE 跑了没有、跑了几趟(D 组按这个数"没未读就不许多问")
SETTLE_STATEMENTS: list[str] = []
def check(label: str, ok: bool, detail: str = "") -> bool:
"""报一条结果;``ok`` 为假就记进失败清单,最后决定退出码。"""
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 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})
@event.listens_for(bind, "before_cursor_execute")
def _tally(conn, cursor, statement, parameters, context, executemany): # noqa: ANN001
lowered = statement.lower().replace("\n", " ")
if "update oa_notification" in lowered:
SETTLE_STATEMENTS.append(statement)
models.Base.metadata.create_all(bind)
db = Session(bind)
# 审批人配置与转办对象认的都是登录账号:库里没有这些人,引擎就组不出待办
for person_id, name, ref in (STARTER, HOLDER, HOLDER2, OTHER_ORG):
db.add(models.User(id=int(person_id), account=ref, display_name=name,
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) -> CurrentUser:
"""接口要的那个登录身份。只建人员行,权限全给(这一门只关心收件人是谁)。"""
person_id, name, ref = person
row = models.User(id=int(person_id), account=ref, display_name=name, status=1)
return CurrentUser(person=row, ref=ref, is_admin=True, permissions=("work:profile",))
def make_flow(db: Session, tag: str, *, node_config: dict | None = None) -> str:
"""一张最小可用的流程:发起 → 财务经理 → 结束。回流程 id。
每个场景各用一条流程:设计缓存按流程 id 认,复用同一个 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=dict(node_config or {"taskValues": [{"type": "identity",
"data": [HOLDER[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}-end"))
db.flush()
return pid
def make_work(db: Session, pid: str, tag: str, *, holders: list[tuple] | None = None) -> models.Work:
"""一张停在「财务经理」的单,待办压在 ``holders`` 手上(默认就是陈晟罡一条)。
通知按引擎真正的写法造(:func:`engine.notify`),这样"通知长什么样"不由脚本自说自话。
"""
now = datetime.now()
row = models.Work(
id=f"w-{tag}", job=f"j-{tag}", serial=f"S-{tag}", title=f"2026年10月VDI项目招待费 {tag}",
process=pid, process_name=f"通知收尾校验流程 {tag}", form="f-shared",
data={"title": "校验"}, creator=STARTER[0], creator_person=STARTER[1],
creator_identity=STARTER[2], status="running", activity=f"{pid}-dept",
activity_name="财务经理", activity_type="manual", current_activity_names="财务经理",
tokens=[{"activity": f"{pid}-dept", "path": "dept"}], start_time=now,
)
db.add(row)
db.flush()
for index, person in enumerate(holders or [HOLDER]):
person_id, name, ref = person
db.add(models.Task(
id=f"t-{tag}-{index}", job=row.job, work=row.id, title=row.title, status="pending",
process=pid, activity=f"{pid}-dept", activity_name="财务经理", activity_type="manual",
person=person_id, identity=ref, identity_name=name,
creator=STARTER[0], creator_person=STARTER[1], creator_identity=STARTER[2],
start_time=now,
))
db.flush()
arrive(db, row, pid, [p[2] for p in (holders or [HOLDER])])
return row
def arrive(db: Session, work: models.Work, pid: str, identities: list[str]) -> None:
"""到达这一环时引擎会发的那条站内信(``_notify_task`` 同一套参数)。"""
engine.notify(
db, identities, type_="task", title=f"您有新的待办:{work.title}",
body=f"{STARTER[1]} 提交的《{work.title}》等待您在【财务经理】环节处理。",
job=work.job, work=work.id, process=work.process, sender=STARTER[1],
)
db.flush()
def _sql_of(db: Session) -> str:
"""把收尾这两条 UPDATE 真的跑一遍,顺手把发出去的 SQL 原文捞回来。
钉的是子查询的**形状**:SELECT 的必须是 ``oa_task.id`` / ``oa_read.id``。写成
``select(Notification.id)`` 也能跑,但 SQLAlchemy 会把站内信表再拖进一次 FROM,
EXISTS 于是恒真——症状是"没记待办号的那几条永远收不掉",看不出来是判据写歪了。
"""
bind = db.get_bind()
captured: list[str] = []
@event.listens_for(bind, "before_cursor_execute")
def _grab(conn, cursor, statement, parameters, context, executemany): # noqa: ANN001
captured.append(statement)
try:
notify_settle.settle(db, HOLDER[2])
finally:
event.remove(bind, "before_cursor_execute", _grab)
return "\n".join(captured)
def note(db: Session, identity: str, *, task: str = "", work: str = "", type_: str = "task",
title: str = "标记") -> models.Notification:
"""塞一条站内信进库(走真 :func:`engine.notify`,顺手把 ``task`` / ``work`` 摆成要的样子)。"""
db.add(models.Notification(
id=f"n-{identity}-{type_}-{title}-{task}-{work}", type=type_, title=title, body="正文",
task=task, work=work, job="", process="p-x", identity=identity, read=False,
))
db.flush()
return db.get(models.Notification, f"n-{identity}-{type_}-{title}-{task}-{work}")
def unread(db: Session, identity: str) -> list[str]:
"""还没读过的站内信标题,排序好便于比较。"""
rows = db.execute(
select(models.Notification.title).where(
models.Notification.identity == identity, models.Notification.read.is_(False)
)
).scalars().all()
return sorted(rows)
# ---------------------------------------------------------------------------
# A 判据
# ---------------------------------------------------------------------------
def check_criteria() -> None:
db = new_session()
pid = make_flow(db, "a")
work = make_work(db, pid, "a")
task = db.execute(select(models.Task).where(models.Task.work == work.id)).scalars().first()
mine = note(db, HOLDER[2], task=task.id, work=work.id, title="带待办号")
legacy = note(db, HOLDER[2], task="", work=work.id, title="老数据没记待办号")
theirs = note(db, OTHER_ORG[2], task=task.id, work=work.id, title="别人的")
blank = note(db, HOLDER[2], task="", work="", title="事项号单据号都空")
arrived = f"您有新的待办:{work.title}"
check("A1 待办还在自己手上时一条都不许多收(读接口不许吃人)",
notify_settle.settle(db, HOLDER[2]) == 0, "第一次收尾就该 0 条")
check("A2 同一条待办的通知发给别人时,我这次收尾不许动别人的",
not theirs.read, "别人那条被误收了")
check("A3 事项号与单据号都是空的(说不出它指哪件事)宁可留着不误伤",
not blank.read, "空事项号那条被误收了")
left = unread(db, HOLDER[2])
check("A3+ 待办还挂着时,这个人名下一条都没被收走",
left == sorted([arrived, "带待办号", "老数据没记待办号", "事项号单据号都空"]), left)
# 那条待办办完了:引擎删行(_complete_task 就是删行),通知得跟着退
gone = note(db, HOLDER[2], task="t-早就没了", work=work.id, title="待办已消失")
db.delete(task)
db.flush()
notify_settle.settle(db, HOLDER[2])
check("A4 待办办完之后,那一条『您有新的待办』当场收尾", mine.read and gone.read)
check("A5 收尾时补上 read_time(已读时间空着,投递记录与界面就没法对账)",
bool(mine.read_time and gone.read_time), f"{mine.read_time} / {gone.read_time}")
check("A6 没记待办号的老数据按『这一单上还有没有我的待办』收尾",
legacy.read, "存量那条没退")
check("A6+ 收完之后只剩下说不清指向的那一条",
unread(db, HOLDER[2]) == ["事项号单据号都空"], unread(db, HOLDER[2]))
check("A6++ 别人名下那一条一个字都没被动过",
unread(db, OTHER_ORG[2]) == ["别人的"], unread(db, OTHER_ORG[2]))
check("A7 再收一次是 0 条(幂等,不反复改写已读时间)",
notify_settle.settle(db, HOLDER[2]) == 0)
stamp = mine.read_time
check("A8 已读的那几条不再被改写", mine.read_time == stamp and notify_settle.settle(db, HOLDER[2]) == 0)
# 交接 / 转办:待办行还在,只是不再属于你
db2 = new_session()
pid2 = make_flow(db2, "a2")
work2 = make_work(db2, pid2, "a2")
task2 = db2.execute(select(models.Task).where(models.Task.work == work2.id)).scalars().first()
handed = note(db2, HOLDER[2], task=task2.id, work=work2.id, title="交出去的那条")
task2.identity = OTHER_ORG[2]
db2.flush()
check("A9 待办换了持有人(交接 / 改派),原主人那两条都收尾:带待办号的那一条按号判,"
"没记号的那一条按『这一单上没有我的待办了』判——行还在,只是不再属于他",
notify_settle.settle(db2, HOLDER[2]) == 2 and handed.read)
check("A10 接手人那条同待办号的通知照旧留着(同一行待办,两个收件人各算各的)",
not note(db2, OTHER_ORG[2], task=task2.id, work=work2.id, title="接手人那条").read)
check("A11 没有这个收件人时直接回 0,不发语句",
notify_settle.settle(db2, "") == 0)
# 判据的写法本身也要钉住:EXISTS 里那个"再进一次 oa_notification"的坑,
# 症状是没记待办号的老数据永远收不掉(子查询变成笛卡尔积,只要这个人还有
# 任何一条站内信,EXISTS 就恒真)。SELECT 的必须是 oa_task.id / oa_read.id。
shape = _sql_of(db2)
check("A12 收尾那两条 UPDATE 的子查询只回表查待办 / 待阅,不再进一次站内信表",
"EXISTS (SELECT oa_task.id" in shape and "EXISTS (SELECT oa_read.id" in shape
and "oa_task, oa_notification" not in shape and "FROM oa_read, oa_notification" not in shape,
shape[:400])
# ---------------------------------------------------------------------------
# B 不该动的类型
# ---------------------------------------------------------------------------
def check_other_types() -> None:
db = new_session()
pid = make_flow(db, "b")
work = make_work(db, pid, "b")
task = db.execute(select(models.Task).where(models.Task.work == work.id)).scalars().first()
finished = note(db, HOLDER[2], type_="completed", task="", work=work.id, title="办结结果")
control = note(db, HOLDER[2], type_="control", task="", work=work.id, title="挂起提示")
meeting = note(db, HOLDER[2], type_="meeting", task="", work="", title="会议提醒")
integration = note(db, HOLDER[2], type_="integration", task="", work=work.id, title="对接留痕")
press_alive = note(db, HOLDER[2], type_="press", task=task.id, work=work.id, title="催办")
expire_alive = note(db, HOLDER[2], type_="expire", task=task.id, work=work.id, title="超时")
read_alive = note(db, HOLDER[2], type_="read", task="", work=work.id, title="抄送")
db.add(models.Read(id="r-b", job=work.job, work=work.id, identity=HOLDER[2], process=pid,
read_type="cc", requires_action=False))
db.flush()
check("B1 待办还挂着时,催办与超时提醒都留着",
notify_settle.settle(db, HOLDER[2]) == 0 and not press_alive.read and not expire_alive.read)
check("B2 抄送那一条在待阅还没登记时留着", not read_alive.read)
check("B3 办结结果 / 挂起恢复那类『已经发生的一件事』永远不动,哪怕这一单上没我的待办",
not any(item.read for item in (finished, control, meeting, integration)),
[item.title for item in (finished, control, meeting, integration) if item.read])
db.delete(task)
db.delete(db.execute(select(models.Read)).scalars().first())
db.flush()
notify_settle.settle(db, HOLDER[2])
check("B4 待办办完:催办与超时提醒一起退(点开要办的那三类同一族)",
press_alive.read and expire_alive.read)
check("B5 待阅登记完(那一行没了):抄送那一条退", read_alive.read)
check("B6 办结结果与会议提醒不跟着退",
not finished.read and not meeting.read and not control.read and not integration.read)
# ---------------------------------------------------------------------------
# C 真流程:引擎动完手,通知得跟着退
# ---------------------------------------------------------------------------
def start_job(db: Session, pid: str, actor) -> models.Work:
"""真发起一张单:走到「财务经理」,待办与那两条站内信都由引擎自己写。"""
result = engine.create_job(
db, process_id=pid, actor=actor,
data={"title": "2026年10月VDI项目招待费"}, title="2026年10月VDI项目招待费",
)
db.flush()
return result.work
def check_real_flow() -> None:
db = new_session()
pid = make_flow(db, "c")
work = start_job(db, pid, actor_of(STARTER))
task = db.execute(select(models.Task).where(models.Task.work == work.id)).scalars().first()
check("C1 引擎到达环节真的写下了那条『您有新的待办』(收尾判的是这份真数据)",
task is not None and unread(db, HOLDER[2]) == [f"您有新的待办:{work.title}"],
unread(db, HOLDER[2]))
# 转办:待办从陈晟罡手里转到贾晨铭手上
engine.transfer(db, task_id=task.id, actor=actor_of(HOLDER), identities=[HOLDER2[2]],
opinion="我在外出差")
db.flush()
check("C2 转办之后:原持有人那条当场收尾(问的是接口,收尾就挂在读出口)",
support_api.unread_count(user=user_of(HOLDER), db=db)["data"]["count"] == 0,
unread(db, HOLDER[2]))
check("C3 接手人收到的那一条(没记待办号那批)留着——他手上确实还有这条待办",
unread(db, HOLDER2[2]) and notify_settle.settle(db, HOLDER2[2]) == 0,
unread(db, HOLDER2[2]))
engine.terminate(db, job=work.job, actor=actor_of(STARTER), opinion="重发一张")
db.flush()
panel = [item["title"] for item in support_api.list_notifications(
user=user_of(HOLDER2), db=db, unread_only=True, page=1, page_size=12)["data"]["items"]]
check("C4 终止把整单待办清空之后,接手人那条『有新的待办』也收尾",
db.execute(select(func.count(models.Task.id)).where(
models.Task.work == work.id)).scalar() == 0
and f"您有新的待办:{work.title}" not in panel, unread(db, HOLDER2[2]))
check("C4+ 终止那一刻告诉他『这张单没了』的那条留下——那是新消息,不是过期提醒",
unread(db, HOLDER2[2]) == [f"待办已终止:{work.title}"], unread(db, HOLDER2[2]))
check("C5 终止那一刻发出去的控制类留痕不跟着退(它说的是已经发生的事)",
any(row.type == "control" and not row.read
for row in db.execute(select(models.Notification)).scalars().all()),
"没找到终止留痕那条站内信")
# 或签:同一环节两条待办,一人办结,引擎把同级一起结掉
db2 = new_session()
pid2 = make_flow(db2, "c2")
work2 = start_job(db2, pid2, actor_of(STARTER))
activity = definition_module.for_work(db2, work2).activity(f"{pid2}-dept")
siblings = [
models.Task(
id=f"t-c2-{index}", job=work2.job, work=work2.id, title=work2.title, status="pending",
process=pid2, activity=activity.id, activity_name=activity.name,
activity_type="manual", person=person, identity=ref, identity_name=name,
creator=STARTER[0], creator_person=STARTER[1], creator_identity=STARTER[2],
start_time=datetime.now(),
)
for index, (person, name, ref) in enumerate([HOLDER, HOLDER2])
]
db2.add_all(siblings)
db2.flush()
arrive(db2, work2, pid2, [HOLDER[2], HOLDER2[2]])
check("C6 两个人各有一条待办、各有一条未读(下一步的前提)",
unread(db2, HOLDER[2]) and unread(db2, HOLDER2[2]))
engine.execute_task(db2, task_id=siblings[0].id, actor=actor_of(HOLDER), route_name="同意")
db2.flush()
check("C7 或签一人办结:他这条通知收尾(走的是真 execute_task)",
support_api.unread_count(user=user_of(HOLDER), db=db2)["data"]["count"] == 0,
unread(db2, HOLDER[2]))
check("C8 同级那条待办被系统一起结掉了,他的通知也收尾(不用等他自己点开)",
db2.execute(select(func.count(models.Task.id)).where(
models.Task.work == work2.id)).scalar() == 0
and notify_settle.settle(db2, HOLDER2[2]) >= 1,
unread(db2, HOLDER2[2]))
# ---------------------------------------------------------------------------
# D 接口与界面
# ---------------------------------------------------------------------------
def check_surfaces() -> None:
db = new_session()
pid = make_flow(db, "d")
work = start_job(db, pid, actor_of(STARTER))
task = db.execute(select(models.Task).where(models.Task.work == work.id)).scalars().first()
note(db, HOLDER[2], type_="completed", task="", work=work.id, title="办结结果")
user = user_of(HOLDER)
SETTLE_STATEMENTS.clear()
panel = support_api.list_notifications(user=user, db=db, unread_only=True, page=1, page_size=12)
check("D1 铃铛面板只摆没读过的:待办还挂着时那一条还在",
sorted(item["title"] for item in panel["data"]["items"])
== sorted([f"您有新的待办:{work.title}", "办结结果"]), panel["data"]["items"])
db.delete(task)
db.flush()
panel = support_api.list_notifications(user=user, db=db, unread_only=True, page=1, page_size=12)
check("D2 待办办完之后重新打开面板:那条『您有新的待办』已经退场,只剩办结结果",
[item["title"] for item in panel["data"]["items"]] == ["办结结果"], panel["data"]["items"])
count = support_api.unread_count(user=user, db=db)["data"]["count"]
check("D3 小红点与面板是同一份账(面板空了就报 0)", count == 1, f"未读数 {count}")
stats = support_api.workbench(user=user, db=db)["data"]
check("D4 工作台『未读消息』那一格也是同一份账", stats["unread"] == count, stats)
support_api.read_all_notifications(user=user, db=db)
check("D5 全部已读之后:面板清空(以前按了按钮列表照旧堆在原处)",
support_api.list_notifications(user=user, db=db, unread_only=True, page=1,
page_size=12)["data"]["items"] == []
and support_api.unread_count(user=user, db=db)["data"]["count"] == 0)
SETTLE_STATEMENTS.clear()
support_api.unread_count(user=user, db=db)
check("D6 一条未读都没有时,收尾那两条 UPDATE 一趟都不许多跑(这颗角标 15 秒问一次)",
SETTLE_STATEMENTS == [], SETTLE_STATEMENTS)
# 有待办挂着(有未读)时收尾会跑,但收不掉任何东西,数字不许漂
db2 = new_session()
pid2 = make_flow(db2, "d2")
start_job(db2, pid2, actor_of(STARTER))
holder = user_of(HOLDER)
before = support_api.unread_count(user=holder, db=db2)["data"]["count"]
SETTLE_STATEMENTS.clear()
after = support_api.unread_count(user=holder, db=db2)["data"]["count"]
check("D7 待办还挂着时反复数,数字不许漂(收尾只认『事项已经不在了』)",
before == after == 1, f"{before} -> {after}")
frontend = _frontend_caliber()
check("D8 前端三个出口都只摆未读(铃铛下拉 / 手机版式 / 首页通知卡片)",
frontend == [], frontend)
def _frontend_caliber() -> list[str]:
"""钉住前端那一层:三个列出口都带 ``unread_only``,读过一条就退出面板。"""
import pathlib
import re
root = pathlib.Path(__file__).resolve().parents[2] / "frontend" / "src"
want = {
"components/layout/AppHeader.vue": 1,
"stores/app.ts": 1,
"views/oa/WorkbenchView.vue": 1,
}
problems: list[str] = []
for rel, times in want.items():
text = (root / rel).read_text(encoding="utf-8")
hits = len(re.findall(r"listNotifications\(\{[^}]*unread_only:\s*true", text, re.S))
if hits < times:
problems.append(f"{rel} 没带 unread_only")
app_store = (root / "stores" / "app.ts").read_text(encoding="utf-8")
if "notifications.value.filter((row) => row.id !== item.id)" not in app_store:
problems.append("stores/app.ts 读过之后没把那条退出面板")
return problems
def main() -> int:
for step in (check_criteria, check_other_types, check_real_flow, check_surfaces):
step()
print(f"\n共 {PASSED + len(FAILS)} 项:通过 {PASSED},失败 {len(FAILS)}")
for item in FAILS:
print(f" - {item}")
return 1 if FAILS else 0
if __name__ == "__main__":
sys.exit(main())