1479 lines
59 KiB
Python
1479 lines
59 KiB
Python
#!/usr/bin/env python3
|
||
"""Shared Yida process-flow schema builder.
|
||
|
||
The schema consumed by integration automation and design process update is the
|
||
same shape:
|
||
|
||
{"props": {"processCode": "TPROC-xxx", ...}, "nodes": [...]}
|
||
|
||
This module accepts either that ready-to-save shape or the flatter node objects
|
||
described in references/yida-process-node.md, then normalizes them into
|
||
the save payload used by `dws yida design process update --content`.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import copy
|
||
from typing import Any
|
||
|
||
|
||
FLOW_PROP_KEYS = ("allowWithdraw", "allowCollaboration", "allowTemporaryStorage")
|
||
FLOW_TOP_LEVEL_KEYS = ("flowConfig", "formulaRules", "approvalSummary", "nodeI18nKeyMap")
|
||
|
||
NODE_CORE_KEYS = {
|
||
"type",
|
||
"componentName",
|
||
"nodeType",
|
||
"tool",
|
||
"toolName",
|
||
"kind",
|
||
"nodeId",
|
||
"name",
|
||
"description",
|
||
"title",
|
||
"approvalType",
|
||
"nextId",
|
||
"prevId",
|
||
"props",
|
||
"childNodes",
|
||
}
|
||
|
||
TYPE_ALIASES = {
|
||
"create_trigger_node": "trigger",
|
||
"trigger_node": "trigger",
|
||
"trigger": "trigger",
|
||
"create_timer_trigger_node": "trigger",
|
||
"timer_trigger_node": "trigger",
|
||
"timerTrigger": "trigger",
|
||
"create_data_create_node": "dataCreate",
|
||
"data_create_node": "dataCreate",
|
||
"AddDataNode": "dataCreate",
|
||
"addData": "dataCreate",
|
||
"dataCreate": "dataCreate",
|
||
"create_data_update_node": "dataUpdate",
|
||
"data_update_node": "dataUpdate",
|
||
"UpdateDataNode": "dataUpdate",
|
||
"updateData": "dataUpdate",
|
||
"dataUpdate": "dataUpdate",
|
||
"create_data_retrieve_node": "dataRetrieve",
|
||
"data_retrieve_node": "dataRetrieve",
|
||
"GetSingleDataNode": "dataRetrieve",
|
||
"GetBatchDataNode": "dataRetrieve",
|
||
"getSingleData": "dataRetrieve",
|
||
"getBatchData": "dataRetrieve",
|
||
"dataRetrieve": "dataRetrieve",
|
||
"DeleteDataNode": "dataDelete",
|
||
"deleteData": "dataDelete",
|
||
"dataDelete": "dataDelete",
|
||
"create_connector_node": "connector",
|
||
"connector_node": "connector",
|
||
"ConnectorNode": "connector",
|
||
"connector": "connector",
|
||
"create_send_message_node": "sendMessage",
|
||
"send_message_node": "sendMessage",
|
||
"SendMessageNode": "sendMessage",
|
||
"sendMessage": "sendMessage",
|
||
"create_send_email_node": "sendEmail",
|
||
"send_email_node": "sendEmail",
|
||
"SendEmailNode": "sendEmail",
|
||
"sendEmail": "sendEmail",
|
||
"create_send_card_node": "sendCard",
|
||
"send_card_node": "sendCard",
|
||
"SendCardNode": "sendCard",
|
||
"CardNode": "sendCard",
|
||
"sendCard": "sendCard",
|
||
"create_update_card_node": "updateCard",
|
||
"update_card_node": "updateCard",
|
||
"UpdateCardNode": "updateCard",
|
||
"CardUpdateNode": "updateCard",
|
||
"updateCard": "updateCard",
|
||
"create_route_node": "route",
|
||
"route_node": "route",
|
||
"ConditionContainer": "route",
|
||
"route": "route",
|
||
"ConditionNode": "condition",
|
||
"ParallelNode": "condition",
|
||
"condition": "condition",
|
||
"create_foreach_node": "forEach",
|
||
"foreach_node": "forEach",
|
||
"CycleContainer": "forEach",
|
||
"forEach": "forEach",
|
||
"foreach": "forEach",
|
||
"create_initiate_approval_node": "initiateApproval",
|
||
"initiate_approval_node": "initiateApproval",
|
||
"InitiateApprovalNode": "initiateApproval",
|
||
"subProcess": "initiateApproval",
|
||
"initiateApproval": "initiateApproval",
|
||
"create_approver_node": "approver",
|
||
"approver_node": "approver",
|
||
"ApprovalNode": "approval",
|
||
"MultiApprovalNode": "approval",
|
||
"approver": "approver",
|
||
"create_executor_node": "executor",
|
||
"executor_node": "executor",
|
||
"OperatorNode": "operator",
|
||
"executor": "executor",
|
||
"create_carbon_copy_node": "carbonCopy",
|
||
"carbon_copy_node": "carbonCopy",
|
||
"CarbonNode": "carbon",
|
||
"carbonCopy": "carbonCopy",
|
||
"GroovyNode": "CodeExecutor",
|
||
"groovy": "CodeExecutor",
|
||
"JavaScriptNode": "CodeExecutor",
|
||
"javascript": "CodeExecutor",
|
||
"AINode": "AIExecutor",
|
||
"ai": "AIExecutor",
|
||
"create_finish_node": "finish",
|
||
"finish_node": "finish",
|
||
"EndNode": "finish",
|
||
"finish": "finish",
|
||
}
|
||
|
||
DEFAULT_NODE_NAMES = {
|
||
"apply": "发起",
|
||
"approval": "审批人",
|
||
"operator": "执行人",
|
||
"carbon": "抄送人",
|
||
"trigger": "表单事件触发",
|
||
"dataCreate": "新增数据",
|
||
"dataUpdate": "更新数据",
|
||
"dataRetrieve": "获取数据",
|
||
"dataDelete": "删除数据",
|
||
"connector": "连接器",
|
||
"sendMessage": "消息通知",
|
||
"sendEmail": "发送邮件",
|
||
"sendCard": "发送卡片",
|
||
"updateCard": "更新卡片",
|
||
"route": "ConditionContainer",
|
||
"condition": "条件",
|
||
"forEach": "循环容器",
|
||
"foreach": "循环容器",
|
||
"initiateApproval": "发起审批",
|
||
"CodeExecutor": "脚本",
|
||
"AIExecutor": "AI 节点",
|
||
"approver": "审批人",
|
||
"executor": "执行人",
|
||
"carbonCopy": "抄送人",
|
||
"finish": "结束",
|
||
}
|
||
|
||
VIEW_COMPONENT_BY_TYPE = {
|
||
"apply": "ApplyNode",
|
||
"approval": "ApprovalNode",
|
||
"operator": "OperatorNode",
|
||
"carbon": "CarbonNode",
|
||
"connector": "ConnectorNode",
|
||
"dataCreate": "AddDataNode",
|
||
"dataUpdate": "UpdateDataNode",
|
||
"dataRetrieve": "GetSingleDataNode",
|
||
"dataDelete": "DeleteDataNode",
|
||
"sendMessage": "SendMessageNode",
|
||
"sendEmail": "SendEmailNode",
|
||
"sendCard": "CardNode",
|
||
"updateCard": "CardUpdateNode",
|
||
"route": "ConditionContainer",
|
||
"condition": "ConditionNode",
|
||
"initiateApproval": "InitiateApprovalNode",
|
||
"approver": "ApprovalNode",
|
||
"executor": "OperatorNode",
|
||
"carbonCopy": "CarbonNode",
|
||
"forEach": "CycleContainer",
|
||
"foreach": "CycleContainer",
|
||
"AIExecutor": "AINode",
|
||
"CodeExecutor": "JavaScriptNode",
|
||
"finish": "EndNode",
|
||
}
|
||
|
||
VIEW_COMPONENT_RULE_KEY = {
|
||
"ConnectorNode": "connectorRules",
|
||
"AddDataNode": "addDataRules",
|
||
"UpdateDataNode": "updateDataRules",
|
||
"DeleteDataNode": "deleteData",
|
||
"GetSingleDataNode": "getData",
|
||
"GetBatchDataNode": "getData",
|
||
"SendMessageNode": "sendMessageRules",
|
||
"SendEmailNode": "sendEmailRules",
|
||
"CardNode": "cardRules",
|
||
"CardUpdateNode": "cardUpdateRules",
|
||
"InitiateApprovalNode": "initiateApprovalRules",
|
||
"CycleContainer": "cycleContainerRules",
|
||
"AINode": "workFlowRules",
|
||
"GroovyNode": "groovy",
|
||
"JavaScriptNode": "JavaScript",
|
||
}
|
||
|
||
TRIGGER_INPUT_KEYS = {
|
||
"formUuid",
|
||
"formEventType",
|
||
"formEventField",
|
||
"triggerFormEventRecursively",
|
||
"conditions",
|
||
"startDate",
|
||
"repeat",
|
||
"end",
|
||
}
|
||
|
||
UNRESOLVED_CARD_BIZ_ID_VALUES = {
|
||
"__masterdata_form_inst_id",
|
||
}
|
||
|
||
|
||
class FlowSchemaError(ValueError):
|
||
"""Raised when a flow spec cannot be normalized safely."""
|
||
|
||
|
||
def i18n_name(value: Any, default: str) -> dict[str, str]:
|
||
if isinstance(value, dict):
|
||
result = copy.deepcopy(value)
|
||
result.setdefault("zh_CN", result.get("name") or default)
|
||
result.setdefault("en_US", "")
|
||
result.setdefault("type", "i18n")
|
||
return result
|
||
text = str(value or default)
|
||
return {"zh_CN": text, "en_US": "", "type": "i18n"}
|
||
|
||
|
||
def normalize_next_id(value: Any) -> list[str]:
|
||
if value is None:
|
||
return []
|
||
if isinstance(value, str):
|
||
return [value] if value else []
|
||
if isinstance(value, list):
|
||
return [str(item) for item in value if item not in (None, "")]
|
||
raise FlowSchemaError(f"nextId must be string or list, got {type(value).__name__}")
|
||
|
||
|
||
def normalize_node_type(node: dict[str, Any]) -> str:
|
||
raw = (
|
||
node.get("componentName")
|
||
or node.get("nodeType")
|
||
or node.get("tool")
|
||
or node.get("toolName")
|
||
or node.get("kind")
|
||
or node.get("type")
|
||
)
|
||
if not raw:
|
||
raise FlowSchemaError(f"node {node.get('nodeId') or '<unknown>'} missing type")
|
||
raw = str(raw)
|
||
return TYPE_ALIASES.get(raw, raw)
|
||
|
||
|
||
def _normalize_trigger_props(props: dict[str, Any]) -> dict[str, Any]:
|
||
result = copy.deepcopy(props)
|
||
inputs = result.get("inputs")
|
||
if inputs is None:
|
||
inputs = {}
|
||
if not isinstance(inputs, dict):
|
||
raise FlowSchemaError("trigger props.inputs must be object")
|
||
|
||
for key in list(TRIGGER_INPUT_KEYS):
|
||
if key in result:
|
||
inputs[key] = result.pop(key)
|
||
|
||
if "triggerType" not in result:
|
||
result["triggerType"] = "TimerEvent" if ("repeat" in inputs or "startDate" in inputs) else "FormEvent"
|
||
result["inputs"] = inputs
|
||
return result
|
||
|
||
|
||
def _script_outputs_schema(outputs: Any) -> list[dict[str, Any]]:
|
||
if not isinstance(outputs, list):
|
||
return []
|
||
result = []
|
||
for item in outputs:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
result.append({
|
||
"description": item.get("desc") or item.get("description") or "",
|
||
"name": item.get("name"),
|
||
"type": item.get("type"),
|
||
"valueType": item.get("valueType"),
|
||
})
|
||
return result
|
||
|
||
|
||
def _normalize_process_payload(node_type: str, props: dict[str, Any]) -> tuple[str, dict[str, Any]]:
|
||
result = copy.deepcopy(props)
|
||
|
||
if node_type in {"approval", "approver", "operator", "executor"} and isinstance(result.get("approver"), dict):
|
||
approver = result["approver"]
|
||
if approver.get("approvalType") and not result.get("approvalType"):
|
||
result["approvalType"] = copy.deepcopy(approver["approvalType"])
|
||
if approver.get("approvals") is not None and "approvals" not in result:
|
||
result["approvals"] = copy.deepcopy(approver.get("approvals"))
|
||
if isinstance(approver.get("approverRules"), dict) and "approverRules" not in result:
|
||
result["approverRules"] = copy.deepcopy(approver["approverRules"])
|
||
|
||
if node_type == "dataRetrieve" and isinstance(result.get("getData"), dict):
|
||
return node_type, copy.deepcopy(result["getData"])
|
||
if node_type == "dataUpdate" and isinstance(result.get("updateDataRules"), dict):
|
||
return node_type, copy.deepcopy(result["updateDataRules"])
|
||
if node_type == "dataDelete" and isinstance(result.get("deleteData"), dict):
|
||
return node_type, copy.deepcopy(result["deleteData"])
|
||
if node_type == "sendMessage" and isinstance(result.get("sendMessageRules"), dict):
|
||
payload = copy.deepcopy(result["sendMessageRules"])
|
||
payload.pop("description", None)
|
||
return node_type, payload
|
||
if node_type == "sendEmail" and isinstance(result.get("sendEmailRules"), dict):
|
||
return node_type, copy.deepcopy(result["sendEmailRules"])
|
||
if node_type == "sendCard":
|
||
if isinstance(result.get("sendCardRules"), dict):
|
||
return node_type, copy.deepcopy(result["sendCardRules"])
|
||
if isinstance(result.get("cardRules"), dict):
|
||
return node_type, copy.deepcopy(result["cardRules"])
|
||
if node_type == "updateCard":
|
||
if isinstance(result.get("updateCardRules"), dict):
|
||
return node_type, copy.deepcopy(result["updateCardRules"])
|
||
if isinstance(result.get("cardUpdateRules"), dict):
|
||
return node_type, copy.deepcopy(result["cardUpdateRules"])
|
||
if node_type == "initiateApproval" and isinstance(result.get("initiateApprovalRules"), dict):
|
||
return node_type, copy.deepcopy(result["initiateApprovalRules"])
|
||
if node_type == "forEach":
|
||
if isinstance(result.get("cycleContainerRules"), dict):
|
||
return "foreach", copy.deepcopy(result["cycleContainerRules"])
|
||
if isinstance(result.get("cycleRules"), dict):
|
||
return "foreach", copy.deepcopy(result["cycleRules"])
|
||
if isinstance(result.get("foreachRules"), dict):
|
||
return "foreach", copy.deepcopy(result["foreachRules"])
|
||
if node_type == "AIExecutor" and isinstance(result.get("workFlowRules"), dict):
|
||
workflow = result["workFlowRules"]
|
||
return node_type, {
|
||
"type": "aiFlow",
|
||
"action": {"flowId": workflow.get("flowId")},
|
||
"outputs": copy.deepcopy(workflow.get("outputs") or []),
|
||
"yidaFieldIdList": copy.deepcopy(workflow.get("yidaFieldIdList") or []),
|
||
}
|
||
if node_type == "CodeExecutor":
|
||
script = result.get("JavaScript") if isinstance(result.get("JavaScript"), dict) else None
|
||
script_type = "JavaScript"
|
||
if script is None and isinstance(result.get("groovy"), dict):
|
||
script = result.get("groovy")
|
||
script_type = "groovy"
|
||
if script is not None:
|
||
return node_type, {
|
||
"inputs": copy.deepcopy(script.get("inputs")),
|
||
"action": copy.deepcopy(script.get("action")),
|
||
"scriptType": script.get("scriptType") or script_type,
|
||
"outputsSchema": _script_outputs_schema(script.get("outputs")),
|
||
}
|
||
|
||
return node_type, result
|
||
|
||
|
||
def _contains_originator_keyword(value: Any) -> bool:
|
||
text = _i18n_text(value, "").lower()
|
||
return any(keyword in text for keyword in ("申请人", "发起人", "applicant", "originator"))
|
||
|
||
|
||
def _actioner_targets_originator(value: Any) -> bool:
|
||
if isinstance(value, str):
|
||
return value.lower() in {"originator", "$originator", "applicant", "$applicant"} or value in {"申请人", "发起人"}
|
||
if not isinstance(value, dict):
|
||
return False
|
||
|
||
rule_type = str(value.get("type") or value.get("approvalType") or "").lower()
|
||
if rule_type in {"originator", "ext_target_approval_originator"}:
|
||
return True
|
||
|
||
for key in ("value", "id", "userId", "fieldId", "fieldName", "label", "name", "description"):
|
||
if _actioner_targets_originator(value.get(key)):
|
||
return True
|
||
return False
|
||
|
||
|
||
def _is_originator_operator_node(node_type: str, node: dict[str, Any], props: dict[str, Any]) -> bool:
|
||
if node_type not in {"operator", "executor"}:
|
||
return False
|
||
if _actioner_targets_originator(props.get("actionerRule")):
|
||
return True
|
||
if _actioner_targets_originator(props.get("executor")) or _actioner_targets_originator(props.get("approver")):
|
||
return True
|
||
if _contains_originator_keyword(node.get("name")) or _contains_originator_keyword(node.get("description")):
|
||
return True
|
||
if _contains_originator_keyword(props.get("name")) or _contains_originator_keyword(props.get("description")):
|
||
return True
|
||
return False
|
||
|
||
|
||
def _operator_action_to_approval_action(action: Any) -> dict[str, Any] | None:
|
||
if isinstance(action, dict):
|
||
normalized = copy.deepcopy(action)
|
||
raw_action = str(normalized.get("action") or "").lower()
|
||
if raw_action in {"submit", "confirm"}:
|
||
normalized["action"] = "agree"
|
||
normalized.setdefault("hidden", False)
|
||
normalized.setdefault("name", i18n_name(normalized.get("name") or normalized.get("text"), "确认"))
|
||
normalized.setdefault("text", copy.deepcopy(normalized["name"]))
|
||
normalized.setdefault("alias", copy.deepcopy(normalized["name"]))
|
||
return normalized
|
||
|
||
raw = str(action or "").lower()
|
||
if raw in {"submit", "confirm", "agree"}:
|
||
return {
|
||
"hidden": False,
|
||
"name": {"en_US": "Confirm", "zh_CN": "确认", "type": "i18n"},
|
||
"text": {"en_US": "Confirm", "zh_CN": "确认", "type": "i18n"},
|
||
"action": "agree",
|
||
"alias": {"en_US": "Confirm", "zh_CN": "确认", "type": "i18n"},
|
||
}
|
||
if raw in {"transfer", "forward"}:
|
||
return {
|
||
"hidden": True,
|
||
"name": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
"text": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
"action": "forward",
|
||
"alias": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
}
|
||
return None
|
||
|
||
|
||
def _originator_approval_props_from_operator(props: dict[str, Any]) -> dict[str, Any]:
|
||
result = copy.deepcopy(props)
|
||
result.pop("actionerRule", None)
|
||
result.pop("finishRule", None)
|
||
result.pop("executor", None)
|
||
result.pop("approver", None)
|
||
|
||
result["approvals"] = [["originator"]]
|
||
approver_rules = copy.deepcopy(result.get("approverRules") if isinstance(result.get("approverRules"), dict) else {})
|
||
approver_rules.update({
|
||
"type": "ext_target_approval_originator",
|
||
"mode": "ApprovalNode_rules_only",
|
||
"approverList": [{"type": "ext_target_approval"}],
|
||
"multiApproverType": approver_rules.get("multiApproverType", "all"),
|
||
"conditionalMode": approver_rules.get("conditionalMode", "conditional"),
|
||
"approvals": [["originator"]],
|
||
"description": approver_rules.get("description") or "发起人本人",
|
||
})
|
||
result["approverRules"] = approver_rules
|
||
|
||
raw_actions = result.get("actions")
|
||
converted_actions = [
|
||
converted
|
||
for converted in (_operator_action_to_approval_action(item) for item in raw_actions or [])
|
||
if converted is not None
|
||
]
|
||
if not converted_actions:
|
||
converted_actions = [
|
||
_operator_action_to_approval_action("submit"),
|
||
_operator_action_to_approval_action("transfer"),
|
||
]
|
||
result["actions"] = [item for item in converted_actions if item is not None]
|
||
result.setdefault("appendActions", [])
|
||
result.setdefault("openDigitalSign", False)
|
||
result.setdefault("noActionersType", "stopProcess")
|
||
return result
|
||
|
||
|
||
def normalize_node(node: dict[str, Any]) -> dict[str, Any]:
|
||
if not isinstance(node, dict):
|
||
raise FlowSchemaError(f"node must be object, got {type(node).__name__}")
|
||
|
||
node_type = normalize_node_type(node)
|
||
node_id = node.get("nodeId")
|
||
if not isinstance(node_id, str) or not node_id:
|
||
raise FlowSchemaError(f"{node_type} node missing nodeId")
|
||
|
||
props = copy.deepcopy(node.get("props") or {})
|
||
if not isinstance(props, dict):
|
||
raise FlowSchemaError(f"node {node_id} props must be object")
|
||
|
||
for key, value in node.items():
|
||
if key == "type" and (
|
||
node.get("componentName")
|
||
or node.get("nodeType")
|
||
or node.get("tool")
|
||
or node.get("toolName")
|
||
or node.get("kind")
|
||
):
|
||
props[key] = copy.deepcopy(value)
|
||
continue
|
||
if key not in NODE_CORE_KEYS:
|
||
props[key] = copy.deepcopy(value)
|
||
|
||
if node_type == "trigger":
|
||
props = _normalize_trigger_props(props)
|
||
node_type, props = _normalize_process_payload(node_type, props)
|
||
approval_type = copy.deepcopy(node.get("approvalType")) if "approvalType" in node else copy.deepcopy(props.get("approvalType"))
|
||
if _is_originator_operator_node(node_type, node, props):
|
||
node_type = "approval"
|
||
approval_type = "ext_target_approval_originator"
|
||
props = _originator_approval_props_from_operator(props)
|
||
|
||
child_nodes = node.get("childNodes") or []
|
||
if not isinstance(child_nodes, list):
|
||
raise FlowSchemaError(f"node {node_id} childNodes must be list")
|
||
|
||
normalized = {
|
||
"name": i18n_name(node.get("name"), DEFAULT_NODE_NAMES.get(node_type, node_type)),
|
||
"type": node_type,
|
||
"nodeId": node_id,
|
||
"nextId": normalize_next_id(node.get("nextId")),
|
||
"props": props,
|
||
"childNodes": [normalize_node(child) for child in child_nodes],
|
||
}
|
||
if "prevId" in node:
|
||
normalized["prevId"] = node["prevId"]
|
||
if "description" in node:
|
||
normalized["description"] = copy.deepcopy(node.get("description"))
|
||
if "title" in node:
|
||
normalized["title"] = copy.deepcopy(node.get("title"))
|
||
if approval_type is not None:
|
||
normalized["approvalType"] = approval_type
|
||
return normalized
|
||
|
||
|
||
def _walk_nodes(nodes: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||
result: list[dict[str, Any]] = []
|
||
for node in nodes:
|
||
result.append(node)
|
||
result.extend(_walk_nodes(node.get("childNodes") or []))
|
||
return result
|
||
|
||
|
||
def _node_label(node: dict[str, Any]) -> str:
|
||
return f"{node.get('nodeId') or '<unknown>'}({ _i18n_text(node.get('name'), str(node.get('type') or 'node')) })"
|
||
|
||
|
||
def _non_empty_assignments(value: Any) -> bool:
|
||
return isinstance(value, list) and any(isinstance(item, dict) for item in value)
|
||
|
||
|
||
def _rule_list_has_entries(value: Any) -> bool:
|
||
if not isinstance(value, dict):
|
||
return False
|
||
rules = value.get("rules")
|
||
if isinstance(rules, list):
|
||
return any(isinstance(item, dict) for item in rules)
|
||
if isinstance(rules, dict):
|
||
return _rule_list_has_entries(rules)
|
||
return False
|
||
|
||
|
||
def _validate_assignment_columns(node: dict[str, Any], assignments: Any) -> None:
|
||
if not isinstance(assignments, list):
|
||
return
|
||
for index, assignment in enumerate(assignments, start=1):
|
||
if not isinstance(assignment, dict):
|
||
raise FlowSchemaError(f"{_node_label(node)} assignment #{index} must be object")
|
||
if not assignment.get("column"):
|
||
raise FlowSchemaError(f"{_node_label(node)} assignment #{index} missing column")
|
||
if not assignment.get("valueType"):
|
||
raise FlowSchemaError(f"{_node_label(node)} assignment #{index} missing valueType")
|
||
|
||
|
||
def _validate_designer_runtime_node(node: dict[str, Any]) -> None:
|
||
node_type = str(node.get("type") or "")
|
||
props = node.get("props")
|
||
if not isinstance(props, dict):
|
||
return
|
||
|
||
if node_type == "dataCreate":
|
||
if not props.get("formUuid"):
|
||
raise FlowSchemaError(f"{_node_label(node)} AddDataNode missing target formUuid")
|
||
assignments = props.get("assignments")
|
||
has_rules = _rule_list_has_entries(props.get("rules"))
|
||
add_data_rules = props.get("addDataRules") if isinstance(props.get("addDataRules"), dict) else {}
|
||
has_add_rules = _rule_list_has_entries(add_data_rules.get("rules"))
|
||
if not (_non_empty_assignments(assignments) or has_rules or has_add_rules):
|
||
raise FlowSchemaError(f"{_node_label(node)} AddDataNode missing field assignment rules")
|
||
_validate_assignment_columns(node, assignments)
|
||
|
||
if node_type == "dataUpdate":
|
||
if not props.get("sourceId"):
|
||
raise FlowSchemaError(f"{_node_label(node)} UpdateDataNode missing sourceId")
|
||
assignments = props.get("assignments")
|
||
update_rules = props.get("updateDataRules") if isinstance(props.get("updateDataRules"), dict) else {}
|
||
has_update_rules = _rule_list_has_entries(update_rules.get("rules"))
|
||
if not (_non_empty_assignments(assignments) or has_update_rules):
|
||
raise FlowSchemaError(f"{_node_label(node)} UpdateDataNode missing field assignment rules")
|
||
_validate_assignment_columns(node, assignments)
|
||
|
||
if node_type == "dataRetrieve":
|
||
if not props.get("sourceId"):
|
||
raise FlowSchemaError(f"{_node_label(node)} GetDataNode missing sourceId")
|
||
|
||
if node_type == "sendCard":
|
||
if not props.get("cardAppId"):
|
||
raise FlowSchemaError(f"{_node_label(node)} CardNode missing cardAppId")
|
||
if not props.get("cardPageCode"):
|
||
raise FlowSchemaError(f"{_node_label(node)} CardNode missing cardPageCode")
|
||
if props.get("sendType") == "update":
|
||
biz_id = props.get("bizId") if isinstance(props.get("bizId"), dict) else {}
|
||
value = str(biz_id.get("value") or "")
|
||
if not value:
|
||
raise FlowSchemaError(f"{_node_label(node)} CardNode sendType=update missing bizId.value")
|
||
if value in UNRESOLVED_CARD_BIZ_ID_VALUES:
|
||
raise FlowSchemaError(
|
||
f"{_node_label(node)} CardNode bizId.value={value!r} is not designer-visible; "
|
||
"choose a real variable from the designer dropdown, such as a current form fieldId"
|
||
)
|
||
|
||
|
||
def validate_flow_schema(flow: dict[str, Any]) -> None:
|
||
if not isinstance(flow, dict):
|
||
raise FlowSchemaError("flow schema must be object")
|
||
props = flow.get("props")
|
||
nodes = flow.get("nodes")
|
||
if not isinstance(props, dict):
|
||
raise FlowSchemaError("flow schema missing props object")
|
||
if not props.get("processCode"):
|
||
raise FlowSchemaError("flow schema missing props.processCode")
|
||
if not isinstance(nodes, list) or not nodes:
|
||
raise FlowSchemaError("flow schema nodes must be non-empty array")
|
||
|
||
seen: set[str] = set()
|
||
for node in _walk_nodes(nodes):
|
||
node_id = node.get("nodeId")
|
||
if node_id in seen:
|
||
raise FlowSchemaError(f"duplicate nodeId: {node_id}")
|
||
seen.add(node_id)
|
||
_validate_designer_runtime_node(node)
|
||
|
||
|
||
def build_automation_flow(
|
||
process_code: str,
|
||
nodes: list[dict[str, Any]],
|
||
*,
|
||
allow_withdraw: bool = True,
|
||
allow_collaboration: bool = True,
|
||
allow_temporary_storage: bool = True,
|
||
) -> dict[str, Any]:
|
||
if not process_code:
|
||
raise FlowSchemaError("processCode is required")
|
||
if not isinstance(nodes, list) or not nodes:
|
||
raise FlowSchemaError("nodes must be non-empty array")
|
||
|
||
flow = {
|
||
"props": {
|
||
"processCode": process_code,
|
||
"allowWithdraw": allow_withdraw,
|
||
"allowCollaboration": allow_collaboration,
|
||
"allowTemporaryStorage": allow_temporary_storage,
|
||
},
|
||
"nodes": [normalize_node(node) for node in nodes],
|
||
}
|
||
validate_flow_schema(flow)
|
||
return flow
|
||
|
||
|
||
def build_flow_schema(spec: Any, *, process_code: str | None = None) -> dict[str, Any]:
|
||
if isinstance(spec, list):
|
||
if not process_code:
|
||
raise FlowSchemaError("processCode is required when spec is a node array")
|
||
return build_automation_flow(process_code, spec)
|
||
|
||
if not isinstance(spec, dict):
|
||
raise FlowSchemaError("flow spec must be object or node array")
|
||
|
||
if "props" in spec and "nodes" in spec:
|
||
props = copy.deepcopy(spec["props"])
|
||
if not isinstance(props, dict):
|
||
raise FlowSchemaError("props must be object")
|
||
if process_code:
|
||
props["processCode"] = process_code
|
||
if "bindingForm" in spec and not props.get("bindingForm"):
|
||
props["bindingForm"] = copy.deepcopy(spec["bindingForm"])
|
||
nodes = spec["nodes"]
|
||
if not isinstance(nodes, list):
|
||
raise FlowSchemaError("nodes must be array")
|
||
flow = {"props": props, "nodes": [normalize_node(node) for node in nodes]}
|
||
for key in FLOW_PROP_KEYS:
|
||
flow["props"].setdefault(key, True)
|
||
for key in FLOW_TOP_LEVEL_KEYS:
|
||
if key in spec:
|
||
flow[key] = copy.deepcopy(spec[key])
|
||
validate_flow_schema(flow)
|
||
return flow
|
||
|
||
nodes = spec.get("nodes")
|
||
if not isinstance(nodes, list):
|
||
raise FlowSchemaError("flow spec missing nodes array")
|
||
|
||
code = process_code or spec.get("processCode")
|
||
flow = build_automation_flow(
|
||
str(code or ""),
|
||
nodes,
|
||
allow_withdraw=bool(spec.get("allowWithdraw", True)),
|
||
allow_collaboration=bool(spec.get("allowCollaboration", True)),
|
||
allow_temporary_storage=bool(spec.get("allowTemporaryStorage", True)),
|
||
)
|
||
if "bindingForm" in spec:
|
||
flow["props"]["bindingForm"] = copy.deepcopy(spec["bindingForm"])
|
||
return flow
|
||
|
||
|
||
def _i18n_text(value: Any, default: str = "") -> str:
|
||
if isinstance(value, dict):
|
||
return str(value.get("zh_CN") or value.get("en_US") or value.get("value") or default)
|
||
return str(value or default)
|
||
|
||
|
||
def _default_component_props() -> dict[str, Any]:
|
||
return {
|
||
"defaultDataSource": {},
|
||
"relateAppType": "",
|
||
"relateOrderEnable": False,
|
||
"relateOrderConfig": [],
|
||
}
|
||
|
||
|
||
def _rule_for_assignment(assignment: dict[str, Any], fields_by_id: dict[str, dict[str, Any]]) -> dict[str, Any]:
|
||
column = str(assignment.get("column") or "")
|
||
field = copy.deepcopy(fields_by_id.get(column) or {})
|
||
rule = {
|
||
"ruleId": f"rule-{column}" if column else "rule-unknown",
|
||
"name": column,
|
||
"label": field.get("label") or column,
|
||
"componentName": field.get("componentName"),
|
||
"componentOption": field.get("componentOption", "[]"),
|
||
"componentProps": copy.deepcopy(field.get("componentProps") or _default_component_props()),
|
||
"required": bool(field.get("required", False)),
|
||
"valueType": assignment.get("valueType", "literal"),
|
||
"value": assignment.get("value"),
|
||
}
|
||
for key in ("__display", "__source"):
|
||
if key in assignment:
|
||
rule[key] = copy.deepcopy(assignment[key])
|
||
return rule
|
||
|
||
|
||
def _component_option_map(child_list: list[dict[str, Any]]) -> dict[str, Any]:
|
||
return {
|
||
str(field.get("fieldId") or field.get("name") or ""): copy.deepcopy(field.get("componentOption", "[]"))
|
||
for field in child_list
|
||
if field.get("fieldId") or field.get("name")
|
||
}
|
||
|
||
|
||
def _rules_for_assignments(
|
||
assignments: list[dict[str, Any]],
|
||
child_list: list[dict[str, Any]],
|
||
existing_rules: Any = None,
|
||
) -> dict[str, Any]:
|
||
rules = copy.deepcopy(existing_rules or {})
|
||
component_option_map = _component_option_map(child_list)
|
||
if assignments and not rules.get("rules"):
|
||
fields_by_id = {str(field.get("fieldId") or field.get("name")): field for field in child_list}
|
||
rules = {
|
||
"ruleId": "rule-root",
|
||
"childList": copy.deepcopy(child_list),
|
||
"componentOptionMap": copy.deepcopy(component_option_map),
|
||
"rules": [_rule_for_assignment(item, fields_by_id) for item in assignments],
|
||
}
|
||
else:
|
||
rules.setdefault("ruleId", "rule-root")
|
||
rules.setdefault("childList", copy.deepcopy(child_list))
|
||
rules.setdefault("componentOptionMap", copy.deepcopy(component_option_map))
|
||
rules.setdefault("rules", [])
|
||
return rules
|
||
|
||
|
||
def _approval_option_lookup(props: dict[str, Any]) -> dict[str, dict[str, Any]]:
|
||
result: dict[str, dict[str, Any]] = {}
|
||
for key in ("approvalUsers", "approvalOptions", "approverOptions"):
|
||
options = props.get(key)
|
||
if not isinstance(options, list):
|
||
continue
|
||
for item in options:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
user_id = item.get("id") or item.get("userId") or item.get("value")
|
||
if isinstance(user_id, str) and user_id:
|
||
normalized = copy.deepcopy(item)
|
||
normalized.setdefault("id", user_id)
|
||
normalized.setdefault("label", item.get("name") or item.get("userName") or user_id)
|
||
normalized.setdefault("type", "employee")
|
||
normalized.setdefault("roleType", "DINGTALK")
|
||
result[user_id] = normalized
|
||
return result
|
||
|
||
|
||
def _approval_value_for_view(value: Any, options_by_id: dict[str, dict[str, Any]]) -> Any:
|
||
if isinstance(value, dict):
|
||
item = copy.deepcopy(value)
|
||
user_id = item.get("id") or item.get("userId") or item.get("value")
|
||
if isinstance(user_id, str) and user_id:
|
||
item.setdefault("id", user_id)
|
||
item.setdefault("label", item.get("name") or item.get("userName") or item.get("id") or "")
|
||
item.setdefault("type", "employee")
|
||
item.setdefault("roleType", "DINGTALK")
|
||
return item
|
||
if isinstance(value, str):
|
||
if value in options_by_id:
|
||
return copy.deepcopy(options_by_id[value])
|
||
return {
|
||
"id": value,
|
||
"label": value,
|
||
"type": "employee",
|
||
"roleType": "DINGTALK",
|
||
}
|
||
return value
|
||
|
||
|
||
def _approver_rules_for_view(node: dict[str, Any], props: dict[str, Any]) -> dict[str, Any]:
|
||
raw_rules = props.get("approverRules") if isinstance(props.get("approverRules"), dict) else {}
|
||
result = copy.deepcopy(raw_rules)
|
||
result.setdefault("type", node.get("approvalType") or props.get("approvalType") or "ext_target_approval")
|
||
result.setdefault("mode", "ApprovalNode_rules_only")
|
||
if result.get("type") == "ext_target_approval_originator":
|
||
approver_list = result.get("approverList")
|
||
if isinstance(approver_list, list) and approver_list:
|
||
normalized_list = []
|
||
for item in approver_list:
|
||
if isinstance(item, dict):
|
||
normalized = copy.deepcopy(item)
|
||
if normalized.get("type") == "ext_target_approval_originator":
|
||
normalized["type"] = "ext_target_approval"
|
||
normalized_list.append(normalized)
|
||
else:
|
||
normalized_list.append(item)
|
||
result["approverList"] = normalized_list
|
||
else:
|
||
result["approverList"] = [{"type": "ext_target_approval"}]
|
||
result.setdefault("description", "发起人本人")
|
||
else:
|
||
result.setdefault("approverList", [{"type": result["type"]}])
|
||
result.setdefault("multiApproverType", "all")
|
||
result.setdefault("conditionalMode", props.get("conditionalMode", "conditional"))
|
||
|
||
approvals = result.get("approvals", props.get("approvals", []))
|
||
if isinstance(approvals, list):
|
||
options_by_id = _approval_option_lookup(props)
|
||
result["approvals"] = [_approval_value_for_view(item, options_by_id) for item in approvals]
|
||
labels = [
|
||
str(item.get("label") or item.get("id") or "")
|
||
for item in result["approvals"]
|
||
if isinstance(item, dict)
|
||
]
|
||
if labels and not result.get("description"):
|
||
result["description"] = "、".join(label for label in labels if label)
|
||
return result
|
||
|
||
|
||
def _operator_actions_for_view(props: dict[str, Any]) -> dict[str, Any]:
|
||
normal_actions = []
|
||
for action in props.get("actions") or []:
|
||
if isinstance(action, dict):
|
||
normalized = copy.deepcopy(action)
|
||
normalized.setdefault("hidden", False)
|
||
normalized.setdefault("name", i18n_name(normalized.get("name") or normalized.get("text"), "提交"))
|
||
normalized.setdefault("text", copy.deepcopy(normalized["name"]))
|
||
normalized.setdefault("alias", copy.deepcopy(normalized["name"]))
|
||
normal_actions.append(normalized)
|
||
continue
|
||
|
||
raw = str(action or "").lower()
|
||
if raw in {"submit", "agree", "confirm"}:
|
||
normal_actions.append({
|
||
"hidden": False,
|
||
"name": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
"text": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
"action": "submit",
|
||
"alias": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
})
|
||
elif raw in {"transfer", "forward"}:
|
||
normal_actions.append({
|
||
"hidden": True,
|
||
"name": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
"text": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
"action": "forward",
|
||
"alias": {"en_US": "Forward", "zh_CN": "转交", "type": "i18n"},
|
||
})
|
||
|
||
if not normal_actions:
|
||
normal_actions.append({
|
||
"hidden": False,
|
||
"name": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
"text": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
"action": "submit",
|
||
"alias": {"en_US": "Submit", "zh_CN": "提交", "type": "i18n"},
|
||
})
|
||
|
||
return {
|
||
"normalActions": normal_actions,
|
||
"appendActions": copy.deepcopy(props.get("appendActions") or []),
|
||
}
|
||
|
||
|
||
def _operator_rules_for_view(node: dict[str, Any], props: dict[str, Any]) -> dict[str, Any]:
|
||
actioner_rule = props.get("actionerRule") if isinstance(props.get("actionerRule"), dict) else {}
|
||
if actioner_rule and not props.get("approvals") and not props.get("approverRules"):
|
||
rule_type = str(actioner_rule.get("type") or "")
|
||
value = str(actioner_rule.get("value") or "")
|
||
if rule_type == "static" and value:
|
||
props = copy.deepcopy(props)
|
||
props["approvals"] = [item.strip() for item in value.split(",") if item.strip()]
|
||
props.setdefault("approvalType", "ext_target_approval")
|
||
return _approver_rules_for_view(node, props)
|
||
|
||
|
||
def _message_recipient_description(props: dict[str, Any]) -> str:
|
||
parts: list[str] = []
|
||
|
||
for item in props.get("toUsers") or []:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
label = item.get("userName") or item.get("name") or item.get("label") or item.get("userId")
|
||
if label:
|
||
parts.append(str(label))
|
||
|
||
for item in props.get("toRoles") or []:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
label = item.get("roleName") or item.get("name") or item.get("label") or item.get("roleCode")
|
||
if label:
|
||
parts.append(str(label))
|
||
|
||
field_labels = {
|
||
"PROCESS_PARTICIPANTS": "流程参与人",
|
||
"PROCESS_APPROVERS": "流程审批人",
|
||
"PROCESS_CARBONS": "流程抄送人",
|
||
"FORM_INST_MODIFIER": "表单修改人",
|
||
}
|
||
for item in props.get("userFields") or []:
|
||
label = field_labels.get(str(item), str(item))
|
||
if label:
|
||
parts.append(label)
|
||
|
||
for key, label in (
|
||
("toVars", "变量接收人"),
|
||
("toGroups", "群组"),
|
||
("toGroupVars", "变量群组"),
|
||
("robotUrls", "机器人"),
|
||
):
|
||
values = props.get(key) or []
|
||
if values:
|
||
parts.append(label)
|
||
|
||
seen: set[str] = set()
|
||
result: list[str] = []
|
||
for part in parts:
|
||
if part not in seen:
|
||
seen.add(part)
|
||
result.append(part)
|
||
return "、".join(result)
|
||
|
||
|
||
def _send_message_rules_for_view(node: dict[str, Any], props: dict[str, Any]) -> tuple[dict[str, Any], str]:
|
||
result = copy.deepcopy(props)
|
||
description = result.get("description")
|
||
if isinstance(description, dict):
|
||
description = _i18n_text(description)
|
||
if not description and node.get("description") not in (None, ""):
|
||
description = _i18n_text(node.get("description"))
|
||
if not description:
|
||
description = _message_recipient_description(result)
|
||
if description:
|
||
result["description"] = description
|
||
return result, str(description or "")
|
||
|
||
|
||
def _condition_description(condition_group: Any) -> str:
|
||
if not isinstance(condition_group, dict):
|
||
return ""
|
||
rules = condition_group.get("rules")
|
||
if not isinstance(rules, list):
|
||
return ""
|
||
parts = []
|
||
for rule in rules:
|
||
if not isinstance(rule, dict):
|
||
continue
|
||
name = str(rule.get("name") or rule.get("id") or "")
|
||
op = str(rule.get("op") or rule.get("opCode") or "")
|
||
value = rule.get("ruleValue", rule.get("value", ""))
|
||
if isinstance(value, list):
|
||
value_text = "、".join(str(item.get("label") or item.get("name") or item.get("id") or item) if isinstance(item, dict) else str(item) for item in value)
|
||
else:
|
||
value_text = str(value)
|
||
if name and op:
|
||
parts.append(f"{name}{op}{value_text}")
|
||
return "，".join(parts)
|
||
|
||
|
||
def _condition_rules_for_view(props: dict[str, Any]) -> dict[str, Any]:
|
||
raw_conditions = props.get("conditions") if isinstance(props.get("conditions"), dict) else {}
|
||
result = copy.deepcopy(raw_conditions)
|
||
result.setdefault("condition", "AND")
|
||
result.setdefault("conditionCode", "&&")
|
||
result.setdefault("rules", [])
|
||
result["calculate"] = props.get("calculate") or raw_conditions.get("calculate") or "condition"
|
||
result["conditions"] = copy.deepcopy(raw_conditions)
|
||
result["isDefault"] = bool(props.get("isDefault", raw_conditions.get("isDefault", False)))
|
||
if "priority" in props:
|
||
result["priority"] = props["priority"]
|
||
elif "priority" in raw_conditions:
|
||
result["priority"] = raw_conditions["priority"]
|
||
description = props.get("description") or raw_conditions.get("description") or _condition_description(raw_conditions)
|
||
if not description and result.get("calculate") == "all" and not result.get("rules"):
|
||
description = "全部数据"
|
||
if description:
|
||
result["description"] = description
|
||
return result
|
||
|
||
|
||
def _build_add_data_rules(
|
||
node_props: dict[str, Any],
|
||
*,
|
||
fields: list[dict[str, Any]] | None = None,
|
||
form_title: str = "",
|
||
) -> dict[str, Any]:
|
||
raw_add_rules = node_props.get("addDataRules") if isinstance(node_props.get("addDataRules"), dict) else {}
|
||
child_list = copy.deepcopy(fields or raw_add_rules.get("inputs", {}).get("childList") or [])
|
||
component_option_map = _component_option_map(child_list)
|
||
|
||
assignments = copy.deepcopy(node_props.get("assignments") or raw_add_rules.get("assignments") or [])
|
||
rules = _rules_for_assignments(assignments, child_list, raw_add_rules.get("rules") or node_props.get("rules"))
|
||
|
||
inputs = copy.deepcopy(raw_add_rules.get("inputs") or node_props.get("inputs") or {})
|
||
inputs.setdefault("childList", copy.deepcopy(child_list))
|
||
inputs.setdefault("componentOptionMap", component_option_map)
|
||
|
||
description = raw_add_rules.get("description")
|
||
if isinstance(description, dict):
|
||
description = _i18n_text(description)
|
||
if not description and form_title:
|
||
description = f"在 [{form_title}] 中新增数据"
|
||
if not description:
|
||
description = node_props.get("description")
|
||
if isinstance(description, dict):
|
||
description = _i18n_text(description)
|
||
|
||
return {
|
||
"formUuid": node_props.get("formUuid", raw_add_rules.get("formUuid", "")),
|
||
"appType": node_props.get("appType", raw_add_rules.get("appType", "")),
|
||
"subFormUuid": node_props.get("subFormUuid", raw_add_rules.get("subFormUuid", "")),
|
||
"insertType": (
|
||
node_props.get("insertType")
|
||
or raw_add_rules.get("insertType")
|
||
or node_props.get("originalType")
|
||
or raw_add_rules.get("originalType")
|
||
or "form"
|
||
),
|
||
"originalType": node_props.get("originalType", raw_add_rules.get("originalType", "form")),
|
||
"type": node_props.get("type", raw_add_rules.get("type", "single")),
|
||
"sourceId": node_props.get("sourceId", raw_add_rules.get("sourceId", "")),
|
||
"assignments": copy.deepcopy(raw_add_rules.get("assignments") or []),
|
||
"inputs": inputs,
|
||
"rules": rules,
|
||
"description": description or None,
|
||
}
|
||
|
||
|
||
def _normalize_none_operation(value: Any) -> str:
|
||
raw = str(value or "").strip()
|
||
lowered = raw.lower()
|
||
if lowered in {"add", "新增一条数据"} or raw == "ADD":
|
||
return "add"
|
||
if lowered in {"ignored", "ignore", "skip", "跳过当前节点"} or raw == "IGNORED":
|
||
return "ignored"
|
||
return lowered or "ignored"
|
||
|
||
|
||
def _condition_rule_text(rule: Any) -> str:
|
||
if not isinstance(rule, dict):
|
||
return ""
|
||
name = str(rule.get("name") or rule.get("label") or rule.get("id") or rule.get("column") or "")
|
||
op = str(rule.get("op") or rule.get("opCode") or "")
|
||
value = rule.get("ruleValue") if rule.get("ruleValue") not in (None, "") else rule.get("value")
|
||
value_text = str(value or "")
|
||
if name and op and value_text:
|
||
return f"{name}{op}{value_text}"
|
||
if name and op:
|
||
return f"{name}{op}"
|
||
return name or value_text
|
||
|
||
|
||
def _condition_description_for_get_data(condition: Any) -> str:
|
||
if not isinstance(condition, dict):
|
||
return ""
|
||
rules = condition.get("rules")
|
||
if not isinstance(rules, list):
|
||
return ""
|
||
parts = [_condition_rule_text(rule) for rule in rules]
|
||
return "，".join(part for part in parts if part)
|
||
|
||
|
||
def _build_get_data_rules(
|
||
node_props: dict[str, Any],
|
||
*,
|
||
form_title: str = "",
|
||
) -> tuple[dict[str, Any], str]:
|
||
raw_get_data = node_props.get("getData") if isinstance(node_props.get("getData"), dict) else {}
|
||
get_data = copy.deepcopy(raw_get_data or node_props)
|
||
get_data.setdefault("type", node_props.get("type") or "single")
|
||
get_data.setdefault("sourceId", node_props.get("sourceId") or "")
|
||
get_data.setdefault("appType", node_props.get("appType") or "")
|
||
get_data.setdefault("originalType", node_props.get("originalType") or "form")
|
||
get_data.setdefault("subSourceId", node_props.get("subSourceId") or "")
|
||
get_data.setdefault("filterType", node_props.get("filterType") or "condition")
|
||
get_data.setdefault("quantity", str(node_props.get("quantity") or "1"))
|
||
get_data.setdefault("assignments", copy.deepcopy(node_props.get("assignments") or []))
|
||
get_data.setdefault("sort", copy.deepcopy(node_props.get("sort") or {"type": "none", "column": ""}))
|
||
|
||
description = get_data.get("description") or node_props.get("description")
|
||
if isinstance(description, dict):
|
||
description = _i18n_text(description)
|
||
if not description:
|
||
condition_text = _condition_description_for_get_data(get_data.get("condition"))
|
||
if condition_text:
|
||
description = condition_text
|
||
elif form_title:
|
||
quantity = get_data.get("quantity") or "1"
|
||
description = f"在 [{form_title}] 中查询 {quantity} 条数据"
|
||
|
||
if description:
|
||
get_data["description"] = description
|
||
condition = get_data.get("condition")
|
||
if isinstance(condition, dict):
|
||
condition.setdefault("description", description)
|
||
condition.setdefault("conditions", copy.deepcopy(condition))
|
||
return get_data, str(description or "")
|
||
|
||
|
||
def _find_data_source_form(
|
||
node_props: dict[str, Any],
|
||
*,
|
||
nodes_by_id: dict[str, dict[str, Any]] | None = None,
|
||
) -> tuple[str, str]:
|
||
app_type = str(node_props.get("appType") or "")
|
||
direct_form = node_props.get("formUuid") or node_props.get("sourceFormUuid")
|
||
if isinstance(direct_form, str) and direct_form:
|
||
return app_type, direct_form
|
||
|
||
source_id = str(node_props.get("sourceId") or "")
|
||
if source_id.startswith("FORM-"):
|
||
return app_type, source_id
|
||
|
||
source_node = (nodes_by_id or {}).get(source_id)
|
||
if isinstance(source_node, dict):
|
||
props = source_node.get("props") if isinstance(source_node.get("props"), dict) else {}
|
||
source_app = str(props.get("appType") or app_type)
|
||
source_form = props.get("formUuid") or props.get("sourceId")
|
||
if isinstance(source_form, str) and source_form.startswith("FORM-"):
|
||
return source_app, source_form
|
||
return app_type, ""
|
||
|
||
|
||
def _build_update_data_rules(
|
||
node_props: dict[str, Any],
|
||
*,
|
||
fields: list[dict[str, Any]] | None = None,
|
||
form_title: str = "",
|
||
) -> tuple[dict[str, Any], str]:
|
||
raw_update_rules = node_props.get("updateDataRules") if isinstance(node_props.get("updateDataRules"), dict) else {}
|
||
rules = copy.deepcopy(raw_update_rules or node_props)
|
||
child_list = copy.deepcopy(fields or raw_update_rules.get("inputs", {}).get("childList") or [])
|
||
component_option_map = _component_option_map(child_list)
|
||
assignments = copy.deepcopy(node_props.get("assignments") or raw_update_rules.get("assignments") or [])
|
||
|
||
rules.setdefault("type", node_props.get("type") or "node")
|
||
rules.setdefault("sourceId", node_props.get("sourceId") or "")
|
||
rules.setdefault("subSourceId", node_props.get("subSourceId") or "")
|
||
rules.setdefault("condition", copy.deepcopy(node_props.get("condition") or {}))
|
||
rules.setdefault("subCondition", copy.deepcopy(node_props.get("subCondition") or {}))
|
||
rules["assignments"] = assignments
|
||
display_rules = _rules_for_assignments(assignments, child_list, raw_update_rules.get("rules") or node_props.get("rules"))
|
||
rules["rules"] = display_rules
|
||
rules["dataRules"] = copy.deepcopy(
|
||
raw_update_rules.get("dataRules")
|
||
or node_props.get("dataRules")
|
||
or display_rules
|
||
)
|
||
inputs = copy.deepcopy(raw_update_rules.get("inputs") or node_props.get("inputs") or {})
|
||
inputs.setdefault("childList", copy.deepcopy(child_list))
|
||
inputs.setdefault("componentOptionMap", component_option_map)
|
||
rules["inputs"] = inputs
|
||
rules.setdefault("rulesFilter", copy.deepcopy(node_props.get("rulesFilter") or []))
|
||
rules.setdefault("tableRulesFilter", copy.deepcopy(node_props.get("tableRulesFilter") or []))
|
||
rules["noneOperation"] = _normalize_none_operation(
|
||
raw_update_rules.get("noneOperation") or node_props.get("noneOperation")
|
||
)
|
||
|
||
description = rules.get("description") or node_props.get("description")
|
||
if isinstance(description, dict):
|
||
description = _i18n_text(description)
|
||
if not description and form_title:
|
||
description = f"更新 [{form_title}] 中的数据"
|
||
if description:
|
||
rules["description"] = description
|
||
return rules, str(description or "")
|
||
|
||
|
||
def _view_component_name_for_node(node: dict[str, Any]) -> str:
|
||
node_type = str(node.get("type") or "")
|
||
props = node.get("props") if isinstance(node.get("props"), dict) else {}
|
||
if node_type == "dataRetrieve":
|
||
get_data = props.get("getData") if isinstance(props.get("getData"), dict) else props
|
||
retrieve_type = str(get_data.get("type") or "").lower()
|
||
return "GetBatchDataNode" if retrieve_type in {"batch", "multiple", "multi"} else "GetSingleDataNode"
|
||
if node_type == "CodeExecutor":
|
||
if "groovy" in props or str(props.get("scriptType") or "").lower() == "groovy":
|
||
return "GroovyNode"
|
||
return "JavaScriptNode"
|
||
return VIEW_COMPONENT_BY_TYPE.get(node_type, str(node.get("componentName") or node_type))
|
||
|
||
|
||
def _view_props_for_node(
|
||
node: dict[str, Any],
|
||
*,
|
||
data_create_metadata: dict[tuple[str, str], dict[str, Any]] | None = None,
|
||
nodes_by_id: dict[str, dict[str, Any]] | None = None,
|
||
) -> dict[str, Any]:
|
||
node_type = str(node.get("type") or "")
|
||
component_name = _view_component_name_for_node(node)
|
||
props = copy.deepcopy(node.get("props") or {})
|
||
name = copy.deepcopy(node.get("name") or i18n_name(None, DEFAULT_NODE_NAMES.get(node_type, node_type)))
|
||
if node.get("description") not in (None, ""):
|
||
props.setdefault("description", copy.deepcopy(node["description"]))
|
||
|
||
view_props: dict[str, Any] = {
|
||
"nodeName": component_name,
|
||
"name": name,
|
||
}
|
||
if node.get("description") not in (None, ""):
|
||
view_props["description"] = copy.deepcopy(node["description"])
|
||
|
||
if component_name == "AddDataNode":
|
||
target_key = (str(props.get("appType") or ""), str(props.get("formUuid") or ""))
|
||
metadata = (data_create_metadata or {}).get(target_key) or {}
|
||
add_data_rules = _build_add_data_rules(
|
||
props,
|
||
fields=metadata.get("fields") or [],
|
||
form_title=str(metadata.get("title") or ""),
|
||
)
|
||
view_props["addDataRules"] = add_data_rules
|
||
elif component_name in {"GetSingleDataNode", "GetBatchDataNode"}:
|
||
target_app, target_form = _find_data_source_form(props, nodes_by_id=nodes_by_id)
|
||
metadata = (data_create_metadata or {}).get((target_app, target_form)) or {}
|
||
get_data, description = _build_get_data_rules(
|
||
props,
|
||
form_title=str(metadata.get("title") or ""),
|
||
)
|
||
view_props["getData"] = get_data
|
||
if description:
|
||
view_props.setdefault("description", description)
|
||
elif component_name == "UpdateDataNode":
|
||
target_app, target_form = _find_data_source_form(props, nodes_by_id=nodes_by_id)
|
||
metadata = (data_create_metadata or {}).get((target_app, target_form)) or {}
|
||
update_data_rules, description = _build_update_data_rules(
|
||
props,
|
||
fields=metadata.get("fields") or [],
|
||
form_title=str(metadata.get("title") or ""),
|
||
)
|
||
view_props["updateDataRules"] = update_data_rules
|
||
if description:
|
||
view_props.setdefault("description", description)
|
||
elif component_name == "ApprovalNode":
|
||
view_props["approverRules"] = _approver_rules_for_view(node, props)
|
||
if props.get("actions") or props.get("appendActions"):
|
||
view_props["actions"] = {
|
||
"normalActions": copy.deepcopy(props.get("actions") or []),
|
||
"appendActions": copy.deepcopy(props.get("appendActions") or []),
|
||
}
|
||
elif component_name == "OperatorNode":
|
||
view_props["approverRules"] = _operator_rules_for_view(node, props)
|
||
view_props["actions"] = _operator_actions_for_view(props)
|
||
elif component_name == "SendMessageNode":
|
||
send_message_rules, description = _send_message_rules_for_view(node, props)
|
||
view_props["sendMessageRules"] = send_message_rules
|
||
if description:
|
||
view_props.setdefault("description", description)
|
||
elif node_type == "condition":
|
||
for key, value in props.items():
|
||
view_props.setdefault(key, copy.deepcopy(value))
|
||
view_props["conditions"] = _condition_rules_for_view(props)
|
||
elif node_type == "route":
|
||
for key, value in props.items():
|
||
view_props.setdefault(key, copy.deepcopy(value))
|
||
else:
|
||
rule_key = VIEW_COMPONENT_RULE_KEY.get(component_name)
|
||
if rule_key:
|
||
view_props[rule_key] = copy.deepcopy(props.get(rule_key) or props)
|
||
|
||
view_props["title"] = copy.deepcopy(node.get("title") or name)
|
||
return view_props
|
||
|
||
|
||
def _view_child_for_node(
|
||
node: dict[str, Any],
|
||
*,
|
||
data_create_metadata: dict[tuple[str, str], dict[str, Any]] | None = None,
|
||
nodes_by_id: dict[str, dict[str, Any]] | None = None,
|
||
) -> dict[str, Any]:
|
||
child = {
|
||
"componentName": _view_component_name_for_node(node),
|
||
"id": node.get("nodeId"),
|
||
"props": _view_props_for_node(node, data_create_metadata=data_create_metadata, nodes_by_id=nodes_by_id),
|
||
}
|
||
nested = node.get("childNodes") or []
|
||
if isinstance(nested, list) and nested:
|
||
child["children"] = [
|
||
_view_child_for_node(item, data_create_metadata=data_create_metadata, nodes_by_id=nodes_by_id)
|
||
for item in nested
|
||
]
|
||
return child
|
||
|
||
|
||
def build_process_view_schema(
|
||
flow: dict[str, Any],
|
||
*,
|
||
data_create_metadata: dict[tuple[str, str], dict[str, Any]] | None = None,
|
||
) -> dict[str, Any]:
|
||
"""Build the designer viewJson that matches a normalized process schema.
|
||
|
||
The backend processJson can execute dataCreate nodes with plain
|
||
``props.assignments``. The Yida designer, however, renders and re-saves
|
||
AddDataNode from ``props.addDataRules.rules.rules`` plus target field
|
||
metadata. This helper keeps both surfaces aligned.
|
||
"""
|
||
validate_flow_schema(flow)
|
||
nodes_by_id = {str(node.get("nodeId")): node for node in _walk_nodes(flow.get("nodes") or [])}
|
||
children = []
|
||
for node in flow.get("nodes") or []:
|
||
children.append(_view_child_for_node(node, data_create_metadata=data_create_metadata, nodes_by_id=nodes_by_id))
|
||
|
||
return {
|
||
"schema": {
|
||
"componentName": "CanvasEngine",
|
||
"id": "canvas",
|
||
"props": {},
|
||
"children": children,
|
||
},
|
||
"bindingForm": flow.get("props", {}).get("bindingForm"),
|
||
"formulaRules": flow.get("formulaRules", []),
|
||
"globalSetting": {
|
||
"enableSignature": False,
|
||
"stopAssociationRulesIfFailed": flow.get("props", {}).get("stopAssociationRulesIfFailed", False),
|
||
"nodeMerge": False,
|
||
"originatorMerge": False,
|
||
"allNodeMerge": False,
|
||
"behaviorList": [],
|
||
"needOpenDigitalSignNodes": [],
|
||
"approvalSummary": flow.get("approvalSummary", []),
|
||
"noRecordRecall": flow.get("props", {}).get("noRecordRecall", False),
|
||
"untimedRule": flow.get("props", {}).get("untimedRule", []),
|
||
},
|
||
}
|
||
|
||
|
||
def _sync_view_top_level_defaults(view: dict[str, Any], flow: dict[str, Any]) -> None:
|
||
props = flow.get("props") if isinstance(flow.get("props"), dict) else {}
|
||
binding_form = props.get("bindingForm")
|
||
if binding_form:
|
||
view["bindingForm"] = binding_form
|
||
view.setdefault("formulaRules", copy.deepcopy(flow.get("formulaRules") or []))
|
||
view.setdefault("flowConfig", copy.deepcopy(flow.get("flowConfig") or {}))
|
||
|
||
global_setting = view.setdefault("globalSetting", {})
|
||
if not isinstance(global_setting, dict):
|
||
global_setting = {}
|
||
view["globalSetting"] = global_setting
|
||
global_setting.setdefault("enableSignature", False)
|
||
global_setting.setdefault("stopAssociationRulesIfFailed", props.get("stopAssociationRulesIfFailed", False))
|
||
global_setting.setdefault("nodeMerge", False)
|
||
global_setting.setdefault("originatorMerge", False)
|
||
global_setting.setdefault("allNodeMerge", False)
|
||
global_setting.setdefault("behaviorList", [])
|
||
global_setting.setdefault("needOpenDigitalSignNodes", [])
|
||
global_setting.setdefault("approvalSummary", flow.get("approvalSummary", []))
|
||
global_setting.setdefault("noRecordRecall", props.get("noRecordRecall", False))
|
||
global_setting.setdefault("untimedRule", props.get("untimedRule", []))
|
||
|
||
|
||
def _iter_view_children(children: list[dict[str, Any]]):
|
||
for child in children:
|
||
yield child
|
||
nested = child.get("children") or []
|
||
if isinstance(nested, list):
|
||
yield from _iter_view_children(nested)
|
||
|
||
|
||
def merge_process_view_schema(
|
||
base_view: dict[str, Any],
|
||
flow: dict[str, Any],
|
||
*,
|
||
data_create_metadata: dict[tuple[str, str], dict[str, Any]] | None = None,
|
||
) -> dict[str, Any]:
|
||
"""Patch a designer viewJson with normalized flow-node configuration.
|
||
|
||
Prefer this over building a view from scratch when a source process version
|
||
already has a valid designer skeleton. It preserves designer-specific node
|
||
ids and props, while refreshing advanced component settings such as
|
||
AddDataNode's UI-visible addDataRules.
|
||
"""
|
||
validate_flow_schema(flow)
|
||
view = copy.deepcopy(base_view)
|
||
schema = view.setdefault("schema", {})
|
||
children = schema.setdefault("children", [])
|
||
nodes_by_id = {str(node.get("nodeId")): node for node in _walk_nodes(flow.get("nodes") or [])}
|
||
seen: set[str] = set()
|
||
|
||
def sync_children(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||
synced: list[dict[str, Any]] = []
|
||
for child in items:
|
||
node_id = str(child.get("id") or "")
|
||
node = nodes_by_id.get(node_id)
|
||
if node:
|
||
fresh_child = _view_child_for_node(
|
||
node,
|
||
data_create_metadata=data_create_metadata,
|
||
nodes_by_id=nodes_by_id,
|
||
)
|
||
component_name = fresh_child["componentName"]
|
||
if (
|
||
child.get("componentName") == component_name
|
||
and str(node.get("type") or "") in {"apply", "finish"}
|
||
):
|
||
seen.add(node_id)
|
||
synced.append(child)
|
||
continue
|
||
child["componentName"] = component_name
|
||
child["props"] = fresh_child["props"]
|
||
if "children" in fresh_child:
|
||
child["children"] = fresh_child["children"]
|
||
else:
|
||
child.pop("children", None)
|
||
seen.add(node_id)
|
||
synced.append(child)
|
||
continue
|
||
nested = child.get("children")
|
||
if isinstance(nested, list):
|
||
child["children"] = sync_children(nested)
|
||
synced.append(child)
|
||
return synced
|
||
|
||
schema["children"] = sync_children(children)
|
||
children = schema.setdefault("children", [])
|
||
|
||
for child in _iter_view_children(children):
|
||
node_id = str(child.get("id") or "")
|
||
node = nodes_by_id.get(node_id)
|
||
if not node:
|
||
continue
|
||
seen.add(node_id)
|
||
|
||
existing_top_level = {str(child.get("id") or ""): child for child in children if child.get("id")}
|
||
ordered_children: list[dict[str, Any]] = []
|
||
for child in children:
|
||
node_id = str(child.get("id") or "")
|
||
if child.get("componentName") == "ApplyNode" and node_id not in nodes_by_id:
|
||
ordered_children.append(child)
|
||
|
||
for node in flow.get("nodes") or []:
|
||
node_id = str(node.get("nodeId") or "")
|
||
if str(node.get("type") or "") == "apply" and not existing_top_level.get(node_id):
|
||
continue
|
||
child = existing_top_level.get(node_id)
|
||
if not child:
|
||
child = _view_child_for_node(
|
||
node,
|
||
data_create_metadata=data_create_metadata,
|
||
nodes_by_id=nodes_by_id,
|
||
)
|
||
ordered_children.append(child)
|
||
|
||
if ordered_children:
|
||
schema["children"] = ordered_children
|
||
_sync_view_top_level_defaults(view, flow)
|
||
return view
|