357 lines
10 KiB
Python
357 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""Merge zkxw-dict.sql + sx-dict.sql into shanxia2.0 sys_dict_* INSERT script."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
ZKXW_SQL = ROOT / "docs/sql/zkxw-dict.sql"
|
|
SX_SQL = ROOT / "docs/sql/sx-dict.sql"
|
|
SHANXIA_SQL = ROOT / "docs/sql/shanxia2.0.sql"
|
|
OUT_SQL = ROOT / "docs/sql/reimport-dict-from-zkxw-sx.sql"
|
|
TENANT = "shanxia2.0"
|
|
# sx 源库部分 CRM 字典无时间戳；目标表 create_time/update_time 为 NOT NULL
|
|
DEFAULT_DT = "2026-05-30 00:00:00"
|
|
|
|
# shanxia2.0 门户内置字典（不在 zkxw-dict / sx-dict 中，从基线 SQL 保留）
|
|
PORTAL_BASELINE_TYPES = frozenset(
|
|
{
|
|
"sys_status",
|
|
"sys_sex",
|
|
"sys_data_scope",
|
|
"sys_visible",
|
|
"menu_type",
|
|
"leave_status",
|
|
"wf_process_status",
|
|
"wf_node_type",
|
|
"wf_approve_type",
|
|
"user_role",
|
|
}
|
|
)
|
|
|
|
DICT_TYPE_RE = re.compile(r"^[a-z][a-z0-9_]*$")
|
|
|
|
TAG_TYPE_MAP = {
|
|
"default": "",
|
|
"primary": "primary",
|
|
"success": "success",
|
|
"danger": "danger",
|
|
"warning": "warning",
|
|
"info": "info",
|
|
}
|
|
|
|
|
|
def split_sql_values(values_part: str) -> list:
|
|
parts: list[str] = []
|
|
cur: list[str] = []
|
|
in_str = False
|
|
i = 0
|
|
while i < len(values_part):
|
|
c = values_part[i]
|
|
if in_str:
|
|
if c == "\\" and i + 1 < len(values_part):
|
|
cur.append(c)
|
|
cur.append(values_part[i + 1])
|
|
i += 2
|
|
continue
|
|
if c == "'":
|
|
if i + 1 < len(values_part) and values_part[i + 1] == "'":
|
|
cur.append("''")
|
|
i += 2
|
|
continue
|
|
in_str = False
|
|
cur.append(c)
|
|
else:
|
|
cur.append(c)
|
|
else:
|
|
if c == "'":
|
|
in_str = True
|
|
cur.append(c)
|
|
elif c == ",":
|
|
parts.append("".join(cur).strip())
|
|
cur = []
|
|
else:
|
|
cur.append(c)
|
|
i += 1
|
|
if cur:
|
|
parts.append("".join(cur).strip())
|
|
return parts
|
|
|
|
|
|
def unquote(val: str):
|
|
val = val.strip()
|
|
if val.upper() == "NULL":
|
|
return None
|
|
if val.startswith("'") and val.endswith("'"):
|
|
return val[1:-1].replace("''", "'")
|
|
if re.fullmatch(r"-?\d+", val):
|
|
return int(val)
|
|
return val
|
|
|
|
|
|
def parse_insert(line: str) -> tuple[str, list[str], list] | None:
|
|
m = re.match(
|
|
r"INSERT INTO `(\w+)` \(([^)]+)\) VALUES \((.+)\);\s*$",
|
|
line.strip(),
|
|
)
|
|
if not m:
|
|
return None
|
|
table = m.group(1)
|
|
cols = [c.strip().strip("`") for c in m.group(2).split(",")]
|
|
vals = [unquote(v) for v in split_sql_values(m.group(3))]
|
|
return table, cols, vals
|
|
|
|
|
|
def sql_literal(val) -> str:
|
|
if val is None:
|
|
return "NULL"
|
|
if isinstance(val, int):
|
|
return str(val)
|
|
s = str(val).replace("\\", "\\\\").replace("'", "''")
|
|
return f"'{s}'"
|
|
|
|
|
|
def is_valid_dict_type(code: str | None) -> bool:
|
|
return bool(code) and bool(DICT_TYPE_RE.match(code))
|
|
|
|
|
|
def map_tag_type(list_class: str | None) -> str:
|
|
if not list_class:
|
|
return ""
|
|
key = str(list_class).strip().lower()
|
|
return TAG_TYPE_MAP.get(key, key if key in TAG_TYPE_MAP.values() else "")
|
|
|
|
|
|
def sx_type_id(dict_id: int) -> str:
|
|
return f"SXDT{dict_id:016X}"
|
|
|
|
|
|
def sx_data_id(dict_code: int) -> str:
|
|
return f"SXDC{dict_code:016X}"
|
|
|
|
|
|
def normalize_row(row: dict) -> dict:
|
|
out = dict(row)
|
|
ct = out.get("create_time")
|
|
ut = out.get("update_time")
|
|
if not ct:
|
|
out["create_time"] = ut or DEFAULT_DT
|
|
if not out.get("update_time"):
|
|
out["update_time"] = out["create_time"] or DEFAULT_DT
|
|
return out
|
|
|
|
|
|
def row_to_insert(table: str, cols: list[str], row: dict) -> str:
|
|
row = normalize_row(row)
|
|
ordered = [row[c] for c in cols]
|
|
vals = ", ".join(sql_literal(v) for v in ordered)
|
|
col_sql = ", ".join(f"`{c}`" for c in cols)
|
|
return f"INSERT INTO `{table}` ({col_sql}) VALUES ({vals});"
|
|
|
|
|
|
def load_portal_baseline():
|
|
types: dict[str, dict] = {}
|
|
data: list[dict] = []
|
|
for line in SHANXIA_SQL.read_text(encoding="utf-8").splitlines():
|
|
parsed = parse_insert(line)
|
|
if not parsed:
|
|
continue
|
|
table, cols, vals = parsed
|
|
row = dict(zip(cols, vals))
|
|
if table == "sys_dict_type":
|
|
code = row.get("dict_type")
|
|
if code not in PORTAL_BASELINE_TYPES or row.get("del_flag", 0) != 0:
|
|
continue
|
|
types[code] = row
|
|
elif table == "sys_dict_data":
|
|
code = row.get("dict_type")
|
|
if code not in PORTAL_BASELINE_TYPES or row.get("del_flag", 0) != 0:
|
|
continue
|
|
row.setdefault("tag_type", "")
|
|
data.append(row)
|
|
return types, data
|
|
|
|
|
|
def load_zkxw():
|
|
types: dict[str, dict] = {}
|
|
data: list[dict] = []
|
|
for line in ZKXW_SQL.read_text(encoding="utf-8").splitlines():
|
|
parsed = parse_insert(line)
|
|
if not parsed:
|
|
continue
|
|
table, cols, vals = parsed
|
|
row = dict(zip(cols, vals))
|
|
if row.get("del_flag", 0) != 0:
|
|
continue
|
|
row["tenant_no"] = TENANT
|
|
if table == "sys_dict_type":
|
|
code = row.get("dict_type")
|
|
if is_valid_dict_type(code):
|
|
types[code] = row
|
|
elif table == "sys_dict_data":
|
|
code = row.get("dict_type")
|
|
if not is_valid_dict_type(code):
|
|
continue
|
|
row["tenant_no"] = TENANT
|
|
row.setdefault("tag_type", "")
|
|
data.append(row)
|
|
return types, data
|
|
|
|
|
|
def load_sx():
|
|
types: dict[str, dict] = {}
|
|
data: list[dict] = []
|
|
for line in SX_SQL.read_text(encoding="utf-8").splitlines():
|
|
parsed = parse_insert(line)
|
|
if not parsed:
|
|
continue
|
|
table, cols, vals = parsed
|
|
row = dict(zip(cols, vals))
|
|
if table == "sys_dict_type":
|
|
dict_id = row.get("dict_id")
|
|
code = row.get("dict_type")
|
|
name = row.get("dict_name")
|
|
if not is_valid_dict_type(code):
|
|
continue
|
|
if str(name) in ("000000", TENANT, "zkxw", "0"):
|
|
continue
|
|
types[code] = {
|
|
"id": sx_type_id(int(dict_id)),
|
|
"dict_name": name,
|
|
"dict_type": code,
|
|
"tenant_no": TENANT,
|
|
"order_num": 0,
|
|
"remark": row.get("remark") or "",
|
|
"create_by": None,
|
|
"create_dept_id": "",
|
|
"create_time": row.get("create_time"),
|
|
"update_by": None,
|
|
"update_time": row.get("update_time") or row.get("create_time"),
|
|
"del_flag": 0,
|
|
}
|
|
elif table == "sys_dict_data":
|
|
dict_code = row.get("dict_code")
|
|
code = row.get("dict_type")
|
|
label = row.get("dict_label")
|
|
value = row.get("dict_value")
|
|
if dict_code is None or not is_valid_dict_type(code):
|
|
continue
|
|
if not label or not str(label).strip():
|
|
continue
|
|
if str(label) in ("planned", "zsjy_visit_status") and str(value) in (
|
|
"zsjy_visit_status",
|
|
"planned",
|
|
):
|
|
continue
|
|
create_by = row.get("create_by")
|
|
data.append(
|
|
{
|
|
"id": sx_data_id(int(dict_code)),
|
|
"dict_label": label,
|
|
"dict_value": value,
|
|
"tag_type": map_tag_type(row.get("list_class")),
|
|
"dict_type": code,
|
|
"tenant_no": TENANT,
|
|
"order_num": row.get("dict_sort") or 0,
|
|
"remark": row.get("remark") or "",
|
|
"create_by": str(create_by) if create_by is not None else None,
|
|
"create_dept_id": "",
|
|
"create_time": row.get("create_time"),
|
|
"update_by": None,
|
|
"update_time": row.get("update_time") or row.get("create_time"),
|
|
"del_flag": 0,
|
|
}
|
|
)
|
|
return types, data
|
|
|
|
|
|
def main():
|
|
portal_types, portal_data = load_portal_baseline()
|
|
zkxw_types, zkxw_data = load_zkxw()
|
|
sx_types, sx_data = load_sx()
|
|
|
|
merged_types = dict(portal_types)
|
|
merged_types.update(zkxw_types)
|
|
merged_types.update(sx_types)
|
|
|
|
type_cols = [
|
|
"id",
|
|
"dict_name",
|
|
"dict_type",
|
|
"tenant_no",
|
|
"order_num",
|
|
"remark",
|
|
"create_by",
|
|
"create_dept_id",
|
|
"create_time",
|
|
"update_by",
|
|
"update_time",
|
|
"del_flag",
|
|
]
|
|
data_cols = [
|
|
"id",
|
|
"dict_label",
|
|
"dict_value",
|
|
"tag_type",
|
|
"dict_type",
|
|
"tenant_no",
|
|
"order_num",
|
|
"remark",
|
|
"create_by",
|
|
"create_dept_id",
|
|
"create_time",
|
|
"update_by",
|
|
"update_time",
|
|
"del_flag",
|
|
]
|
|
|
|
# portal baseline -> zkxw -> sx
|
|
seen_data_ids: set[str] = set()
|
|
merged_data: list[dict] = []
|
|
for row in portal_data + zkxw_data + sx_data:
|
|
rid = row["id"]
|
|
if rid in seen_data_ids:
|
|
continue
|
|
seen_data_ids.add(rid)
|
|
if row["dict_type"] not in merged_types:
|
|
continue
|
|
merged_data.append(row)
|
|
|
|
lines = [
|
|
"-- Reimport dictionary data for shanxia2.0",
|
|
"-- Sources: shanxia2.0 portal baseline + zkxw-dict.sql + sx-dict.sql",
|
|
"-- Generated by: backend/scripts/generate_dict_reimport_sql.py",
|
|
"",
|
|
"SET NAMES utf8mb4;",
|
|
"SET FOREIGN_KEY_CHECKS = 0;",
|
|
"",
|
|
"DELETE FROM `sys_dict_data`;",
|
|
"DELETE FROM `sys_dict_type`;",
|
|
"",
|
|
"BEGIN;",
|
|
"",
|
|
"-- sys_dict_type",
|
|
]
|
|
for code in sorted(merged_types.keys()):
|
|
lines.append(row_to_insert("sys_dict_type", type_cols, merged_types[code]))
|
|
|
|
lines.append("")
|
|
lines.append("-- sys_dict_data")
|
|
for row in merged_data:
|
|
lines.append(row_to_insert("sys_dict_data", data_cols, row))
|
|
|
|
lines.extend(["", "COMMIT;", "", "SET FOREIGN_KEY_CHECKS = 1;", ""])
|
|
|
|
OUT_SQL.write_text("\n".join(lines), encoding="utf-8")
|
|
print(
|
|
f"Wrote {OUT_SQL.relative_to(ROOT)}: "
|
|
f"{len(merged_types)} types, {len(merged_data)} data rows "
|
|
f"(portal={len(portal_types)}, zkxw={len(zkxw_types)}, sx={len(sx_types)})"
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|