unis-oa/backend/scripts/check_selector_kinds.py

423 lines
20 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
"""守设计器上「这个名字是哪一类 / 它同时还是哪一类」这两问:省的是往返,不许改口。
设计器每预览一个环节,都要给环节上每个审批人来源回两句话:这一行解析不到人时
它其实是哪一类(``selector_kind_of``),重名时它同时还是哪一类
(``selector_kind_conflict``)。改造前这两问是**逐条问库**:一个名字把人员、部门、
岗位角色、分组各问一趟,两个函数又各问一遍。一张 15 个手工环节的设计跑一次去重
体检,光这两问就是三十多趟纯排队(远端库上一趟十几毫秒)。
``app/service/org.py`` 现在用两样东西省这些往返,两样都只许改**问库次数**:
* 复用已有的五档预探(:func:`org.probe_selectors`):探针说过这一档不沾,那条只会
回空的查询就不发。探针从不替「存在」下结论——探不到、整层关掉、探针问崩了,
都照原样去问库。
* 把问出来的存在性按「类 + 值」缓存在本 Session 里(``org._kind_exists``):同一个
名字被两个函数各问一遍就此并成一次;写过 ``users`` / ``oa_unit`` / ``oa_role`` /
``oa_group`` 任何一张,答案当场作废。
于是这个脚本一次钉七条:
1. **判定与改造前一字不差**:同一批名字,新写法与「逐条问库、不缓存不跳档」的老写法,
四个类别逐一对齐,两个函数交出的措辞逐字对齐;
2. **问过不再问**:同一个 Session 里第二次问同一个名字,一条语句都不许多发;
3. **探针说不沾就一条都不发**;
4. **整批预探严格比逐个问库省**,且答案一样;
5. **探针整层关掉(``OA_SELECTOR_PROBE=off``)答案不变**;
6. **这四张表任何一张被写过,答案当场重来**:新建一个与已有岗位角色重名的部门,
下一句必须说「部门与岗位角色」(临时行跑在事务里,跑完整体回滚,库里不留东西);
7. **去重体检整张设计一次预热**:预热与否交出的报文一字不差,问库条数严格更少。
::
PYTHONPATH=. python3 scripts/check_selector_kinds.py
"""
from __future__ import annotations
import json
import sys
from sqlalchemy import event, or_, select
from app import models, readcache
from app.db import SessionLocal, engine
from app.service import dedupaudit, org
FAILS: list[str] = []
PASSED = 0
CODE = "zz-check-kinds"
#: 数语句条数:这一层买的就是「少排几次队」,判据只看条数。
ROWS: list[str] = []
@event.listens_for(engine, "after_cursor_execute")
def _count(conn, cursor, statement, parameters, context, many): # noqa: ANN001
ROWS.append(" ".join(statement.split())[:120])
def check(label: str, ok: bool, detail: str = "") -> None:
global PASSED
if ok:
PASSED += 1
print(f"[通过] {label}")
else:
FAILS.append(label)
print(f"[FAIL] {label}{f' -> {detail}' if detail else ''}")
def counted(fn):
"""跑一趟,交回 ``(结果, 这一趟问了几条库)``。"""
start = len(ROWS)
value = fn()
return value, len(ROWS) - start
def cold() -> None:
"""把只读缓存整场作废:下一条量的是「第一次问」,不是缓存里的存货。"""
readcache.invalidate_everywhere()
def bare_exists(db, value: str, kind: str) -> bool:
"""改造前 ``selector_kind_of`` / ``selector_kind_conflict`` 里的写法:逐条问库。"""
if kind == "person":
return bool(db.execute(
select(models.User.id).where(
or_(models.User.account == value, models.User.display_name == value),
models.User.status == models.UserStatus.ACTIVE,
)
).first())
if kind == "unit":
return bool(org._find_units(db, value))
if kind == "role":
return bool(db.execute(select(models.Role.id).where(models.Role.name == value)).first())
if kind == "group":
return bool(db.execute(select(models.Group.id).where(models.Group.name == value)).first())
return False
#: 两个函数各自要看哪几档,顺序与实现一致。
KINDS = ("person", "unit", "role", "group")
def truth(db, name: str) -> dict[str, bool]:
"""老写法给的答案:逐条问库,不缓存不跳档。"""
return {kind: bare_exists(db, name, kind) for kind in KINDS}
# ---------------------------------------------------------------------------
# 1 / 2 / 5:判定一致、问过不再问、探针关掉一致
# ---------------------------------------------------------------------------
def same_verdict(db, names: list[str]) -> None:
probe_on = org.PROBE_ENABLED
for name in names:
want = truth(db, name)
cold()
org.PROBE_ENABLED = True
got, _ = counted(lambda: {kind: org._kind_exists(db, name, kind) for kind in KINDS})
check(f"「{name}」四类判定与逐条问库一致", got == want, f"{got} != {want}")
again, trips = counted(lambda: {kind: org._kind_exists(db, name, kind) for kind in KINDS})
check(f"「{name}」第二次问不再问库({trips} 条)", trips == 0 and again == got, f"{trips} 条")
cold()
org.PROBE_ENABLED = False # 等价于 OA_SELECTOR_PROBE=off
off, off_trips = counted(
lambda: {kind: org._kind_exists(db, name, kind) for kind in KINDS})
check(f"「{name}」探针关掉之后判定一致", off == want, f"{off} != {want}")
warm, warm_trips = counted(
lambda: {kind: org._kind_exists(db, name, kind) for kind in KINDS})
check(f"「{name}」探针关掉也照样只问一次库({off_trips} → {warm_trips} 条)",
warm_trips == 0 and warm == off, f"{off_trips} → {warm_trips}")
org.PROBE_ENABLED = probe_on
def probe_skips_everything(db) -> None:
"""四类都不是的一个名字:预热之后四档一条查询都不该发。"""
name = f"{CODE}四处都不是"
want = truth(db, name)
check(f"「{name}」老写法确认四类都不是", not any(want.values()), str(want))
cold()
warm_probe, warm_trips = counted(lambda: org.warm_kind_probe(db, [name]))
answers, trips = counted(
lambda: {kind: org._kind_exists(db, name, kind) for kind in KINDS})
check(f"「{name}」整批预探一条语句({warm_trips} 条)+ 四档一条都不问({trips} 条)",
trips == 0 and not any(answers.values()), f"{trips} 条 / {answers}")
del warm_probe
def batch_beats_one_by_one(db, names: list[str]) -> None:
"""整批预探 vs 一个一个问库:答案一样,条数严格更少。"""
org.PROBE_ENABLED = False
cold()
bare, bare_trips = counted(lambda: {
name: (org.selector_kinds_of(db, [name])[name],
org.selector_kind_conflicts(db, [name])[name]) for name in names})
org.PROBE_ENABLED = True
cold()
warm, warm_trips = counted(lambda: {
name: (org.selector_kinds_of(db, names)[name],
org.selector_kind_conflicts(db, names)[name]) for name in names})
check(f"{len(names)} 个名字:整批预探比逐个问库省({bare_trips} → {warm_trips} 条)",
warm_trips < bare_trips, f"{bare_trips} → {warm_trips}")
check("整批与逐个交出的两句话一模一样", warm == bare, f"{warm} != {bare}")
def wording_matches_the_old_functions(db, names: list[str]) -> None:
"""两个函数交出的那句话,逐字对老写法。"""
for name in names:
flags = truth(db, name)
want_of = next((label for kind, label in org._KIND_ORDER if flags[kind]), "")
want_clash = next((label for left, right, label in org._KIND_CLASHES
if flags[left] and flags[right]), "")
got_of = org.selector_kind_of(db, name)
got_clash = org.selector_kind_conflict(db, name)
check(f"「{name}」它是哪一类:措辞一致", got_of == want_of, f"{got_of!r} != {want_of!r}")
check(f"「{name}」它和谁重名:措辞一致", got_clash == want_clash,
f"{got_clash!r} != {want_clash!r}")
# ---------------------------------------------------------------------------
# 6:这四张表任何一张被写过,答案当场重来
# ---------------------------------------------------------------------------
def write_invalidates(db) -> None:
"""临时行跑在事务里,跑完整体回滚:库里一个字节都不留。"""
role_name = db.execute(
select(models.Role.name).order_by(models.Role.id).limit(1)).scalars().first()
if not role_name:
check("库里有岗位角色可供造重名", False, "库里一个岗位角色都没有,这条测不了")
return
cold()
before, _ = counted(lambda: org.selector_kind_conflict(db, role_name))
check(f"造重名之前「{role_name}」不说自己同时是部门", before == "", repr(before))
db.add(models.Unit(name=role_name, alias="", description="", parent_name="", path=""))
db.flush() # 写了就算数,不必等提交
after, trips = counted(lambda: org.selector_kind_conflict(db, role_name))
check(f"新建同名部门之后当场说「部门与岗位角色」(重问了 {trips} 条)",
after == "部门与岗位角色", repr(after))
db.add(models.Role(name=f"{CODE}角色", description="", list_auth=[], unit=""))
db.add(models.Group(name=f"{CODE}分组", description="", list_identity=[], list_person=[], unit=""))
db.flush()
kinds, _ = counted(lambda: org.selector_kinds_of(db, [f"{CODE}角色", f"{CODE}分组"]))
check("新建的岗位角色当场认得", kinds.get(f"{CODE}角色") == "岗位角色", str(kinds))
check("新建的分组当场认得", kinds.get(f"{CODE}分组") == "分组", str(kinds))
db.add(models.User(account=f"{CODE}user", display_name=f"{CODE}在职同志",
password_hash="x", organization_id=None, role="member",
status=models.UserStatus.ACTIVE))
db.flush()
person, _ = counted(lambda: org.selector_kind_of(db, f"{CODE}在职同志"))
check("新建的在职人员当场认得", person == "人员", repr(person))
db.add(models.User(account=f"{CODE}off", display_name=f"{CODE}停用同志",
password_hash="x", organization_id=None, role="member",
status=models.UserStatus.DISABLED))
db.flush()
stopped, _ = counted(lambda: org._kind_exists(db, f"{CODE}停用同志", "person"))
check("停用的账号不算「人员」", stopped is False, repr(stopped))
# ---------------------------------------------------------------------------
# 7:整张设计一次预热,体检报文一字不差
# ---------------------------------------------------------------------------
def audit_matches(db) -> None:
"""去重体检:预热与否交出的报文一字不差,条数严格更少。"""
# 一次读回所有手工环节,两张画布各挑各的:**报文**挑环节最多的那张(样本越大越能
# 看出漂移),**条数**挑 org 选择器最多的那张。预热合起来批量问的是角色 / 部门 /
# 分组 / 人员那几档,一张全是「发起人」的画布一次也省不到(发起人就在单据上,
# 不去库里问),拿它比条数只会把这一档测成"看着没效果"。
rows = db.execute(
select(models.Activity.process, models.Activity.config)
.where(models.Activity.type == "manual")
).all()
manuals: dict[str, int] = {}
org_refs: dict[str, int] = {}
org_nodes: dict[str, int] = {}
for process_id, config in rows:
manuals[process_id] = manuals.get(process_id, 0) + 1
picked = 0
for item in (config or {}).get("taskValues") or []:
if isinstance(item, dict) and str(item.get("type") or "") != "creator":
picked += len(item.get("data") or [])
org_refs[process_id] = org_refs.get(process_id, 0) + picked
# 省不省得下来看的是"有几环各自要去问":一环上的几个值本来就是一趟
org_nodes[process_id] = org_nodes.get(process_id, 0) + (1 if picked else 0)
account = db.execute(
select(models.User.account)
.where(models.User.status == models.UserStatus.ACTIVE, models.User.account != "")
.order_by(models.User.id).limit(1)
).scalars().first()
biggest = max(manuals, key=lambda key: (manuals[key], key)) if manuals else ""
process = db.get(models.Process, biggest) if biggest else None
if process is None or not account:
check("库里有流程与在职账号可跑体检", False, "库里没有流程或在职账号")
return
def payload(target: models.Process) -> str:
return json.dumps(dedupaudit.audit(db, process_id=target.id, as_identity=account),
ensure_ascii=False, sort_keys=True)
def measure(target: models.Process) -> tuple[str, int, int]:
"""同一张画布各跑两遍:预热与不预热的报文,以及各自问了几条库。"""
real_warm = dedupaudit._warm_org
cold()
warmed, warm_trips = counted(lambda: payload(target))
cold()
dedupaudit._warm_org = lambda *args, **kwargs: None # 退回逐环节各问各的
bare, bare_trips = counted(lambda: payload(target))
dedupaudit._warm_org = real_warm
return warmed, warm_trips, bare_trips, bare # type: ignore[return-value]
warmed, warm_trips, bare_trips, bare = measure(process)
check(f"体检报文与预热与否无关({len(warmed)} 字节)", warmed == bare)
print(f" 借 {process.name} 量报文({manuals[biggest]} 个手工环节),样例身份 {account}")
heaviest = max(org_nodes, key=lambda key: (org_nodes[key], org_refs[key], key)) if org_nodes else ""
sample = db.get(models.Process, heaviest) if heaviest else None
if sample is None or org_nodes.get(heaviest, 0) < 2:
# 只有一环要去问库里的时候,预热与逐环节问的是同一趟,省不出东西:
# 这一档量的是"多环各自问一遍 vs 一次问完",样本不够就别报红。
print(f"[跳过] 整张设计一次预热更省:库里没有一张画布带两环以上要问 org 的手工环节"
f"(最多 {org_nodes.get(heaviest, 0)} 环),预热与逐环节问同样几趟")
return
if sample.id != process.id:
print(f" 借 {sample.name} 量条数({org_nodes[heaviest]} 环 / {org_refs[heaviest]} 个 org 选择器)")
_, warm_trips, bare_trips, _ = measure(sample)
check(f"整张设计一次预热更省({bare_trips} → {warm_trips} 条)", warm_trips < bare_trips,
f"{bare_trips} → {warm_trips}")
def sample_names(db) -> list[str]:
"""库里真有的每一类各取一个,再加一个什么都不是的。"""
names: list[str] = []
picks = (
select(models.Role.name).order_by(models.Role.id).limit(1),
select(models.Group.name).order_by(models.Group.id).limit(1),
select(models.Unit.name).where(models.Unit.name != "").order_by(models.Unit.id).limit(1),
select(models.User.display_name)
.where(models.User.status == models.UserStatus.ACTIVE, models.User.display_name != "")
.order_by(models.User.id).limit(1),
)
for statement in picks:
value = db.execute(statement).scalars().first()
if value and str(value) not in names:
names.append(str(value))
names.append(f"{CODE}查无此名")
return names
def directory_existence_matches(db) -> None:
"""审批人目录的存在性判定:走探针那一条语句,与逐类批量问库必须给同一份答案。
``org.selectors_exist`` 改成走一条五档 ``EXISTS`` 的探针语句(顺带把答案存进本 Session
让后面展开成员时跳档)。省的是往返,判定口径一个字不许动:这里把两种写法在同一份
数据上对一遍,值特意挑那些容易对不齐的——停用的人、带不带尾分隔符的部门路径、Hub 的
id 路径、``users.id`` 那种数字、以及探针认得而这四档不该认的账号。
"""
wanted = [
" " + CODE + " 前后有空格", # 两端空白要洗掉
"", # 空值一律 False
CODE + "查无此名",
]
picks = (
select(models.User.account).where(models.User.status == models.UserStatus.ACTIVE)
.order_by(models.User.id).limit(1),
select(models.User.display_name).where(models.User.status == models.UserStatus.ACTIVE)
.order_by(models.User.id).limit(1),
select(models.Unit.name).where(models.Unit.name != "").order_by(models.Unit.id).limit(1),
select(models.Unit.path).where(models.Unit.path != "").order_by(models.Unit.id).limit(1),
select(models.Role.name).order_by(models.Role.id).limit(1),
select(models.Group.name).order_by(models.Group.id).limit(1),
)
for statement in picks:
value = db.execute(statement).scalars().first()
if value:
wanted.append(str(value))
# 带 / 不带尾分隔符的部门路径、Hub 的 id 路径、users.id 那种数字
unit = db.execute(
select(models.Unit).where(models.Unit.path != "").order_by(models.Unit.id).limit(1)
).scalars().first()
if unit is not None:
wanted.append(str(unit.path).rstrip(chr(92)))
wanted.append(str(unit.path))
if unit.hub_org_id:
wanted.append(f"/1/{unit.hub_org_id}/")
person_id = db.execute(select(models.User.id).order_by(models.User.id).limit(1)).scalars().first()
if person_id is not None:
wanted.append(str(person_id))
# 停用的人:探针的 identity 那一档认得这个账号,这四档不该认
disabled = models.User(
account=f"{CODE}-off", display_name=f"{CODE}停用", status=models.UserStatus.DISABLED,
role=models.ROLE_MEMBER, password_hash="!",
)
db.add(disabled)
db.flush()
wanted.append(disabled.account)
named = list(dict.fromkeys(str(value or "").strip() for value in wanted))
probe_on = org.PROBE_ENABLED
try:
org.PROBE_ENABLED = True
cold()
old, old_trips = counted(lambda: org._selectors_exist_by_query(db, named, [v for v in named if v]))
cold()
new, new_trips = counted(lambda: org.selectors_exist(db, wanted))
check(f"目录存在性:探针一条语句与逐类批量问库答案一致({len(named)} 个值)",
new == old, f"差异:{ {k: (old.get(k), new.get(k)) for k in old if old.get(k) != new.get(k)} }")
check(f"目录存在性:确实少问了库({old_trips} → {new_trips} 条)",
new_trips < old_trips, f"{old_trips} → {new_trips}")
cold()
off, off_trips = counted(lambda: org.selectors_exist(db, wanted))
org.PROBE_ENABLED = False
cold()
fell_back, fell_trips = counted(lambda: org.selectors_exist(db, wanted))
check("探针关掉之后也回同一份答案", off == new == fell_back, f"{off} != {fell_back}")
check(f"探针关掉之后退回逐类问库({new_trips} → {fell_trips} 条)",
fell_trips == old_trips, f"{fell_trips} != {old_trips}")
finally:
org.PROBE_ENABLED = probe_on
def main() -> int:
db = SessionLocal()
try:
names = sample_names(db)
print(f"设计器名字两问自检(试 {len(names)} 个名字:"
+ "、".join(name if len(name) <= 12 else name[:12] + "…" for name in names) + ")")
same_verdict(db, names)
probe_skips_everything(db)
batch_beats_one_by_one(db, names)
wording_matches_the_old_functions(db, names)
directory_existence_matches(db)
write_invalidates(db)
audit_matches(db)
except Exception as exc: # noqa: BLE001 - 连不上库不该把自检算成失败
print(f"跳过:跑不起来(多半是连不上数据库):{exc}")
return 0
finally:
db.rollback() # 临时行一律不落地
db.close()
total = PASSED + len(FAILS)
print(f"\n共 {total} 项,通过 {PASSED},失败 {len(FAILS)}")
for item in FAILS:
print(f" 未通过:{item}")
return 1 if FAILS else 0
if __name__ == "__main__":
sys.exit(main())