unis-oa/backend/scripts/check_done_cc_split.py

342 lines
20 KiB
Python
Raw Permalink 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 用户口径)。
用户提的原话是:需处理的那几条处理完应该在**已办**里,从前却落进了已阅;
不需处理的那几条才是已阅。第二条:处理弹窗里那句意见不该是必填。
翻成代码是三句话,这一篇逐条钉::
PYTHONPATH=. python3 scripts/check_done_cc_split.py
1. **归档行按 ``requires_action`` 分家**:``oa_read_completed`` 还是那一张表(写侧一动不动),
读这一侧 ``requires_action=1`` 归已办(``GET /task/completed`` 里 ``done_source="cc"``),
``=0`` 归已阅(``GET /read/completed``)。两边各认一半,加起来才是归档行的全量——
两处判据不许在同一行上都说自己看见它。
2. **历史行不用回填**:改版之前办完、一直躺在已阅里的那几条(``requires_action=1`` 且已有
``handle_time``)今天自动出现在已办、同时从已阅消失。脚本直接在库里插一条"老写法
留下的行",再用新读法问一遍,就是这个证据。
3. **意见选填**:``mark_read(handling=True)`` 空着意见也登记(落 ``handle_time``),
「标记已读」那一趟(``handling=False``)照旧不动需处理的行、单独报 ``skipped``。
必填的是那颗钮,不是那几个字。
外加两条一起守住:折叠口径是(单 × 来源)——同一张单的审批表态与抄送处理摆两条,
各自的次数各数各的;以及角标(首页 / 工作台)那个数与列表翻得到的是同一个数。
库里不留东西:探针行都挂在合成身份 ``__done_split_*__`` 下,开头与结尾各清一遍,
中间的状态改动不 commit(引擎那几路只 flush)。
"""
from __future__ import annotations
import csv
import io
from datetime import datetime, timedelta
from sqlalchemy import delete, select
from app import models, schemas
from app.api.export import export_tasks
from app.api.portal import home_counts
from app.api.runtime import handle_read, list_completed, list_read_completed
from app.api.support import workbench
from app.db import SessionLocal
from app.deps import CurrentUser, actor_of
from app.engine import engine
STAMP = datetime.now().strftime("%m%d%H%M%S")
ME = f"__done_split_me_{STAMP}"
PROCESS = f"done_split_p_{STAMP}"
BASE = datetime(2026, 1, 1, 9, 0, 0)
FAILS: list[str] = []
PASSED = 0
def check(label: str, condition, detail: str = "") -> bool:
global PASSED
if condition:
PASSED += 1
print(f"[通过] {label}")
else:
FAILS.append(label)
print(f"[FAIL] {label}" + (f" -> {detail}" if detail else ""))
return bool(condition)
def purge() -> None:
"""清掉上一篇(或上一次跑挂了)留下的探针行。"""
with SessionLocal() as db:
db.execute(delete(models.TaskCompleted).where(models.TaskCompleted.identity == ME))
db.execute(delete(models.ReadCompleted).where(models.ReadCompleted.identity == ME))
db.execute(delete(models.Read).where(models.Read.identity == ME))
db.execute(delete(models.OperationLog).where(models.OperationLog.detail.like(f"%{STAMP}%")))
db.commit()
def add_approval(db, work: str, minutes: int, activity: str, *, times: int = 1) -> None:
"""插几条环节上的表态(同一条单被办过几次,用来验折叠)。"""
for index in range(times):
moment = BASE + timedelta(minutes=minutes + index)
db.add(models.TaskCompleted(
task=f"task-{work}-{index}-{STAMP}", job=f"job-{work}-{STAMP}", work=work,
title=f"分家校验单-{work}", process=PROCESS, process_name=f"分家校验流程-{STAMP}",
serial=f"SPLIT{work}{STAMP}", activity=f"act-{activity}", activity_name=activity,
person="me", identity=ME, identity_name="分家校验账号", creator_person="张三",
start_time=moment - timedelta(minutes=1), completed_time=moment,
latest=index == times - 1))
def add_read_completed(db, work: str, *, requires_action: bool, minutes: int,
opinion: str = "", handled: bool = True,
forwarded: bool = False) -> models.ReadCompleted:
"""插一条归档件:需处理的与不需处理的各造得出,模拟「改版之前就这么写的行」。
``forwarded`` 那一档是**办结之后的转发**:库里 ``read_type`` 仍是 ``cc``,靠这一格分细
(见 ``sql/upgrade/20261116_read_forwarded.sql``)。分家认的是"要不要处理",
转发与抄送同一条路,所以这一格不参与判据,只该在出参里说得出。
"""
moment = BASE + timedelta(minutes=minutes)
row = models.ReadCompleted(
read=f"read-{work}-{STAMP}", job=f"job-{work}-{STAMP}", work=work,
work_completed="", completed=False, title=f"分家校验单-{work}",
process=PROCESS, process_name=f"分家校验流程-{STAMP}", serial=f"SPLIT{work}{STAMP}",
activity="act-cc", activity_name="财务复核", person="me", identity=ME,
identity_name="分家校验账号", sender="李四", creator_person="张三",
read_type="cc", requires_action=requires_action, opinion=opinion, forwarded=forwarded,
start_time=moment - timedelta(hours=1), view_time=moment,
handle_time=moment if (requires_action and handled) else None)
db.add(row)
return row
def add_read(db, work: str, *, requires_action: bool, minutes: int,
opinion: str = "请补充说明") -> models.Read:
"""插一条还压在待阅 / 待办里的行(办结之前它还在 ``oa_read``)。"""
moment = BASE + timedelta(minutes=minutes)
row = models.Read(
job=f"job-{work}-{STAMP}", work=work, completed=False,
title=f"分家校验单-{work}", process=PROCESS, process_name=f"分家校验流程-{STAMP}",
serial=f"SPLIT{work}{STAMP}", activity="act-cc", activity_name="财务复核",
person="me", identity=ME, identity_name="分家校验账号", sender="李四",
creator_person="张三", read_type="cc", requires_action=requires_action,
opinion=opinion, start_time=moment)
db.add(row)
return row
def done_page(db, user, **query) -> dict:
return list_completed(
user=user, db=db, keyword=query.get("keyword", ""), process=query.get("process", ""),
category="", start_date=query.get("start_date", ""), end_date=query.get("end_date", ""),
page=query.get("page", 1), page_size=query.get("page_size", 50),
)["data"]
def read_page(db, user) -> dict:
return list_read_completed(user=user, db=db, keyword="", kind="",
page=1, page_size=50)["data"]
def shape(items: list[dict]) -> list[tuple[str, str]]:
"""收成 ``(哪张单, 哪一档来源)``:这一篇所有断言只看这两样。"""
return [(str(item.get("work") or ""), str(item.get("done_source") or "")) for item in items]
def main() -> int:
purge()
with SessionLocal() as db:
person = db.execute(select(models.User).limit(1)).scalars().first()
if person is None:
print("[FAIL] 库里没有任何 users 行,造不出 CurrentUser")
return 1
user = CurrentUser(person=person, ref=ME, is_admin=True)
actor = actor_of(user)
try:
# A:同一张单上我既批过一步、又被抄送要求处理过 → 已办摆两条
add_approval(db, "A", 300, "部门主管", times=2)
add_read_completed(db, "A", requires_action=True, minutes=420, opinion="凭证已补齐")
# HIST:改版之前办完、当时落在已阅里的那一条(写侧一个字没变)
add_read_completed(db, "HIST", requires_action=True, minutes=240, opinion="已核对,无问题")
# P:不需处理、点开即看完 → 只在已阅
add_read_completed(db, "P", requires_action=False, minutes=180)
# N / M:还压在待办里的需处理行,分别走「空意见处理」与「批量标记已读」
row_n = add_read(db, "N", requires_action=True, minutes=60)
row_m = add_read(db, "M", requires_action=True, minutes=90)
row_q = add_read(db, "Q", requires_action=False, minutes=120)
db.flush()
n_id, m_id, q_id = row_n.id, row_m.id, row_q.id
data = done_page(db, user)
got = shape(data["items"])
check("需处理办完的那两条进了已办(含改版之前办完的历史行)",
("A", "cc") in got and ("HIST", "cc") in got, str(got))
check("不需处理的那条不在已办里(它归已阅)",
all(work != "P" for work, _source in got), str(got))
check("还没处理的三条也没进已办",
all(work not in {"N", "M", "Q"} for work, _source in got), str(got))
check("同一张单的审批表态与抄送处理各摆一条",
got.count(("A", "approval")) == 1 and got.count(("A", "cc")) == 1, str(got))
# A 的抄送处理在 16:00、A 的审批表态最近一次在 14:01、历史那条在 13:00;
# 不需处理那条(12:00)根本不在这一屏。这一条同时钉住"排序按各自那一档的时刻"
check("排序按「最近一次办完」倒序,抄送那一档用的是处理时刻",
got == [("A", "cc"), ("A", "approval"), ("HIST", "cc")], str(got))
cc_row = next(item for item in data["items"] if item.get("done_source") == "cc")
approval_row = next(item for item in data["items"]
if item.get("done_source") == "approval")
check("抄送那一行带的是处理时刻与那句意见",
cc_row["completed_time"] == "2026-01-01 16:00:00" and cc_row["opinion"] == "凭证已补齐",
str(cc_row))
check("抄送那一行说得出来源,且不给自己安排撤回",
cc_row.get("recallable") is None and cc_row.get("processing_type") == "cc"
and "recall_blocker" not in cc_row, str(cc_row))
check("审批那一行仍然带着撤回那一档判断(没被并表弄丢)",
"recallable" in approval_row and "recall_blocker" in approval_row,
str(sorted(approval_row)))
check("已办的总数数的是组:一张单的两档来源算两条",
data["total"] == len(got) == 3, str((data["total"], got)))
check("翻页与页眉同一个数(翻到底不重不漏)",
sorted(shape(done_page(db, user, page=1, page_size=1)["items"])
+ shape(done_page(db, user, page=2, page_size=1)["items"])
+ shape(done_page(db, user, page=3, page_size=1)["items"])) == sorted(got),
str(got))
read_data = read_page(db, user)
read_works = [str(item.get("work")) for item in read_data["items"]]
check("已阅只剩不需处理那一档", read_works == ["P"], str(read_works))
check("办完的抄送不再出现在已阅里(两处不同时要紧的是各认一半)",
"HIST" not in read_works and "A" not in read_works, str(read_works))
check("已阅的总数跟着这一档一起收", read_data["total"] == 1, str(read_data["total"]))
counts = home_counts(db, user)
check("首页角标的已办 = 已办列表的条数",
counts["task_completed"] == data["total"], str(counts["task_completed"]))
check("首页角标的已阅 = 已阅列表的条数",
counts["read_completed"] == read_data["total"], str(counts["read_completed"]))
check("工作台那个「我的已办」与首页、列表同一个口径",
workbench(user=user, db=db)["data"]["completed"] == data["total"],
str(workbench(user=user, db=db)["data"]["completed"]))
body = export_tasks(
scope="completed", keyword="", process="", category="", expired="",
start_date="", end_date="", db=db, user=user,
).body.decode("utf-8-sig")
lines = list(csv.reader(io.StringIO(body)))
header, rows_csv = lines[0], lines[1:]
check("导出与页面读同一份两本账", len(rows_csv) == data["total"], str(len(rows_csv)))
check("导出那枚「类型」两档都点名了",
{line[header.index("类型")] for line in rows_csv} == {"审批办理", "抄送处理"},
str([line[header.index("类型")] for line in rows_csv]))
# ---------------- 3) 意见选填:空着也能办完 ----------------
handled = engine.mark_read(db, read_id=n_id, actor=actor, opinion=" ", handling=True)
db.flush()
check("空着处理意见也登记得掉(落处理时间,来意那句留着)",
handled.handle_time is not None and handled.requires_action is True
and handled.opinion == "请补充说明", str(handled.opinion))
check("空意见处理完的那条当场进了已办",
("N", "cc") in shape(done_page(db, user)["items"]),
str(shape(done_page(db, user)["items"])))
check("它同时从已阅里缺席:已阅只有不需处理那一档",
"N" not in [str(item.get("work")) for item in read_page(db, user)["items"]],
str([item.get("work") for item in read_page(db, user)["items"]]))
check("接口那一路也认空意见(单条「处理」不再挡人)",
handle_read(read_id=m_id, body=schemas.ReadViewBody(opinion="", attachments=[]),
user=user, db=db, request=None) is not None, "")
# 那一路自己 commit,顺手落了一条操作日志:探针留下的那条按 target 收掉,
# 不许留在真人名下(本脚本其余状态改动都不提交,收尾 rollback)
with SessionLocal() as log_db:
log_db.execute(delete(models.OperationLog).where(models.OperationLog.target == m_id))
log_db.commit()
check("接口那一路办完的那条同样在已办里",
("M", "cc") in shape(done_page(db, user)["items"]),
str(shape(done_page(db, user)["items"])))
# ---------------- 4) 只有「处理」才算办完,标记已读不算 ----------------
row_k = add_read(db, "K", requires_action=True, minutes=150)
db.flush()
result = engine.mark_reads_seen(db, read_ids=[row_k.id], actor=actor)
db.flush()
check("「标记已读」只是盖一个看过的章:行还在待阅,处理时间是空的",
result.marked == 1 and db.get(models.Read, row_k.id) is not None
and db.get(models.Read, row_k.id).handle_time is None, str(result))
batch = engine.mark_reads_batch(db, read_ids=[q_id, row_k.id], actor=actor, handling=False)
db.flush()
check("批量只盖章那一趟:不需处理那条登记掉、需处理那条报 skipped 不动它",
batch.marked == 1 and batch.handled == 0 and batch.skipped
and str(batch.skipped[0]["id"]) == str(row_k.id)
and db.get(models.Read, row_k.id) is not None, str(batch))
check("已阅里现在躺着那条不需处理的",
"Q" in [str(item.get("work")) for item in read_page(db, user)["items"]],
str([item.get("work") for item in read_page(db, user)["items"]]))
batch2 = engine.mark_reads_batch(db, read_ids=[row_k.id], actor=actor, handling=True)
db.flush()
check("批量处理那一趟不写意见也办得动(意见选填)",
batch2.handled == 1 and not batch2.skipped, str(batch2))
check("办完之后 K 也在已办里,已阅始终没收到它",
("K", "cc") in shape(done_page(db, user)["items"])
and "K" not in [str(item.get("work")) for item in read_page(db, user)["items"]],
str(shape(done_page(db, user)["items"])))
# 折叠的组数与列表同步变了(角标不许停在旧数上)
# 三张空白意见处理掉(N / M / K)之后一共 6 个组:
# 抄送那一档 5 条(A、HIST、N、M、K)+ 审批那一档 1 条(A)
check("又处理完三条之后,已办角标跟着列表一起涨",
home_counts(db, user)["task_completed"] == done_page(db, user)["total"] == 6,
str((home_counts(db, user)["task_completed"], done_page(db, user)["total"])))
# ---------------- 5) 一只搜索框,两档行 ----------------
both = shape(done_page(db, user, keyword="分家校验单-A")["items"])
check("搜标题时两档行都搜得出来(同一句话对两类行同样成立)",
{source for _work, source in both} == {"approval", "cc"}, str(both))
starter = shape(done_page(db, user, keyword="张三")["items"])
check("搜发起人姓名时两档都答得上",
{source for _work, source in starter} == {"approval", "cc"}, str(starter))
sender_only = shape(done_page(db, user, keyword="李四")["items"])
check("搜递送人只有抄送那一档答得上(审批行压根没有这一格)",
bool(sender_only) and {source for _work, source in sender_only} == {"cc"},
str(sender_only))
check("搜不到就是空表,不把两档一起倒出来",
shape(done_page(db, user, keyword="查无此单")["items"]) == [], "")
dated = shape(done_page(db, user, start_date="2026-01-01T15:30:00",
end_date="2026-01-01T16:30:00")["items"])
check("日期窗口筛的是各自那一档的处理时刻",
dated == [("A", "cc")], str(dated))
# ---------------- 6) 转发走的是同一档:判据只看要不要处理 ----------------
# 用户那句原话里"抄送、转发"并列。转发在库里就是 read_type=cc + forwarded=1,
# 所以办完的转发该进已办、看过的转发该进已阅,判据一个字都不多。
add_read_completed(db, "FWD", requires_action=True, minutes=600,
opinion="已按转发要求补了说明", forwarded=True)
add_read_completed(db, "FWDREAD", requires_action=False, minutes=610, forwarded=True)
db.flush()
fwd_done = done_page(db, user)
fwd_shape = shape(fwd_done["items"])
fwd_read = [str(item.get("work")) for item in read_page(db, user)["items"]]
check("办完的转发也在已办里(与抄送同一档,不另开一路)",
("FWD", "cc") in fwd_shape, str(fwd_shape))
check("只是看过的转发在已阅里,不在已办里",
"FWDREAD" in fwd_read and all(work != "FWDREAD" for work, _s in fwd_shape),
str((fwd_read, fwd_shape)))
fwd_row = next(item for item in fwd_done["items"] if item.get("work") == "FWD")
check("已办那一行说得出这是办结后的转发(forwarded 带得出)",
fwd_row.get("forwarded") is True and fwd_row.get("done_source") == "cc"
and fwd_row.get("read_type") == "cc", str(sorted(fwd_row)))
# 抄送处理那一档 6 条(A、HIST、N、M、K、FWD)+ 审批 1 条(A)= 7 个组;
# 只是看过的 FWDREAD 不进这一屏,所以角标只涨 1
check("总数与角标只涨办完那一条(看过的转发不算已办)",
fwd_done["total"] == len(fwd_shape) == 7
and home_counts(db, user)["task_completed"] == fwd_done["total"],
str((fwd_done["total"], len(fwd_shape),
home_counts(db, user)["task_completed"])))
finally:
db.rollback()
purge()
print()
print(f"通过 {PASSED} 项,失败 {len(FAILS)} 项")
return 1 if FAILS else 0
if __name__ == "__main__":
raise SystemExit(main())