1924 lines
92 KiB
Python
1924 lines
92 KiB
Python
"""表单运行时:环节字段权限、明细表、计算公式、金额大写。
|
||
|
||
三件事都是"同一份表单在不同环节长得不一样、值不全靠人手填"这一类问题,
|
||
放在一个模块里,前端对应的镜像是 ``frontend/src/utils/formRuntime.ts``,
|
||
两边的常量(权限取值、明细表列类型、大写金额口径)必须保持一致。
|
||
|
||
- 字段权限:环节 ``config.formPerms`` 记 ``{字段名: hidden|readonly|editable|required}``,
|
||
没配的字段沿用自己的 ``required`` / ``readonly`` / ``hidden``(表单设计器上那个
|
||
「默认隐藏」开关,见 ``effective_perm``)。权限只在服务端算一次数,
|
||
前端拿到的只是同一份结果用来渲染,绕过界面也改不动不该改的字段。
|
||
- 明细表:``type=table`` 的字段存一个对象数组,列定义在 ``columns`` 上;
|
||
空行落库前丢掉,必填列和行数上下界在这里拦。
|
||
- 计算公式:``type=formula`` 的字段由 ``formula`` 表达式算出,走引擎那套受限
|
||
表达式沙箱;每次提交后重算,所以条件分支和统计都能直接用。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
import re
|
||
from typing import Any, Iterable
|
||
|
||
#: 环节字段权限的四种取值,与前端 PERM_* 常量一致。
|
||
PERM_HIDDEN = "hidden"
|
||
PERM_READONLY = "readonly"
|
||
PERM_EDITABLE = "editable"
|
||
PERM_REQUIRED = "required"
|
||
PERM_VALUES = (PERM_HIDDEN, PERM_READONLY, PERM_EDITABLE, PERM_REQUIRED)
|
||
|
||
#: 明细表里能用的列类型:只放不需要复杂交互的基础控件,
|
||
#: 附件、人员、子表套子表这些在格子里放不下的都不给。
|
||
#: 明细列能用的类型:与前端 ``types.TABLE_COLUMN_TYPES`` 一一对应,
|
||
#: 也就是主表能填的类型除了标题/系统带出/嵌套明细/公式/排版类之外全部可用。
|
||
#: 明细列与主表共用前端那一个录入控件,所以两边类型清单必须一起改。
|
||
TABLE_COLUMN_TYPES = (
|
||
"text",
|
||
"textarea",
|
||
"number",
|
||
"money",
|
||
"date",
|
||
"datetime",
|
||
"time",
|
||
"daterange",
|
||
"month",
|
||
"months",
|
||
"year",
|
||
"timerange",
|
||
"week",
|
||
"mobile",
|
||
"email",
|
||
"idcard",
|
||
"url",
|
||
"address",
|
||
"location",
|
||
"select",
|
||
"radio",
|
||
"checkbox",
|
||
"switch",
|
||
"rate",
|
||
"dept",
|
||
"cascader",
|
||
"user",
|
||
"attachment",
|
||
"image",
|
||
"signature",
|
||
"relation",
|
||
"picker",
|
||
)
|
||
|
||
#: 这几类列得有选项来源:字典编码或手写选项,否则格子里连能点的东西都没有。
|
||
OPTION_COLUMN_TYPES = ("select", "radio", "checkbox")
|
||
|
||
#: 天生存一串值的字段类型;下拉框与下拉选择那一格另外看字段上的 ``multiple``
|
||
#: (真正该问的是下面那一句,两份清单一起改最容易漏)。
|
||
LIST_VALUE_TYPES = ("checkbox", "relation")
|
||
|
||
|
||
def holds_list_value(field: dict) -> bool:
|
||
"""这一格存的是一串值吗(多选、关联审批单,以及勾了「可以选好几个」的下拉框 / 下拉选择)。"""
|
||
return _linkage().holds_list_value(field)
|
||
|
||
#: 不需要参与录入与必填校验的类型。
|
||
#: 分组标题与空白占位是纯版面:没有值、没有控件,必填与权限都轮不到它们。
|
||
#: ``embed`` 也在这一列:它把一块地方让给外部系统的页面,自己不产生值(方案见
|
||
#: docs/embed-page-field-design.md §1)。但它**不是 divider**——它的 key 是环节字段权限
|
||
#: 的挂点,"哪一环能看见这个外部页面"是安全边界,api/design.py 那边不放过它。
|
||
NON_INPUT_TYPES = ("divider", "description", "group", "spacer", "hidden", "auto", "formula", "embed",
|
||
"tabs")
|
||
|
||
#: 值由系统带出 / 公式算出来的那两类:永远不给录入框,环节也改不了它,但设计者可以让它
|
||
#: 「必填」——要求这一格必须带得出、算得出值。与前端 SYSTEM_FILLED_TYPES 一致。
|
||
SYSTEM_FILLED_TYPES = ("auto", "formula")
|
||
|
||
_CN_DIGITS = "零壹贰叁肆伍陆柒捌玖"
|
||
_CN_UNITS = ["", "拾", "佰", "仟"]
|
||
_CN_GROUPS = ["", "万", "亿", "万亿"]
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 字段与权限
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def fields_of(content: object) -> list[dict]:
|
||
"""表单 ``content`` 里的字段列表;结构不对就返回空,别让脏数据炸了流程。"""
|
||
if not isinstance(content, dict):
|
||
return []
|
||
raw = content.get("fields")
|
||
return [item for item in raw if isinstance(item, dict)] if isinstance(raw, list) else []
|
||
|
||
|
||
def normalize_person_values(db, fields: list[dict], data: dict) -> dict:
|
||
"""把选人字段(含明细表里的选人列)写成登录账号,就地返回同一份 ``data``。
|
||
|
||
选人控件交出来的本来就是账号,这一层管的是**别人写进来的**:开放接口、找人脚本、
|
||
数据源带出的值。DN 会随部门改名漂,落库之前不洗成账号,这一格以后就谁也认不出是谁
|
||
(口径见 :mod:`app.service.personref`)。
|
||
|
||
换的是**认得出是谁**的那些值(一批格子一次换算完,:func:`personref.map_accounts`),
|
||
认不出的一律原样留着。这里刻意不按 DN 尾巴剪一刀:部门改过一次名之后 DN 末段就是
|
||
姓名(``hub_sync._sync_identity_rows_of`` 按身份名重算),照着尾巴剪等于把一个人洗成
|
||
一段中文,比留着原值更糟。同理,只动 ``type=user`` 的格子,文本里带反斜杠的
|
||
(``a\\b\\c`` 这种)一律不碰。
|
||
"""
|
||
from . import personref # 延迟导入:这一层是叶子模块,模块级不拽别的服务
|
||
|
||
if not isinstance(data, dict):
|
||
return data
|
||
# (所在容器, 该洗的格子):主表一项,明细表每行一项
|
||
targets: list[tuple[dict, tuple[str, ...]]] = []
|
||
for field in fields or []:
|
||
key = str(field.get("key") or "")
|
||
kind = str(field.get("type") or "")
|
||
if not key or key not in data:
|
||
continue
|
||
if kind == "user":
|
||
targets.append((data, (key,)))
|
||
elif kind == "table":
|
||
columns = tuple(
|
||
str(column.get("key") or "")
|
||
for column in columns_of(field)
|
||
if str(column.get("type") or "") == "user" and str(column.get("key") or "")
|
||
)
|
||
if not columns or not isinstance(data[key], list):
|
||
continue
|
||
# 明细行是请求体里的同一批对象,改之前先复制,别把调用方手里的快照也改了
|
||
rows: list = []
|
||
for row in data[key]:
|
||
if not isinstance(row, dict):
|
||
rows.append(row)
|
||
continue
|
||
copied = dict(row)
|
||
rows.append(copied)
|
||
targets.append((copied, columns))
|
||
data[key] = rows
|
||
values = [
|
||
str(item)
|
||
for container, keys in targets
|
||
for key in keys
|
||
for item in (container[key] if isinstance(container[key], list) else [container[key]])
|
||
if str(item or "").strip()
|
||
]
|
||
if not values:
|
||
return data
|
||
mapping = personref.map_accounts(db, values)
|
||
if not mapping:
|
||
return data
|
||
for container, keys in targets:
|
||
for key in keys:
|
||
current = container[key]
|
||
if isinstance(current, list):
|
||
container[key] = [mapping.get(str(item).strip(), item) for item in current]
|
||
elif str(current or "").strip():
|
||
container[key] = mapping.get(str(current).strip(), current)
|
||
return data
|
||
|
||
|
||
def fillable(field: dict) -> bool:
|
||
return str(field.get("type") or "") not in NON_INPUT_TYPES
|
||
|
||
|
||
def system_filled(field: dict) -> bool:
|
||
"""这一格的值是系统给的还是人填的:系统给的那两类只能要求"算得出值",不能要求人去填。"""
|
||
return str(field.get("type") or "") in SYSTEM_FILLED_TYPES
|
||
|
||
|
||
def perms_of(config: object) -> dict[str, str]:
|
||
"""取环节的字段权限;认 ``formPerms``,顺手兼容历史写法 ``fieldPerms``。"""
|
||
source = config if isinstance(config, dict) else {}
|
||
raw = source.get("formPerms")
|
||
if not isinstance(raw, dict):
|
||
raw = source.get("fieldPerms")
|
||
if not isinstance(raw, dict):
|
||
return {}
|
||
return {
|
||
str(key): str(value)
|
||
for key, value in raw.items()
|
||
if str(value) in PERM_VALUES
|
||
}
|
||
|
||
|
||
def perm_map(config: object, fields: Iterable[dict] | None = None) -> dict[str, str]:
|
||
"""环节那份字段权限,外加「标签页藏整片 / 藏一页」展开出来的那几笔 hidden。
|
||
|
||
凡是**要拿这份字典去判某个格子**的地方都走这里,别再直接 :func:`perms_of`:展开这件事
|
||
只要有一处漏了,那一处就会对着一格看不见、却仍然必填的字段喊「请填写」——那张单就地卡死。
|
||
界面那份(``form_perms`` 原样摊给前端)留的是没展开的原件,前端用
|
||
``utils/tabPages.ts:expandPerms`` 展开同一份,判据只有一份实现的说法不成立,
|
||
但两句措辞由 ``check_tabs.py`` 与 ``tabPages.spec.ts`` 钉在一起。
|
||
"""
|
||
perms = perms_of(config)
|
||
if not perms or not fields:
|
||
return perms
|
||
from . import tabpages # 延迟导入:那一层要读 embed,模块级互相引用会绕成圈
|
||
|
||
return tabpages.expand_perms(fields, perms)
|
||
|
||
|
||
def hidden_by_default(field: dict) -> bool:
|
||
"""「默认隐藏」这一档此刻真的算隐藏吗。
|
||
|
||
只在**这一格没配显示条件**时才算。勾了「默认隐藏」又配了「显示条件」的格子说的是
|
||
同一件事的两头:"平时不露,条件成立才露"——说话的是条件,默认值不能把它盖成
|
||
"永远不露"。这种配法在设计器里最自然(这一格只归某几个部门填),一旦被默认值吃掉,
|
||
格子在哪个环节都不出现,而提交时那一格的值也跟着被丢掉(``editable_keys`` 认的就是
|
||
这一句)。没配条件的格子(单据编号、金额大写那类)一个字都不变,照旧全局不露。
|
||
前端镜像在 ``utils/formRuntime.hiddenByDefault``。
|
||
"""
|
||
return bool(field.get("hidden")) and not _linkage().has_rules(field.get("visibleWhen"))
|
||
|
||
|
||
def effective_perm(field: dict, perms: dict[str, str], data: dict | None = None) -> str:
|
||
"""单个字段在这个环节上的最终权限.
|
||
|
||
底子是环节配置(没配就看字段自己的 required / readonly / hidden);传了 ``data``
|
||
就再叠一层联动条件。**联动只会往严的方向加**(隐藏 / 只读 / 必填),不会把环节锁死的
|
||
字段放开,这样「环节说只读」不会因为某个字段联动而漏水。
|
||
"""
|
||
key = str(field.get("key") or "")
|
||
named = perms.get(key)
|
||
if named == PERM_HIDDEN:
|
||
return PERM_HIDDEN
|
||
if data is None:
|
||
# 没有这份数据就算不了联动:勾了「默认隐藏」的格子保守按隐藏算(回看那一屏的口径不变)。
|
||
# 字段自己在表单设计器上勾了「默认隐藏」:没有哪一环节点名要它,就按隐藏算,
|
||
# 值照样存、公式照总算;某环节显式给了别的权限,就是那一环特意要看见它,字段默认让位。
|
||
override = named or (PERM_HIDDEN if field.get("hidden") else None)
|
||
if override == PERM_HIDDEN:
|
||
return PERM_HIDDEN
|
||
if override:
|
||
return override
|
||
if not fillable(field):
|
||
return PERM_READONLY
|
||
if field.get("required"):
|
||
return PERM_REQUIRED
|
||
if field.get("readonly"):
|
||
return PERM_READONLY
|
||
return PERM_EDITABLE
|
||
state = _linkage().state_of(field, data)
|
||
if not state["visible"]:
|
||
return PERM_HIDDEN
|
||
# 环节显式给了别的权限就是那一环特意要看见它,字段默认让位;没点名时按「默认隐藏」算,
|
||
# 而配了显示条件并由条件放行到这里的格子,默认值不再说话(见 :func:`hidden_by_default`)。
|
||
override = named or (PERM_HIDDEN if hidden_by_default(field) else None)
|
||
base = override or (PERM_READONLY if not fillable(field) else PERM_EDITABLE)
|
||
if base == PERM_HIDDEN: # pragma: no cover - 上面已挡
|
||
return PERM_HIDDEN
|
||
if state["readonly"]:
|
||
return PERM_READONLY
|
||
if state["required"]:
|
||
return PERM_REQUIRED
|
||
if override:
|
||
return override
|
||
if field.get("required"):
|
||
return PERM_REQUIRED
|
||
if field.get("readonly"):
|
||
return PERM_READONLY
|
||
return base
|
||
|
||
|
||
def field_hidden(field: dict, perms: "dict[str, str] | None", data: dict | None = None) -> bool:
|
||
"""这一格在这一环**到底露不露**:这个问句的判据只留在这一处。
|
||
|
||
必填(:func:`missing_required`)、阈值那句红字(前端 ``utils/formThreshold.ts`` 的镜像)、
|
||
阈值与额度要不要当场拦人(``threshold.blocked_here`` / ``quota.hidden_keys``)、
|
||
外部取数失败要不要当场拦人(``fetch.apply_form``)读的都是这一句——只要有一处自己另写一份,
|
||
就会出现"界面上没说、后端真挡"那道缝:审批人点同意被一条屏幕上根本没出现的规则卡在这一环,
|
||
看不见、改不动、也没有那句可照着改的话。
|
||
|
||
``perms`` 必须是 :func:`perm_map` 展开过的那一份(环节直接设的隐藏、标签页整页隐藏
|
||
落到每一格头上的那几笔都在里面),``data`` 用来算字段自己的联动条件。
|
||
没给 ``perms``(调用方不知道是哪个环节,例如试算与外部脚本)一律按**露着**算:
|
||
宁可按配置挡,也不要在无人知情时悄悄放行。
|
||
"""
|
||
if perms is None:
|
||
return False
|
||
return effective_perm(field, perms, data) == PERM_HIDDEN
|
||
|
||
|
||
def visible_fields(fields: Iterable[dict], perms: dict[str, str], data: dict | None = None) -> list[dict]:
|
||
return [item for item in fields if not field_hidden(item, perms, data)]
|
||
|
||
|
||
def editable_keys(fields: Iterable[dict], perms: dict[str, str], data: dict | None = None) -> set[str]:
|
||
return {
|
||
str(item.get("key") or "")
|
||
for item in fields
|
||
if effective_perm(item, perms, data) in (PERM_EDITABLE, PERM_REQUIRED) and item.get("key")
|
||
}
|
||
|
||
|
||
def writable_ignoring_self(field: dict, perms: dict[str, str], data: dict | None = None) -> bool:
|
||
"""把「读自己那几条」摘掉以后,这一格在这个环节填得动吗。
|
||
|
||
问的是「挡着这一笔值的到底只有它自己那一句吗」。前端镜像在
|
||
``utils/formRuntime.writableIgnoringSelf``。
|
||
"""
|
||
rest = _linkage().stripped_of_self(field)
|
||
if not rest or data is None:
|
||
return False
|
||
return effective_perm(rest, perms, data) in (PERM_EDITABLE, PERM_REQUIRED)
|
||
|
||
|
||
def self_gated_keys(fields: Iterable[dict], perms: dict[str, str], data: dict) -> set[str]:
|
||
"""只被自己那句条件收走 / 锁住的格子:这一笔值正是让它藏起来的原因。
|
||
|
||
``editable_keys`` 按合并后的数据算,「本字段有值才显示」「有值就锁住」这一类条件在
|
||
人刚敲完的那一刻就把这一格收了,于是这一笔刚写下的值按「这个环节改不动」退回原样——
|
||
人看着自己写的字凭空消失。摘掉自引用那几条以后这一格本来就填得动,那这一笔值就该收下。
|
||
|
||
只放宽「收不收这一笔值」,不放宽界面上露不露、必填要不要、阈值挡不挡人:那几处读的
|
||
仍然是带自引用的那一份条件,一寸没动。
|
||
"""
|
||
return {
|
||
str(item.get("key") or "")
|
||
for item in fields
|
||
if item.get("key")
|
||
and effective_perm(item, perms, data) not in (PERM_EDITABLE, PERM_REQUIRED)
|
||
and writable_ignoring_self(item, perms, data)
|
||
}
|
||
|
||
|
||
def _linkage():
|
||
"""延迟导入,避开 dicts -> formruntime 的循环(大写金额那条也是同一个套路)。"""
|
||
from . import dicts as _dicts
|
||
|
||
return _dicts
|
||
|
||
|
||
def _kernel():
|
||
"""取数内核(取值写法 / 源的健康判据 / 入参引用检查),同样延迟导入。"""
|
||
from . import binding as _binding
|
||
|
||
return _binding
|
||
|
||
|
||
def _relation_fill():
|
||
"""关联单据带出(``linkFill``)那一层,同样延迟导入:它本身要吃本模块的列口径。"""
|
||
from . import linkfill as _linkfill
|
||
|
||
return _linkfill
|
||
|
||
|
||
#: 候选来源=外部数据源时,那张源除了关键词还要按什么筛(``{form.x}`` 那一份入参表)。
|
||
#: 与字段上外部取数的 ``args`` 同一个形状、同一套解析,见 service/binding.py。
|
||
OPTION_ARGS_KEY = "dataSourceArgs"
|
||
#: 级联选择字段:值是从顶级一路到末级的字典项数组,见 cascader_problems。
|
||
CASCADER_TYPE = "cascader"
|
||
|
||
|
||
def empty_value(field: dict) -> bool:
|
||
"""没填的判定:空串、空数组、空对象都算空,数字 0 和布尔 False 不算。"""
|
||
value = field.get("__value__") if "__value__" in field else field
|
||
if value is None:
|
||
return True
|
||
if isinstance(value, str):
|
||
return not value.strip()
|
||
if isinstance(value, (list, dict, tuple, set)):
|
||
return len(value) == 0
|
||
return False
|
||
|
||
|
||
#: 天生有值的类型:只有开与关两档,没有「没填」这一档
|
||
ALWAYS_ANSWERED_TYPES = ("switch",)
|
||
|
||
|
||
def answered(field: dict, value: Any) -> bool:
|
||
"""这一格算不算「已经填了」:必填那道闸用它,前端镜像在 ``utils/formRuntime.ts:isAnswered``。
|
||
|
||
开关是唯一的例外:控件摆出来就是关着的,压根没拨过与存了 ``False`` 是同一件事。
|
||
以前这两种都按空算,于是给开关勾上必填的人,只要没去碰那一下就被说成「还没填写」——
|
||
一个根本没有空可填的格子在问人要值。关着就是回答「不」。
|
||
"""
|
||
kind = str(field.get("type") or "").strip()
|
||
if kind in ALWAYS_ANSWERED_TYPES:
|
||
return True
|
||
# 定位那一格存的是一个物件:全是空串的物件要算没填,只写了一句地址要算填了。
|
||
if kind == LOCATION_TYPE:
|
||
return location_filled(value)
|
||
return not empty_value({"__value__": value})
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 定位 / 时间段 / 星期 / 富文本这几类的取值与把关
|
||
# ---------------------------------------------------------------------------
|
||
|
||
#: 定位那格存的物件只认这三个键,脏键一律丢掉(前端镜像 ``utils/formRuntime.locationValue``)。
|
||
LOCATION_TYPE = "location"
|
||
LOCATION_KEYS = ("lng", "lat", "address")
|
||
#: 星期几的取值:1-7(周一到周日),与前端 ``WEEK_DAY_VALUES`` 一致。
|
||
WEEK_DAY_VALUES = ("1", "2", "3", "4", "5", "6", "7")
|
||
#: 能配「字数上限 / 校验正则」的文本类字段,与前端 ``TEXT_LIMIT_TYPES`` 一致。
|
||
TEXT_LIMIT_TYPES = ("text", "textarea", "richtext")
|
||
#: 能配「允许类型 / 最多几个 / 单个多大」的附件类字段,与前端 ``FILE_LIMIT_TYPES`` 一致。
|
||
FILE_LIMIT_TYPES = ("attachment", "image")
|
||
#: 明细列在表格上怎么摆的那三档合法值,与前端 ``TABLE_COLUMN_ALIGNMENTS`` /
|
||
#: ``TABLE_COLUMN_AGGREGATES`` / ``TABLE_COLUMN_WIDTHS`` 同一份清单。认不出的写法多半是
|
||
#: 手改 JSON 或从别处粘来的配置:与其运行时默默按默认摆(配的人以为配好了),保存就说清。
|
||
COLUMN_ALIGNMENTS = ("auto", "left", "center", "right")
|
||
COLUMN_AGGREGATES = ("none", "sum", "avg", "max", "min", "count")
|
||
#: 能求和 / 平均 / 最大 / 最小的列类型:只有这两类装的是数。其余列只能数个数。
|
||
NUMERIC_AGGREGATE_TYPES = ("number", "money")
|
||
#: 明细列宽的合法区间(px):比一颗勾选框还窄、比一整屏还宽的都算配歪了。
|
||
COLUMN_WIDTH_MIN = 60
|
||
COLUMN_WIDTH_MAX = 640
|
||
#: 空白格的高度区间(px),与前端 ``SPACER_MIN_HEIGHT`` / ``SPACER_MAX_HEIGHT`` 一致。
|
||
SPACER_MIN_HEIGHT = 8
|
||
SPACER_MAX_HEIGHT = 240
|
||
#: 正则的判定方式:**整格匹配**(``fullmatch``)。半匹配会让 ``\d{6}`` 放过
|
||
#: ``abc123456def``,配的人以为挡住了、其实没挡,所以按整格算并把这句写在属性面板的提示里。
|
||
|
||
|
||
def location_value(value: object) -> dict:
|
||
"""把定位那一格的取值整形成只含 lng / lat / address 的物件,空的那几栏剔掉。"""
|
||
if not isinstance(value, dict):
|
||
return {}
|
||
out: dict[str, str] = {}
|
||
for key in LOCATION_KEYS:
|
||
text = str(value.get(key) or "").strip()
|
||
if text:
|
||
out[key] = text
|
||
return out
|
||
|
||
|
||
def location_filled(value: object) -> bool:
|
||
"""有经纬度,或者只写了一句地址,都算填了。
|
||
|
||
浏览器定位在台式机、没授权、非 https 的页面上本来就取不到,只让人补一句地址是
|
||
这里有意留的活口——不然外勤单子在没有手机的桌面上就发不出去。
|
||
"""
|
||
hit = location_value(value)
|
||
return bool(hit.get("address") or (hit.get("lng") and hit.get("lat")))
|
||
|
||
|
||
def location_text(value: object) -> str:
|
||
"""只读、导出、打印里的那一句人话:地址在前,经纬度收在小括号里。"""
|
||
hit = location_value(value)
|
||
coord = f"{hit['lng']}, {hit['lat']}" if "lng" in hit and "lat" in hit else (hit.get("lng") or hit.get("lat") or "")
|
||
address = hit.get("address", "")
|
||
if address and coord:
|
||
return f"{address}({coord})"
|
||
return address or coord
|
||
|
||
|
||
def range_text(value: object, sep: str = " ~ ") -> str:
|
||
"""日期区间 / 时间段那两项写成一句人话。"""
|
||
items = value if isinstance(value, (list, tuple)) else [value]
|
||
return sep.join(str(item).strip() for item in items if str(item or "").strip())
|
||
|
||
|
||
#: 星期几的中文名(1=周一):导出与标题都念这一份,界面上的那份在前端 i18n。
|
||
WEEK_LABELS = {"1": "周一", "2": "周二", "3": "周三", "4": "周四", "5": "周五", "6": "周六", "7": "周日"}
|
||
|
||
|
||
def week_text(value: object) -> str:
|
||
"""星期那格念成「周一、周三」;库里存的是 1-7,认不得的值原样退回。"""
|
||
items = value if isinstance(value, (list, tuple)) else ([] if value in (None, "") else [value])
|
||
return "、".join(WEEK_LABELS.get(str(item), str(item)) for item in items if str(item or "").strip())
|
||
|
||
|
||
#: 多选月份那一格的写法:与「月份」同一句式(``2026-10``),跨年也照这个排。
|
||
#: 前端镜像在 ``utils/formRuntime.ts`` 的 ``monthList`` / ``monthsText``。
|
||
_MONTH_ITEM = re.compile(r"^\d{4}-(0[1-9]|1[0-2])$")
|
||
|
||
|
||
def month_list(value: object) -> list[str]:
|
||
"""多选月份的值整形:只留 2026-10 这样的写法,去重、按时间先后排好。"""
|
||
items = value if isinstance(value, (list, tuple)) else ([] if value in (None, "") else [value])
|
||
picked = {text for text in (str(item or "").strip() for item in items) if _MONTH_ITEM.match(text)}
|
||
return sorted(picked)
|
||
|
||
|
||
def months_text(value: object) -> str:
|
||
"""多选月份念成一句人话:连着几个月并成一段。
|
||
|
||
一年之内写作「2026年10-11月」,跨年写作「2026年12月-2027年2月」,中间断开的各写各的;
|
||
同一年里断开的好几段只报一次年份(「2026年1月、3-5月」)。库里存的是
|
||
``["2026-10", "2026-11"]``,直接转字符串会把中括号灌进单元格。
|
||
"""
|
||
indexes = [int(item[:4]) * 12 + int(item[5:]) - 1 for item in month_list(value)]
|
||
if not indexes:
|
||
return ""
|
||
runs: list[list[int]] = []
|
||
for index in indexes:
|
||
if runs and index == runs[-1][1] + 1:
|
||
runs[-1][1] = index
|
||
else:
|
||
runs.append([index, index])
|
||
parts: list[str] = []
|
||
# 上一年说过一次就不再重复;跨年那一段把两头都写全,之后的一段重新报年,
|
||
# 否则「、5月」会挂到别人家的年份底下去。
|
||
spoken_year: int | None = None
|
||
for start_index, end_index in runs:
|
||
start_year, start_month = divmod(start_index, 12)
|
||
end_year, end_month = divmod(end_index, 12)
|
||
if start_year != end_year:
|
||
spoken_year = None
|
||
parts.append(f"{start_year}年{start_month + 1}月-{end_year}年{end_month + 1}月")
|
||
continue
|
||
span = f"{start_month + 1}月" if start_index == end_index else f"{start_month + 1}-{end_month + 1}月"
|
||
if spoken_year == start_year:
|
||
parts.append(span)
|
||
else:
|
||
spoken_year = start_year
|
||
parts.append(f"{start_year}年{span}")
|
||
return "、".join(parts)
|
||
|
||
|
||
#: 多选月份那三档挑选姿势:取值与设计器里「挑选方式」是同一套(前端 ``monthsStyleOf``)。
|
||
#:
|
||
#: 这一格的候选是那一年那 12 个月,谈不上候选来源,所以这里**没有「自动」这一档**:
|
||
#: 没配过就是下拉多选。平铺那一档摊开是 12 个格子、要吃掉一整行,不能当默认。
|
||
#: 与前端 ``utils/formRuntime.ts`` 的 ``MONTHS_STYLES`` / ``monthsStyleOf`` 同一份口径。
|
||
MONTHS_TYPE = "months"
|
||
MONTHS_STYLES = ("dropdown", "dialog", "inline")
|
||
MONTHS_STYLE_DEFAULT = "dropdown"
|
||
|
||
|
||
def months_style_of(field: dict) -> str:
|
||
"""这一格该用哪一种姿势挑:认不出的写法(手改的、别的类型留下的)一律回落到默认那档。"""
|
||
style = str((field or {}).get("pickerStyle") or "").strip()
|
||
return style if style in MONTHS_STYLES else MONTHS_STYLE_DEFAULT
|
||
|
||
|
||
def months_config_problems(field: dict) -> list[str]:
|
||
"""多选月份这一格自己的配置问题(设计期):眼下只有挑选姿势认不认这一条。
|
||
|
||
保存时 ``api/design.py`` 会把认不出的写法收掉,这一句是给接口与 AI 起草那条路兜底——
|
||
一个不认识的值活到填单那一刻,就只剩渲染器替人猜该画哪一只控件了。
|
||
"""
|
||
style = str(field.get("pickerStyle") or "").strip()
|
||
if style and style not in MONTHS_STYLES:
|
||
return [f"的挑选方式不认识:{style}(下拉多选 / 弹出框多选 / 平铺点选 三选一)"]
|
||
return []
|
||
|
||
|
||
def markdown_text(value: object) -> str:
|
||
"""把 Markdown 原文压成一段适合进表格 / 标题的纯文本。
|
||
|
||
富文本格存的是原文而不是 HTML,导出时不 strip 的话,一整段排版会连 ``##``、
|
||
``-``、``**`` 一起灌进单元格,Excel 里根本没法读。这里只去记号、不解析语义。
|
||
"""
|
||
text = str(value or "")
|
||
if not text.strip():
|
||
return ""
|
||
text = re.sub(r"```.*?```", " ", text, flags=re.S) # 整块代码
|
||
text = re.sub(r"`([^`]*)`", r"\1", text) # 行内代码
|
||
text = re.sub(r"!\[([^\]]*)\]\(([^)]*)\)", r"\1", text) # 图片:只留 alt
|
||
text = re.sub(r"\[([^\]]*)\]\(([^)]*)\)", r"\1(\2)", text) # 链接:文字(地址)
|
||
text = re.sub(r"^\s{0,3}#{1,6}\s*", "", text, flags=re.M) # 标题井号
|
||
text = re.sub(r"^\s{0,3}>\s?", "", text, flags=re.M) # 引用
|
||
text = re.sub(r"^\s*[-*+]\s+", "", text, flags=re.M) # 无序列表
|
||
text = re.sub(r"^\s*\d+[.)]\s+", "", text, flags=re.M) # 有序列表
|
||
text = re.sub(r"(\*\*|__|\*|_)", "", text) # 加粗斜体
|
||
text = re.sub(r"^\s*([-*_]\s*){3,}$", "", text, flags=re.M) # 分割线
|
||
return re.sub(r"[ ]+", " ", text).strip()
|
||
|
||
|
||
def _text_limit(field: dict) -> int:
|
||
"""字段配的字数上限;没配或配歪回 0(= 不限)。"""
|
||
raw = field.get("maxLength")
|
||
try:
|
||
value = int(str(raw).strip())
|
||
except (TypeError, ValueError):
|
||
return 0
|
||
return value if value > 0 else 0
|
||
|
||
|
||
def _pattern_of(field: dict) -> str:
|
||
return str(field.get("pattern") or "").strip()
|
||
|
||
|
||
def text_config_problems(field: dict) -> list[str]:
|
||
"""字数上限与校验正则**本身**配得对不对(设计期判,与前端 ``textConfigProblems`` 同口径)。
|
||
|
||
编译不过的式子在提交时会被判成"永远不匹配",那一格从此谁都填不对,
|
||
所以宁可保存那一刻就挡下来。
|
||
"""
|
||
problems: list[str] = []
|
||
raw = field.get("maxLength")
|
||
if raw is not None and str(raw).strip():
|
||
try:
|
||
value = int(str(raw).strip())
|
||
except (TypeError, ValueError):
|
||
problems.append("的字数上限要是一个整数")
|
||
else:
|
||
if value < 1 or value > 100000:
|
||
problems.append("的字数上限要在 1-100000 之间")
|
||
pattern = _pattern_of(field)
|
||
if pattern:
|
||
try:
|
||
re.compile(pattern)
|
||
except re.error:
|
||
problems.append(f"的校验正则「{pattern}」编译不过,检查括号与转义")
|
||
return problems
|
||
|
||
|
||
def file_config_problems(field: dict) -> list[str]:
|
||
"""附件那三个限制配得对不对(设计期)。"""
|
||
problems: list[str] = []
|
||
files = field.get("maxFiles")
|
||
if files is not None and str(files).strip():
|
||
try:
|
||
count = int(str(files).strip())
|
||
except (TypeError, ValueError):
|
||
problems.append("的最多文件数要是一个整数")
|
||
else:
|
||
if count < 0 or count > 99:
|
||
problems.append("的最多文件数要在 0-99 之间(0 = 不限)")
|
||
size = field.get("maxSizeMb")
|
||
if size is not None and str(size).strip():
|
||
try:
|
||
megabytes = float(str(size).strip())
|
||
except (TypeError, ValueError):
|
||
problems.append("的单个大小要是一个数字")
|
||
else:
|
||
if megabytes < 0 or megabytes > 1024:
|
||
problems.append("的单个大小要在 0-1024 MB 之间(0 = 不限)")
|
||
return problems
|
||
|
||
|
||
def _file_mime(name: object) -> str:
|
||
import mimetypes
|
||
|
||
return mimetypes.guess_type(str(name or ""))[0] or ""
|
||
|
||
|
||
def accept_hits(accept: object, name: object, extension: object = "") -> bool:
|
||
"""这个文件命中 ``accept`` 那套写法吗(``.pdf`` / ``image/*`` / ``image/png``)。
|
||
|
||
没配 accept 就是不限;图片那一格默认收 ``image/*``,口径与前端 ``utils/formRuntime.acceptOf``
|
||
一致——界面挡的是体验,这里挡的是绕过界面塞进来的文件。
|
||
"""
|
||
text = str(accept or "").strip()
|
||
if not text:
|
||
return True
|
||
label = str(name or "").strip().lower()
|
||
ext = str(extension or "").strip().lstrip(".").lower() or (
|
||
os.path.splitext(label)[1].lstrip(".") if label else ""
|
||
)
|
||
mime = _file_mime(label or (f"file.{ext}" if ext else ""))
|
||
for item in (part.strip().lower() for part in text.split(",")):
|
||
if not item:
|
||
continue
|
||
if item.startswith("."):
|
||
if item[1:] == ext:
|
||
return True
|
||
elif item.endswith("/*"):
|
||
if mime and mime.startswith(item[:-1]):
|
||
return True
|
||
elif item == ext or item == label:
|
||
return True
|
||
return False
|
||
|
||
|
||
def effective_accept(field: dict) -> str:
|
||
"""这一格真正生效的 accept:图片格没配也还是只收图片。"""
|
||
custom = str(field.get("accept") or "").strip()
|
||
kind = str(field.get("type") or "")
|
||
if kind == "image":
|
||
return custom or "image/*"
|
||
if kind == "attachment":
|
||
return custom
|
||
return ""
|
||
|
||
|
||
def _file_items(value: object) -> list[dict]:
|
||
return rows_of(value)
|
||
|
||
|
||
def value_problems(fields: Iterable[dict], perms: dict[str, str], data: dict) -> list[str]:
|
||
"""提交时按字段类型判一次值本身:长度、正则、月份写法、时间段顺序、附件限制。
|
||
|
||
只判本环节**改得动**的那几格:上一环节留下的旧值格式不对,不该由一个改不动它的
|
||
审批人背锅(口径与 ``selection_problems`` 同一套)。
|
||
"""
|
||
problems: list[str] = []
|
||
for field in fields:
|
||
key = str(field.get("key") or "")
|
||
if not key or effective_perm(field, perms, data) not in (PERM_EDITABLE, PERM_REQUIRED):
|
||
continue
|
||
kind = str(field.get("type") or "")
|
||
value = (data or {}).get(key)
|
||
label = str(field.get("label") or key)
|
||
if kind in TEXT_LIMIT_TYPES:
|
||
text = value if isinstance(value, str) else ("" if value is None else str(value))
|
||
limit = _text_limit(field)
|
||
if limit and len(text.strip()) > limit:
|
||
problems.append(f"「{label}」超出字数上限({limit} 字,现在 {len(text.strip())} 字)")
|
||
pattern = _pattern_of(field)
|
||
if pattern and text.strip():
|
||
try:
|
||
matched = re.fullmatch(pattern, text.strip())
|
||
except re.error:
|
||
# 编译不过的式子在保存那道闸就挡了;库里躺着的旧配置不拦人,只跳过这一条
|
||
matched = None
|
||
if matched is None:
|
||
problems.append(f"「{label}」的写法不对,要符合{pattern}")
|
||
elif kind == "month":
|
||
text = str(value or "").strip()
|
||
if text and not _DEFAULT_MONTH.match(text):
|
||
problems.append(f"「{label}」不是 2026-01 这样的月份")
|
||
elif kind == "year":
|
||
text = str(value or "").strip()
|
||
if text and not _DEFAULT_YEAR.match(text):
|
||
problems.append(f"「{label}」不是 2026 这样的年份")
|
||
elif kind == "months":
|
||
items = value if isinstance(value, (list, tuple)) else ([] if value in (None, "") else [value])
|
||
odd = [str(item) for item in items if not _MONTH_ITEM.match(str(item or "").strip())]
|
||
if odd:
|
||
problems.append(f"「{label}」里有不是 2026-01 这样写法的月份({'、'.join(odd)})")
|
||
elif kind in ("timerange", "daterange", "week", LOCATION_TYPE):
|
||
problem = _shape_problem(kind, value)
|
||
if problem:
|
||
problems.append(f"「{label}」{problem}")
|
||
elif kind in NUMERIC_RANGE_TYPES:
|
||
problem = _range_problem(field, value)
|
||
if problem:
|
||
problems.append(f"「{label}」{problem}")
|
||
elif kind in FILE_LIMIT_TYPES:
|
||
problems.extend(_file_problems(field, value, label))
|
||
return problems
|
||
|
||
|
||
#: 能配「最小值 / 最大值」的字段类型:数字与金额两类(明细列同理)。
|
||
#: 评分的 ``max`` 是满星数、不是取值范围,别混进来。
|
||
NUMERIC_RANGE_TYPES = ("number", "money")
|
||
|
||
|
||
def _range_problem(field: dict, value: object) -> str:
|
||
"""这一格的数在不在配好的上下限里;没配、或值是空的,都不说话。
|
||
|
||
界面上 ``<input type="number">`` 的 ``min`` / ``max`` 只把不合法的输入标个红,压根拦不住
|
||
人继续往下走,所以提交这一趟得判。「权威判定在提交那一步」这条规矩在这儿的意思是:
|
||
别只留一层浏览器给的软提示——接口直传与脚本写进来的值根本不经过那只框。
|
||
"""
|
||
if value in (None, ""):
|
||
return ""
|
||
try:
|
||
number = float(str(value).strip())
|
||
except (TypeError, ValueError):
|
||
return ""
|
||
low = _number(field.get("min"))
|
||
high = _number(field.get("max"))
|
||
if low is not None and number < low:
|
||
return f"小于配好的最小值 {field.get('min')}"
|
||
if high is not None and number > high:
|
||
return f"大于配好的最大值 {field.get('max')}"
|
||
return ""
|
||
|
||
|
||
def _shape_problem(kind: str, value: object) -> str:
|
||
"""这几类的值形状:星期几只能是 1-7,时间段得有先后,定位得是个物件。"""
|
||
if kind == "week":
|
||
items = value if isinstance(value, (list, tuple)) else ([] if value in (None, "") else [value])
|
||
odd = [str(item) for item in items if str(item) not in WEEK_DAY_VALUES]
|
||
return f"只能勾周一到周日,「{'、'.join(odd)}」不在其中" if odd else ""
|
||
if kind == "timerange":
|
||
items = [str(item or "").strip() for item in (value if isinstance(value, (list, tuple)) else [])]
|
||
filled = [item for item in items if item]
|
||
odd = [item for item in filled if not _DEFAULT_CLOCK.match(item)]
|
||
if odd:
|
||
return f"不是 09:30 这样的钟点({'、'.join(odd)})"
|
||
if len(filled) == 2 and filled[0] > filled[1]:
|
||
return f"的结束时间({filled[1]})早于开始时间({filled[0]})"
|
||
return ""
|
||
if kind == "daterange":
|
||
items = [str(item or "").strip() for item in (value if isinstance(value, (list, tuple)) else [])]
|
||
filled = [item for item in items if item]
|
||
if len(filled) == 2 and filled[0] > filled[1]:
|
||
return f"的结束日期({filled[1]})早于开始日期({filled[0]})"
|
||
return ""
|
||
if kind == LOCATION_TYPE and value not in (None, "", {}) and not isinstance(value, dict):
|
||
return "装的不是一个位置(经纬度 + 地址)"
|
||
return ""
|
||
|
||
|
||
def _file_problems(field: dict, value: object, label: str) -> list[str]:
|
||
"""附件格的三道限制:几个、单个多大、什么类型。库里存的每条自带 name / extension / length。"""
|
||
problems: list[str] = []
|
||
items = _file_items(value)
|
||
if not items:
|
||
return problems
|
||
max_files = _int(field.get("maxFiles"), 0)
|
||
if max_files and len(items) > max_files:
|
||
problems.append(f"「{label}」最多只能挂 {max_files} 个文件,现在有 {len(items)} 个")
|
||
megabytes = _number(field.get("maxSizeMb")) or 0
|
||
if megabytes > 0:
|
||
for item in items:
|
||
size = _number(item.get("length")) or 0
|
||
if size > megabytes * 1024 * 1024:
|
||
problems.append(
|
||
f"「{label}」里的「{item.get('name') or '未命名'}」有 {round(size / 1024 / 1024, 1)} MB,"
|
||
f"超过这一格限的 {megabytes:g} MB"
|
||
)
|
||
accept = effective_accept(field)
|
||
if accept:
|
||
for item in items:
|
||
if not accept_hits(accept, item.get("name"), item.get("extension")):
|
||
problems.append(
|
||
f"「{label}」里的「{item.get('name') or '未命名'}」不是允许的类型(只收 {accept})"
|
||
)
|
||
return problems
|
||
|
||
|
||
def hidden_by_condition(field: dict, data: dict | None) -> bool:
|
||
"""这一格是因为**自己的显示条件不成立**才藏起来的吗。
|
||
|
||
跟「勾了默认隐藏」不是一回事:编号、金额大写那一类全局不露却仍然要有值,藏起来不等于
|
||
可以不生成;而配了显示条件的格子,条件翻走说的是「这一单根本用不到它」——既没有录入框,
|
||
又不适用这一单,再催一句「还没填写」就是让人对着一片空白找输入框。
|
||
"""
|
||
condition = field.get("visibleWhen")
|
||
if condition in (None, "", {}, []):
|
||
return False
|
||
return not _linkage().condition_ok(condition, data or {})
|
||
|
||
|
||
def missing_required(
|
||
fields: Iterable[dict], perms: dict[str, str], data: dict, *, prefix: str = ""
|
||
) -> list[str]:
|
||
"""这个环节必须填而没填的字段标题,按表单顺序返回。"""
|
||
problems: list[str] = []
|
||
for field in fields:
|
||
perm = effective_perm(field, perms, data)
|
||
key = str(field.get("key") or "")
|
||
if not key:
|
||
continue
|
||
# 必填只认环节的最后一道判断:effective_perm 已经把字段自己的 required 折算进来了,
|
||
# 而环节显式标成 editable 就是"允许留空",不该再拿字段老的 required 卡人。
|
||
must = perm == PERM_REQUIRED
|
||
if not must and perm in (PERM_READONLY, PERM_HIDDEN) and key not in perms:
|
||
# 系统带出与公式没有录入框,权限算出来永远是只读;字段自己勾了必填,就要它算得出值。
|
||
# 字段级「默认隐藏」也走这一条:编号、金额大写这种不显示但仍要有值的格子,
|
||
# 藏起来不等于可以不生成。环节显式隐藏(key in perms)才是真不用管。
|
||
#
|
||
# 但**因显示条件不成立而藏起来**的那一格不算这一笔:那种配法说的是「这一单用不到它」
|
||
# (生产上「默认隐藏 + 显示条件 + 必填」的系统带出格就是这么把自己钉死的——
|
||
# 屏幕上没有那一格,提交却永远说它没填)。
|
||
must = (
|
||
system_filled(field)
|
||
and bool(field.get("required"))
|
||
and not hidden_by_condition(field, data)
|
||
)
|
||
if not must:
|
||
continue
|
||
if not answered(field, (data or {}).get(key)):
|
||
problems.append(f"{prefix}{field.get('label') or key}")
|
||
return problems
|
||
|
||
|
||
def _row_problems(field: dict, rows: list[dict]) -> list[str]:
|
||
"""明细表的行级校验:必填列、行数上下界,返回人能看懂的一句话。"""
|
||
label = str(field.get("label") or field.get("key") or "")
|
||
columns = columns_of(field)
|
||
min_rows = _int(field.get("minRows"), 0)
|
||
max_rows = _int(field.get("maxRows"), 0)
|
||
problems: list[str] = []
|
||
if min_rows and len(rows) < min_rows:
|
||
problems.append(f"「{label}」至少要有 {min_rows} 行")
|
||
if max_rows and len(rows) > max_rows:
|
||
problems.append(f"「{label}」最多只能有 {max_rows} 行")
|
||
for index, row in enumerate(rows, start=1):
|
||
for column in columns:
|
||
column_key = str(column.get("key") or "")
|
||
if not column_key:
|
||
continue
|
||
# 勾了「只读」或「隐藏此列」那一列(设计器明细列上那两颗开关,与填单时锁格子、
|
||
# 收掉整列的是同一份 ``column.readonly`` / ``column.hidden``)压根没有录入框:
|
||
# 必填卡的是人,而这一列的值归默认值 /
|
||
# 自动带出 / 关联带出 / 额度台账给,照旧拦等于把单子钉死在这一环——那一格
|
||
# 谁也改不动,却永远说它没填。本行公式那一列不在其列:它没勾只读,公式算不
|
||
# 出值仍是配置坏了,该说。口径与主表 ``missing_required`` 同一取向(没有录入
|
||
# 框的那几类只在其值真归系统管时才算数),前端不摆红星也是同一句。
|
||
if (
|
||
column.get("required")
|
||
and not column_not_for_people(column)
|
||
and not answered(column, row.get(column_key))
|
||
):
|
||
problems.append(f"「{label}」第 {index} 行的「{column.get('label') or column_key}」还没填写")
|
||
# 列里那几样限制(字数、正则、取值上下限、月份写法、时间段先后、星期、附件三个限制)
|
||
# 照判:明细列与主表共用一只控件,只判主表等于在列上开了个口子。
|
||
#
|
||
# 这一问**不跟着必填走**——以前整段套在「没勾必填就跳过」里面,于是非必填的列
|
||
# 填了什么都没人看,那三道限制等于只在浏览器里说了算;接口直传与脚本写入的值
|
||
# 压根不经过那只框。判据仍是 value_problems 那一份,主表明细一个都不多判。
|
||
for problem in value_problems([column], {}, row):
|
||
problems.append(problem.replace(f"「{column.get('label') or column_key}」",
|
||
f"「{label}」第 {index} 行的「{column.get('label') or column_key}」", 1))
|
||
return problems
|
||
|
||
|
||
def validate_submit(
|
||
fields: Iterable[dict], perms: dict[str, str], data: dict, cache: object | None = None
|
||
) -> list[str]:
|
||
"""一次提交的表单校验;返回问题列表,空列表就是可以提交。"""
|
||
items = list(fields)
|
||
problems = missing_required(items, perms, data or {})
|
||
# 值本身合不合这一格的规矩(字数、正则、月份写法、时间段先后、附件的类型与大小):
|
||
# 界面上都挡过一遍,这里是有权威权的那一道,绕不过去。
|
||
problems.extend(value_problems(items, perms, data or {}))
|
||
for field in items:
|
||
if str(field.get("type") or "") != "table":
|
||
continue
|
||
key = str(field.get("key") or "")
|
||
if effective_perm(field, perms, data) == PERM_HIDDEN or not key:
|
||
continue
|
||
problems.extend(_row_problems(field, rows_of((data or {}).get(key))))
|
||
if problems:
|
||
break
|
||
problems.extend(selection_problems(items, perms, data or {}, cache))
|
||
return problems
|
||
|
||
|
||
def cascader_problems(fields: Iterable[dict], perms: dict[str, str], data: dict, cache: object) -> list[str]:
|
||
"""级联选择(``cascader``):值必须是一条从顶级字典项一路选到某个下级的完整路径。
|
||
|
||
这里不能套用普通下拉的「值必须在可选项里」:层级字典没配 ``cascadeFrom`` 时
|
||
``effective_options`` 只放顶级项,而级联控件天生就要选到第二、第三级,
|
||
照那套口径会把合法的值全判成越界。
|
||
"""
|
||
if cache is None:
|
||
return []
|
||
linkage = _linkage()
|
||
problems: list[str] = []
|
||
for field in fields:
|
||
if str(field.get("type") or "") != CASCADER_TYPE:
|
||
continue
|
||
key = str(field.get("key") or "")
|
||
code = str(field.get("dictCode") or "").strip()
|
||
if not key or not code:
|
||
continue
|
||
if effective_perm(field, perms, data) not in (PERM_EDITABLE, PERM_REQUIRED):
|
||
continue
|
||
picked = [str(item) for item in linkage._values(data.get(key))]
|
||
if not picked:
|
||
continue
|
||
label = str(field.get("label") or key)
|
||
items = {
|
||
str(item.get("value")): item for item in cache.items(code) if item.get("enabled", True) # type: ignore[attr-defined]
|
||
}
|
||
previous = ""
|
||
for depth, value in enumerate(picked):
|
||
item = items.get(value)
|
||
if item is None:
|
||
problems.append(f"「{label}」选到了字典里不存在或已停用的选项")
|
||
break
|
||
parent = str(item.get("parent") or "")
|
||
if not depth and parent:
|
||
problems.append(f"「{label}」要先选上一级")
|
||
break
|
||
if depth and parent != previous:
|
||
problems.append(f"「{label}」的上下级对不上")
|
||
break
|
||
previous = value
|
||
return problems
|
||
|
||
|
||
def selection_problems(fields: Iterable[dict], perms: dict[str, str], data: dict, cache: object) -> list[str]:
|
||
"""联动可选范围校验:选中的值必须是此刻真的能选的项。
|
||
|
||
只管本环节可编辑的字段:陈年旧值不该由一个改不动它的审批人来背锅。
|
||
"""
|
||
if cache is None:
|
||
return []
|
||
linkage = _linkage()
|
||
problems: list[str] = cascader_problems(fields, perms, data, cache)
|
||
for field in fields:
|
||
key = str(field.get("key") or "")
|
||
if not key or effective_perm(field, perms, data) not in (PERM_EDITABLE, PERM_REQUIRED):
|
||
continue
|
||
if not _has_option_rule(field, data):
|
||
continue
|
||
options = linkage.effective_options(field, data, cache) # type: ignore[arg-type]
|
||
if options is None:
|
||
continue
|
||
# 命中哪一条候选来源,就按那一条的「存哪一列」比(effective_options 内部是同一张视图)
|
||
view = linkage.option_view(field, data)
|
||
# 比的是这一格**存的那一列**:配过「显示 / 存值」的字段,候选本体与存的值不是一回事
|
||
allowed = {linkage.stored_of(view, item) for item in options}
|
||
current = linkage._values(data.get(key))
|
||
stale = [value for value in current if value not in allowed]
|
||
if stale:
|
||
if linkage.accepts_outside_value(field):
|
||
# 这一格勾了「带出的值不在候选里也收下」:值是外部取数 / 关联单据带出 / 字典带出
|
||
# 写进来的(三道带出都排在这一次校验之前),本地那份清单不判对面给的值
|
||
continue
|
||
parent = str(view.get("cascadeFrom") or "").strip()
|
||
hint = f"(请先选对「{label_of(fields, parent)}」)" if parent else ""
|
||
if _kernel().entries(field.get("fetch")) or linkage.has_route_fill(field):
|
||
# 那一格不是人选的,是提交这一刻外部取数(或候选路由自带的那份带出)写进来的。
|
||
# 不说这句,填单的人就只能站在一个自己填不了的格子前问「这个值是哪来的」
|
||
problems.append(
|
||
f"「{field.get('label') or key}」由外部取数带回的取值不在可选范围内"
|
||
f"(候选来自{'数据字典' if str(view.get('dictCode') or '').strip() else '手填选项'},"
|
||
"把那一项补进清单,或把这一格的候选来源改成外部数据源 / 流程单据)"
|
||
)
|
||
continue
|
||
problems.append(f"「{field.get('label') or key}」的取值已不在可选范围内{hint}")
|
||
return problems
|
||
|
||
|
||
def label_of(fields: Iterable[dict], key: str) -> str:
|
||
for field in fields:
|
||
if str(field.get("key") or "") == key:
|
||
return str(field.get("label") or key)
|
||
return key
|
||
|
||
|
||
def _has_option_rule(field: dict, data: dict | None = None) -> bool:
|
||
"""这个字段的可选项会不会随别的字段变化(字典 / 级联 / 带条件的选项)。"""
|
||
linkage = _linkage()
|
||
# 候选来自流程单据 / 外部数据源的格子:服务端手上只有搜出来的那一页,
|
||
# 拿它当合法值清单会把人正常选中的单据判成越界,这一类交给对面系统说话。
|
||
if not linkage.constrains_values(field, data):
|
||
return False
|
||
if str(field.get("type") or "") == CASCADER_TYPE:
|
||
# 级联的合法值口径不一样,走 cascader_problems
|
||
return False
|
||
view = linkage.option_view(field, data)
|
||
if str(view.get("dictCode") or "").strip():
|
||
return True
|
||
if str(view.get("cascadeFrom") or "").strip():
|
||
return True
|
||
raw = view.get("options")
|
||
if isinstance(raw, list):
|
||
return any(isinstance(item, dict) and item.get("when") for item in raw)
|
||
return False
|
||
|
||
|
||
def linkage_problems(fields: Iterable[dict]) -> list[str]:
|
||
"""设计期检查联动配置本身:引用了不存在的字段、级联上级选了自己、条件写了不认识的算子。
|
||
|
||
**联动条件读自己不再是配错**(2026-11 起):「外部带回来的合同编号有值才露这一格」判的
|
||
正是这一格自己的值,前端界面上也摆得出这一档(``LinkagePanel.conditionSources`` 把本字段
|
||
留在清单最前面),后端再报这一句就成了一处配得出来、另一处不让存的死结。
|
||
"""
|
||
items = [item for item in fields if isinstance(item, dict)]
|
||
keys = {str(item.get("key") or "") for item in items}
|
||
linkage = _linkage()
|
||
problems: list[str] = []
|
||
for field in items:
|
||
key = str(field.get("key") or "")
|
||
label = str(field.get("label") or key)
|
||
# 级联上级选到自己还是配错:候选得由另一格来筛,自己筛自己筛不出东西。
|
||
# 联动条件读自己是正常用法;带出规则读自己同样是常态(从本字段的字典项里取 extra)。
|
||
if str(field.get("cascadeFrom") or "").strip() == key:
|
||
problems.append(f"「{label}」的级联上级选了它自己")
|
||
for dep in linkage.condition_dependencies(field):
|
||
if dep != key and dep not in keys:
|
||
problems.append(f"「{label}」的联动条件引用了不存在的字段「{dep}」")
|
||
for dep in linkage.auto_fill_dependencies(field):
|
||
if dep != key and dep not in keys:
|
||
problems.append(f"「{label}」的带出规则引用了不存在的字段「{dep}」")
|
||
for dep in linkage.auto_fill_targets(field):
|
||
if dep not in keys:
|
||
problems.append(f"「{label}」的带出规则写向了不存在的字段「{dep}」")
|
||
elif dep == key:
|
||
problems.append(f"「{label}」的带出规则不能写回自己")
|
||
for name in ("visibleWhen", "requiredWhen", "readonlyWhen"):
|
||
condition = field.get(name)
|
||
if condition in (None, "", {}, []):
|
||
continue
|
||
if not isinstance(condition, dict):
|
||
problems.append(f"「{label}」的「{name}」配置格式不对")
|
||
continue
|
||
for rule in condition.get("rules") or []:
|
||
if not isinstance(rule, dict):
|
||
continue
|
||
if str(rule.get("op") or "eq") not in linkage.CONDITION_OPS:
|
||
problems.append(f"「{label}」的「{name}」用了不支持的比较符 {rule.get('op')}")
|
||
# 条件左右两头挑的是同一格:自己跟自己比永远比不出新意思,配了也是白配。
|
||
# (两边值的形状比不了就不给挑,那一档只在前端收窄:后端没有那份类型矩阵。)
|
||
right = str(rule.get("valueField") or "").strip()
|
||
left = str(rule.get("field") or "").strip()
|
||
if right and right == left:
|
||
problems.append(f"「{label}」的联动条件拿「{label_of(items, left)}」和自己比")
|
||
return problems
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 明细表
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def columns_of(field: dict) -> list[dict]:
|
||
raw = field.get("columns")
|
||
return [item for item in raw if isinstance(item, dict)] if isinstance(raw, list) else []
|
||
|
||
|
||
def table_column_types() -> tuple[str, ...]:
|
||
return TABLE_COLUMN_TYPES
|
||
|
||
|
||
def _int(value: object, default: int = 0) -> int:
|
||
try:
|
||
return int(value) # type: ignore[arg-type]
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def column_not_for_people(column: dict) -> bool:
|
||
"""这一列的值归不归人填:勾了只读、整列藏起来,两样都是"人改不动这一格"。
|
||
|
||
必填卡的是人,所以这两样都不卡必填,前端也不摆那颗红星
|
||
(前端镜像 ``utils/formRuntime.columnNotForPeople``)。本行公式那一列**不在这一问里**:
|
||
它没勾只读,公式算不出值仍是配置坏了,照旧要说。
|
||
"""
|
||
return bool(column.get("readonly")) or bool(column.get("hidden"))
|
||
|
||
|
||
def column_display_problems(column: dict) -> list[str]:
|
||
"""明细列在表格上怎么摆的那三样(列宽 / 对齐 / 合计)配得对不对(设计期)。
|
||
|
||
这三样是纯展现:不改任何一格的值,也不参与提交那道闸,所以只判"配置本身认不认识"。
|
||
与前端 ``utils/formRuntime.validateTableField`` 同一把尺子。
|
||
"""
|
||
problems: list[str] = []
|
||
raw = column.get("width")
|
||
if raw not in (None, "", 0):
|
||
width = _number(raw)
|
||
if width is None or width < COLUMN_WIDTH_MIN or width > COLUMN_WIDTH_MAX:
|
||
problems.append(f"的列宽要在 {COLUMN_WIDTH_MIN}-{COLUMN_WIDTH_MAX}px 之间,或留「自动」")
|
||
align = column.get("align")
|
||
if align not in (None, "") and str(align) not in COLUMN_ALIGNMENTS:
|
||
problems.append(f"的对齐方式不认识:{align}")
|
||
aggregate = column.get("aggregate")
|
||
if aggregate not in (None, "") and str(aggregate) not in COLUMN_AGGREGATES:
|
||
problems.append(f"的合计方式不认识:{aggregate}")
|
||
elif str(aggregate or "") not in ("", "none", "count") and str(column.get("type") or "") not in NUMERIC_AGGREGATE_TYPES:
|
||
problems.append("不是数字或金额列,合计只能数个数")
|
||
low = _number(column.get("min"))
|
||
high = _number(column.get("max"))
|
||
if low is not None and high is not None and low > high:
|
||
problems.append("的最小值大于最大值")
|
||
return problems
|
||
|
||
|
||
def row_is_empty(row: dict, columns: list[dict]) -> bool:
|
||
keys = [str(item.get("key") or "") for item in columns] or list(row.keys())
|
||
# 带出那一行本来就可能是空的:对方那张单里这一列没填,行还是那一张单的,删掉等于把关联弄丢
|
||
if str(row.get(ROW_LINK_KEY) or "").strip():
|
||
return False
|
||
return all(empty_value({"__value__": row.get(key)}) for key in keys)
|
||
|
||
|
||
def max_rows_of(field: dict) -> int:
|
||
"""这一张明细表最多几行;0 / 没配 = 不限。口径只在这一处(``normalise_rows`` 与关联带出共用)。"""
|
||
return _int((field or {}).get("maxRows"), 0)
|
||
|
||
|
||
def rows_of(value: object) -> list[dict]:
|
||
"""把明细表字段的值收成对象数组;脏数据、标量、嵌套数组一律丢掉。"""
|
||
if not isinstance(value, list):
|
||
return []
|
||
return [dict(item) for item in value if isinstance(item, dict)]
|
||
|
||
|
||
#: 明细行上记「这一行是谁带出来的」那一格。下划线开头 = 服务端自己写的留痕,
|
||
#: 导出、打印、明细导出都只认配好的列,看不见它;写它的人是 ``service/linkfill.py``。
|
||
ROW_LINK_KEY = "_link"
|
||
|
||
#: 明细行上记「这几列的公式值是人自己敲的」那一格(存列标识的数组),与 ``_link`` 同一层。
|
||
#: 写它的是前端 ``FormRenderer.setFormulaCell``,读它的是 ``utils/formRuntime.applyRowFormulas``。
|
||
#: 服务端一路只当它是行上的一份留痕:本行公式只有前端会算,所以这里**只负责带着它走**
|
||
#: (``normalise_rows`` 别把它当野键丢掉),一旦哪天服务端也参与重算,判据仍是这一份。
|
||
#: 只有列上勾了「公式带入后允许修改」(``column.formulaEditable``)才会出现它。
|
||
ROW_MANUAL_KEY = "_manual"
|
||
|
||
#: 能配「默认值」的明细列类型,与前端 ``COLUMN_DEFAULT_TYPES`` 一致。
|
||
#: 只收装得下单个值的那几类:多选、选人、部门、附件、图片、签名、日期区间、关联单据
|
||
#: 一格装的不止一个值,级联要的是整条路径——默认成什么都是设计器替人做主,不开这个口子。
|
||
COLUMN_DEFAULT_TYPES = (
|
||
"text",
|
||
"textarea",
|
||
"number",
|
||
"money",
|
||
"date",
|
||
"datetime",
|
||
"time",
|
||
"month",
|
||
"year",
|
||
"select",
|
||
"radio",
|
||
"switch",
|
||
"rate",
|
||
)
|
||
|
||
#: 默认值的写法,对齐界面上那几种原生输入框(date / datetime-local / time)的取值。
|
||
_DEFAULT_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
|
||
_DEFAULT_DATETIME = re.compile(r"^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}")
|
||
_DEFAULT_TIME = re.compile(r"^\d{2}:\d{2}")
|
||
_DEFAULT_MONTH = re.compile(r"^\d{4}-(0[1-9]|1[0-2])$")
|
||
_DEFAULT_YEAR = re.compile(r"^\d{4}$")
|
||
_DEFAULT_CLOCK = re.compile(r"^([01]\d|2[0-3]):[0-5]\d$")
|
||
|
||
|
||
def _number(raw: object) -> float | None:
|
||
try:
|
||
return float(str(raw).strip())
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def _default_text(raw: object) -> str:
|
||
"""把 ``defaultValue`` 收成比对的文本;布尔 ``True`` 按前端一样写作 ``true``。"""
|
||
if isinstance(raw, bool):
|
||
return "true" if raw else ""
|
||
return str(raw if raw is not None else "").strip()
|
||
|
||
|
||
def column_default_problem(column: dict) -> str:
|
||
"""这一列的默认值写歪了没有:写歪给一句人话,能用回空串。
|
||
|
||
与前端 ``utils/formRuntime.columnDefaultProblem`` 同一把尺子。默认值写歪不会挡住保存,
|
||
只会让那一格永远是空的,还得填单的人自己去猜为什么,所以设计器里就得说清楚。
|
||
"""
|
||
raw = column.get("defaultValue")
|
||
text = _default_text(raw)
|
||
if not text:
|
||
return ""
|
||
kind = str(column.get("type") or "")
|
||
shown = f"「{text}」"
|
||
if kind not in COLUMN_DEFAULT_TYPES:
|
||
return f"是 {kind or '未设置'} 列,配不了默认值"
|
||
if kind in ("number", "money"):
|
||
return "" if _number(text) is not None else f"{shown}不是数字,默认值填不进数字格"
|
||
if kind == "rate":
|
||
stars = _number(text)
|
||
top = _int(column.get("max"), 5) or 5
|
||
if stars is None or not float(stars).is_integer() or not 1 <= stars <= top:
|
||
return f"{shown}不是 1-{top} 之间的整数星级"
|
||
return ""
|
||
if kind == "switch":
|
||
return "" if text in ("true", "1") else f"{shown}不是开关认的值(只能选「默认打开」)"
|
||
if kind == "date":
|
||
return "" if _DEFAULT_DATE.match(text) else f"{shown}不是 2026-01-31 这样的日期"
|
||
if kind == "datetime":
|
||
return "" if _DEFAULT_DATETIME.match(text) else f"{shown}不是 2026-01-31 09:00 这样的日期时间"
|
||
if kind == "time":
|
||
return "" if _DEFAULT_TIME.match(text) else f"{shown}不是 09:30 这样的时间"
|
||
if kind == "month":
|
||
return "" if _DEFAULT_MONTH.match(text) else f"{shown}不是 2026-01 这样的月份"
|
||
if kind == "year":
|
||
return "" if _DEFAULT_YEAR.match(text) else f"{shown}不是 2026 这样的年份"
|
||
# 下拉与单选:静态选项时得选得到一个;绑字典的条目在这儿读不到,交给提交那道闸判。
|
||
if kind in ("select", "radio") and not str(column.get("dictCode") or "").strip():
|
||
options = column.get("options")
|
||
options = options if isinstance(options, list) else []
|
||
if options and not any(
|
||
str((item or {}).get("value") if isinstance(item, dict) else item).strip() == text for item in options
|
||
):
|
||
return f"默认值「{text}」不在这一列的选项里"
|
||
return ""
|
||
|
||
|
||
def column_default(column: dict) -> Any:
|
||
"""这一列真正能落进格子的默认值;没配、类型不支持、写歪、归本行公式算,一律回 ``None``。
|
||
|
||
塑形口径与前端 ``columnDefault`` 一致:数字那三类存数,日期时间存控件认的 ``T`` 写法,
|
||
开关只有「默认打开」值得写(关着本来就等于没配)。
|
||
"""
|
||
if str(column.get("formula") or "").strip():
|
||
return None
|
||
if column_default_problem(column):
|
||
return None
|
||
raw = column.get("defaultValue")
|
||
text = _default_text(raw)
|
||
if not text:
|
||
return None
|
||
kind = str(column.get("type") or "")
|
||
if kind in ("number", "money", "rate", "year"):
|
||
value = _number(text)
|
||
if value is None:
|
||
return None
|
||
return int(value) if float(value).is_integer() else value
|
||
if kind == "switch":
|
||
return True
|
||
return text.replace(" ", "T") if kind == "datetime" else text
|
||
|
||
|
||
def fill_row_defaults(columns: list[dict], row: dict) -> dict:
|
||
"""把配了默认值的列补齐:只补还空着的那一格,别人填过的一个都不动。"""
|
||
fillers = [(str(item.get("key") or ""), column_default(item)) for item in columns]
|
||
targets = [(key, value) for key, value in fillers if key and value is not None]
|
||
for key, value in targets:
|
||
if empty_value({"__value__": row.get(key)}):
|
||
row[key] = value
|
||
return row
|
||
|
||
|
||
def normalise_rows(value: object, field: dict) -> list[dict]:
|
||
"""落库前的整型:只留认识的列、丢空行、补齐默认值、按 ``maxRows`` 截断。
|
||
|
||
默认值排在丢空行之后:整行没碰过的照样丢掉,别拿默认值凭空造出一行来;
|
||
添了行又只填了一格的人,其余空格则由默认值替他填好。
|
||
"""
|
||
columns = columns_of(field)
|
||
allowed = {str(item.get("key") or "") for item in columns}
|
||
rows: list[dict] = []
|
||
for row in rows_of(value):
|
||
# ``_link`` 与 ``_manual`` 都不在列清单里,但它们是「这一行是谁带出来的」
|
||
# 「哪几格归人管」的唯一凭据:页面回传时丢掉前者,下一次带出认不出旧行,
|
||
# 会把人改过的行当新行重排一遍;丢掉后者,下一轮重算就把人家自己敲的数盖回公式值
|
||
kept = {
|
||
k: v
|
||
for k, v in row.items()
|
||
if not allowed or k in allowed or k in (ROW_LINK_KEY, ROW_MANUAL_KEY)
|
||
}
|
||
if row_is_empty(kept, columns):
|
||
continue
|
||
rows.append(fill_row_defaults(columns, kept))
|
||
max_rows = max_rows_of(field)
|
||
return rows[:max_rows] if max_rows else rows
|
||
|
||
|
||
def column_total(value: object, field: dict, column_key: str = "") -> float:
|
||
"""明细表某一列的合计;不传列名时取第一个数值列。"""
|
||
columns = columns_of(field)
|
||
target = str(column_key or "")
|
||
if not target:
|
||
numeric = [
|
||
str(item.get("key") or "")
|
||
for item in columns
|
||
if str(item.get("type") or "") in ("number", "money")
|
||
]
|
||
target = numeric[0] if numeric else ""
|
||
if not target:
|
||
return 0.0
|
||
total = 0.0
|
||
for row in rows_of(value):
|
||
try:
|
||
total += float(row.get(target) or 0)
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return round(total, 2)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 计算公式字段
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
def formula_fields(fields: Iterable[dict]) -> list[dict]:
|
||
out: list[dict] = []
|
||
for item in fields:
|
||
if str(item.get("type") or "") != "formula":
|
||
continue
|
||
if not str(item.get("formula") or "").strip():
|
||
continue
|
||
if not str(item.get("key") or "").strip():
|
||
continue
|
||
out.append(item)
|
||
return out
|
||
|
||
|
||
def compute_formulas(fields: Iterable[dict], data: dict, context: dict) -> dict:
|
||
"""按公式重算 ``formula`` 字段,返回算出来的增量。
|
||
|
||
单个字段算不出来不影响别的字段:把错的那格留空并记进 ``_formulaErrors``,
|
||
界面据此提示,流程不会被一个写坏的表达式卡死。
|
||
"""
|
||
from ..engine import expressions # 延迟导入:engine 反过来会 import 本模块
|
||
|
||
items = formula_fields(fields)
|
||
if not items:
|
||
return {}
|
||
payload = {**context, "data": {**(data or {})}}
|
||
out: dict[str, Any] = {}
|
||
errors: dict[str, str] = {}
|
||
for item in items:
|
||
key = str(item.get("key") or "")
|
||
source = str(item.get("formula") or "")
|
||
payload["data"] = {**(data or {}), **out}
|
||
try:
|
||
value = expressions.evaluate(source, payload)
|
||
except expressions.ExpressionError as exc:
|
||
errors[key] = str(exc)
|
||
continue
|
||
out[key] = _plain(value)
|
||
if out:
|
||
data.update(out)
|
||
if errors:
|
||
data["_formulaErrors"] = errors
|
||
return out
|
||
|
||
|
||
def _plain(value: object) -> Any:
|
||
"""公式结果只留 JSON 存得下的类型,别的(日期、集合)统一转文本。"""
|
||
if value is None or isinstance(value, (str, int, float, bool)):
|
||
return value
|
||
if isinstance(value, (list, tuple)):
|
||
return [_plain(item) for item in value]
|
||
if isinstance(value, dict):
|
||
return {str(k): _plain(v) for k, v in value.items()}
|
||
return str(value)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 金额中文大写
|
||
# ---------------------------------------------------------------------------
|
||
|
||
_CN_NEGATIVE = "负"
|
||
_CN_ZERO = "零元整"
|
||
|
||
|
||
def chinese_upper(amount: object) -> str:
|
||
"""数字金额转中文大写,口径与财务票据一致(到角分,整尾补「整」)。"""
|
||
try:
|
||
value = float(amount) # type: ignore[arg-type]
|
||
except (TypeError, ValueError):
|
||
return ""
|
||
if value != value: # NaN
|
||
return ""
|
||
if abs(value) >= 1e16:
|
||
return ""
|
||
negative = value < 0
|
||
value = abs(round(value + 1e-9, 2))
|
||
yuan = int(value)
|
||
cents = int(round((value - yuan) * 100))
|
||
if yuan == 0 and cents == 0:
|
||
return _CN_ZERO
|
||
parts: list[str] = []
|
||
if yuan:
|
||
parts.append(_yuan_text(yuan))
|
||
jiao, fen = divmod(cents, 10)
|
||
if jiao == 0 and fen == 0:
|
||
parts.append("整")
|
||
else:
|
||
if jiao:
|
||
parts.append(f"{_CN_DIGITS[jiao]}角")
|
||
elif yuan:
|
||
parts.append("零")
|
||
if fen:
|
||
parts.append(f"{_CN_DIGITS[fen]}分")
|
||
elif jiao:
|
||
parts.append("整")
|
||
text = "".join(parts)
|
||
if not text:
|
||
text = _CN_ZERO
|
||
return (_CN_NEGATIVE if negative else "") + text
|
||
|
||
|
||
def _yuan_text(yuan: int) -> str:
|
||
"""元以上的部分,按四位一节拼 万 / 亿;不足四位的前面补零(壹佰零贰万零叁佰零肆)。"""
|
||
text = ""
|
||
group = 0
|
||
remaining = yuan
|
||
while remaining:
|
||
section = remaining % 10_000
|
||
remaining //= 10_000
|
||
if section:
|
||
# 低节不足四位说明中间空了高位,读出来要带个零。
|
||
lead = "零" if text and section < 1_000 else ""
|
||
text = _section_text(section) + _CN_GROUPS[group] + lead + text
|
||
group += 1
|
||
return f"{text}元"
|
||
|
||
|
||
def _section_text(section: int) -> str:
|
||
digits = [int(ch) for ch in str(section)]
|
||
length = len(digits)
|
||
out = ""
|
||
zero = False
|
||
for index, digit in enumerate(digits):
|
||
unit = _CN_UNITS[length - index - 1]
|
||
if digit == 0:
|
||
zero = True
|
||
continue
|
||
if zero and out:
|
||
out += "零"
|
||
out += _CN_DIGITS[digit] + unit
|
||
zero = False
|
||
return out
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 设计器校验(前端 validateFields 的服务端镜像)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
#: 带「单位」这一栏的字段类型:数字、金额、计算公式三类共用同一套数字展现配置,
|
||
#: 与前端 ``FieldInspector.NUMBER_FORMAT_TYPES`` 一致。明细表列没有公式,只有前两类。
|
||
UNIT_FIELD_TYPES = ("number", "money", "formula")
|
||
UNIT_COLUMN_TYPES = ("number", "money")
|
||
#: 单位只是贴在数字框里侧的一小截后缀,超宽会把明细表的格子顶开。
|
||
UNIT_MAX_LENGTH = 8
|
||
#: 纯数字(含符号、小数、千分位)不算单位。
|
||
_NUMERIC_UNIT = re.compile(r"^[-+]?[\d,.]+$")
|
||
|
||
|
||
def unit_problem(raw: object) -> str:
|
||
"""「单位」这一栏写得能不能用,能用回空串。
|
||
|
||
单位是贴在数字框里侧的后缀(``1,200.00 元`` 后面那一小截灰字),不是值。
|
||
填成一个数字(费用报销单曾被填成 ``11``)就麻烦了:它跟输入框里的数值长得
|
||
一模一样,填单的人只会问「这个 11 是哪来的」,说不清是自己填的还是系统算的;
|
||
导出、大写金额、条件分支读的都是数值,这一栏从头到尾只影响观感。
|
||
"""
|
||
unit = str(raw or "").strip()
|
||
if not unit:
|
||
return ""
|
||
if _NUMERIC_UNIT.match(unit):
|
||
return (
|
||
f"「{unit}」是个数字:它会贴在数字框里侧,看着就像填进去的数值。"
|
||
"请写单位(如「元」)或留空"
|
||
)
|
||
if len(unit) > UNIT_MAX_LENGTH:
|
||
return f"「{unit}」太长了,最多 {UNIT_MAX_LENGTH} 个字符"
|
||
return ""
|
||
|
||
|
||
def display_unit(raw: object) -> str:
|
||
"""真贴得出去的单位;配歪的一律当没配(调用方决定要不要补默认值)。
|
||
|
||
新校验只管保存那一刻,库里已经躺着的老表单不会被追溯改写,渲染这层再兜一道:
|
||
「11」这种单位与其在数字框里演一个数值,不如什么都不显示。
|
||
"""
|
||
unit = str(raw or "").strip()
|
||
return "" if not unit or unit_problem(unit) else unit
|
||
|
||
|
||
def data_source_row(db, code: str):
|
||
"""候选来源指向的那张数据源;没给 ``db``(设计器镜像那一份)就不去查库。"""
|
||
if db is None or not str(code or "").strip():
|
||
return None
|
||
from sqlalchemy import select
|
||
|
||
from .. import models
|
||
|
||
return db.execute(
|
||
select(models.DataSource).where(models.DataSource.code == str(code).strip())
|
||
).scalar_one_or_none()
|
||
|
||
|
||
def _source_config_problems(field: dict, kind: str, db=None, keys: set[str] | None = None) -> list[str]:
|
||
"""一套候选来源配到底了没有:半截的配置、指向的源不能用、入参引用掉在地上。
|
||
|
||
字段自己那一份(兜底配置)与条件路由里的每一条都问这一句——**同一套判据,
|
||
只不过换了一张视图**,所以两条路不会一边放行一边报错。措辞是给面板原样显示的,
|
||
前端镜像在 ``utils/optionSource.ts``。
|
||
"""
|
||
linkage = _linkage()
|
||
kernel = _kernel()
|
||
problems: list[str] = []
|
||
if kind == linkage.SOURCE_DICT and not str(field.get("dictCode") or "").strip():
|
||
problems.append("还没选择要用的数据字典")
|
||
source_code = str(field.get("dataSourceCode") or "").strip()
|
||
args_at = "候选来源那张数据源"
|
||
if kind == linkage.SOURCE_DATA_SOURCE and not source_code:
|
||
problems.append("还没选择要用哪一张外部数据源")
|
||
if kind == linkage.SOURCE_DATA_SOURCE and source_code:
|
||
if db is not None:
|
||
# 源被删 / 停用 / 是取一个值的 / 方向只在往外写:填单那一格只会是一个空下拉。
|
||
# 判据与「字段上的外部取数」「字典绑的外部来源」共用内核那一句(service/binding.py)
|
||
reason = kernel.source_problem(
|
||
source_code, data_source_row(db, source_code),
|
||
want=kernel.WANT_SEARCH, want_noun="候选",
|
||
)
|
||
if reason:
|
||
problems.append(reason)
|
||
problems.extend(kernel.arg_ref_problems(
|
||
field.get(OPTION_ARGS_KEY), keys or set(), args_at,
|
||
self_ref=str(field.get("key") or "").strip(),
|
||
))
|
||
# 手填那条路:每个选项自己填「显示文字」和「存的值」,存的值空着等于选了就存个空白
|
||
if kind == linkage.SOURCE_MANUAL:
|
||
raw_options = field.get("options")
|
||
blank = [
|
||
item
|
||
for item in (raw_options if isinstance(raw_options, list) else [])
|
||
if isinstance(item, dict) and not str(item.get("value") or "").strip()
|
||
]
|
||
if blank:
|
||
problems.append(f"有 {len(blank)} 个选项没填要存的值,填了会存成空白")
|
||
if kind == linkage.SOURCE_PROCESS:
|
||
# 「关联已审批流程」挑到一张被终止的单子,是这一格最常见的一种配歪:
|
||
# 能挂哪几档由字段上说清,勾到一种都不剩就先挡下来,别留一只永远搜不到东西的挑选器
|
||
problems.extend(linkage.relation_status_problems(field))
|
||
# 候选范围(只给我发起的 / 与我相关)写歪了同样先说一句:界面上挑不出歪值,
|
||
# 歪值只从接口直传与 AI 起草那两条路进来,服务端认不出来会照默认那一档走
|
||
problems.extend(linkage.relation_scope_problems(field))
|
||
return problems
|
||
|
||
|
||
def _fetch_entries(field: dict) -> list[dict]:
|
||
"""这一格身上所有会跑的取数条目:字段那份 ``fetch`` +候选路由各条自带的 ``fill``。"""
|
||
linkage = _linkage()
|
||
kernel = _kernel()
|
||
listed = list(kernel.entries(field.get("fetch")))
|
||
listed.extend(
|
||
entry
|
||
for entry in (linkage.route_fill_entry(route) for route in linkage.routes_of(field))
|
||
if entry
|
||
)
|
||
return listed
|
||
|
||
|
||
def _fetch_targets(field: dict) -> set[str]:
|
||
"""这份取数写进哪些格子(``picks`` 的那些去向;候选路由那条 fill 的去向也算在这儿)。"""
|
||
out: set[str] = set()
|
||
for entry in _fetch_entries(field):
|
||
out |= {str(target) for target in (entry.get("picks") or {}).values()}
|
||
return out
|
||
|
||
|
||
def _fetch_writes(field: dict, key: str) -> bool:
|
||
"""有没有一条取数落在**这一格**上:条目自带的 ``pick`` 是取一个值写进它自己那一格,
|
||
``picks`` 里点名这一格也算。
|
||
"""
|
||
if key and key in _fetch_targets(field):
|
||
return True
|
||
return any(str(entry.get("pick") or "").strip() for entry in _fetch_entries(field))
|
||
|
||
|
||
def _rule_hits_self(rules: Any, key: str) -> bool:
|
||
"""``autoFill`` / ``linkFill`` 那两类带出的去向里有没有这一格(配在发起那一格身上,写的是别的格子)。"""
|
||
if not key or not isinstance(rules, list):
|
||
return False
|
||
return any(
|
||
isinstance(rule, dict) and str(rule.get("to") or "").strip() == key for rule in rules
|
||
)
|
||
|
||
|
||
def filled_by_other(field: dict, rows: Iterable[dict]) -> str:
|
||
"""隔壁那一格的带出有没有指着这一格(那同样是系统写进来的值,回那一种带出的名字)。
|
||
|
||
认四种去向:字典带出(``autoFill[].to``)、关联单据带出(``linkFill.rules[].to``)、
|
||
外部取数(``fetch`` 各条目的 ``picks``)与候选路由那一条自带的 ``fill``。只认
|
||
「去向正好等于这一格的字段名」——明细列那种 ``表.列`` 的写法不算,那一格在表里,
|
||
这一句问的是主表这一格。
|
||
"""
|
||
key = str(field.get("key") or "").strip()
|
||
if not key:
|
||
return ""
|
||
linkage = _linkage()
|
||
kernel = _kernel()
|
||
relation = _relation_fill()
|
||
fetched = False
|
||
for other in rows or []:
|
||
if not isinstance(other, dict) or str(other.get("key") or "").strip() == key:
|
||
continue
|
||
if _rule_hits_self(other.get("autoFill"), key):
|
||
return "字典带出"
|
||
if key in relation.targets(other):
|
||
return "关联单据带出"
|
||
# 隔壁那条取数只有**去向点名这一格**才算(它自带的 pick 写的是它自己那一格)
|
||
if key in _fetch_targets(other):
|
||
fetched = True
|
||
return "外部取数" if fetched else ""
|
||
|
||
|
||
def filled_by_label(field: dict, rows: Iterable[dict] | None = None) -> str:
|
||
"""这一格的值是不是**系统带进来的**,是哪一种带出(报错与提示要说清是哪一头)。
|
||
|
||
三种带出都排在提交校验之前跑:外部取数(``fetch``)、关联单据带出(``linkFill``)、
|
||
字典带出(``autoFill``)。判的是**有没有一条带出的落点在这一格上**,不是「这一格有没有
|
||
配带出」——后两类都配在发起那一格身上、写进的是别的格子,光看有没有配会把人挑的那一格
|
||
说成是系统写的(生产上「项目名称」配了字典带出,反被提醒「这一格的值由字典带出写入」)。
|
||
都没落上就是这一格由人填,回空串。
|
||
给了同表其它字段(``rows``)时还认**隔壁那一格的带出指着这一格**——那同样是系统写的值:
|
||
一张下拉自己没配带出、值却是隔壁带进来的,不该再说「这一档不起作用」。
|
||
"""
|
||
key = str(field.get("key") or "").strip()
|
||
if _fetch_writes(field, key):
|
||
# 候选路由自带的那一份带出走的是也是取数内核,同一句判据(fillOnly 那一档不写自己)
|
||
return "外部取数"
|
||
fill = field.get("linkFill")
|
||
if isinstance(fill, dict) and _rule_hits_self(fill.get("rules"), key):
|
||
return "关联单据带出"
|
||
if _rule_hits_self(field.get("autoFill"), key):
|
||
return "字典带出"
|
||
if rows is None:
|
||
return ""
|
||
return filled_by_other(field, rows)
|
||
|
||
|
||
def option_source_problems(
|
||
field: dict, db=None, keys: set[str] | None = None, rows: Iterable[dict] | None = None
|
||
) -> list[str]:
|
||
"""候选来源与挑选方式配到哪一步了,几句话说明白(前端镜像 ``utils/optionSource.optionSourceProblems``)。
|
||
|
||
管三类毛病:配得半截(选了字典没挑字典、选了源没挑源、样式跟这一格不搭)、
|
||
指向的源已经不能用(删了 / 停了 / 不是列表型 / 方向只在往外写),以及这一格同时
|
||
挂着外部取数、两边口径互相打脸。前两类是「存得下来、填单时那一格是空的」,
|
||
第三类是「界面看着挺好、提交那一刻被拦」,都在保存这一刻挡下来。
|
||
|
||
``db`` 不给就只判写法与结构(前端镜像那份拿不到库);``keys`` 是同一张表单里
|
||
已有的字段名,用来判候选入参里的 ``{form.x}`` 引用有没有掉在地上。
|
||
"""
|
||
linkage = _linkage()
|
||
kernel = _kernel()
|
||
field_type = str(field.get("type") or "")
|
||
if field_type not in linkage.OPTION_SOURCE_TYPES:
|
||
return []
|
||
kinds = linkage.source_kinds_of(field_type)
|
||
problems: list[str] = []
|
||
declared = str(field.get("optionSource") or "").strip()
|
||
if declared and declared not in kinds:
|
||
problems.append(f"这类字段挑不了「{declared}」这种候选来源,请重新选一个")
|
||
kind = linkage.source_kind_of(field)
|
||
problems.extend(_source_config_problems(field, kind, db, keys))
|
||
# 勾了「可以选好几个」之后这一格存的是一串值:额度与外部取数那两头都只认一笔 / 一个值
|
||
if linkage.holds_list_value(field) and isinstance(field.get("quota"), dict):
|
||
problems.append(
|
||
"这一格控一笔额度,只能挑一笔:勾了「可以选好几个」之后额度那一头认不出选中的是哪一笔,请取消多选"
|
||
)
|
||
if linkage.holds_list_value(field) and kernel.entries(field.get("fetch")):
|
||
problems.append(
|
||
"这一格的值由外部取数写入,取的是一笔;勾了「可以选好几个」之后两边存的形状对不上,请取消多选"
|
||
)
|
||
if linkage.holds_list_value(field) and isinstance(field.get("threshold"), dict):
|
||
problems.append(
|
||
"这一格的阈值条件比的是一个值;勾了「可以选好几个」之后这条条件多半永远不命中,"
|
||
"请取消多选或换个格子"
|
||
)
|
||
problems.extend(linkage.option_map_problems(field))
|
||
problems.extend(linkage.picker_display_problems(field))
|
||
filled_by = filled_by_label(field, rows)
|
||
if linkage.accepts_outside_value(field):
|
||
if not isinstance(field.get(linkage.ALLOW_OUTSIDE_VALUE_KEY), bool):
|
||
problems.append("「带出的值不在候选里也收下」这一档要勾成是或否")
|
||
if not filled_by:
|
||
problems.append(
|
||
"这一格没配任何带出(外部取数 / 关联单据带出 / 字典带出),"
|
||
"「带出的值不在候选里也收下」这一档暂时不起作用"
|
||
)
|
||
if filled_by and linkage.constrains_values(field) and not linkage.accepts_outside_value(field):
|
||
# 这一格的值是提交那一刻由系统写进来的,而候选是判越界的那两种来源:
|
||
# 两边各自都配得对,凑一起必定在 selection_problems 上炸给填单的人看
|
||
problems.append(
|
||
f"这一格的值由{filled_by}写入,候选又来自{'手填选项' if kind == linkage.SOURCE_MANUAL else '数据字典'}"
|
||
":取回来的编码必须在那份清单里,否则提交时会被判「取值已不在可选范围内」。"
|
||
"请把带回来的值补进这份清单,把候选来源改成外部数据源 / 流程单据,"
|
||
"或勾上「带出的值不在候选里也收下」"
|
||
)
|
||
# 一串值配下拉不再是问题:那只下拉带勾选框,挑中的几条挂在框里(前端 ``Select`` 的 multiple)
|
||
style = str(field.get("pickerStyle") or "").strip()
|
||
if style and style not in linkage.PICKER_STYLES:
|
||
problems.append(f"挑选方式不认识:{style}")
|
||
elif style == "inline" and kind in linkage.SEARCHED_SOURCES:
|
||
problems.append("这一格的候选是搜出来的,铺不成一排,请改成下拉选项或弹出框")
|
||
# 条件路由那几条(``optionRoutes``):清单本身 + 每一条用的那一种来源,逐条再过一遍同一套判据
|
||
# 字典带出读的是字典项的附加值:字段上这一本与候选路由里那几本都没有,这一档就是空转
|
||
fills = field.get("autoFill")
|
||
if isinstance(fills, list) and fills and not str(field.get("dictCode") or "").strip() \
|
||
and not linkage.dict_route_codes(field):
|
||
problems.append(
|
||
"配了字典带出,可这一格没挂数据字典(字段上与候选来源那几条里都没有),这一档不起作用"
|
||
)
|
||
problems.extend(linkage.route_problems(field))
|
||
for index, route in enumerate(linkage.routes_of(field), start=1):
|
||
reasons = _source_config_problems(
|
||
linkage.route_view(field, route), linkage.route_source_of(route), db, keys
|
||
)
|
||
problems.extend(f"第 {index} 条候选来源:{text}" for text in reasons)
|
||
# 这一条自带的带出(``fill``):走外部取数那同一套判据——源在不在、入参引用掉没掉
|
||
# 在地上、带出去向那一格还在不在。门牌单独写「的带出」,不与这一条的候选配置串
|
||
entry = linkage.route_fill_entry(route)
|
||
if entry:
|
||
at = f"第 {index} 条候选来源的带出"
|
||
problems.extend(kernel.entry_problems(db, entry, keys or set(), at))
|
||
# 带出去向指着这一格自己不行:运行时那份是「只写带出去向」的,这一格那一个值
|
||
# 是人从候选里挑的(fetch.FILL_ONLY_KEY),写回它自己只会把人刚挑的那一笔盖掉
|
||
own = str(field.get("key") or "").strip()
|
||
if own:
|
||
for name, target in (entry.get("picks") or {}).items():
|
||
if str(target or "").strip() == own:
|
||
problems.append(
|
||
f"{at}不能把「{name}」带进自己:这一格的值是人从候选里挑的,"
|
||
"带出只写别的格子"
|
||
)
|
||
return problems
|
||
|
||
|
||
def validate_schema(fields: Iterable[dict], db=None) -> list[str]:
|
||
"""表单定义本身的问题:明细表没有可用列、公式为空、联动引用悬空等。
|
||
|
||
``db`` 给了才判得动「引用的数据源还在不在」那一类,设计器保存那条路要传。
|
||
"""
|
||
rows = [item for item in fields if isinstance(item, dict)]
|
||
field_keys = {str(item.get("key") or "").strip() for item in rows}
|
||
problems: list[str] = linkage_problems(rows)
|
||
# 「一张表单只有一个标签页」要数出现次数;记下第一个的位置,好跟前端说同一句话
|
||
tabs_at = 0
|
||
for index, field in enumerate(fields, start=1):
|
||
key = str(field.get("key") or "")
|
||
label = str(field.get("label") or key) or f"第 {index} 个字段"
|
||
kind = str(field.get("type") or "")
|
||
if kind == "table":
|
||
columns = columns_of(field)
|
||
if not columns:
|
||
problems.append(f"「{label}」还没有任何列")
|
||
seen: set[str] = set()
|
||
# 明细列的候选入参只能引用同一张表里的列名
|
||
column_keys = {str(item.get("key") or "").strip() for item in columns}
|
||
# 「选台账」那一列的选项由额度台账供,不要求表单自己配字典或静态选项
|
||
from . import quota as quota_service
|
||
|
||
picked = quota_service.pick_columns(field)
|
||
for column in columns:
|
||
column_key = str(column.get("key") or "").strip()
|
||
column_type = str(column.get("type") or "")
|
||
if not column_key:
|
||
problems.append(f"「{label}」有列没填列名")
|
||
elif column_key in seen:
|
||
problems.append(f"「{label}」列名「{column_key}」重复")
|
||
else:
|
||
seen.add(column_key)
|
||
if column_type not in TABLE_COLUMN_TYPES:
|
||
problems.append(f"「{label}」的列「{column.get('label') or column_key}」类型不支持:{column_type}")
|
||
# 选择类列得有个来源,不然填单时那一格是空的,谁也发现不了
|
||
column_label = str(column.get("label") or column_key)
|
||
sourced = (
|
||
bool(str(column.get("dictCode") or "").strip())
|
||
or bool(str(column.get("dataSourceCode") or "").strip())
|
||
or bool(column.get("options"))
|
||
)
|
||
if column_type == CASCADER_TYPE:
|
||
if not sourced:
|
||
problems.append(f"「{label}」的列「{column_label}」还没选择要用的层级字典")
|
||
elif column_type in OPTION_COLUMN_TYPES and not sourced and column_key not in picked:
|
||
problems.append(f"「{label}」的列「{column_label}」既没写选项也没选字典")
|
||
for reason in option_source_problems(column, db, column_keys, columns):
|
||
problems.append(f"「{label}」的列「{column_label}」{reason}")
|
||
if column_type in UNIT_COLUMN_TYPES:
|
||
reason = unit_problem(column.get("unit"))
|
||
if reason:
|
||
problems.append(f"「{label}」的列「{column_label}」的单位{reason}")
|
||
if column_type == MONTHS_TYPE:
|
||
for reason in months_config_problems(column):
|
||
problems.append(f"「{label}」的列「{column_label}」{reason}")
|
||
# 默认值写歪 = 表单存得下来、那一格却永远空着;带出来源那一条在
|
||
# ``autofill.problems`` 里一起判,两边都是保存那一刻挡下来。
|
||
default_problem = column_default_problem(column)
|
||
if default_problem:
|
||
problems.append(f"「{label}」的列「{column_label}」{default_problem}")
|
||
if column_type in TEXT_LIMIT_TYPES:
|
||
problems.extend(
|
||
f"「{label}」的列「{column_label}」{reason}" for reason in text_config_problems(column)
|
||
)
|
||
if column_type in FILE_LIMIT_TYPES:
|
||
problems.extend(
|
||
f"「{label}」的列「{column_label}」{reason}" for reason in file_config_problems(column)
|
||
)
|
||
# 列宽 / 对齐 / 合计 / 上下限:这一列在表格上怎么摆与数字管到哪儿,
|
||
# 写歪了都是"存得下来、看上去却没配",保存那一刻说清。
|
||
problems.extend(
|
||
f"「{label}」的列「{column_label}」{reason}" for reason in column_display_problems(column)
|
||
)
|
||
min_rows = _int(field.get("minRows"), 0)
|
||
max_rows = _int(field.get("maxRows"), 0)
|
||
if min_rows and max_rows and min_rows > max_rows:
|
||
problems.append(f"「{label}」的最少行数大于最多行数")
|
||
if kind == CASCADER_TYPE and not str(field.get("dictCode") or "").strip():
|
||
problems.append(f"「{label}」还没选择要用的层级字典")
|
||
for reason in option_source_problems(field, db, field_keys, rows):
|
||
problems.append(f"「{label}」{reason}")
|
||
# 关联单据带出:从挂着的那几张单里取哪一列、写进哪一格。指向掉在地上、合并档
|
||
# 与那一格的形状对不上,都是「存得下来、那一格永远是空的」,保存这一刻挡下来。
|
||
# 只有主表字段配得上这一层:明细列里的关联单带出是「一行生一批行」,没人能预期。
|
||
for reason in _relation_fill().problems(field, field_keys, rows):
|
||
problems.append(f"「{label}」{reason}")
|
||
if kind == "formula" and not str(field.get("formula") or "").strip():
|
||
problems.append(f"「{label}」还没有填写计算公式")
|
||
if kind in UNIT_FIELD_TYPES:
|
||
reason = unit_problem(field.get("unit"))
|
||
if reason:
|
||
problems.append(f"「{label}」的单位{reason}")
|
||
# 字数上限 / 校验正则 / 附件三个限制 / 空白格高度:配歪了当场说。
|
||
# 编译不过的正则在提交时会被判成「永远不匹配」,那一格从此谁都填不对,
|
||
# 比少配一项严重得多,不能留到运行时。
|
||
if kind in TEXT_LIMIT_TYPES:
|
||
problems.extend(f"「{label}」{reason}" for reason in text_config_problems(field))
|
||
if kind in FILE_LIMIT_TYPES:
|
||
problems.extend(f"「{label}」{reason}" for reason in file_config_problems(field))
|
||
if kind == MONTHS_TYPE:
|
||
problems.extend(f"「{label}」{reason}" for reason in months_config_problems(field))
|
||
if kind == "spacer" and field.get("height") not in (None, ""):
|
||
height = _number(field.get("height"))
|
||
if height is None or height < SPACER_MIN_HEIGHT or height > SPACER_MAX_HEIGHT:
|
||
problems.append(
|
||
f"「{label}」的空白高度要在 {SPACER_MIN_HEIGHT}-{SPACER_MAX_HEIGHT}px 之间"
|
||
)
|
||
if kind == "embed":
|
||
# 局部导入:embed 那层要问注册表,模块级互相引用会绕成圈(与上面 quota 同一处理)
|
||
from . import embed as embed_service
|
||
|
||
problems.extend(embed_service.problems(field, db, at=f"「{label}」",
|
||
field_keys=field_keys, targets=rows))
|
||
if kind == "tabs":
|
||
# 标签页那一格只判"这几页配得对不对";页里那些格子还是按它们自己的类型各判各的,
|
||
# 归属这件事不参与任何校验——这正是把字段平铺而不是嵌进来的好处。
|
||
from . import tabpages
|
||
|
||
problems.extend(tabpages.problems(field, db, at=f"「{label}」",
|
||
field_keys=field_keys, targets=rows))
|
||
if tabs_at:
|
||
# 两个页签各切一屏,第二个切的是谁?与前端 formLayout.validateFields 同一句
|
||
problems.append(f"标签页字段只能有一个(第 {tabs_at} 个与第 {index} 个)")
|
||
else:
|
||
tabs_at = index
|
||
return problems
|