#!/usr/bin/env python3 """守「关联流程」这两件事:候选只列**我发起的**,那一行能写**对方表单里的哪几格**。 用户提的原话是:**「关联流程的时候,展示字段我希望是可以选择到表单中的字段进行展示」**、 **「选择流程范围不应该是已办,而是只有我发起的流程,不应该把我所有已办的流程展示出来」**。 界面那一半在 ``frontend/src/components/oa/design/OptionSourcePanel.vue``(那一档下拉 + 「显示与存值 / 那一行小字」里多出来的一截清单),这一篇钉口径与数据那一半:: PYTHONPATH=. python3 scripts/check_relation_scope.py **范围那一档(``relationScope``)** 1. **默认是「只给我发起的」**:``created`` 这一档落成 ``work.creator_identity == 我``; 以前只有「我发起 / 我办过 / 我被抄送」那一片并集(``related``),于是挑历史单时 一大半是别人发起、我只是顺手批过的单子。 2. **管理员也照收**:``_visible_work_filter`` 放过管理员说的是他**看得见**别人的单, 这一档问的是「这张单算不算你发起的」——一条事实,跟谁在查没关系。放过管理员会让 同一只挑选器在两人口中列出两批单子,配的人在自己账号下试出来的手感就骗人。 3. **只收候选,不收已存的值**:回显走 ``/work/summaries``,不跟着这一档收窄。改版前 挑上的、或别人代挑的那几张单,回显还得念得出名字,不能因为挑不进来了就念成一串 job。 4. **脏值退回默认那一档**,界面上另说一句;这一格跟着候选来源一起清(换成字典就没有 「谁的单」可问了)。 **显示那一档(``data.字段名``)** 5. **列名按前缀认,不写死清单**:单据本体只有标题 / 单号 / 流程名 / 发起人那几列, 对方表单里有哪些格要问那条流程的表单,所以 ``data.`` 那一头按前缀认。 6. **点了哪几列才读表单正文**:``/work/related`` 原本 ``with_data=False``,正文那一列 从头到尾没人读;点名了才把正文带回来,且**只回点名的那几列**(翻成人话之后)。 7. **翻成人话与导出同一把尺**:走 ``exportfmt.cell_text``——字典编码落「差旅费」而不是 「CL01」,附件落文件名,签名落「已签名」,不是 ``str(value)`` 糊上去的一坨。 8. **回的形状就是点路径**:后端嵌着放(``{"data": {"明细": {"金额": …}}}``),前端 ``pickKeyOf`` 一段一段点下去就取得到,两边不另造一套写法。 9. **上限一处收**:一行候选最多读 8 列(``MAX_RELATION_DISPLAY_FIELDS``),接口上那句 ``fields`` 与字段上配到的列都过同一份清洗。 **回显那一头认几个名字(``GET /work/summaries`` 的 ``by`` / ``process``)** 10. **「名字点得开那张单」与「存为」选哪一列无关**(原话:**「下拉选择组件我也希望可以实现选择 流程可以跳转,并且不需要考虑选择存的字段才对。关联审批流程组件也是一样」**):这一格的存值列 由 ``optionMap.valueKey`` 说了算——``job``(默认)/ ``serial``(单据编号)/ 限定流程之后的 ``data.某列``(对方表单里那一格)。回显拿存着的值问摘要,接口就按**同一列**把它认回单据: job 与单号走索引等值,``data.某列`` 只在**限定了流程**时认(范围收到 ``process`` 那一条索引上, 不在两张表上现扫 JSON 正文),且比的是那一格的**原文**——字典、附件那类「库里存码、界面念名」 的列认不到,就照旧少回一条:念得出存着的值、点不开,也比点进一张不相干的单强。 11. **归档表的 ``serial`` 上有索引**:已经挂上的关联单据九成套在归档表里,按单号认的那一句 没索引就是每次开单倒扫整张只长不删的表。 12. **认领的顺序 job 在前**(``{**by_form, **by_serial, **by_job}``):万一有人把单号起成了别张单的 job,认 job 的那一格不该翻到错的那张单上。 最后把前后端那几句共用的常量与措辞对一遍:两边各写一遍迟早会漂,漂了这里就红。 """ from __future__ import annotations import inspect import pathlib import re import sys sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent)) from app import models # noqa: E402 from app.api import design as design_api, runtime as runtime_api # noqa: E402 from app.service import dicts, formruntime, processdata # noqa: E402 FAILS: list[str] = [] def eq(name: str, got, want) -> None: if got != want: FAILS.append(f"{name}:期望 {want!r},实得 {got!r}") def ok(name: str, condition, detail=None) -> None: if not condition: FAILS.append(f"{name}:{detail if detail is not None else '条件不成立'}") def sql(clause) -> str: """把一条 SQLAlchemy 条件摊成文本好比对;``None`` 当成空串(不能用 ``or``,条件本身不能判真假)。""" return "" if clause is None else str(clause) class Person: """顶替 ``models.User`` 那一行:``CurrentUser.person_id`` 只读 ``.id``。""" def __init__(self, user_id: int = 1) -> None: self.id = user_id def user(ref: str = "zhangsan", is_admin: bool = False) -> runtime_api.CurrentUser: return runtime_api.CurrentUser(person=Person(), ref=ref, is_admin=is_admin) # --------------------------------------------------------------------------- # 1. 范围那一档 # --------------------------------------------------------------------------- def check_scope_reading() -> None: relation = {"key": "rel", "type": "relation"} eq("没配过就是只给自已发起的", dicts.relation_scope(relation), "created") eq("默认值与档位清单同一条", dicts.RELATION_SCOPE_DEFAULT, dicts.RELATION_SCOPE_CREATED) eq("明写与我相关才放开", dicts.relation_scope({**relation, "relationScope": "related"}), "related") eq("认不出的值退回默认,不报错也不留", dicts.relation_scope({**relation, "relationScope": "handled"}), "created") eq("写成非字符串也一样", dicts.relation_scope({**relation, "relationScope": 7}), "created") # 设计期那一句:界面上挑不出歪值,歪值只从接口直传与 AI 起草进来 eq("没写这一格一个字都不说", formruntime.option_source_problems(relation, db=None), []) eq("档位认不出要说", formruntime.option_source_problems( {**relation, "relationScope": "handled"}, db=None), ["候选范围里有认不出的档位:handled"]) eq("空串是要人挑,不是不限", formruntime.option_source_problems( {**relation, "relationScope": ""}, db=None), ["候选范围还没挑:只给自已发起的,还是与我相关的都算"]) # 候选来源的条件路由:那几条各带一份范围,措辞跟着这一条走 routed = {"key": "rel", "type": "relation", "optionSource": "process", "optionRoutes": [{"source": "process", "relationScope": "handled"}]} eq("路由里那一条也认这一档", dicts.route_problems(routed), ["「rel」的第 1 条候选来源:候选范围里有认不出的档位:handled"]) # 挂在某一条路由上的那一档要留得下来:漏在 ROUTE_OWNED_KEYS 里就是存进去即失效 per_route = {"key": "rel", "type": "relation", "optionSource": "process", "optionRoutes": [ {"source": "process", "relationProcess": "p1", "relationScope": "related"}]} eq("路由自己那一档不被当残骸清掉", [r.get("relationScope") for r in dicts.routes_of(per_route)], ["related"]) eq("按命中那条路由算范围", dicts.relation_scope(dicts.option_view(per_route, {})), "related") # 换来源时这一档跟着清:留着下一任看不出它已经不起作用 saved = design_api.clean_option_source(design_api.clean_formats({"fields": [ {"key": "rel", "type": "relation", "optionSource": "process", "relationScope": "related"}, {"key": "rel2", "type": "relation", "optionSource": "dict", "dictCode": "x", "relationScope": "related"}, ]}))["fields"] eq("还在用流程单据时那一档留着", saved[0].get("relationScope"), "related") eq("换成字典就抹掉,不留一份不起作用的配置", "relationScope" in saved[1], False) def check_scope_sql() -> None: """两张表上那一条条件:默认只认发起人,放开才认「与我相关」那一片。""" for model in (models.Work, models.WorkCompleted): created = sql(runtime_api._related_clause(model, user(), "", "", None, "created")) ok(f"{model.__tablename__}:默认那一条比的是发起人", "creator_identity" in created, created) ok(f"{model.__tablename__}:默认那一条不查已办表", "oa_task_completed" not in created, created) ok(f"{model.__tablename__}:默认那一条不查待阅表", "oa_read" not in created, created) related = sql(runtime_api._related_clause(model, user(), "", "", None, "related")) ok(f"{model.__tablename__}:放开之后查办过的", "oa_task_completed" in related, related) ok(f"{model.__tablename__}:放开之后查抄送过的", "oa_read_completed" in related, related) admin_created = sql(runtime_api._related_clause(model, user(is_admin=True), "", "", None, "created")) # 条件就一句「发起人 = 我」:不因为换了管理员就多带一段 EXISTS 去捞别人的单 ok(f"{model.__tablename__}:管理员也只给自已发起的", admin_created.count("creator_identity =") == 1, admin_created) ok(f"{model.__tablename__}:管理员那一条不放过整库", "EXISTS" not in admin_created.upper(), admin_created) # 状态与范围各加各的条件,互不顶掉 both = sql(runtime_api._related_clause(models.Work, user(), "出差", "p1", ("completed",), "created")) for needle in ("creator_identity", "status IN", "title LIKE", "serial LIKE", "process ="): ok(f"条件里 {needle} 还在", needle in both, both) # --------------------------------------------------------------------------- # 2. 那一行读对方表单里的哪几格 # --------------------------------------------------------------------------- def check_display_paths() -> None: eq("带前缀的列名原样认", dicts.clean_relation_display_paths("data.金额"), ("金额",)) eq("去重、去空、去脏", dicts.clean_relation_display_paths("data.金额,金额, ,x..y,"), ("金额",)) eq("深层路径收", dicts.clean_relation_display_paths("明细.金额"), ("明细.金额",)) eq("上限一处收", len(dicts.clean_relation_display_paths(",".join(f"f{i}" for i in range(30)))), dicts.MAX_RELATION_DISPLAY_FIELDS) eq("超长那一条丢掉而不是截一半", dicts.clean_relation_display_paths("x" * 200), ()) eq("只有流程单据有表单可读", dicts.form_column_path(dicts.SOURCE_PROCESS, "data.金额"), "金额") eq("字典挂这一列当配错", dicts.form_column_path(dicts.SOURCE_DICT, "data.金额"), "") eq("没有前缀不算这一类", dicts.form_column_path(dicts.SOURCE_PROCESS, "金额"), "") # 认不出的列不报错,退回默认列;认得出的表单列要一路认到底 field = {"key": "rel", "type": "relation", "optionMap": {"valueKey": "data.no", "labelKey": "data.金额"}} eq("显示那一列认下 data.金额", dicts.option_map_of(field)["labelKey"], "data.金额") eq("存值那一列也认(挂别的流程的单,存它的立项编号)", dicts.option_map_of(field)["valueKey"], "data.no") eq("设计期不念黄字", dicts.option_map_problems(field), []) eq("这一格点到的是哪几列", dicts.relation_display_paths({ "type": "relation", "optionMap": {"labelKey": "data.金额"}, "picker": {"dialog": {"noteKeys": ["serial", "data.日期"], "badgeKey": "data.状态"}}, }), ("金额", "状态", "日期")) eq("字典那一格读不出表单列", dicts.relation_display_paths({ "optionMap": {"labelKey": "data.金额"}, "type": "select", }), ()) many = {"type": "relation", "optionMap": {"valueKey": "data.a", "labelKey": "data.b"}, "picker": {"dialog": {"noteKeys": [f"data.c{i}" for i in range(20)]}}} eq("字段上配到 30 列也只剩 8 列的额度", len(dicts.relation_display_paths(many)), dicts.MAX_RELATION_DISPLAY_FIELDS) class Row: """顶替一张单据:``FormDisplay`` 只读 ``process`` 与 ``data`` 两个属性。""" def __init__(self, process: str, data: dict) -> None: self.process = process self.data = data def check_form_display() -> None: """取出来的那一份是**给人看的那句话**,不是 ``str(value)`` 糊上去的一坨。""" defs = { "amount": {"key": "amount", "type": "money", "label": "报销金额"}, "cate": {"key": "cate", "type": "select", "label": "费用类别", "options": [{"value": "CL01", "label": "差旅费"}]}, "file": {"key": "file", "type": "attachment", "label": "发票"}, "items": {"key": "items", "type": "table", "label": "明细"}, } original = processdata.field_defs_of_process processdata.field_defs_of_process = lambda db, pid: defs if pid == "p1" else {} try: view = processdata.FormDisplay(None, ["amount", "cate", "file", "items", "gone"]) row = view.of(Row("p1", { "amount": 12000, "cate": "CL01", "file": [{"name": "发票.pdf", "url": "http://x/1"}], "items": [{"金额": 300}, {"金额": 400}], })) eq("钱按表单那一格的类型落成一句", row["amount"], "12000") eq("字典编码翻成名称,与导出同一把尺", row["cate"], "差旅费") eq("附件只留文件名", row["file"], "发票.pdf") eq("明细表压成一行", row["items"], "金额=300 | 金额=400") ok("取不到的列不放空串占位", "gone" not in row, str(row)) # 深层列名走 fetch.pick_path 那一套写法:明细表要点就得写下标 deep = processdata.FormDisplay(None, ["items.0.金额"]).of( Row("p1", {"items": [{"金额": 300}, {"金额": 400}]}) ) eq("深层路径嵌回同一个形状给点路径读", deep, {"items": {"0": {"金额": "300"}}}) eq("不写下标就明说取不到,不悄悄拿头一行糊过去", processdata.FormDisplay(None, ["items.金额"]).of(Row("p1", {"items": [{"金额": 300}]})), {}) eq("整表那句先到就留整表", processdata.FormDisplay(None, ["items", "items.0.金额"]).of(Row("p1", {"items": [{"金额": 300}]})), {"items": "金额=300"}) eq("那一格先到就留那一格", processdata.FormDisplay(None, ["items.0.金额", "items"]).of(Row("p1", {"items": [{"金额": 300}]})), {"items": {"0": {"金额": "300"}}}) # 「与导出同一把尺」不是嘴上说说:取文本的那一段确实只调 exportfmt body = inspect.getsource(processdata.FormDisplay._text) ok("翻文本走 exportfmt,不自带一套", "exportfmt.cell_text" in body and "exportfmt.scalar_text" in body, body) eq("一列都没配就一个字都不取", processdata.FormDisplay(None, []).active, False) eq("没配列时取出来是空", processdata.FormDisplay(None, []).of(Row("p1", {"amount": 1})), {}) # 认不出字段定义(环节表单之外手敲的列名)也要落一句人话,不能摆一坨 Python 字面量 other = processdata.FormDisplay(None, ["tags"]).of(Row("p_other", {"tags": ["甲", "乙"]})) eq("认不出的列按通用形状落", other["tags"], "甲、乙") long_view = processdata.FormDisplay(None, ["remark"]) got = long_view.of(Row("p_other", {"remark": "一" * 400}))["remark"] ok("长文本收在一行之内", len(got) <= processdata.DISPLAY_TEXT_MAX, f"{len(got)} 字") finally: processdata.field_defs_of_process = original def check_endpoint_conditions() -> None: """两条接口各按哪一条条件筛:候选那一头收范围,回显那一头只问「看得见」。""" for name in ("search_related_works", "work_summaries"): body = inspect.getsource(getattr(runtime_api, name)) ok(f"{name} 认那句 fields", "clean_relation_display_paths" in body, name) related = inspect.getsource(runtime_api.search_related_works) ok("候选那一头按范围收", "_related_clause" in related and "wanted_scope" in related, related[:400]) # 回显那一头不能跟着范围走:改版前挑上的单还得念得出名字,不然念成一串 job summaries = inspect.getsource(runtime_api.work_summaries) ok("回显只问看不看得见,不问是谁发起的", "_visible_work_filter" in summaries and "_related_clause" not in summaries, summaries[:600]) def check_summary_lookup() -> None: """回显那一头认几个名字:job、单号、以及限定流程之后对方表单里那一格。""" # 「那一格的原文」这一句是真算的:筛行 / 聚合那种写法存不出值,MySQL 的 JSON 路径也点不动 eq("点路径拼成 JSON 路径", runtime_api._form_json_path("projectNo"), '$."projectNo"') eq("明细里那一格也点得下去", runtime_api._form_json_path("明细.0.金额"), '$."明细"."0"."金额"') for unreadable in ("明细[名称=甲].金额", "明细.sum(金额)", "", "a..b"): eq(f"这种写法不认:{unreadable or '(空)'}", runtime_api._form_json_path(unreadable), "") body = inspect.getsource(runtime_api.work_summaries) ok("按 job 认", "model.job.in_(wanted)" in body, body[:600]) ok("按单号认", "model.serial.in_(wanted)" in body, body[:600]) ok("按对方表单那一格认", "form_column_path" in body and "json_extract" in body, body[:900]) # 表单那一格没有索引可依,只在限定了流程时认——范围收在 process 那条索引上 ok("按表单那一格认要先限定流程", "form_path and process.strip()" in body, body[:900]) ok("认的顺序 job 在前", "{**by_form, **by_serial, **by_job}" in body, body[:1200]) # 界面上那一头:把「存的是哪一列 + 限的哪条流程」一起报出去,不然接口无从按列去认 picker = _read(PARALLEL_FILES["frontend_picker"]).read_text(encoding="utf-8") ok("界面把存值列与限定的流程一起报出去", "by: keys.value.valueKey" in picker and "process: props.process" in picker, "") api_ts = _read(PARALLEL_FILES["frontend_api"]).read_text(encoding="utf-8") ok("接口那句带 by 与 process", "query.by" in api_ts and "query.process" in api_ts, "") # 归档表那个单号索引:模型与建表脚本两份都得在,少一份就是「本地快、线上扫全表」 models_py = _read("backend/app/models.py").read_text(encoding="utf-8") archived = models_py.split("class WorkCompleted(", 1) declared = next( (line.strip() for line in (archived[1].splitlines() if len(archived) == 2 else []) if line.strip().startswith("serial:")), "", ) ok("归档表的 serial 声明了索引", "index=True" in declared, declared) schema = _read("sql/schema.sql").read_text(encoding="utf-8") ok("建表脚本里那条单号索引也在", "ix_oa_work_completed_serial" in schema, "") def check_summary_payload() -> None: """没点列时摘要里压根不该出现 ``data``:那一句是「不多读一列正文」的凭据。""" class Summary: job = "J1" serial = "S1" title = "一张单" process = "p1" process_name = "流程" status = "completed" creator_person = "张三" creator_unit_name = "行政部" start_time = None finish_time = None current_activity_names = "" eq("没点列不多带一个键", "data" in runtime_api._relation_summary(Summary()), False) eq("点了才带上", runtime_api._relation_summary(Summary(), {"金额": "1"}), {**runtime_api._relation_summary(Summary()), "data": {"金额": "1"}}) # --------------------------------------------------------------------------- # 3. 前后端常量与措辞对齐 # --------------------------------------------------------------------------- #: 两边各写一遍、必须一模一样的东西:一份在后端,一份镜像在前端 PARALLEL_FILES = { "backend": "backend/app/service/dicts.py", "frontend_scope": "frontend/src/utils/optionSource.ts", "frontend_map": "frontend/src/utils/optionMap.ts", "frontend_picker": "frontend/src/components/oa/OptionPicker.vue", "frontend_api": "frontend/src/api/work.ts", } #: 脚本跑在 backend/ 下,仓库根要往上退一层 ROOT = pathlib.Path(__file__).resolve().parent.parent.parent def _read(rel: str): return ROOT / rel PARALLEL_PHRASES = [ ("backend", "frontend_scope", ["候选范围里有认不出的档位"]), ] # (前端那一份在哪个文件, 后端写法, 前端写法) PARALLEL_CONSTANTS = [ # 默认那一档两边必须同一句,否则界面按 A 档渲染、后端按 B 档查库 ("frontend_scope", "RELATION_SCOPE_CREATED = \"created\"", "RELATION_SCOPE_CREATED: RelationScope = 'created'"), ("frontend_scope", "RELATION_SCOPE_RELATED = \"related\"", "RELATION_SCOPE_RELATED: RelationScope = 'related'"), ("frontend_scope", "RELATION_SCOPE_DEFAULT = RELATION_SCOPE_CREATED", "RELATION_SCOPE_DEFAULT: RelationScope = RELATION_SCOPE_CREATED"), # 「读对方表单」的写法前缀与上限:一个决定怎么认列,一个决定最多问几列 ("frontend_map", 'PROCESS_FORM_PREFIX = "data."', "export const PROCESS_FORM_PREFIX = 'data.'"), ("frontend_map", "MAX_RELATION_DISPLAY_FIELDS = 8", "export const MAX_RELATION_DISPLAY_FIELDS = 8"), ] def check_wording_parity() -> None: root = pathlib.Path(__file__).resolve().parents[2] texts: dict[str, str] = {} for key, rel in PARALLEL_FILES.items(): path = root / rel if not path.exists(): print(f"[跳过] 找不到 {rel}(只部署后端时正常)") continue texts[key] = path.read_text(encoding="utf-8") for side_a, side_b, phrases in PARALLEL_PHRASES: if side_a not in texts or side_b not in texts: continue for phrase in phrases: ok(f"「{phrase}」前后端都在", phrase in texts[side_a] and phrase in texts[side_b], f"{PARALLEL_FILES[side_a]} / {PARALLEL_FILES[side_b]}") for side, backend_snippet, frontend_snippet in PARALLEL_CONSTANTS: if "backend" not in texts or side not in texts: continue name = backend_snippet.split(" ")[0].split("=")[0] ok(f"{name} 两边同一句", backend_snippet in texts["backend"] and frontend_snippet in texts[side], f"{PARALLEL_FILES['backend']}:{backend_snippet!r} / {PARALLEL_FILES[side]}:{frontend_snippet!r}") # 界面文案两边都要有,缺一边就是切到英文给配的人看一串键名 locales = {} for name in ("zh", "en"): path = root / f"frontend/src/i18n/locales/{name}.ts" if path.exists(): locales[name] = path.read_text(encoding="utf-8") if locales: for key in ("relationScope:", "relationScopeCreated:", "relationScopeRelated:", "relationScopeOnlyNote:", "relationScopeAndStatusNote:"): for name, text in locales.items(): ok(f"词条 {key} 在 {name} 里", bool(re.search(rf"^\s*{re.escape(key)}", text, re.M))) # --------------------------------------------------------------------------- def main(argv: list[str]) -> int: stages = [ ("候选范围那一档", check_scope_reading), ("那一条 SQL", check_scope_sql), ("读对方表单的哪几格", check_display_paths), ("取出来的那一份文本", check_form_display), ("两条接口各按哪一条筛", check_endpoint_conditions), ("摘要里那个 data 键", check_summary_payload), ("回显认哪几个名字", check_summary_lookup), ("前后端常量与措辞", check_wording_parity), ] for title, stage in stages: before = len(FAILS) stage() marks = "通过" if len(FAILS) == before else f"{len(FAILS) - before} 条不对" print(f"[{marks}] {title}") for line in FAILS: print(f"[FAIL] {line}") if FAILS: print(f"共 {len(FAILS)} 条不对") return 1 print("通过:关联流程的候选范围与展示列口径一致") return 0 if __name__ == "__main__": raise SystemExit(main(sys.argv[1:]))