#!/usr/bin/env python3 """守批量登记待阅这一条:``POST /read/view/batch`` 逐条成事、口径与单条一字不差。 待阅一屏十几条,一条条点「标记已阅」是要点十几下的体力活,所以加了一个批量口子。 批量最容易坏的是两件事,这里逐条钉住: 1. **不许把「需处理」批量洗成看过**:勾选里混着 ``requires_action`` 那几条时, 「标记已读」那一趟(``handling=False``)原样留着(回 ``skipped`` 说清是哪几条), 只有「批量处理」那一趟才把它们办掉——替人按下那一颗钮,比少一个批量按钮严重得多。 (处理意见**可以留空**:2026-11 用户提的,那一句改成选填,空格子也算表过态。) 2. **一条失败不许带走整批**:勾 5 条,其中 1 条是别人的、1 条 id 根本不存在, 那两条各自报错,剩下 3 条照旧登记并真的提交;界面拿得到逐条原因。 顺带钉住四件配套的小事:空勾选按 400 回;同一个 id 传两次只算一条;附件只跟着 真正被处理的那几条走(普通登记不收附件,与单条同一口径);登记完 ``/read/processing/count`` 那个角标要跟着降下来,不然右上角一直红着。 办完的行归哪一屏另有一支判据守着(``check_done_cc_split.py``:需处理算已办、 不需处理算已阅),这一支只管批量这一路逐条成事。 单据是真发的、待阅是真落在收件人名下,收尾按 job 与标题清干净 (复用 ``check_write_payload.purge``),附件行按 id 删。缺流程或缺账号时报「跳过」。:: PYTHONPATH=. python3 scripts/check_read_batch.py """ from __future__ import annotations import os import pathlib import sys from datetime import datetime sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent)) os.environ.setdefault("OA_SCHEDULER", "off") from sqlalchemy import select # noqa: E402 from starlette.testclient import TestClient # noqa: E402 from app import models, schemas # noqa: E402 from app.db import SessionLocal # noqa: E402 from app.main import app # noqa: E402 from app.security import create_access_token # noqa: E402 from app.service import personref # noqa: E402 from check_write_payload import purge # noqa: E402 PROCESS_NAME = "备用金申请流程" DATA = { "loanType": "personalLoan", "loanReason": "批量待阅校验", "loanItems": [{"loanNote": "校验", "loanType": "personalLoan", "loanTypeName": "校验", "loanAmount": 1000, "returnDate": "2099-12-31"}], "loanAmountTotal": 1000, "payItems": [{"payee": "康文靖", "bankName": "校验银行", "bankAccount": "6222020200009999", "payAmount": 1000, "payWay": "bank"}], } STAMP = datetime.now().strftime("%m%d%H%M%S") FAILS: list[str] = [] PASSED = 0 def check(label: str, passed: bool, detail: str = "") -> bool: """报一条结果;``passed`` 为假就记进失败清单。返回它本身,好让调用方就此收尾。""" global PASSED if passed: PASSED += 1 print(f"[通过] {label}") else: FAILS.append(label) print(f"[FAIL] {label}" + (f" -> {detail}" if detail else "")) return passed class Api: """薄壳:把一次接口调用折成 ``(status, data, message)``。""" def __init__(self) -> None: self._client = TestClient(app, raise_server_exceptions=False) @staticmethod def token(person: models.User) -> str: return create_access_token(str(person.id))[0] def call(self, method: str, path: str, *, token: str, json: dict | None = None): response = self._client.request( method, f"/api/v1{path}", headers={"Authorization": f"Bearer {token}"}, json=json) try: body = response.json() except ValueError: body = {} body = body if isinstance(body, dict) else {} return response.status_code, body.get("data"), str(body.get("message") or "") def post(self, path: str, *, token: str, json: dict | None = None): return self.call("POST", path, token=token, json=json) def get(self, path: str, *, token: str): return self.call("GET", path, token=token) # 每一次批量真办成几条(marked + handled)都记在这里:最后那条角标断言按总数对账, # 不写死数字——库里本来就可能留着几条与本次无关的待阅。 TALLY: list[int] = [] #: 单次批量上限,与 ``app/api/runtime.py`` 里的 ``BATCH_LIMIT`` 是同一个数: #: 那里改了而这里没跟着改,下面「勾过上限」那一条就会红给你看 BATCH_LIMIT = 50 def batch(api: Api, token: str, ids: list[str], **kwargs): """打一次批量登记;``opinion`` / ``handling`` / ``attachments`` 都走 kwargs。""" result = api.post( "/read/view/batch", token=token, json={"ids": ids, "opinion": kwargs.get("opinion", ""), "handling": kwargs.get("handling", True), "attachments": kwargs.get("attachments", [])}) data = result[1] or {} TALLY.append(int(data.get("marked") or 0) + int(data.get("handled") or 0)) return result def reads_of(db, work_id: str, identity: str) -> list[models.Read]: db.rollback() # 接口用的是另一个 Session,快照不换就看不见刚才写的 return list(db.execute( select(models.Read).where(models.Read.work == work_id, models.Read.identity == identity) ).scalars().all()) def dones_of(db, work_id: str, identity: str) -> list[models.ReadCompleted]: db.rollback() return list(db.execute( select(models.ReadCompleted).where( models.ReadCompleted.work == work_id, models.ReadCompleted.identity == identity) ).scalars().all()) def main() -> int: # noqa: C901 - 一条直线跑完六组断言,拆开反而要把 id 传来传去 db = SessionLocal() process = db.execute( select(models.Process).where(models.Process.name == PROCESS_NAME, models.Process.enabled.is_(True)) ).scalars().first() if process is None: print(f"[跳过] 没有已发布的「{PROCESS_NAME}」,这一项校不了") db.close() return 0 people = db.execute( select(models.User).where(models.User.status == models.UserStatus.ACTIVE).order_by(models.User.id) ).scalars().all() starter = next((row for row in people if row.role == models.ROLE_ADMIN), None) others = [row for row in people if starter is None or row.id != starter.id] if starter is None or len(others) < 2: print("[跳过] 库里凑不出一个管理员加两个收件人,批量这一路校不了") db.close() return 0 reader, stranger = others[0], others[1] ref = personref.ref_of api = Api() admin = api.token(starter) mine = api.token(reader) jobs: list[str] = [] titles: list[str] = [f"批量待阅门-{STAMP}"] attachments: list[str] = [] status, data, message = api.post("/job", token=admin, json={"process": process.id, "data": DATA, "title": titles[0]}) if status >= 400 or not data: print(f"[跳过] 这张校验单没发起来({status} {message}),这一项校不了") db.close() return 0 jobs.append(str(data.get("job") or "")) job, work_id = str(data.get("job") or ""), str(data.get("work") or "") tasks = [row for row in (data.get("tasks") or []) if not row.get("finish_time")] def make_reads() -> None: """在收件人名下摆出三条待阅:抄送需处理 / 分享 / 批注 @ 无需处理,各一条。 同一个人、同一张单、同一类待阅只留一条,所以要批量就靠三个来源各摆一条。 """ task_id = str(tasks[0].get("id") or "") api.post(f"/task/{task_id}/cc", token=admin, json={"identities": [ref(reader)], "opinion": "请补一句处理意见", "requires_action": True}) api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(reader)], "opinion": "分享给你看"}) api.post(f"/work/{work_id}/comments", token=admin, json={"content": "@你看一眼就行", "mentions": [ref(reader)], "mention_action": False}) try: if not check("这张校验单拿得到在途待办", bool(tasks), "发起没给待办"): return 1 make_reads() api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(stranger)], "opinion": "也分享给别人"}) mine_rows = {row.read_type: row for row in reads_of(db, work_id, ref(reader))} check("收件人名下摆出三条待阅(三个来源各一条)", {"cc", "share", "comment"} <= set(mine_rows), f"实际 {sorted(mine_rows)}") check("三条都还没进已阅", not dones_of(db, work_id, ref(reader))) _, counts, _ = api.get("/read/processing/count", token=mine) total_before = int((counts or {}).get("total") or 0) action_id = str(getattr(mine_rows.get("cc"), "id", "") or "") share_id = str(getattr(mine_rows.get("share"), "id", "") or "") comment_id = str(getattr(mine_rows.get("comment"), "id", "") or "") # 待阅的 id 一律当场抄成字符串:登记成功那一刻 ``oa_read`` 那行就没了, # 晚一步再碰 ORM 对象是问库要一条已经不存在的记录(查账那几趟还会把快照换掉) if not check("三条待阅都拿得到 id", bool(action_id and share_id and comment_id), f"{action_id} / {share_id} / {comment_id}"): raise SystemExit(1) # --------- 1) 批量标记已读:不要求处理的直接登记,需处理的原样留着 --------- status, data, message = batch(api, mine, [share_id, comment_id, action_id], handling=False) check("批量标记已阅打得通", status < 400, f"{status} {message}") check("不要求处理的那几条一次登记完", int((data or {}).get("marked") or 0) == 2 and int((data or {}).get("handled") or 0) == 0, str(data)) check("需处理那一条没被批量洗掉:还在待阅里、也没进已阅", action_id in {row.id for row in reads_of(db, work_id, ref(reader))} and action_id not in {row.read for row in dones_of(db, work_id, ref(reader))}, str(data)) skipped = (data or {}).get("skipped_items") or [] check("跳过的那条报得出是哪一条、为什么", int((data or {}).get("skipped") or 0) == 1 and len(skipped) == 1 and skipped[0].get("id") == action_id and "处理" in str(skipped[0].get("reason")), str(skipped)) done = [row for row in dones_of(db, work_id, ref(reader)) if row.read != action_id] check("登记掉的两条真的进了已阅档", len(done) == 2, f"已阅 {len(done)} 条") # --------- 2) 批量处理:带着共用处理意见,把需处理的那几条一起办掉 --------- png = models.Attachment(name=f"批量待阅门-{STAMP}.png", extension=".png", storage="", length=8, type="attachment", person=str(reader.id)) db.add(png) db.commit() attachments.append(png.id) status, data, message = batch(api, mine, [action_id], opinion="已核对,无问题", attachments=[png.id]) handled_row = next((row for row in dones_of(db, work_id, ref(reader)) if row.read == action_id), None) check("批量处理:需处理那条办掉了(界面上归已办,不在已阅)", status < 400 and int((data or {}).get("handled") or 0) == 1 and handled_row is not None and action_id not in {row.id for row in reads_of(db, work_id, ref(reader))}, f"{status} {message} {data}") check("处理意见与随附图片记在这条已阅上(不是抄送人来意那一句)", handled_row is not None and handled_row.opinion == "已核对,无问题" and handled_row.handle_time is not None and [str(item.get("id")) for item in (handled_row.attachments or [])] == [png.id], "" if handled_row is None else f"opinion={handled_row.opinion!r} " f"attachments={handled_row.attachments}") claim = db.get(models.Attachment, png.id) check("随附的附件行认到这条已阅记录与这一单", claim is not None and claim.type == models.Attachment.KIND_READ and claim.business_id == handled_row.id and claim.work == work_id, "" if claim is None else f"type={claim.type} business_id={claim.business_id} " f"work={claim.work}") # --------- 3) 登记完角标跟着降:列表与右上角说的是同一件事 --------- # 两头都看,但各管各的口径。这一单上的待阅要**清空**,这是列表自己说的话,precise; # 右上角那个数数的是这个人**所有单**的待阅——同一台 dev 库上别的脚本也在往同一个 # 收件人身上抄送与清场(check_cc_entries_to_read.py 用的就是同一个 others[0]), # 拿它做等式会莫名红一次,所以只断言「至少降掉这一趟办成的条数」。 _, counts, _ = api.get("/read/processing/count", token=mine) total_after = int((counts or {}).get("total") or 0) check("这一单上的待阅这一趟全登记干净了", not reads_of(db, work_id, ref(reader)), f"还剩 {len(reads_of(db, work_id, ref(reader)))} 条") check("登记完待阅角标跟着降(列表与右上角说的是同一件事)", total_after <= total_before - sum(TALLY), f"登记前 {total_before} / 登记后 {total_after} / 这一趟办成 {sum(TALLY)} 条") # --------- 4) 一条失败不带走整批 --------- api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(reader)], "opinion": "再分享一次"}) api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(stranger)], "opinion": "也分享给别人"}) mine_ids = {row.id for row in reads_of(db, work_id, ref(reader))} other_ids = {row.id for row in reads_of(db, work_id, ref(stranger))} if check("批量失败的这一组拿得到新的一条与别人的一条", bool(mine_ids) and bool(other_ids), f"自己的 {mine_ids} / 别人的 {other_ids}"): fresh_id = next(iter(mine_ids)) other_id = next(iter(other_ids)) status, data, message = batch(api, mine, [fresh_id, other_id, f"不存在-{STAMP}"]) errors = (data or {}).get("errors") or [] check("自己的那条照常登记", status < 400 and int((data or {}).get("marked") or 0) == 1 and fresh_id not in {row.id for row in reads_of(db, work_id, ref(reader))}, f"{status} {message} {data}") check("别人的、与根本不存在的那两条只算它们自己失败", int((data or {}).get("failed") or 0) == 2 and len(errors) == 2 and any(item.get("id") == other_id for item in errors) and any(item.get("id") == f"不存在-{STAMP}" for item in errors), str(errors)) check("不是本人名下那条挡得住,且原样留在待阅里", other_id in {row.id for row in reads_of(db, work_id, ref(stranger))}, str(errors)) # --------- 5) 边角:空勾选、重复 id、再来一次 --------- status, _, message = batch(api, mine, []) check("一条都没勾按 400 回,不静悄悄成功", status >= 400 and bool(message), f"{status} {message}") api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(reader)], "opinion": "第三次分享"}) again_ids = {row.id for row in reads_of(db, work_id, ref(reader))} if check("重复摆一条出来(同一个人同一类只留一条)", len(again_ids) == 1, str(again_ids)): again_id = next(iter(again_ids)) status, data, message = batch(api, mine, [again_id, again_id]) check("同一个 id 传两次只算一条,不多登记一次", status < 400 and int((data or {}).get("marked") or 0) == 1, f"{status} {message} {data}") status, data, message = batch(api, mine, [again_id]) # 这一条按新口径归 already,不再算 failed:列表页被页签缓存住时,「刚在单据页里 # 看过的那一条」还挂在屏幕上,人勾它不算做错,报成失败等于无端端吓人一句 check("对已经登记掉的那条再点一次:算 already 不算失败,也不重复进档", status < 400 and int((data or {}).get("marked") or 0) == 0 and int((data or {}).get("failed") or 0) == 0 and int((data or {}).get("already") or 0) == 1 and len([row for row in dones_of(db, work_id, ref(reader)) if row.read == again_id]) == 1, f"{status} {message} {data}") # 光有个计数不够:界面上要说得出是哪一条之前办过,人才知道自己勾回来的是哪张单。 # 顺手把理由也钉住——它和 failed 那句「待阅不存在」是两回事 already_items = (data or {}).get("already_items") or [] check("已登记过的那一条在 already_items 里点得出名:哪个 id、为什么没动", len(already_items) == 1 and str(already_items[0].get("id")) == again_id and "已登记为已阅" in str(already_items[0].get("reason")), str(already_items)) # --------- 6) 混选一批:那句共用的处理意见只该跟着「需处理」的那几条走 --------- # 列表页上一屏必然混着两种:要人表态的与只是给人看的。从前不要求处理的那几条也会 # 吃下这句共用意见(mark_read 里「先来的一句占住 opinion」),于是一句「已核对」 # 变成 N 张单子的处理意见、还顺手盖上处理时间——档案里从此分不清谁真的表过态。 mixed_task = str((tasks[0] or {}).get("id") or "") api.post(f"/task/{mixed_task}/cc", token=admin, json={"identities": [ref(reader)], "opinion": "再来一条要处理的", "requires_action": True}) api.post(f"/work/{work_id}/share", token=admin, json={"identities": [ref(reader)], "opinion": "再看一条不用处理的"}) # id 一律当场抄成字符串:登记成功那一刻 oa_read 那行就没了,晚一步再碰 ORM 对象 # 是要一条已经不存在的记录(这个坑上面那条注释里写过,别在下一段里再踩一次) mixed = {row.read_type: str(row.id) for row in reads_of(db, work_id, ref(reader))} if check("混选这一组摆得出(需处理与不需处理各一条)", {"cc", "share"} <= set(mixed), f"实际 {sorted(mixed)}"): status, data, message = batch(api, mine, [mixed["cc"], mixed["share"]], opinion="已核对,无问题") rows = {row.read: row for row in dones_of(db, work_id, ref(reader))} share_row = rows.get(mixed["share"]) cc_row = rows.get(mixed["cc"]) check("混选时两种各归各:一条登记、一条按意见处理", status < 400 and int((data or {}).get("handled") or 0) == 1 and int((data or {}).get("marked") or 0) == 1, f"{status} {message} {data}") check("只是登记已阅的那条没被写进这句共用意见,也没被盖上处理时间", share_row is not None and (share_row.opinion or "") != "已核对,无问题" and share_row.handle_time is None, f"opinion={getattr(share_row, 'opinion', None)!r} handle_time={getattr(share_row, 'handle_time', None)}") check("需处理那条吃的正是本人这一趟写的这句意见", cc_row is not None and cc_row.opinion == "已核对,无问题" and cc_row.handle_time is not None, f"opinion={getattr(cc_row, 'opinion', None)!r}") # --------- 7) 一次勾过单次上限:被切掉的条数要如实报,不能静悄悄 --------- # 待阅一页最多 200 条,上限是 50:从前直接切片,界面收到「已阅 50」就以为整批都办了, # 剩下那 10 条既不算成功也不算失败。现在单列 truncated——那几条是一条都没碰。 status, data, message = batch(api, mine, [f"没有这条-{i}" for i in range(BATCH_LIMIT + 10)]) check("勾过上限时回出 truncated,被切掉的那几条不进任何一档", status < 400 and int((data or {}).get("truncated") or 0) == 10 and int((data or {}).get("failed") or 0) == BATCH_LIMIT and int((data or {}).get("marked") or 0) == 0 and int((data or {}).get("handled") or 0) == 0, f"{status} {message} {data}") status, data, message = batch(api, mine, []) check("没勾满上限时 truncated 是 0(不是漏字段)", status >= 400 or int((data or {}).get("truncated") or 0) == 0, f"{status} {data}") # --------- 7b) 一张图配一批:这一张图要跟着每一条走 --------- # 审计发现(2026-11):批量那一路把同一份 attachments 递给每一条需处理的待阅, # 而一条附件行只认一个 business_id,于是第二条起撞「附件已被其它批注使用」—— # 勾 5 条待阅贴一张截图,只办得成 1 条。修法是后认领的那几条各插一条指针行 # (storage 仍指同一个对象,MinIO 里一份字节),不是报错也不是静默丢图。 for row in reads_of(db, work_id, ref(reader)) + dones_of(db, work_id, ref(reader)): db.delete(row) db.commit() api.post(f"/task/{mixed_task}/cc", token=admin, json={"identities": [ref(reader)], "opinion": "要处理甲", "requires_action": True}) api.post(f"/work/{work_id}/comments", token=admin, json={"content": "@要处理乙", "mentions": [ref(reader)], "mention_action": True}) need_two = [str(row.id) for row in reads_of(db, work_id, ref(reader)) if row.requires_action] png_many = models.Attachment(name=f"批量待阅门-多图-{STAMP}.png", extension=".png", storage="", length=8, type="attachment", person=str(reader.id)) db.add(png_many) db.commit() attachments.append(png_many.id) if check("一张图这一组摆得出(两条需处理 + 一张图)", len(need_two) == 2, f"实际 {len(need_two)} 条"): status, data, message = batch(api, mine, need_two, opinion="两张一起表个态", attachments=[png_many.id]) rows_many = {row.read: row for row in dones_of(db, work_id, ref(reader))} check("一张图配两条需处理:两条都登记掉,不再只办成一条", status < 400 and int((data or {}).get("handled") or 0) == 2 and int((data or {}).get("failed") or 0) == 0 and len(rows_many) == 2, f"{status} {message} {data}") check("两条归档各带本人那句意见与那张图(图没被第一条独吞)", all(rows_many.get(one) is not None and rows_many[one].opinion == "两张一起表个态" and [str(item.get("id")) for item in (rows_many[one].attachments or [])] != [] for one in need_two), str({one: getattr(rows_many.get(one), "attachments", None) for one in need_two})) claims = list(db.execute( select(models.Attachment).where(models.Attachment.name == png_many.name) ).scalars().all()) check("附件按条各插一条指针行,指向同一个存储对象、归属互不相同", len(claims) == 2 and len({row.storage for row in claims}) == 1 and len({row.business_id for row in claims}) == 2 and {row.business_id for row in claims} == {row.id for row in rows_many.values()}, f"行数 {len(claims)} storage {sorted({row.storage for row in claims})} " f"business_id {sorted({row.business_id for row in claims})}") # --------- 7c) 批量之外的认领口径不许被带松 --------- # 批注那一路(同一张图抢两次)仍然是错误:允许克隆是批量这一层的事, # 全局放开等于让一条附件同时属于两条批注,档案里从此说不清谁附的。 status, data, message = batch(api, mine, [f"不存在-{STAMP}"], opinion="带图但没办成", attachments=[png_many.id]) check("整批一条没办成时那张图不被认领,也不留孤儿行", status < 400 and int((data or {}).get("failed") or 0) == 1 and db.get(models.Attachment, png_many.id) is not None and db.get(models.Attachment, png_many.id).business_id in {row.id for row in rows_many.values()}, f"{status} {message} {data}") # --------- 8) 请求体口径:驼峰与下划线都认 --------- body = schemas.ReadBatchBody.model_validate({"ids": ["a1", "a2"], "opinion": "x", "handling": False, "attachments": ["f1"]}) check("批量请求体认 ids / opinion / handling / attachments", body.ids == ["a1", "a2"] and body.handling is False and body.attachments == ["f1"], repr(body)) body = schemas.ReadBatchBody.model_validate({"ids": ["a1"], "attachments": ["f1"]}) check("没写 handling 时默认按「带意见一起处理」走", body.handling is True, repr(body.handling)) finally: db.rollback() if attachments: db.query(models.Attachment).filter(models.Attachment.id.in_(attachments))\ .delete(synchronize_session=False) db.commit() purge(db, jobs, titles) db.close() print(f"\n合计 {PASSED + len(FAILS)} 项:通过 {PASSED} / 失败 {len(FAILS)}") return 1 if FAILS else 0 if __name__ == "__main__": raise SystemExit(main())