235 lines
11 KiB
Python
235 lines
11 KiB
Python
#!/usr/bin/env python3
|
||
"""联动条件读**自己那一格**(自引用):判得出结果、不当配错、也不把人刚写的值抹掉。
|
||
|
||
PYTHONPATH=. python3 scripts/check_self_visible.py
|
||
|
||
用户那句原话:"表单中字段的显示判断条件,需要可以设置判断本身字段的值情况来确定是否可以
|
||
展示"。以前这一档压根配不出来:设计器把本字段从条件清单里筛掉(``LinkagePanel`` 那句
|
||
``item.key !== props.field.key``),后端保存时还要报一句「联动条件引用了自己」,于是
|
||
「外部带回来的合同编号有值才露这一格」只能造一个中间变量绕一圈。
|
||
|
||
放开之后要钉住三件事,缺一件就成了新坑:
|
||
|
||
1. **只放宽"判谁",不放宽"怎么判"**:自引用走的就是 ``compare`` 那一条路,别的条件一个
|
||
字节都不受影响;级联上级选自己、条件左右两头是同一格、指向不存在的字段,三句照旧要说。
|
||
2. **自指不进级联清值那圈**:``depends_on`` 仍把自指摘掉("自己变了要清自己的失效值"会把
|
||
刚写进来那一份当越界抹掉),``condition_dependencies`` 留着(设计期与界面重算都读它)。
|
||
3. **"只被自己藏起来"的那一笔值要收下**:``visibleWhen`` 判自己有没有值、``readonlyWhen``
|
||
判自己有没有值,都会在人刚敲完的那一刻把这一格收走或锁上,引擎那一段按"这一环改不动"
|
||
退回原值,人看着自己写的字凭空消失。摘掉自引用那几条以后本来就填得动,就收下这一笔;
|
||
环节明写隐藏、被别的格子挡住、类型压根没有录入框,三档都不算,一寸没放宽。
|
||
|
||
**空格算没填**这一条也在这里钉:``dicts._is_empty`` 一直把一串空格当没填,前端
|
||
``isEmptyValue`` 以前只认空串,于是"有值才显示"这一档两边能算出两个结果(界面按 notEmpty
|
||
露着一行空白,服务端按 empty 判它没填)。这次一并收齐,两边同一把尺子。
|
||
|
||
前端镜像钉在 ``utils/formLinkage.self.spec.ts``、``components/oa/FormRenderer.self.spec.ts``
|
||
与 ``components/oa/design/LinkagePanel.self.spec.ts``。全程不碰库。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import sys
|
||
|
||
from app.service import dicts, formruntime
|
||
|
||
FAILS: list[str] = []
|
||
|
||
|
||
def check(label: str, got: object, want: object) -> None:
|
||
if got != want:
|
||
FAILS.append(f"{label}:想要 {want!r},拿到 {got!r}")
|
||
|
||
|
||
def problems(*fields: dict) -> list[str]:
|
||
return formruntime.linkage_problems(list(fields))
|
||
|
||
|
||
OWN = "contractNo"
|
||
OTHERS = [
|
||
{"key": "dept", "label": "申请部门", "type": "dept"},
|
||
{"key": "amount", "label": "报销金额", "type": "money"},
|
||
]
|
||
|
||
|
||
def own(**patch: object) -> dict:
|
||
return {"key": OWN, "label": "合同编号", "type": "text", **patch}
|
||
|
||
|
||
def when(rules: list[dict], match: str = "all") -> dict:
|
||
return {"match": match, "rules": rules}
|
||
|
||
|
||
# ------------------------------------------------------------------ 1. 判得出结果
|
||
check(
|
||
"本字段有值才露:没值不成立",
|
||
dicts.state_of(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}),
|
||
{"visible": False, "required": False, "readonly": False},
|
||
)
|
||
check(
|
||
"本字段有值才露:带进值来就成立",
|
||
dicts.state_of(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {OWN: "HT-2026-011"}),
|
||
{"visible": True, "required": False, "readonly": False},
|
||
)
|
||
check(
|
||
"没值才露是反过来的同一句",
|
||
[
|
||
dicts.state_of(own(visibleWhen=when([{"field": OWN, "op": "empty"}])), {}),
|
||
dicts.state_of(own(visibleWhen=when([{"field": OWN, "op": "empty"}])), {OWN: "HT-1"}),
|
||
],
|
||
[
|
||
{"visible": True, "required": False, "readonly": False},
|
||
{"visible": False, "required": False, "readonly": False},
|
||
],
|
||
)
|
||
check(
|
||
"拿自己的值比大小也讲得通(这一格自己判自己一个数)",
|
||
[
|
||
dicts.state_of({"key": "amount", "label": "金额", "type": "money", "visibleWhen": when([{"field": "amount", "op": "gt", "value": 5000}])}, {"amount": 8000}),
|
||
dicts.state_of({"key": "amount", "label": "金额", "type": "money", "visibleWhen": when([{"field": "amount", "op": "gt", "value": 5000}])}, {"amount": 200}),
|
||
],
|
||
[{"visible": True, "required": False, "readonly": False}, {"visible": False, "required": False, "readonly": False}],
|
||
)
|
||
check(
|
||
"右边挑自己也算读自己:另一格跟自己比,判的是自己此刻的值",
|
||
dicts.state_of(own(visibleWhen=when([{"field": "amount", "op": "gt", "valueField": OWN}])), {OWN: 100}),
|
||
# 右边 100、左边没填 -> 比不出结果,这一条不算成立
|
||
{"visible": False, "required": False, "readonly": False},
|
||
)
|
||
check(
|
||
"有值就锁住:锁住自己的正是自己那一格",
|
||
[
|
||
dicts.state_of(own(readonlyWhen=when([{"field": OWN, "op": "notEmpty"}])), {}),
|
||
dicts.state_of(own(readonlyWhen=when([{"field": OWN, "op": "notEmpty"}])), {OWN: "HT-1"}),
|
||
],
|
||
[
|
||
{"visible": True, "required": False, "readonly": False},
|
||
{"visible": True, "required": False, "readonly": True},
|
||
],
|
||
)
|
||
check("空格算没填:两边同一把尺子", dicts._is_empty(" "), True)
|
||
check(
|
||
"只敲了空格那一格不露(前端 isEmptyValue 同一寸)",
|
||
dicts.state_of(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {OWN: " "})["visible"],
|
||
False,
|
||
)
|
||
check("0 与 False 都算填了,别把判空做成判零", [dicts._is_empty(0), dicts._is_empty(False)], [False, False])
|
||
|
||
# ------------------------------------------------------------------ 2. 上游与配错
|
||
check(
|
||
"条件层面的上游留着自指,级联清值那圈摘掉它",
|
||
[
|
||
dicts.condition_dependencies(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}, {"field": "amount", "op": "gt", "valueField": "dept"}]))),
|
||
dicts.depends_on(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}, {"field": "amount", "op": "gt", "valueField": "dept"}]))),
|
||
],
|
||
[[OWN, "amount", "dept"], ["amount", "dept"]],
|
||
)
|
||
check("自引用不再是配错", problems(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), *OTHERS), [])
|
||
check(
|
||
"级联上级选自己照旧要说",
|
||
"级联上级选了它自己" in "".join(problems(own(cascadeFrom=OWN), *OTHERS)),
|
||
True,
|
||
)
|
||
check(
|
||
"左右两头是同一格照旧要说(自己跟自己比没有新意思)",
|
||
problems(own(visibleWhen=when([{"field": OWN, "op": "eq", "valueField": OWN}])), *OTHERS),
|
||
['「合同编号」的联动条件拿「合同编号」和自己比'],
|
||
)
|
||
check(
|
||
"同一条里既有自引用又有悬空引用:只放行指向自己的那一条",
|
||
problems(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}, {"field": "gone", "op": "eq", "value": "x"}])), *OTHERS),
|
||
['「合同编号」的联动条件引用了不存在的字段「gone」'],
|
||
)
|
||
check("带出规则写回自己仍是配错", "不能写回自己" in "".join(problems(own(dictCode="d", autoFill=[{"to": OWN, "pick": "value"}]), *OTHERS)), True)
|
||
|
||
# ------------------------------------------------------------------ 3. 摘掉自引用那几条
|
||
check(
|
||
"只剩自引用时等于没配条件",
|
||
dicts.without_self_rules(when([{"field": OWN, "op": "notEmpty"}]), OWN),
|
||
{"match": "all", "rules": []},
|
||
)
|
||
check("一条都没摘动时回 None(原本没读自己)", dicts.without_self_rules(when([{"field": "dept", "op": "notEmpty"}]), OWN), None)
|
||
check(
|
||
"混着配时只摘读自己那一条",
|
||
dicts.without_self_rules(when([{"field": OWN, "op": "notEmpty"}, {"field": "dept", "op": "notEmpty"}]), OWN),
|
||
{"match": "all", "rules": [{"field": "dept", "op": "notEmpty"}]},
|
||
)
|
||
check("没读过自己的格子不用摘", dicts.stripped_of_self(own()), None)
|
||
check(
|
||
"三栏一起摘:只摘显隐会漏掉「有值就锁住」那一栏",
|
||
sorted(dicts.stripped_of_self(own(readonlyWhen=when([{"field": OWN, "op": "notEmpty"}])))),
|
||
sorted({"key": OWN, "label": "合同编号", "type": "text", "readonlyWhen": {"match": "all", "rules": []}}),
|
||
)
|
||
|
||
# ------------------------------------------------------------------ 4. 只被自己收走的格子,值要收下
|
||
check(
|
||
"值没带回来:这一格此刻是隐藏的",
|
||
formruntime.effective_perm(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {}),
|
||
formruntime.PERM_HIDDEN,
|
||
)
|
||
check(
|
||
"值带回来了:这一格露着、也填得动",
|
||
formruntime.effective_perm(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {OWN: "HT-1"}),
|
||
formruntime.PERM_EDITABLE,
|
||
)
|
||
check(
|
||
"藏起它的只有它自己:这一笔值算填得动",
|
||
formruntime.self_gated_keys([own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}]))], {}, {}),
|
||
{OWN},
|
||
)
|
||
check(
|
||
"「有值就锁住」那一栏同样放宽",
|
||
formruntime.self_gated_keys([own(readonlyWhen=when([{"field": OWN, "op": "notEmpty"}]))], {}, {OWN: "HT-1"}),
|
||
{OWN},
|
||
)
|
||
check(
|
||
"环节明写隐藏:藏它的是环节,不借这一档翻案",
|
||
formruntime.self_gated_keys([own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}]))], {OWN: formruntime.PERM_HIDDEN}, {}),
|
||
set(),
|
||
)
|
||
check(
|
||
"还有一条读别的格子的条件没放行:藏它的是那一格",
|
||
formruntime.self_gated_keys(
|
||
[own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}, {"field": "dept", "op": "notEmpty"}]))], {}, {}
|
||
),
|
||
set(),
|
||
)
|
||
check("没读自己的格子压根不掺和这一档", formruntime.self_gated_keys([own()], {}, {}), set())
|
||
check(
|
||
"说明文字那种没有录入框的格子不放宽(自引用也放不开 NON_INPUT)",
|
||
formruntime.self_gated_keys(
|
||
[{"key": OWN, "label": "说明", "type": "description", "visibleWhen": when([{"field": OWN, "op": "notEmpty"}])}], {}, {}
|
||
),
|
||
set(),
|
||
)
|
||
# 「这一格填了 SKIP 就不露」那一类:条件一放行,必填立刻跟着要它
|
||
check(
|
||
"自引用条件放行的那一格,必填照常要",
|
||
[
|
||
formruntime.missing_required([own(required=True, visibleWhen=when([{"field": OWN, "op": "ne", "value": "SKIP"}]))], {}, {OWN: "SKIP"}),
|
||
formruntime.missing_required([own(required=True, visibleWhen=when([{"field": OWN, "op": "ne", "value": "SKIP"}]))], {}, {}),
|
||
],
|
||
[[], ["合同编号"]],
|
||
)
|
||
check(
|
||
"默认隐藏 + 只判自己:说话的是条件,不是默认值",
|
||
[
|
||
formruntime.effective_perm(own(hidden=True, visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {OWN: "HT-1"}),
|
||
formruntime.effective_perm(own(hidden=True, visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {}),
|
||
],
|
||
[formruntime.PERM_EDITABLE, formruntime.PERM_HIDDEN],
|
||
)
|
||
check(
|
||
"放宽的只是收不收这一笔值,界面上露不露一寸没动",
|
||
[
|
||
formruntime.effective_perm(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {}),
|
||
formruntime.field_hidden(own(visibleWhen=when([{"field": OWN, "op": "notEmpty"}])), {}, {}),
|
||
],
|
||
[formruntime.PERM_HIDDEN, True],
|
||
)
|
||
|
||
if FAILS:
|
||
print("\n".join(FAILS))
|
||
sys.exit(f"失败 {len(FAILS)} 句")
|
||
print("通过:联动条件判自己那一格——判得出、不当配错、只被自己藏起来的值照样收下")
|