dsh-crwu-workbench 0.0.10

package/skills/dws/dingtalk-misc/scripts/yida_form_fields.py

@@ -0,0 +1,315 @@
+"""
+宜搭表单字段构造 — 按 type 分发，每种字段类型产出一个 component dict。
+
+支持 19 种字段类型 + Divider。被 yida_form_builder.py 调用。
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+from yida_schema_common import (
+    generate_field_id,
+    i18n,
+    next_node_id,
+    normalize_field_type,
+    build_option_data_source,
+    OPTION_FIELD_TYPES,
+    SUPPORTED_FIELD_TYPES,
+)
+
+
+def build_field_component(
+    field: dict[str, Any],
+    *,
+    used_colors: Optional[set[str]] = None,
+    app_type: str = "",
+    form_uuid: str = "",
+    corp_id: str = "",
+) -> tuple[dict[str, Any], set[str]]:
+    """
+    根据字段定义 dict 构造一个组件节点。
+
+    返回 (component_node, updated_used_colors)。
+    """
+    if used_colors is None:
+        used_colors = set()
+
+    raw_type = field.get("type", "")
+    component_name = normalize_field_type(raw_type)
+    label = field.get("label", "")
+    required = field.get("required", False)
+    field_id = generate_field_id(component_name)
+
+    node: dict[str, Any] = {
+        "componentName": component_name,
+        "id": next_node_id(),
+        "props": {
+            "label": i18n(label),
+            "fieldId": field_id,
+            "__category__": "form",
+            "behavior": field.get("behavior", "NORMAL"),
+            "visibility": ["PC", "MOBILE"],
+            "submittable": "DEFAULT",
+        },
+    }
+
+    props = node["props"]
+
+    # required
+    if required:
+        props["validation"] = [{"type": "required"}]
+
+    # placeholder
+    if field.get("placeholder"):
+        props["placeholder"] = i18n(field["placeholder"])
+
+    # defaultValue
+    if field.get("defaultValue") is not None:
+        props["defaultValue"] = field["defaultValue"]
+
+    # --- 按类型分发 ---
+    if component_name == "TextareaField":
+        _apply_textarea_props(props, field)
+    elif component_name == "NumberField":
+        _apply_number_props(props, field)
+    elif component_name == "RateField":
+        _apply_rate_props(props, field)
+    elif component_name in ("DateField", "CascadeDateField"):
+        _apply_date_props(props, field, component_name)
+    elif component_name in OPTION_FIELD_TYPES:
+        used_colors = _apply_option_props(props, field, component_name, used_colors)
+    elif component_name in ("EmployeeField", "DepartmentSelectField"):
+        _apply_people_props(props, field)
+    elif component_name == "CountrySelectField":
+        _apply_people_props(props, field)
+    elif component_name == "AddressField":
+        _apply_address_props(props, field)
+    elif component_name == "AttachmentField":
+        _apply_attachment_props(props, field)
+    elif component_name == "ImageField":
+        _apply_image_props(props, field)
+    elif component_name == "SerialNumberField":
+        _apply_serial_number_props(props, field, app_type, form_uuid, field_id, corp_id)
+    elif component_name == "TableField":
+        used_colors = _apply_table_props(node, field, used_colors, app_type, form_uuid, corp_id)
+    elif component_name == "AssociationFormField":
+        _apply_association_props(props, field, app_type)
+    elif component_name == "Divider":
+        _apply_divider_props(props, field, label)
+
+    return node, used_colors
+
+
+# ---------------------------------------------------------------------------
+# 各类型 props 应用
+# ---------------------------------------------------------------------------
+
+
+def _apply_textarea_props(props: dict, field: dict) -> None:
+    props["rows"] = field.get("rows", 4)
+    props["htmlType"] = "textarea"
+
+
+def _apply_number_props(props: dict, field: dict) -> None:
+    fmt = field.get("format", "INT")
+    if fmt == "FLOAT":
+        props["precision"] = field.get("precision", 2)
+        props["format"] = "money_w4"
+    elif fmt == "PERCENT":
+        props["precision"] = field.get("precision", 2)
+        props["format"] = "percent"
+    else:
+        props["precision"] = 0
+        props["format"] = "integer"
+
+    if field.get("suffix"):
+        props["innerAfter"] = i18n(field["suffix"])
+    if field.get("prefix"):
+        props["innerBefore"] = i18n(field["prefix"])
+    if field.get("min") is not None:
+        props["min"] = field["min"]
+    if field.get("max") is not None:
+        props["max"] = field["max"]
+
+
+def _apply_rate_props(props: dict, field: dict) -> None:
+    props["count"] = field.get("total", 5)
+    if field.get("allowHalf"):
+        props["allowHalf"] = True
+
+
+def _apply_date_props(props: dict, field: dict, component_name: str) -> None:
+    fmt = field.get("format", "yyyy-MM-dd")
+    props["format"] = fmt
+    if "HH" in fmt:
+        props["showTime"] = True
+
+
+def _apply_option_props(
+    props: dict,
+    field: dict,
+    component_name: str,
+    used_colors: set[str],
+) -> set[str]:
+    options = field.get("options", [])
+    if not options:
+        return used_colors
+
+    is_checkbox = component_name in ("CheckboxField", "MultiSelectField")
+    props["isUseDataSourceColor"] = True
+    data_source, used_colors = build_option_data_source(
+        options, is_checkbox=is_checkbox, used_colors=used_colors
+    )
+    props["dataSource"] = data_source
+    if not is_checkbox and data_source:
+        props["value"] = data_source[0]["value"]
+    return used_colors
+
+
+def _apply_people_props(props: dict, field: dict) -> None:
+    multi = field.get("multi") or field.get("multiple")
+    if multi:
+        props["multiple"] = True
+        props["mode"] = "multiple"
+
+
+def _apply_address_props(props: dict, field: dict) -> None:
+    level = field.get("level", "ADDRESS")
+    props["addressType"] = level
+
+
+def _apply_attachment_props(props: dict, field: dict) -> None:
+    props["autoUpload"] = True
+    props["maxFileSize"] = field.get("maxFileSize", 100)
+    if field.get("maxFiles"):
+        props["maxItems"] = field["maxFiles"]
+    if field.get("fileTypes"):
+        props["accept"] = field["fileTypes"]
+
+
+def _apply_image_props(props: dict, field: dict) -> None:
+    props["autoUpload"] = True
+    if field.get("maxFiles"):
+        props["maxItems"] = field["maxFiles"]
+
+
+def _apply_serial_number_props(
+    props: dict,
+    field: dict,
+    app_type: str,
+    form_uuid: str,
+    field_id: str,
+    corp_id: str,
+) -> None:
+    # 流水号不允许 required
+    if "validation" in props:
+        props["validation"] = [v for v in props["validation"] if v.get("type") != "required"]
+
+    serial_rule = field.get("serialNumberRule") or [
+        {
+            "__hide_delete__": False,
+            "ruleType": "date",
+            "content": "",
+            "formField": "",
+            "dateFormat": "yyyyMMdd",
+            "timeZone": "+8",
+            "digitCount": 4,
+            "isFixed": True,
+            "isFixedTips": "",
+            "resetPeriod": "noClean",
+            "resetPeriodTips": "",
+            "initialValue": 1,
+        },
+        {
+            "__hide_delete__": True,
+            "ruleType": "autoCount",
+            "content": "",
+            "formField": "",
+            "dateFormat": "yyyyMMdd",
+            "timeZone": "+8",
+            "digitCount": "4",
+            "isFixed": True,
+            "isFixedTips": "",
+            "resetPeriod": "noClean",
+            "resetPeriodTips": "",
+            "initialValue": 1,
+        },
+    ]
+    props["serialNumberRule"] = serial_rule
+
+    serial_rule_json = json.dumps({"type": "custom", "value": serial_rule}).replace('"', '\\"')
+    props["formula"] = {
+        "expression": f'SERIALNUMBER("{corp_id}", "{app_type}", "{form_uuid}", "{field_id}", "{serial_rule_json}")'
+    }
+
+
+def _apply_table_props(
+    node: dict,
+    field: dict,
+    used_colors: set[str],
+    app_type: str,
+    form_uuid: str,
+    corp_id: str,
+) -> set[str]:
+    props = node["props"]
+    props["layout"] = "TABLE"
+    props["mobileLayout"] = "TILED"
+    props["maxItems"] = field.get("maxItems", 50)
+
+    children_defs = field.get("children", [])
+    children_nodes: list[dict[str, Any]] = []
+    for child_field in children_defs:
+        child_node, used_colors = build_field_component(
+            child_field,
+            used_colors=used_colors,
+            app_type=app_type,
+            form_uuid=form_uuid,
+            corp_id=corp_id,
+        )
+        children_nodes.append(child_node)
+
+    node["children"] = children_nodes
+    return used_colors
+
+
+def _apply_association_props(props: dict, field: dict, app_type: str) -> None:
+    source_app = field.get("sourceApp", app_type)
+    source_form = field.get("sourceForm", "")
+    display_field_code = field.get("displayFieldCode", "")
+
+    if source_form:
+        props["associationForm"] = {
+            "appType": source_app,
+            "formUuid": source_form,
+            "formType": "receipt",
+            "formTitle": "",
+            "mainFieldId": display_field_code,
+            "mainComponentName": "TextField",
+            "mainFieldLabel": "",
+        }
+        props["dataFilterRules"] = {"instanceFieldId": None}
+
+    filling_rules = field.get("dataFillingRules", [])
+    if filling_rules:
+        normalized: list[dict[str, Any]] = []
+        for rule in filling_rules:
+            src = rule.get("source", "")
+            tgt = rule.get("target", "")
+            normalized.append({
+                "source": src,
+                "sourceFieldId": src,
+                "sourceType": rule.get("sourceType", "form"),
+                "target": tgt,
+                "targetFieldId": tgt,
+                "targetType": rule.get("targetType", "form"),
+            })
+        props["dataFillingRules"] = {"mainRules": normalized}
+
+
+def _apply_divider_props(props: dict, field: dict, label: str) -> None:
+    props["title"] = i18n(label)
+    props["type"] = field.get("dividerType", "multi-parallelograms-end")
+    props.pop("validation", None)
+    props["behavior"] = "NORMAL"
+    props.pop("__category__", None)

package/skills/dws/dingtalk-misc/scripts/yida_form_inspector.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+yida_form_inspector.py — 跨表单元数据巡查工具
+
+为「自定义页面联动其他表单」场景提供元数据采集能力，让 AI 在生成 JSX 前就能
+拿到目标应用下所有表单的 formUuid + 字段 ID，避免硬编码错误。
+
+【调用前必读】references/yida-custom-page-codegen.md §9
+    跨表单联动 5 种模式（只读聚合 / 提交其他表 / Master-Detail / 多表 Dashboard /
+    跨表搬运）。本脚本只负责取字段元数据，JSX 写法以 codegen.md 为准——不要
+    看到 --help 就直接拼 JSX。
+
+用法:
+    # 列出应用下全部表单（含 formUuid / formType / title）
+    python yida_form_inspector.py --action list-forms --app APP_X
+
+    # 查看单张表单的字段（fieldId / dataType / label）
+    python yida_form_inspector.py --action fields --app APP_X --form FORM-XXX
+
+    # 一次性导出多张表单的字段汇总（推荐：跨表整合页面用）
+    python yida_form_inspector.py --action bundle --app APP_X --forms FORM-A,FORM-B,FORM-C --output ./forms.json
+
+    # 直接生成可粘贴到 JSX 的 FIELDS 常量代码
+    python yida_form_inspector.py --action fields-snippet --app APP_X --form FORM-XXX
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _run_dws(args):
+    cmd = ["dws"] + args
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except FileNotFoundError:
+        print("[FAIL] 找不到 'dws' 命令，请确认已安装并在 PATH 中", file=sys.stderr)
+        return None
+    except subprocess.TimeoutExpired:
+        print("[FAIL] dws 调用超时", file=sys.stderr)
+        return None
+    if result.returncode != 0:
+        err = result.stderr.strip() or result.stdout.strip()
+        print(f"[FAIL] dws 执行失败 (exit {result.returncode}): {err}", file=sys.stderr)
+        return None
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        print(f"[FAIL] 输出非 JSON: {exc}\n{result.stdout[:300]}", file=sys.stderr)
+        return None
+
+
+def _list_forms(app, form_types=None):
+    args = ["yida", "app", "list-forms", "--app", app, "--format", "json"]
+    if form_types:
+        args.extend(["--form-types", form_types])
+    data = _run_dws(args)
+    if data is None:
+        return None
+    if isinstance(data, dict):
+        for key in ("forms", "data", "items", "list"):
+            if isinstance(data.get(key), list):
+                return data[key]
+        return [data]
+    if isinstance(data, list):
+        return data
+    return []
+
+
+_FIELD_ID_VALUE_RE = re.compile(r'\b[A-Za-z]+Field_[A-Za-z0-9]+\b')
+_COMPONENT_LIST_KEYS = ("components", "fields", "data", "items", "result", "children", "list")
+
+
+def _walk_values(obj):
+    if isinstance(obj, dict):
+        yield obj
+        for value in obj.values():
+            yield from _walk_values(value)
+    elif isinstance(obj, list):
+        for item in obj:
+            yield from _walk_values(item)
+
+
+def _find_nested_value(obj, keys):
+    if isinstance(obj, dict):
+        for key in keys:
+            value = obj.get(key)
+            if value not in (None, ""):
+                return value
+        for value in obj.values():
+            found = _find_nested_value(value, keys)
+            if found not in (None, ""):
+                return found
+    elif isinstance(obj, list):
+        for item in obj:
+            found = _find_nested_value(item, keys)
+            if found not in (None, ""):
+                return found
+    return None
+
+
+def _normalize_i18n_label(label):
+    if isinstance(label, str):
+        raw = label.strip()
+        if raw.startswith("{") and raw.endswith("}"):
+            try:
+                parsed = json.loads(raw)
+            except json.JSONDecodeError:
+                return label
+            if isinstance(parsed, dict):
+                return (parsed.get("zh_CN") or parsed.get("zh-CN")
+                        or parsed.get("text") or parsed.get("pureEn_US")
+                        or parsed.get("en_US") or label)
+        return label
+    if isinstance(label, dict):
+        return (label.get("zh_CN") or label.get("zh-CN") or label.get("text")
+                or label.get("pureEn_US") or label.get("en_US") or "")
+    return label or ""
+
+
+def _find_field_id(obj):
+    value = _find_nested_value(obj, ("fieldId", "fieldCode", "field_id", "fieldKey"))
+    if isinstance(value, str):
+        match = _FIELD_ID_VALUE_RE.search(value)
+        return match.group(0) if match else value
+    key_value = _find_nested_value(obj, ("key", "name", "id"))
+    if isinstance(key_value, str):
+        match = _FIELD_ID_VALUE_RE.search(key_value)
+        if match:
+            return match.group(0)
+    text = json.dumps(obj, ensure_ascii=False) if isinstance(obj, (dict, list)) else str(obj)
+    match = _FIELD_ID_VALUE_RE.search(text)
+    return match.group(0) if match else None
+
+
+def _extract_component_items(data):
+    if isinstance(data, dict):
+        for key in _COMPONENT_LIST_KEYS:
+            value = data.get(key)
+            if isinstance(value, list):
+                return value
+            if isinstance(value, dict):
+                nested = _extract_component_items(value)
+                if nested:
+                    return nested
+    if isinstance(data, list):
+        return data
+
+    found = []
+    seen = set()
+    for item in _walk_values(data):
+        if not isinstance(item, dict):
+            continue
+        field_id = _find_field_id(item)
+        if field_id and field_id not in seen:
+            seen.add(field_id)
+            found.append(item)
+    return found
+
+
+def _components(app, form):
+    data = _run_dws(["yida", "form", "components", "--app", app,
+                     "--form", form, "--format", "json"])
+    if data is None:
+        return None
+    return _extract_component_items(data)
+
+
+def _normalize_field(comp):
+    field_id = _find_field_id(comp)
+    label = (_find_nested_value(comp, ("label", "title", "text", "displayName", "nameCn"))
+             or "")
+    label = _normalize_i18n_label(label)
+    return {
+        "fieldId": field_id,
+        "label": label,
+        "dataType": _find_nested_value(comp, ("dataType", "valueType")) or "",
+        "componentName": _find_nested_value(comp, ("componentName", "type", "component")) or "",
+    }
+
+
+def _camel_safe(text, fallback):
+    if not text:
+        text = fallback
+    cleaned = re.sub(r"[^A-Za-z0-9]+", " ", text).strip()
+    if not cleaned:
+        return fallback
+    parts = cleaned.split()
+    return parts[0].lower() + "".join(p.capitalize() for p in parts[1:])
+
+
+def _action_list_forms(args):
+    forms = _list_forms(args.app, args.form_types)
+    if forms is None:
+        return 1
+    summary = []
+    for f in forms:
+        summary.append({
+            "formUuid": f.get("formUuid") or f.get("formId") or f.get("uuid"),
+            "title": f.get("title") or f.get("name"),
+            "formType": f.get("formType") or f.get("type"),
+            "appType": f.get("appType") or args.app,
+        })
+    print(json.dumps({"ok": True, "app": args.app, "count": len(summary),
+                      "forms": summary}, ensure_ascii=False, indent=2))
+    return 0
+
+
+def _action_fields(args):
+    if not args.form:
+        print("错误: --action fields 需要 --form", file=sys.stderr)
+        return 1
+    comps = _components(args.app, args.form)
+    if comps is None:
+        return 1
+    fields = [_normalize_field(c) for c in comps]
+    print(json.dumps({"ok": True, "app": args.app, "form": args.form,
+                      "count": len(fields), "fields": fields},
+                     ensure_ascii=False, indent=2))
+    return 0
+
+
+def _action_fields_snippet(args):
+    if not args.form:
+        print("错误: --action fields-snippet 需要 --form", file=sys.stderr)
+        return 1
+    comps = _components(args.app, args.form)
+    if comps is None:
+        return 1
+    lines = ["// 由 yida_form_inspector.py 自动生成",
+             f"// 表单: {args.form}",
+             "var FIELDS = {"]
+    used = set()
+    for idx, comp in enumerate(comps):
+        f = _normalize_field(comp)
+        if not f["fieldId"]:
+            continue
+        var_name = _camel_safe(f["label"], f"field{idx}")
+        base = var_name
+        n = 2
+        while var_name in used:
+            var_name = f"{base}{n}"
+            n += 1
+        used.add(var_name)
+        comment = f"  // {f['label']} ({f['dataType']})" if f["label"] else ""
+        lines.append(f"  {var_name}: '{f['fieldId']}',{comment}")
+    lines.append("};")
+    print("\n".join(lines))
+    return 0
+
+
+def _action_bundle(args):
+    if not args.forms:
+        print("错误: --action bundle 需要 --forms FORM-A,FORM-B,...", file=sys.stderr)
+        return 1
+    form_ids = [s.strip() for s in args.forms.split(",") if s.strip()]
+    bundle = {"ok": True, "app": args.app, "forms": {}}
+    for fid in form_ids:
+        comps = _components(args.app, fid)
+        if comps is None:
+            bundle["forms"][fid] = {"ok": False, "error": "fetch_failed"}
+            continue
+        bundle["forms"][fid] = {
+            "ok": True,
+            "fields": [_normalize_field(c) for c in comps],
+        }
+    out = json.dumps(bundle, ensure_ascii=False, indent=2)
+    if args.output:
+        Path(args.output).write_text(out, encoding="utf-8")
+        print(f"[OK] 已写入 {args.output}（{len(form_ids)} 张表单）")
+    else:
+        print(out)
+    return 0
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description=(
+            "跨表单元数据巡查 / FIELDS 常量生成 "
+            "【调用前必读】references/yida-custom-page-codegen.md §9"
+            "（跨表单联动 5 种模式），不要只看 --help 就拼 JSX"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    ap.add_argument("--action", required=True,
+                    choices=["list-forms", "fields", "fields-snippet", "bundle"])
+    ap.add_argument("--app", required=True, help="应用编码 appType")
+    ap.add_argument("--form", help="单表 formUuid（fields / fields-snippet 用）")
+    ap.add_argument("--forms", help="多表 formUuid 逗号分隔（bundle 用）")
+    ap.add_argument("--form-types",
+                    help="list-forms 过滤：receipt / process / report / display 等")
+    ap.add_argument("--output", help="bundle 写入文件")
+    args = ap.parse_args()
+
+    handlers = {
+        "list-forms": _action_list_forms,
+        "fields": _action_fields,
+        "fields-snippet": _action_fields_snippet,
+        "bundle": _action_bundle,
+    }
+    return handlers[args.action](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())