647 lines
33 KiB
Python
647 lines
33 KiB
Python
#!/usr/bin/env python3
|
||
"""出差备案申请:把「一家四格」收成「一格四家」。
|
||
|
||
生产上那张「出差备案申请」为四种项目分类各摆了一行同构字段(项目名称 / 项目编码 /
|
||
最终客户名称 / 项目阶段 × PMS / VDI / 行政 / 定制 = 16 格),配的都是同一件事,
|
||
只因为「一格只能挂一个来源」才被迫摊开,靠每格的显示条件互相藏起来。
|
||
候选来源条件路由(``optionRoutes`` + ``fetch.sources[].when`` + ``optionRoutes[].fill``)
|
||
落地之后,这 16 格可以收成 4 格:分类选 PMS 就问 ``pms_project`` 要候选,选 VDI 就换
|
||
``SCC_Project``,选行政 / 定制就回落到字段自己那一份、只跑这一家那一条外部取数。
|
||
|
||
这个脚本干三件事,默认**一个字都不改**:
|
||
|
||
1. 照着表上真实的字段算一遍收拢后的样子(条件从各格的显示条件里读,来源从各格自己身上读);
|
||
2. 用运行时那套口径把四种分类各跑一遍,逐条比对收拢前后「问哪一家、候选几条、
|
||
带出写哪几格、写进来的值一不一样」;
|
||
3. 按设计器保存的同一条路做校验(``clean_option_source`` + ``form_problems``)。
|
||
|
||
确认没问题再落库:
|
||
|
||
python3 scripts/collapse_trip_form.py # 看对照与校验
|
||
python3 scripts/collapse_trip_form.py --json /tmp/new.json # 顺手把结果写成文件
|
||
python3 scripts/collapse_trip_form.py --write --perms # 存成新的表单版本 + 收环节权限
|
||
OA_ENV=prod python3 scripts/collapse_trip_form.py # 对生产库跑(默认也是按当前档位连库)
|
||
|
||
只在读得出把握时才 ``--write``:字段名一改,环节权限、导出列、报表口径读的都是字段名,
|
||
``--perms`` 会把环节上那 16 条权限折到 4 格上,导出列与外部回写还得人工对一遍。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import copy
|
||
import json
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parents[0].parent))
|
||
|
||
from sqlalchemy import select # noqa: E402
|
||
|
||
from app import models # noqa: E402
|
||
from app.db import SessionLocal # noqa: E402
|
||
from app.service import binding, dicts, fetch, formruntime # noqa: E402
|
||
|
||
#: 驱动那一格:收拢后四种分类共用它的取值决定问哪一家。
|
||
DRIVER = "project_type"
|
||
|
||
#: 四组同构字段。``members`` 是表上现在的格子(缺了就不管它),``key`` / ``label`` 是收拢后那一格。
|
||
GROUPS: list[dict] = [
|
||
{"members": ["project_pms", "project_scc", "project_xz", "project_dz"],
|
||
"key": "project", "label": "项目名称"},
|
||
{"members": ["project_code_pms", "project_code_SCC", "project_code_xz", "project_code_dz"],
|
||
"key": "project_code", "label": "项目编码"},
|
||
{"members": ["customer_name_pms", "customer_scc", "customer_xz", "customer_dz"],
|
||
"key": "customer_name", "label": "最终客户名称"},
|
||
{"members": ["project_stage_pms", "project_stage_scc", "project_stage_xz", "project_stage_dz"],
|
||
"key": "project_stage", "label": "项目阶段"},
|
||
]
|
||
|
||
#: 收拢后拿哪一格的模样当基准:能挑候选的优先(字典 > 外部数据源 > 手填 > 只读取数)。
|
||
KIND_RANK = {"dict": 0, "dataSource": 1, "manual": 2, "fetch": 3}
|
||
|
||
#: 分类还没选、清单里一条都不成立时回落到哪一份:``first`` 用第一家那套来源,
|
||
#: ``empty`` 给一份空候选(四家来源各不相同时更诚实:还没选分类,这一格本来就没得挑)。
|
||
BASE_WHEN_UNMATCHED = {"project": "empty"}
|
||
|
||
|
||
def load_form(db, wanted: str) -> models.FormElement:
|
||
"""按 id 或名字找那张表单;名字撞上好几张就停下来问清楚,别猜。"""
|
||
row = db.get(models.FormElement, wanted)
|
||
if row is not None:
|
||
return row
|
||
rows = db.execute(
|
||
select(models.FormElement).where(models.FormElement.name == wanted)
|
||
).scalars().all()
|
||
if len(rows) == 1:
|
||
return rows[0]
|
||
raise SystemExit(f"表单「{wanted}」在库里{'没有' if not rows else '有 ' + str(len(rows)) + ' 张'},用 --form 说清楚是哪一张")
|
||
|
||
|
||
def driver_value_of(field: dict) -> str:
|
||
"""这一格的显示条件是不是「某一类分类才显示」这一种:是就回那个分类值,不是回空串。
|
||
|
||
收成一家靠的就是这一句:原来「PMS 才显示这一格」与收拢后「分类是 PMS 就用这一家」
|
||
是同一个条件,直接搬过去,不让人再抄一遍。
|
||
"""
|
||
cond = field.get("visibleWhen") or {}
|
||
rules = cond.get("rules") if isinstance(cond, dict) else None
|
||
if not isinstance(rules, list) or len(rules) != 1 or cond.get("match") not in (None, "all"):
|
||
return ""
|
||
rule = rules[0]
|
||
if not isinstance(rule, dict) or rule.get("op") != "eq" or rule.get("field") != DRIVER:
|
||
return ""
|
||
return str(rule.get("value") or "").strip()
|
||
|
||
|
||
def when_of(value: str) -> dict:
|
||
return {"match": "all", "rules": [{"op": "eq", "field": DRIVER, "value": value}]}
|
||
|
||
|
||
def kind_of(field: dict) -> str:
|
||
"""这一格现在问谁要候选:外部取数那一头回 ``fetch``。"""
|
||
if field.get("fetch"):
|
||
return "fetch"
|
||
return str(field.get("optionSource") or "") or "manual"
|
||
|
||
|
||
#: 每一种来源各自带的那几格配置,换一家就得重问一遍(与前端 ROUTE_OWNED_KEYS 同一分工)。
|
||
ROUTE_KIND_KEYS = {
|
||
"manual": ["options"],
|
||
"dict": ["dictCode", "cascadeFrom"],
|
||
"dataSource": ["dataSourceCode", "dataSourceArgs"],
|
||
"process": ["relationProcess", "relationStatuses"],
|
||
}
|
||
|
||
|
||
def has_candidates(member: dict) -> bool:
|
||
"""这一格是不是真的能挑候选:字典 / 数据源 / 关联流程 / 填了选项的手填才算。
|
||
|
||
纯文本那几格(行政项目阶段之类手填的)没有候选可搬,收成一家之后它们跟着
|
||
这一格共用的那一份来源走就行,别给它们造一条空候选的路由。
|
||
"""
|
||
kind = kind_of(member)
|
||
if kind == "manual":
|
||
return bool(member.get("options"))
|
||
return kind in ROUTE_KIND_KEYS
|
||
|
||
|
||
def route_from(member: dict, value: str, alias: dict[str, str]) -> dict:
|
||
"""把一格的候选来源配置搬成清单里的一条:条件 + 那一家的来源 + 它自带的带出。"""
|
||
kind = kind_of(member)
|
||
route: dict = {"when": when_of(value), "source": kind}
|
||
for name in ROUTE_KIND_KEYS[kind]:
|
||
if member.get(name) not in (None, "", [], {}):
|
||
route[name] = copy.deepcopy(member[name])
|
||
if member.get("optionMap"):
|
||
route["optionMap"] = copy.deepcopy(member["optionMap"])
|
||
if member.get("note"):
|
||
route["note"] = member["note"]
|
||
fill = clean_fill(copy.deepcopy(member.get("fetch") or {}), alias)
|
||
if fill:
|
||
route["fill"] = fill
|
||
return route
|
||
|
||
|
||
def clean_fill(cfg: dict, alias: dict[str, str]) -> dict:
|
||
"""一格的取数配置摊成「这一家自带的带出」:源、入参、带出去向,落点搬到收拢后的名字上。"""
|
||
out: dict = {}
|
||
code = str(cfg.get("source") or "").strip()
|
||
if code:
|
||
out["source"] = code
|
||
for name in ("args", "picks", "extras"):
|
||
rows = cfg.get(name)
|
||
if not isinstance(rows, dict) or not rows:
|
||
continue
|
||
if name == "picks":
|
||
rows = {key: alias.get(str(value), value) for key, value in rows.items()}
|
||
out[name] = copy.deepcopy(rows)
|
||
return out
|
||
|
||
|
||
def fetch_entry_from(member: dict, value: str, alias: dict[str, str]) -> dict:
|
||
"""把一格「只读取数」那一份配置搬成清单里的一条:条件跟着走,落点搬到收拢后的名字上。
|
||
|
||
``picks`` 写的是别的字段的名字,被收拢的那 16 个名字马上就没了。留着不是"暂时没生效",
|
||
是等下一个字段占用旧名字时把数悄悄盖到它头上(同 utils/formRename 搬带出的理由)。
|
||
"""
|
||
cfg = copy.deepcopy(member.get("fetch") or {})
|
||
cfg.pop("when", None)
|
||
picks = cfg.get("picks")
|
||
if isinstance(picks, dict):
|
||
cfg["picks"] = {key: alias.get(str(value_), value_) for key, value_ in picks.items()}
|
||
entry = {key: item for key, item in cfg.items() if item not in (None, "", {}, [])}
|
||
entry["when"] = when_of(value)
|
||
return entry
|
||
|
||
|
||
def merged_field(members: list[tuple[dict, str]], key: str, label: str, alias: dict[str, str]) -> dict:
|
||
"""一组同构字段收成那一格。
|
||
|
||
``members`` 是「(原来那一格, 它对应的分类值)」,按表上先后顺序给。
|
||
"""
|
||
ranked = sorted(members, key=lambda pair: KIND_RANK.get(kind_of(pair[0]), 9))
|
||
base_src = copy.deepcopy(ranked[0][0])
|
||
merged: dict = {
|
||
"key": key,
|
||
"label": label,
|
||
"type": base_src.get("type") or "text",
|
||
"col": min(int(item.get("col") or 1) for item, _ in members),
|
||
"row": min(int(item.get("row") or 1) for item, _ in members),
|
||
"span": max(int(item.get("span") or 6) for item, _ in members),
|
||
}
|
||
if base_src.get("required"):
|
||
merged["required"] = True
|
||
if base_src.get("readonly"):
|
||
merged["readonly"] = True
|
||
|
||
routes: list[dict] = []
|
||
entries: list[dict] = []
|
||
fills: list[dict] = []
|
||
for member, value in members:
|
||
if kind_of(member) == "fetch":
|
||
entries.append(fetch_entry_from(member, value, alias))
|
||
elif has_candidates(member):
|
||
routes.append(route_from(member, value, alias))
|
||
# 字典那一家的带出读的是「此刻命中的那一本」的附加值,所以各格的 autoFill 合成一份就够:
|
||
# 命中的那本没有那一列时一个字段都不写(dicts.apply_auto_fill 里 value is None 直接跳过),
|
||
# 不会把隔壁家带来的值抹掉。
|
||
for rule in member.get("autoFill") or []:
|
||
if not isinstance(rule, dict):
|
||
continue
|
||
moved = copy.deepcopy(rule)
|
||
moved["to"] = alias.get(str(rule.get("to") or ""), str(rule.get("to") or ""))
|
||
if moved not in fills:
|
||
fills.append(moved)
|
||
# 挑候选那一格的挑选方式(搜哪几列、下拉与弹窗各念哪几列)也合成一份:换一家之后
|
||
# 还能按上一家那样搜,是配表的人唯一能感觉出来的那点是或否。这几列写在哪儿历史上有
|
||
# 两种形状(picker 顶上与 picker.dialog / picker.dropdown 里),三种都认。
|
||
picker = member.get("picker")
|
||
if isinstance(picker, dict):
|
||
for place in ("", "dialog", "dropdown"):
|
||
bucket = picker if place == "" else picker.get(place)
|
||
if not isinstance(bucket, dict):
|
||
continue
|
||
for name in ("searchKeys", "noteKeys"):
|
||
keys = bucket.get(name)
|
||
if not isinstance(keys, list):
|
||
continue
|
||
target = merged.setdefault("picker", {})
|
||
if place:
|
||
target = target.setdefault(place, {})
|
||
target[name] = list(dict.fromkeys((target.get(name) or []) + keys))
|
||
|
||
if routes:
|
||
# 分类还没选(或选了没配的那一类)时清单里一条都不成立,回落到字段自己那一份。
|
||
base = BASE_WHEN_UNMATCHED.get(key, "first")
|
||
if base == "empty":
|
||
merged["optionSource"] = "manual"
|
||
merged["options"] = []
|
||
else:
|
||
merged["optionSource"] = routes[0]["source"]
|
||
for name in ROUTE_KIND_KEYS.get(routes[0]["source"], []) + ["optionMap"]:
|
||
if name in routes[0]:
|
||
merged[name] = copy.deepcopy(routes[0][name])
|
||
# 与兜底那一份一模一样的一条不用留在清单里:清单不成立时用的就是它,
|
||
# 少一条,下一任配表的人少认一条(「项目阶段」四家共用一本字典就是这么收干净的)。
|
||
if BASE_WHEN_UNMATCHED.get(key, "first") == "first":
|
||
same = [name for name in ROUTE_KIND_KEYS.get(merged.get("optionSource", ""), [])] + ["optionMap"]
|
||
routes = [item for item in routes if item["source"] != merged.get("optionSource")
|
||
or any(item.get(name) != merged.get(name) for name in same)]
|
||
# 一条都不剩就别留这个键:清单空着与没挂清单是同一件事,空数组只会让下一任以为配过
|
||
if routes:
|
||
merged["optionRoutes"] = routes
|
||
if entries:
|
||
merged["fetch"] = {"sources": entries}
|
||
# 行政 / 定制那两家是「取回来直接落这一格」,落进来的值不在这格的候选里;
|
||
# 不勾这一条,页面会把刚带出来的值当越界清掉(见 optionSource.allowOutsideValue)。
|
||
merged["allowOutsideValue"] = True
|
||
if fills:
|
||
merged["autoFill"] = fills
|
||
return merged
|
||
|
||
|
||
def mark_outside_value(fields: list[dict]) -> list[str]:
|
||
"""被别人的带出写进值的候选格,统一勾上「带回来的值不在候选里也收下」。
|
||
|
||
收成一家之后这种格子变多了:「项目阶段」原来 VDI 那一格是纯文本,收拢后是 PMS 那一家的
|
||
字典下拉,可 VDI 的字典仍旧要把 `extra.stageName` 写进来。那个名字不在 PMS 的阶段清单里,
|
||
不勾这一条,提交时就被判「取值已不在可选范围内」(口径见 optionSource.allowOutsideValue)。
|
||
"""
|
||
written: set[str] = set()
|
||
for item in fields:
|
||
for rule in item.get("autoFill") or []:
|
||
if isinstance(rule, dict) and rule.get("to"):
|
||
written.add(str(rule["to"]))
|
||
for name in fetch_targets(item):
|
||
written.add(name)
|
||
marked: list[str] = []
|
||
for item in fields:
|
||
has_options = bool(item.get("optionRoutes")) or bool(item.get("dictCode")) or bool(item.get("options"))
|
||
if item.get("key") in written and has_options and not item.get("allowOutsideValue"):
|
||
item["allowOutsideValue"] = True
|
||
marked.append(str(item.get("key")))
|
||
return marked
|
||
|
||
|
||
def fetch_targets(field: dict) -> list[str]:
|
||
"""这一格的取数往哪些格子上写(清单里那几条 + 老的单源写法都算)。"""
|
||
cfg = field.get("fetch") or {}
|
||
rows = [cfg] if cfg.get("source") else list(cfg.get("sources") or [])
|
||
out: list[str] = []
|
||
for entry in rows:
|
||
if isinstance(entry, dict):
|
||
out.extend(str(value) for value in (entry.get("picks") or {}).values())
|
||
return out
|
||
|
||
|
||
def shape_deltas(members: list[tuple[dict, str]], merged: dict) -> list[str]:
|
||
"""这一组里哪些分类的必填 / 只读跟着变了:必填与只读是字段级的,收成一家就只剩一份。
|
||
|
||
这是收拢唯一躲不掉的那点妥协。宁可在这里说清楚,也不要等人填单时才发现。
|
||
"""
|
||
lines: list[str] = []
|
||
home = f"{merged['label']}({merged['key']})"
|
||
for attr, name in (("required", "必填"), ("readonly", "只读")):
|
||
want = bool(merged.get(attr))
|
||
moved = [value for member, value in members if bool(member.get(attr)) != want]
|
||
if moved:
|
||
# 这一份开关收成一家之后只剩一个:跟的是当基准的那一家,其余几家跟着它变
|
||
lines.append(f"「{home}」的{name}跟 {members[0][0].get('key')} 那一家走({'有' if want else '没有'}),"
|
||
f"{('、'.join(moved))} 这几家{'变成' if want else '不再'}{name}")
|
||
return lines
|
||
|
||
|
||
def collapse(fields: list[dict]) -> tuple[list[dict], list[str]]:
|
||
"""按 GROUPS 收拢,回(新字段清单,说给人听的几行)。"""
|
||
by_key = {str(item.get("key") or ""): item for item in fields}
|
||
notes: list[str] = []
|
||
taken: set[str] = set()
|
||
out: list[dict] = []
|
||
for group in GROUPS:
|
||
members: list[tuple[dict, str]] = []
|
||
for name in group["members"]:
|
||
member = by_key.get(name)
|
||
if member is None:
|
||
notes.append(f"跳过:表上没有「{name}」({group['label']})")
|
||
continue
|
||
value = driver_value_of(member)
|
||
if not value:
|
||
raise SystemExit(
|
||
f"「{name}」的显示条件不是「{DRIVER} 等于某一个值」这一种,"
|
||
"收拢脚本不敢自己猜它对应哪一家,请先在设计器里把条件改回单条等值或人工收这一组"
|
||
)
|
||
taken.add(name)
|
||
members.append((member, value))
|
||
if not members:
|
||
continue
|
||
merged = merged_field(members, group["key"], group["label"], alias_map())
|
||
out.append(merged)
|
||
homes = "、".join(f"{item.get('key')}={value}" for item, value in members)
|
||
notes.append(f"收成「{merged['label']}」({merged['key']}):{homes}")
|
||
notes.extend(f" 注意:{line}" for line in shape_deltas(members, merged))
|
||
left = [copy.deepcopy(item) for item in fields if str(item.get("key") or "") not in taken]
|
||
return reflow(left + out), notes
|
||
|
||
|
||
def reflow(fields: list[dict]) -> list[dict]:
|
||
"""把腾出来的空行收掉:还留着格子的行按先后重新编号,别的字段整体上移。"""
|
||
used = sorted({int(item.get("row") or 1) for item in fields})
|
||
rank = {row: index + 1 for index, row in enumerate(used)}
|
||
for item in fields:
|
||
item["row"] = rank.get(int(item.get("row") or 1), int(item.get("row") or 1))
|
||
return fields
|
||
|
||
|
||
def reflow_layout(layout: dict, dropped: list[str], added: list[dict]) -> dict:
|
||
"""移动端那份字段顺序表:删掉收走的,把新格插在第一格原来的位置上。"""
|
||
out = copy.deepcopy(layout or {})
|
||
mobile = out.get("mobile")
|
||
if not isinstance(mobile, dict) or not isinstance(mobile.get("fields"), list):
|
||
return out
|
||
rows = mobile["fields"]
|
||
anchor = next((i for i, item in enumerate(rows) if isinstance(item, dict) and item.get("key") in set(dropped)), None)
|
||
kept = [item for item in rows if not (isinstance(item, dict) and item.get("key") in set(dropped))]
|
||
if anchor is None:
|
||
mobile["fields"] = kept
|
||
return out
|
||
insert_at = min(anchor, len(kept))
|
||
for offset, field in enumerate(added):
|
||
kept.insert(insert_at + offset, {"key": field["key"], "style": "row"})
|
||
mobile["fields"] = kept
|
||
return out
|
||
|
||
|
||
def branch_view(field: dict, data: dict, cache: dicts.DictCache) -> dict:
|
||
"""这一格在这一种分类下实际长什么样:问哪一家、候选几条、这一回跑哪几条取数。
|
||
|
||
回落后读的是字段自己那一份(``option_view`` 已经把两条路合成一份视图了),所以收拢前后
|
||
两边走的是同一句问法,比对才不是拿苹果比橘子。
|
||
"""
|
||
route = dicts.matched_route(field, data) or {}
|
||
view = dicts.option_view(field, data)
|
||
options = dicts.effective_options(field, data, cache)
|
||
cfg = fetch.config_of(field, data)
|
||
entries = binding.active_entries(cfg, data) if cfg else []
|
||
home = str(route.get("dictCode") or route.get("dataSourceCode") or view.get("dictCode")
|
||
or view.get("dataSourceCode") or "")
|
||
if not home and not route and str(view.get("optionSource") or "") not in ("", "manual"):
|
||
home = str(view.get("optionSource") or "")
|
||
return {
|
||
"route": home,
|
||
"hit": bool(route),
|
||
"count": len(options) if options is not None else 0,
|
||
"listable": options is not None,
|
||
"fetch": [str(item.get("source") or "") for item in entries],
|
||
}
|
||
|
||
|
||
def probe_branches(fields: list[dict], driver_values: list[str], cache: dicts.DictCache, db,
|
||
target: str) -> list[dict]:
|
||
"""按每一种分类挑一个真候选,看带出最后写到哪几格、写的是什么。"""
|
||
field = next((item for item in fields if item.get("key") == target), None)
|
||
if field is None:
|
||
return []
|
||
rows = []
|
||
for value in driver_values:
|
||
data = {item.get("key"): "" for item in fields if item.get("key")}
|
||
data[DRIVER] = value
|
||
view = branch_view(field, data, cache, db)
|
||
picked: dict = {}
|
||
problems: list[str] = []
|
||
options = dicts.effective_options(field, data, cache)
|
||
if options:
|
||
item = options[0]
|
||
data[target] = dicts.stored_of(field, item)
|
||
touched = dicts.apply_auto_fill(fields, data, cache)
|
||
picked = {key: data.get(key) for key in touched}
|
||
problems = formruntime.selection_problems(fields, {}, data, cache)
|
||
elif view["fetch"]:
|
||
picked = {"<跑取数>": ",".join(view["fetch"])}
|
||
rows.append({"分类": value, "命中": view["route"] or "回落", "候选": view["count"],
|
||
"取数": view["fetch"], "带出": picked, "越界": problems})
|
||
return rows
|
||
|
||
|
||
def alias_map() -> dict[str, str]:
|
||
"""原来那一格 → 收拢后那一格,比对与搬权限都用它。"""
|
||
return {name: group["key"] for group in GROUPS for name in group["members"]}
|
||
|
||
|
||
def rep_key(members: list[str], by_key: dict[str, dict]) -> str:
|
||
"""一组里挑「当基准的那一格」:能挑候选的优先,跟 merged_field 同一把尺子。"""
|
||
live = [name for name in members if name in by_key]
|
||
return sorted(live, key=lambda name: KIND_RANK.get(kind_of(by_key[name]), 9))[0] if live else ""
|
||
|
||
|
||
def fold_perms(db, form_id: str, by_key: dict[str, dict], *, write: bool) -> list[str]:
|
||
"""环节上那 16 条字段权限折到 4 格:认得出旧名字的搬过去,认不出的报出来。"""
|
||
lines: list[str] = []
|
||
alias = alias_map()
|
||
reps = {group["key"]: rep_key(group["members"], by_key) for group in GROUPS}
|
||
processes = db.execute(select(models.Process).where(models.Process.latest_form == form_id)).scalars().all()
|
||
for process in processes:
|
||
for activity in db.execute(
|
||
select(models.Activity).where(models.Activity.process == process.id)
|
||
).scalars():
|
||
config = activity.config if isinstance(activity.config, dict) else {}
|
||
perms = config.get("formPerms")
|
||
if not isinstance(perms, dict) or not any(name in perms for name in alias):
|
||
continue
|
||
kept = {key: value for key, value in perms.items() if key not in alias}
|
||
moved = 0
|
||
for group in GROUPS:
|
||
target = group["key"]
|
||
listed = [name for name in group["members"] if name in perms]
|
||
moved += len(listed)
|
||
if not listed:
|
||
continue
|
||
# 优先照「当基准的那一格」在这一环的权限把关;它没被列上就退而用这一组里
|
||
# 第一个被列上的,宁可少给一点权限,也不把原来读得着的格子放开给人改。
|
||
rep = reps.get(target) or ""
|
||
kept[target] = perms[rep if rep in listed else listed[0]]
|
||
stale = [key for key in kept if key not in by_key and key not in {group["key"] for group in GROUPS}]
|
||
lines.append(
|
||
f"{process.name} / {activity.name}:搬走 {moved} 条,"
|
||
f"这一环从此按 {sorted(group['key'] for group in GROUPS if group['key'] in kept)} 把关"
|
||
+ (f";顺带发现 {len(stale)} 条早就指向不存在的字段:{'、'.join(sorted(stale))}" if stale else "")
|
||
)
|
||
if write:
|
||
config["formPerms"] = kept
|
||
activity.config = config
|
||
if write:
|
||
db.flush()
|
||
return lines
|
||
|
||
|
||
def fetch_preview(db, cfg: dict, data: dict) -> dict:
|
||
"""按这一条取数配置真跑一次(SQL / HTTP 都只读那一头的查询),看落进来的是什么。"""
|
||
code = str(cfg.get("source") or "")
|
||
row = fetch.get_source(db, code)
|
||
if row is None:
|
||
return {"source": code, "error": "找不到这个源"}
|
||
try:
|
||
args = fetch.resolve_args(db, cfg, data)
|
||
out = fetch.preview(db, row, args, actor=None)
|
||
return {"source": code, "args": args, "value": out.get("value"), "extras": out.get("extras"),
|
||
"error": out.get("error") or ""}
|
||
except Exception as exc: # noqa: BLE001 演示脚本:把失败摊出来就行
|
||
return {"source": code, "error": f"{type(exc).__name__}: {exc}"}
|
||
|
||
|
||
def family_rows(fields: list[dict], value: str, alias: dict[str, str]) -> dict[str, list[dict]]:
|
||
"""这一家两边的字段:收拢前是四格(各挂一个分类),收拢后是同样那四格的收成版。
|
||
|
||
比对只在这一小撮格子上跑:带出去向得落在传进去的字段清单里才算数(``live_target``),
|
||
顺带也不会被隔壁家的取数与带出惊动。
|
||
"""
|
||
merged_keys = set(alias.values())
|
||
group_of = {name: group["key"] for group in GROUPS for name in group["members"]}
|
||
rows: dict[str, list[dict]] = {"before": [], "after": []}
|
||
for item in fields:
|
||
name = str(item.get("key") or "")
|
||
if name in merged_keys:
|
||
rows["after"].append(item)
|
||
elif name in group_of and driver_value_of(item) == value:
|
||
rows["before"].append(item)
|
||
return rows
|
||
|
||
|
||
def run_fetch(db, rows: list[dict], data: dict) -> None:
|
||
"""走提交链路里那一条外部取数(SQL 只读那几条),值原地写回 ``data``。
|
||
|
||
行政 / 定制那两家的名称与编码就是这么落进来的,光看配置说不出它到底取回什么,
|
||
所以这里真跑一次:``fetch.apply_form`` 与提交时是同一句。
|
||
"""
|
||
fetch.apply_form(db, rows, data)
|
||
|
||
|
||
def pick_and_fill(fields: list[dict], data: dict, key: str, cache: dicts.DictCache) -> dict:
|
||
"""在这一格里挑一个真候选,回「带出写到哪几格、写的是什么」。"""
|
||
field = next((item for item in fields if item.get("key") == key), None)
|
||
if field is None:
|
||
return {}
|
||
options = dicts.effective_options(field, data, cache) or []
|
||
if not options:
|
||
return {}
|
||
# 存哪一列要按「此刻命中的那一条」问,字段自己那一份 optionMap 是另一家的(口径同
|
||
# formruntime 判越界那一处:先 option_view 再 stored_of)
|
||
data[key] = dicts.stored_of(dicts.option_view(field, data), options[0])
|
||
# 别的格子这一趟先按住带出:不按住的话,隔壁家那一格也会拿自己那本字典往空值上带一次,
|
||
# 比对口径就不是「这一家带出哪几格」而是「整张表带出哪几格」了。
|
||
rows = [{**item, "autoFill": []} if item.get("key") != key else item for item in fields]
|
||
touched = dicts.apply_auto_fill(rows, data, cache)
|
||
return {str(name): data.get(name) for name in touched}
|
||
|
||
|
||
def describe(key: str, view: dict, fills: dict) -> str:
|
||
home = view["route"] or ("取数 " + ",".join(view["fetch"]) if view["fetch"] else "没候选")
|
||
hits = "换成这一家" if view["hit"] else "回落字段本身"
|
||
return f"{key}|问 {home}({hits})|候选 {view['count']} 条|带出 {sorted(fills) or '无'}"
|
||
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("--form", default="出差备案申请", help="表单名或 id,默认「出差备案申请」")
|
||
parser.add_argument("--write", action="store_true", help="存成新的表单版本(默认只算不改)")
|
||
parser.add_argument("--perms", action="store_true", help="连带把环节上的字段权限折到收拢后那几格")
|
||
parser.add_argument("--json", default="", help="把收拢后的 content 写到这个文件")
|
||
args = parser.parse_args()
|
||
|
||
with SessionLocal() as db:
|
||
row = load_form(db, args.form)
|
||
content = copy.deepcopy(row.content if isinstance(row.content, dict) else json.loads(row.content))
|
||
fields = content.get("fields") or []
|
||
by_key = {str(item.get("key") or ""): item for item in fields}
|
||
cache = dicts.DictCache(db)
|
||
values = [str(item.get("value") or "") for item in (cache.items(DRIVER) or [])]
|
||
alias = alias_map()
|
||
merged_keys = [group["key"] for group in GROUPS]
|
||
|
||
print(f"表单:{row.name} v{row.version}({row.id})|现字段 {len(fields)} 格"
|
||
f"|{DRIVER} 的取值:{'、'.join(values)}")
|
||
new_fields, notes = collapse(fields)
|
||
for line in notes:
|
||
print(" ·", line)
|
||
marked = mark_outside_value(new_fields)
|
||
print(f"字段数:{len(fields)} → {len(new_fields)}")
|
||
if marked:
|
||
print(" · 这些格子会被别人的带出写值,勾上「带回来的值不在候选里也收下」:", "、".join(marked))
|
||
merged_by_key = {str(item.get("key")): item for item in new_fields}
|
||
|
||
print("\n== 逐家比对:同一种分类,收拢前后各跑一遍候选 + 带出 + 外部取数")
|
||
bad = 0
|
||
for value in values:
|
||
before = family_rows(fields, value, alias)["before"]
|
||
after = family_rows(new_fields, value, alias)["after"]
|
||
present = {str(item.get("key") or "") for item in before}
|
||
old_key = next((name for name in GROUPS[0]["members"] if name in present), "")
|
||
if not old_key:
|
||
print(f"{value}:表上没有这一家,跳过")
|
||
continue
|
||
old_data = {str(item.get("key")): "" for item in before}
|
||
new_data = {str(item.get("key")): "" for item in after}
|
||
old_data[DRIVER] = new_data[DRIVER] = value
|
||
old_field, new_field = by_key[old_key], merged_by_key[GROUPS[0]["key"]]
|
||
old_view, new_view = branch_view(old_field, old_data, cache), branch_view(new_field, new_data, cache)
|
||
old_fill = pick_and_fill(before, old_data, old_key, cache)
|
||
new_fill = pick_and_fill(after, new_data, GROUPS[0]["key"], cache)
|
||
run_fetch(db, before, old_data)
|
||
run_fetch(db, after, new_data)
|
||
# 只比字段上的值:`_fetch` 那份留痕记的是「哪一格什么时候取过数」,键名跟着
|
||
# 字段名走,本来就该不一样,比它只会一直报「要人看」
|
||
def settled(source: dict) -> dict:
|
||
return {str(key): val for key, val in source.items()
|
||
if key not in (DRIVER, fetch.TRACE_KEY) and val not in ("", None)}
|
||
|
||
got_old = {alias.get(key, key): val for key, val in settled(old_data).items()}
|
||
got_new = settled(new_data)
|
||
same_home = (old_view["route"], old_view["count"], old_view["fetch"]) == \
|
||
(new_view["route"], new_view["count"], new_view["fetch"])
|
||
same_write = got_old == got_new
|
||
bad += 0 if (same_home and same_write) else 1
|
||
print(f"{value}:{'一致' if same_home and same_write else '要人看'}")
|
||
print(" 收拢前", describe(old_key, old_view, {alias.get(k, k): v for k, v in old_fill.items()}))
|
||
print(" 收拢后", describe(GROUPS[0]["key"], new_view, new_fill))
|
||
for name in sorted(set(got_old) | set(got_new)):
|
||
flag = "同一份" if got_old.get(name) == got_new.get(name) else "对不上"
|
||
print(f" {name}: 前 {got_old.get(name)!r} / 后 {got_new.get(name)!r} {flag}")
|
||
problems = formruntime.selection_problems(after, {}, new_data, cache)
|
||
if problems:
|
||
print(" 越界/校验:", problems)
|
||
bad += 1
|
||
|
||
added = [merged_by_key[name] for name in merged_keys if name in merged_by_key]
|
||
new_content = {"fields": new_fields,
|
||
"layout": reflow_layout(content.get("layout") or {}, sorted(alias), added)}
|
||
from app.api import design # noqa: PLC0415 只要那两个清洗函数与设计期校验
|
||
washed = design.clean_option_source(design.clean_formats(new_content))
|
||
problems = design.form_problems(washed, db)
|
||
print("\n== 按设计器保存那一条路口径校验:", "通过" if not problems else problems)
|
||
keys = {str(item.get("key") or "") for item in new_fields}
|
||
for item in new_fields:
|
||
extra = formruntime.option_source_problems(item, db=db, rows=new_fields, keys=keys)
|
||
if extra:
|
||
print(f" 「{item.get('label')}」设计期还要说:", extra)
|
||
if args.json:
|
||
Path(args.json).write_text(json.dumps(washed, ensure_ascii=False, indent=1), encoding="utf-8")
|
||
print(f"收拢后的 content 写到 {args.json}")
|
||
for line in fold_perms(db, row.id, by_key, write=args.write):
|
||
print("环节权限:", line)
|
||
if not args.write:
|
||
print("\n没动库。对着 --json 那一份确认过,再加 --write 存成新版本(环节权限加 --perms)")
|
||
return 0
|
||
if problems:
|
||
raise SystemExit("校验没过,不落库")
|
||
backup = Path(f"/tmp/form-{row.id}-v{row.version}.json")
|
||
backup.write_text(json.dumps(content, ensure_ascii=False, indent=1), encoding="utf-8")
|
||
row.content = washed
|
||
row.version = (row.version or 1) + 1
|
||
db.commit()
|
||
print(f"已存成 v{row.version};改之前那一份在 {backup}")
|
||
print(f"比对结果:{len(values) - bad} 家一致,{bad} 家要人看")
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|