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