unis-oa/backend/scripts/check_self_visible.py

235 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode 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
"""联动条件读**自己那一格**(自引用):判得出结果、不当配错、也不把人刚写的值抹掉。
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("通过:联动条件判自己那一格——判得出、不当配错、只被自己藏起来的值照样收下")