unis-oa/backend/scripts/collapse_trip_form.py

647 lines
33 KiB
Python
Raw Blame History

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden 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
"""出差备案申请:把「一家四格」收成「一格四家」。
生产上那张「出差备案申请」为四种项目分类各摆了一行同构字段(项目名称 / 项目编码 /
最终客户名称 / 项目阶段 × 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())