dsh-crwu-workbench 0.0.10

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

@@ -0,0 +1,589 @@
+#!/usr/bin/env python3
+"""Yida process draft save/publish helper.
+
+Flow for creating a new process definition:
+
+  1. create draft from the initial/published process id
+  2. generate process schema with yida_process_flow.build_flow_schema
+  3. save draft with `dws yida design process update`
+  4. optionally publish with `dws yida design process publish`
+
+The flow schema is the same shape used by integration automation:
+`build_automation_flow` output from references/yida-process-node.md can
+be passed directly via --flow-file / --flow-json.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPT_DIR))
+
+from yida_process_flow import (  # noqa: E402
+    FlowSchemaError,
+    build_flow_schema,
+    build_process_view_schema,
+    merge_process_view_schema,
+)
+
+
+MAX_FLOW_FILE_SIZE = 1024 * 1024
+MAX_INLINE_JSON = 256 * 1024
+
+
+def _gather_allowed_roots() -> list[Path]:
+    roots: list[Path] = []
+    extra = os.environ.get("OPENYIDA_ALLOWED_ROOTS", "")
+    if extra:
+        parts: list[str] = [extra]
+        for sep in (os.pathsep, ":", ","):
+            parts = [seg for chunk in parts for seg in chunk.split(sep)]
+        roots.extend(Path(part).expanduser().resolve() for part in parts if part.strip())
+    legacy = os.environ.get("OPENCLAW_WORKSPACE")
+    if legacy:
+        roots.append(Path(legacy).expanduser().resolve())
+    roots.append(Path.cwd().resolve())
+    roots.append(Path(tempfile.gettempdir()).resolve())
+    roots.append(Path("/tmp").resolve())
+    roots.append(Path("/private/tmp").resolve())
+
+    seen: set[str] = set()
+    result: list[Path] = []
+    for root in roots:
+        key = str(root)
+        if key not in seen:
+            seen.add(key)
+            result.append(root)
+    return result
+
+
+def _resolve_safe_path(path_str: str) -> Path:
+    target = Path(path_str).expanduser()
+    target = target.resolve() if target.is_absolute() else (Path.cwd() / target).resolve()
+    roots = _gather_allowed_roots()
+    for root in roots:
+        try:
+            target.relative_to(root)
+            return target
+        except ValueError:
+            continue
+    listing = "\n  - ".join(str(root) for root in roots)
+    raise ValueError(f"路径超出允许范围：{path_str}\n已尝试的允许根目录：\n  - {listing}")
+
+
+def _load_json(file_path: str | None, inline_json: str | None, label: str) -> Any:
+    if file_path:
+        safe = _resolve_safe_path(file_path)
+        if not safe.exists():
+            raise ValueError(f"{label} 文件不存在: {safe}")
+        if safe.stat().st_size > MAX_FLOW_FILE_SIZE:
+            raise ValueError(f"{label} 文件过大 (限制 {MAX_FLOW_FILE_SIZE:,} 字节)")
+        return json.loads(safe.read_text(encoding="utf-8"))
+    if inline_json:
+        if len(inline_json.encode("utf-8")) > MAX_INLINE_JSON:
+            raise ValueError(f"{label} 内联 JSON 过长 (限制 {MAX_INLINE_JSON:,} 字节)")
+        return json.loads(inline_json)
+    raise ValueError(f"必须提供 --{label}-file 或 --{label}-json")
+
+
+def _run_dws(args: list[str], dry_run: bool = False) -> Any | None:
+    cmd = ["dws"] + args
+    if dry_run:
+        print(f"  [dry-run] {' '.join(cmd)}")
+        return {"dry_run": True}
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except FileNotFoundError:
+        print("  [FAIL] 找不到 'dws' 命令", 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 _iter_dicts(value: Any):
+    if isinstance(value, dict):
+        yield value
+        for child in value.values():
+            yield from _iter_dicts(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _iter_dicts(child)
+
+
+def _iter_flow_nodes(nodes: list[dict[str, Any]]):
+    for node in nodes:
+        yield node
+        child_nodes = node.get("childNodes") or []
+        if isinstance(child_nodes, list):
+            yield from _iter_flow_nodes(child_nodes)
+
+
+def _extract_payload(data: Any) -> Any:
+    if isinstance(data, dict):
+        for key in ("result", "content", "data"):
+            value = data.get(key)
+            if value is not None:
+                return value
+    return data
+
+
+def _loads_maybe(value: Any) -> Any:
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+    return value
+
+
+def _i18n_text(value: Any) -> str:
+    value = _loads_maybe(value)
+    if isinstance(value, dict):
+        return str(value.get("zh_CN") or value.get("en_US") or value.get("pureEn_US") or value.get("value") or "")
+    return str(value or "")
+
+
+def _extract_records(data: Any) -> list[Any]:
+    payload = _extract_payload(data)
+    payload = _loads_maybe(payload)
+    if isinstance(payload, dict):
+        for key in ("data", "result", "records", "list"):
+            value = payload.get(key)
+            if isinstance(value, list):
+                return value
+    if isinstance(payload, list):
+        return payload
+    return []
+
+
+def _load_form_titles(app_type: str, dry_run: bool = False) -> dict[str, str]:
+    resp = _run_dws([
+        "yida", "app", "list-forms",
+        "--app", app_type,
+        "--format", "json",
+    ], dry_run=dry_run)
+    titles: dict[str, str] = {}
+    if not resp or dry_run:
+        return titles
+    for item in _extract_records(resp):
+        item = _loads_maybe(item)
+        if not isinstance(item, dict):
+            continue
+        form_uuid = item.get("formUuid")
+        if isinstance(form_uuid, str) and form_uuid:
+            titles[form_uuid] = _i18n_text(item.get("title")) or form_uuid
+    return titles
+
+
+def _field_from_component(item: Any) -> dict[str, Any] | None:
+    item = _loads_maybe(item)
+    if not isinstance(item, dict):
+        return None
+    field_id = item.get("key") or item.get("fieldId") or item.get("componentId") or item.get("id")
+    component_name = item.get("componentName")
+    if not isinstance(field_id, str) or not field_id:
+        return None
+    if component_name in {"Page", "FormContainer"}:
+        return None
+    label = _i18n_text(item.get("label") or item.get("varName")) or field_id
+    return {
+        "fieldId": field_id,
+        "name": field_id,
+        "value": field_id,
+        "label": label,
+        "text": label,
+        "componentName": component_name,
+        "componentOption": "[]",
+        "required": False,
+        "componentProps": {
+            "defaultDataSource": {},
+            "relateAppType": "",
+            "relateOrderEnable": False,
+            "relateOrderConfig": [],
+        },
+    }
+
+
+def _load_form_schema(app_type: str, form_uuid: str, dry_run: bool = False) -> dict[str, Any] | None:
+    resp = _run_dws([
+        "yida", "design", "form", "get-schema",
+        "--app", app_type,
+        "--form", form_uuid,
+        "--format", "json",
+    ], dry_run=dry_run)
+    if not resp or dry_run:
+        return None
+    payload = _extract_payload(resp)
+    payload = _loads_maybe(payload)
+    return payload if isinstance(payload, dict) else None
+
+
+def _iter_schema_components(value: Any, parent: dict[str, Any] | None = None):
+    value = _loads_maybe(value)
+    if isinstance(value, list):
+        for item in value:
+            yield from _iter_schema_components(item, parent)
+        return
+    if not isinstance(value, dict):
+        return
+
+    current_parent = parent
+    if isinstance(value.get("componentName"), str):
+        yield value, parent
+        current_parent = value
+
+    for key in ("pages", "componentsTree", "children"):
+        child = value.get(key)
+        if isinstance(child, (list, dict)):
+            yield from _iter_schema_components(child, current_parent)
+
+
+def _field_from_schema_node(item: Any, parent: dict[str, Any] | None = None) -> dict[str, Any] | None:
+    item = _loads_maybe(item)
+    if not isinstance(item, dict):
+        return None
+    component_name = item.get("componentName")
+    props = item.get("props") if isinstance(item.get("props"), dict) else {}
+    field_id = props.get("fieldId") or item.get("key") or item.get("fieldId") or item.get("componentId") or item.get("id")
+    if not isinstance(field_id, str) or not field_id:
+        return None
+    if component_name in {"Page", "RootHeader", "RootContent", "RootFooter", "FormContainer"}:
+        return None
+
+    label = _i18n_text(props.get("label") or item.get("label") or item.get("varName")) or field_id
+    field_props = copy.deepcopy(props)
+    if parent and isinstance(parent, dict):
+        parent_component = parent.get("componentName")
+        parent_props = parent.get("props") if isinstance(parent.get("props"), dict) else {}
+        parent_id = parent_props.get("fieldId") or parent.get("fieldId") or parent.get("id")
+        if parent_component:
+            field_props.setdefault("parentComponentName", parent_component)
+        if parent_id:
+            field_props.setdefault("parentId", parent_id)
+
+    return {
+        "fieldId": field_id,
+        "name": field_id,
+        "value": field_id,
+        "label": label,
+        "text": label,
+        "componentName": component_name,
+        "componentOption": "[]",
+        "required": bool(props.get("required", False)),
+        "props": field_props,
+        "componentProps": {
+            "defaultDataSource": copy.deepcopy(props.get("defaultDataSource") or {}),
+            "relateAppType": props.get("relateAppType", ""),
+            "relateOrderEnable": bool(props.get("relateOrderEnable", False)),
+            "relateOrderConfig": copy.deepcopy(props.get("relateOrderConfig") or []),
+        },
+    }
+
+
+def _load_form_fields_from_schema(app_type: str, form_uuid: str, dry_run: bool = False) -> list[dict[str, Any]]:
+    schema = _load_form_schema(app_type, form_uuid, dry_run=dry_run)
+    if not schema:
+        return []
+    fields: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for item, parent in _iter_schema_components(schema):
+        field = _field_from_schema_node(item, parent)
+        if not field:
+            continue
+        field_id = str(field.get("fieldId") or "")
+        if field_id in seen:
+            continue
+        seen.add(field_id)
+        fields.append(field)
+    return fields
+
+
+def _load_form_fields(app_type: str, form_uuid: str, dry_run: bool = False) -> list[dict[str, Any]]:
+    fields = _load_form_fields_from_schema(app_type, form_uuid, dry_run=dry_run)
+    if fields:
+        return fields
+
+    resp = _run_dws([
+        "yida", "form", "components",
+        "--app", app_type,
+        "--form", form_uuid,
+        "--format", "json",
+    ], dry_run=dry_run)
+    if not resp or dry_run:
+        return []
+    fields = []
+    for item in _extract_records(resp):
+        field = _field_from_component(item)
+        if field:
+            fields.append(field)
+    return fields
+
+
+def _collect_data_create_targets(flow: dict[str, Any], default_app: str) -> set[tuple[str, str]]:
+    targets: set[tuple[str, str]] = set()
+    for node in _iter_flow_nodes(flow.get("nodes") or []):
+        props = node.get("props") or {}
+        node_type = str(node.get("type") or "")
+        if node_type == "dataCreate":
+            form_uuid = props.get("formUuid")
+        elif node_type == "dataRetrieve":
+            form_uuid = props.get("sourceId")
+        else:
+            continue
+        if not isinstance(form_uuid, str) or not form_uuid:
+            continue
+        if node_type == "dataRetrieve" and not form_uuid.startswith("FORM-"):
+            continue
+        app_type = props.get("appType") if isinstance(props.get("appType"), str) else ""
+        targets.add((app_type or default_app, form_uuid))
+    return targets
+
+
+def _build_data_create_metadata(flow: dict[str, Any], app_type: str, dry_run: bool = False) -> dict[tuple[str, str], dict[str, Any]]:
+    targets = _collect_data_create_targets(flow, app_type)
+    if not targets:
+        return {}
+
+    titles_by_app: dict[str, dict[str, str]] = {}
+    metadata: dict[tuple[str, str], dict[str, Any]] = {}
+    for target_app, form_uuid in sorted(targets):
+        if target_app not in titles_by_app:
+            titles_by_app[target_app] = _load_form_titles(target_app, dry_run=dry_run)
+        metadata[(target_app, form_uuid)] = {
+            "title": titles_by_app[target_app].get(form_uuid, form_uuid),
+            "fields": _load_form_fields(target_app, form_uuid, dry_run=dry_run),
+        }
+    return metadata
+
+
+def _load_source_view(app_type: str, process_code: str, process_id: str, dry_run: bool = False) -> dict[str, Any] | None:
+    if not app_type or not process_code or not process_id or dry_run:
+        return None
+    resp = _run_dws([
+        "yida", "design", "process", "get",
+        "--app", app_type,
+        "--process-code", process_code,
+        "--process-id", process_id,
+        "--format", "json",
+    ], dry_run=dry_run)
+    if not resp:
+        return None
+    for item in _iter_dicts(resp):
+        view_json = item.get("viewJson")
+        if isinstance(view_json, str) and view_json:
+            parsed = _loads_maybe(view_json)
+            if isinstance(parsed, dict):
+                return parsed
+    return None
+
+
+def _extract_process_id(data: Any) -> str:
+    for item in _iter_dicts(data):
+        for key in ("processId", "id", "processVersionId", "result", "content"):
+            value = item.get(key)
+            if isinstance(value, (str, int)) and str(value):
+                return str(value)
+    return ""
+
+
+def _load_optional_text(file_path: str | None, inline_value: str | None, label: str) -> str:
+    if file_path:
+        safe = _resolve_safe_path(file_path)
+        if not safe.exists():
+            raise ValueError(f"{label} 文件不存在: {safe}")
+        if safe.stat().st_size > MAX_FLOW_FILE_SIZE:
+            raise ValueError(f"{label} 文件过大 (限制 {MAX_FLOW_FILE_SIZE:,} 字节)")
+        return safe.read_text(encoding="utf-8")
+    return inline_value or ""
+
+
+def _summarize_flow(flow: dict[str, Any]) -> list[str]:
+    nodes = list(_iter_flow_nodes(flow.get("nodes") or []))
+    counts: dict[str, int] = {}
+    for node in nodes:
+        node_type = str(node.get("type") or "unknown")
+        counts[node_type] = counts.get(node_type, 0) + 1
+
+    lines = [
+        f"节点数: {len(nodes)}",
+        "节点类型: " + ", ".join(f"{key}={counts[key]}" for key in sorted(counts)),
+    ]
+
+    data_targets = []
+    card_rules = []
+    for node in nodes:
+        props = node.get("props") if isinstance(node.get("props"), dict) else {}
+        node_name = _i18n_text(node.get("name")) or str(node.get("nodeId") or "")
+        node_type = str(node.get("type") or "")
+        if node_type == "dataCreate":
+            data_targets.append(f"{node_name}->{props.get('appType') or '<当前应用>'}/{props.get('formUuid')}")
+        if node_type == "sendCard":
+            biz_id = props.get("bizId") if isinstance(props.get("bizId"), dict) else {}
+            card_rules.append(
+                f"{node_name}: page={props.get('cardPageCode')}, sendType={props.get('sendType')}, "
+                f"bizId={biz_id.get('value')}"
+            )
+
+    if data_targets:
+        lines.append("新增数据目标: " + "; ".join(data_targets))
+    if card_rules:
+        lines.append("卡片规则: " + "; ".join(card_rules))
+    return lines
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        description="宜搭流程定义保存/发布：新建草稿 -> 生成流程 schema -> 保存流程 -> 可选发布",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    ap.add_argument("--app", help="应用编码 appType；--schema-only 时可不传")
+    ap.add_argument("--form", help="流程表单 formUuid；创建草稿时必填")
+    ap.add_argument("--process-code", required=True, help="流程 code，如 TPROC-XXX")
+    ap.add_argument("--source-process-id", help="源流程版本 id，用于 create-draft")
+    ap.add_argument("--draft-process-id", help="已有草稿 processId；传入后跳过 create-draft")
+    ap.add_argument("--flow-file", help="流程 schema / build_automation_flow 输入 JSON 文件")
+    ap.add_argument("--flow-json", help="流程 schema / build_automation_flow 输入内联 JSON")
+    ap.add_argument("--view-file", help="可选 viewJson 文件")
+    ap.add_argument("--view-json", help="可选内联 viewJson")
+    ap.add_argument("--publish", action="store_true", help="保存后发布流程")
+    ap.add_argument("--schema-only", action="store_true", help="只输出生成后的流程 schema，不调用 dws")
+    ap.add_argument("--yes", action="store_true", help="确认执行保存/发布")
+    ap.add_argument("--dry-run", action="store_true", help="打印将执行的命令，不调用 dws")
+    args = ap.parse_args(argv)
+
+    try:
+        flow_spec = _load_json(args.flow_file, args.flow_json, "flow")
+        flow = build_flow_schema(flow_spec, process_code=args.process_code)
+        if args.form:
+            flow.setdefault("props", {})["bindingForm"] = args.form
+        view_content = _load_optional_text(args.view_file, args.view_json, "view") if (args.view_file or args.view_json) else ""
+    except (ValueError, json.JSONDecodeError, FlowSchemaError) as exc:
+        print(f"错误: {exc}", file=sys.stderr)
+        return 1
+
+    flow_json = json.dumps(flow, ensure_ascii=False, separators=(",", ":"))
+
+    if args.schema_only:
+        print(json.dumps(flow, ensure_ascii=False, indent=2))
+        return 0
+
+    if not args.app:
+        print("错误: 保存/发布流程必须提供 --app", file=sys.stderr)
+        return 1
+
+    if not args.yes and not args.dry_run:
+        print("错误: 保存/发布流程是高影响操作，必须显式传 --yes", file=sys.stderr)
+        return 1
+
+    if not args.draft_process_id and (not args.form or not args.source_process_id):
+        print("错误: 未传 --draft-process-id 时，必须提供 --form 和 --source-process-id 创建草稿", file=sys.stderr)
+        return 1
+
+    if not view_content:
+        print("Step 0/4: 生成流程设计器 viewJson")
+        print("  [检查] 流程摘要")
+        for line in _summarize_flow(flow):
+            print(f"    - {line}")
+        metadata = _build_data_create_metadata(flow, args.app, dry_run=args.dry_run)
+        source_view_id = args.source_process_id or args.draft_process_id or ""
+        source_view = _load_source_view(args.app, args.process_code, source_view_id, dry_run=args.dry_run)
+        if source_view:
+            view = merge_process_view_schema(source_view, flow, data_create_metadata=metadata)
+        else:
+            view = build_process_view_schema(flow, data_create_metadata=metadata)
+        view_content = json.dumps(view, ensure_ascii=False, separators=(",", ":"))
+        print(f"  [OK] viewJson {len(view_content):,} 字节")
+
+    # Step 1: create or reuse draft
+    draft_process_id = args.draft_process_id or ""
+    if draft_process_id:
+        print(f"Step 1/4: 复用草稿 processId={draft_process_id}")
+    else:
+        print("Step 1/4: 新建流程草稿")
+        resp = _run_dws([
+            "yida", "design", "process", "create-draft",
+            "--app", args.app,
+            "--form", args.form,
+            "--process-id", args.source_process_id,
+            "--format", "json",
+        ], dry_run=args.dry_run)
+        if args.dry_run:
+            draft_process_id = "<draft-process-id>"
+        else:
+            if not resp:
+                return 1
+            draft_process_id = _extract_process_id(resp)
+            if not draft_process_id:
+                print("  [FAIL] create-draft 返回中未找到 processId", file=sys.stderr)
+                return 1
+            print(f"  [OK] 新草稿 processId={draft_process_id}")
+
+    print(f"Step 2/4: 生成流程 schema ({len(flow_json):,} 字节)")
+
+    # Step 3: save draft
+    print("Step 3/4: 保存流程草稿")
+    update_args = [
+        "yida", "design", "process", "update",
+        "--app", args.app,
+        "--process-code", args.process_code,
+        "--process-id", draft_process_id,
+        "--content", flow_json,
+        "--yes",
+        "--format", "json",
+    ]
+    if view_content:
+        update_args.extend(["--view-content", view_content])
+    resp = _run_dws(update_args, dry_run=args.dry_run)
+    if not args.dry_run and not resp:
+        return 1
+
+    # Step 4: optional publish
+    if args.publish:
+        print("Step 4/4: 发布流程")
+        resp = _run_dws([
+            "yida", "design", "process", "publish",
+            "--app", args.app,
+            "--process-code", args.process_code,
+            "--process-id", draft_process_id,
+            "--yes",
+            "--format", "json",
+        ], dry_run=args.dry_run)
+        if not args.dry_run and not resp:
+            return 1
+    else:
+        print("Step 4/4: 跳过发布（未传 --publish）")
+
+    print(json.dumps({
+        "ok": True,
+        "app": args.app,
+        "processCode": args.process_code,
+        "draftProcessId": draft_process_id,
+        "schemaSize": len(flow_json),
+        "published": bool(args.publish),
+        "dryRun": bool(args.dry_run),
+    }, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())