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