hap-cli 0.5.0__py3-none-any.whl

hap_cli/core/flow_node.py

@@ -0,0 +1,1001 @@
+"""Workflow node management for MingDAO HAP.
+
+Covers: add/delete/get nodes, save node config, update node name/desc,
+data processing nodes (create/update/delete/search records),
+code test, webhook test, AIGC test, code templates, and JSON-to-controls.
+"""
+
+from typing import Any, Optional
+
+from hap_cli.core.session import Session
+
+
+# ── Node Type Constants ──────────────────────────────────────────────────
+
+NODE_TYPE = {
+    "START": 0,
+    "BRANCH": 1,
+    "BRANCH_ITEM": 2,
+    "FILL": 3,
+    "APPROVAL": 4,
+    "CC": 5,
+    "ACTION": 6,           # Data processing: add/edit/delete record
+    "SEARCH": 7,            # Get single record
+    "WEBHOOK": 8,
+    "FORMULA": 9,
+    "MESSAGE": 10,
+    "EMAIL": 11,
+    "DELAY": 12,
+    "GET_MORE_RECORD": 13,  # Get multiple records / batch ops
+    "CODE": 14,
+    "LINK": 15,
+    "SUB_PROCESS": 16,
+    "PUSH": 17,
+    "FILE": 18,
+    "TEMPLATE": 19,
+    "PBP": 20,
+    "JSON_PARSE": 21,
+    "AUTHENTICATION": 22,
+    "PARAMETER": 23,
+    "API_PACKAGE": 24,
+    "API": 25,
+    "APPROVAL_PROCESS": 26,
+    "NOTICE": 27,
+    "SNAPSHOT": 28,
+    "LOOP": 29,
+    "RETURN": 30,
+    "AIGC": 31,
+    "PLUGIN": 32,
+    "AGENT": 33,
+    "SYSTEM": 100,
+    "TOOLS": 101,
+    "FIND_SINGLE_MESSAGE": 1000,
+    "FIND_MORE_MESSAGE": 1001,
+}
+
+# ── Action ID Constants (for ACTION / SEARCH / GET_MORE_RECORD) ──────────
+
+ACTION_ID = {
+    # ACTION node (type 6) operations
+    "ADD_RECORD": "1",
+    "EDIT_RECORD": "2",
+    "DELETE_RECORD": "3",
+    "CREATE_FILE": "4",
+    "CREATE_RECORD": "5",
+    "REFRESH_SINGLE_DATA": "6",
+    "REFUND": "7",
+    "RELATION": "20",
+    # FORMULA node (type 9) operations
+    "NUMBER_FORMULA": "100",
+    "DATE_FORMULA": "101",
+    "JAVASCRIPT": "102",
+    "PYTHON": "103",
+    "DATE_DIFF_FORMULA": "104",
+    "OBJECT_TOTAL": "105",
+    "FUNCTION_CALCULATION": "106",
+    "WORKSHEET_TOTAL": "107",
+    "CUSTOM_ACTION_TOTAL": "108",
+    # EMAIL node (type 11) operations
+    "SEND_EMAIL_SINGLE_DISPLAY": "201",
+    "SEND_EMAIL": "202",
+    "SEND_TEMPLATE_MESSAGE": "203",
+    # LOOP node (type 29) operations
+    "CONDITION_LOOP": "210",
+    "COUNT_LOOP": "211",
+    # GET_MORE_RECORD node (type 13) operations
+    "FROM_WORKSHEET": "400",
+    "FROM_RECORD": "401",
+    "FROM_ADD": "402",
+    "FROM_ARRAY": "403",
+    "FROM_CODE_ARRAY": "404",
+    "FROM_ARTIFICIAL": "405",
+    # SEARCH node (type 7) operations
+    "WORKSHEET_FIND": "406",
+    "BATCH_FIND": "407",
+    "FROM_PBP_INPUT_ARRAY": "408",
+    "FROM_API_ARRAY": "409",
+    "FROM_PBP_OUTPUT_ARRAY": "410",
+    "BATCH_ACTION": "411",
+    "BATCH_UPDATE": "412",
+    "BATCH_DELETE": "413",
+    "FROM_PLUGIN_ARRAY": "414",
+    "REFRESH_MULTIPLE_DATA": "415",
+    "RECORD_LINK_PAY": "416",
+    "RECORD_LINK_FIND": "420",
+    "RECORD_UPDATE": "421",
+    "RECORD_DELETE": "422",
+    # PBP
+    "PBP": "500",
+    "PBP_INPUT": "501",
+    "PBP_OUT": "502",
+    # JSON
+    "JSON_PARSE": "510",
+    "FROM_JSON_PARSE_ARRAY": "511",
+    # AUTH
+    "NO_AUTH": "520",
+    "BASIC_AUTH": "521",
+    "AUTH_CODE": "522",
+    "CREDENTIALS": "523",
+    "REFRESH_CREDENTIALS": "524",
+    # AIGC
+    "AIGC_TEXT": "531",
+    "AIGC_OBJECT": "532",
+    "AGENT": "533",
+}
+
+APP_TYPE = {
+    "SHEET": 1,
+    "TASK": 2,
+    "LOOP": 5,
+    "DATE": 6,
+    "WEBHOOK": 7,
+    "CUSTOM_ACTION": 8,
+}
+
+
+# ── Node CRUD ────────────────────────────────────────────────────────────
+
+
+def add_node(
+    session: Session,
+    process_id: str,
+    flow_node_type: int,
+    name: str = "",
+    node_id: str = "",
+    select_node_id: str = "",
+    action_id: str = "",
+) -> dict[str, Any]:
+    """Add a new node to a workflow.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        flow_node_type: Node type (see NODE_TYPE dict)
+        name: Node name
+        node_id: Explicit node ID (auto-generated if empty)
+        select_node_id: Insert after this node
+        action_id: Action sub-type (see ACTION_ID dict)
+
+    Returns:
+        Created node info
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "flowNodeType": flow_node_type,
+    }
+    if name:
+        data["name"] = name
+    if node_id:
+        data["nodeId"] = node_id
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    if action_id:
+        data["actionId"] = action_id
+    return session.workflow_call("flowNode/add", data)
+
+
+def delete_node(
+    session: Session,
+    process_id: str,
+    node_id: str,
+) -> dict[str, Any]:
+    """Delete a node from a workflow.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID to delete
+
+    Returns:
+        Deletion result
+    """
+    return session.workflow_call(
+        "flowNode/delete",
+        {"processId": process_id, "nodeId": node_id},
+    )
+
+
+def get_nodes(
+    session: Session,
+    process_id: str,
+    instance_id: str = "",
+) -> dict[str, Any]:
+    """Get all nodes of a workflow.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        instance_id: Optional instance ID for runtime view
+
+    Returns:
+        Node tree/list
+    """
+    data: dict[str, Any] = {"processId": process_id}
+    if instance_id:
+        data["instanceId"] = instance_id
+    return session.workflow_call("flowNode/get", data)
+
+
+def get_node_detail(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    flow_node_type: int = 0,
+    select_node_id: str = "",
+    app_id: str = "",
+    instance_id: str = "",
+) -> dict[str, Any]:
+    """Get detailed configuration of a node.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        flow_node_type: Node type
+        select_node_id: Context node
+        app_id: App ID
+        instance_id: Instance ID (for runtime)
+
+    Returns:
+        Node detail dict with full configuration
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if flow_node_type:
+        data["flowNodeType"] = flow_node_type
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    if app_id:
+        data["appId"] = app_id
+    if instance_id:
+        data["instanceId"] = instance_id
+    return session.workflow_call("flowNode/getNodeDetail", data)
+
+
+# ── Node Update ──────────────────────────────────────────────────────────
+
+
+def update_node_name(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    name: str,
+) -> dict[str, Any]:
+    """Update a node's name.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        name: New name
+
+    Returns:
+        Update result
+    """
+    return session.workflow_call(
+        "flowNode/updateFlowNodeName",
+        {"processId": process_id, "nodeId": node_id, "name": name},
+    )
+
+
+def update_node_desc(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    desc: str = "",
+    alias: str = "",
+) -> dict[str, Any]:
+    """Update a node's description and alias.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        desc: Description
+        alias: Node alias
+
+    Returns:
+        Update result
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if desc:
+        data["desc"] = desc
+    if alias:
+        data["alias"] = alias
+    return session.workflow_call("flowNode/nodeDesc", data)
+
+
+def save_node(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    flow_node_type: int,
+    config: dict[str, Any],
+    name: str = "",
+    select_node_id: str = "",
+) -> dict[str, Any]:
+    """Save a node's full configuration.
+
+    This is the universal node save endpoint that supports ALL node types.
+    The config dict varies by node type.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        flow_node_type: Node type (see NODE_TYPE dict)
+        config: Node-specific configuration dict. Keys vary by type:
+            - ACTION(6): actionId, appId, appType, fields, selectNodeId,
+                operateCondition, sorts, executeType, filters
+            - SEARCH(7): actionId, appId, findFields, executeType, fields,
+                operateCondition, sorts, random, filters, link
+            - GET_MORE_RECORD(13): actionId, appId, operateCondition, fields,
+                selectNodeId, sorts, numberFieldValue, filters
+            - FILL(3): formProperties, accounts, submitBtnName, schedule
+            - APPROVAL(4): accounts, condition, multipleLevel
+            - CC(5): accounts, smsContent, templateId
+            - EMAIL(11): accounts, subject, content
+            - WEBHOOK(8): url, method, headers, body, contentType
+            - CODE(14): code, inputDatas, version, actionId
+            - FORMULA(9): actionId, fieldValue, fieldType
+            - DELAY(12): time, unit, executeTime
+            - SUB_PROCESS(16): subProcessId
+            - PUSH(17): pushType, content, appId, viewId, link
+            - FILE(18): appId, fileName, pdf
+            - JSON_PARSE(21): jsonStr, controls
+            - AIGC(31): model, prompt, systemMessage, outputs, actionId
+            - LOOP(29): actionId, executeType, numberFieldValue
+            - SNAPSHOT(28): appId
+            - BRANCH(1/2): operateCondition, resultTypeId
+        name: Node name
+        select_node_id: Context node
+
+    Returns:
+        Save result
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "nodeId": node_id,
+        "flowNodeType": flow_node_type,
+    }
+    if name:
+        data["name"] = name
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    data.update(config)
+    return session.workflow_call("flowNode/saveNode", data)
+
+
+# ── Testing ──────────────────────────────────────────────────────────────
+
+
+def test_code(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    code: str,
+    input_data: Optional[list] = None,
+    action_id: str = "",
+    version: str = "",
+) -> dict[str, Any]:
+    """Test a code block node.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Code node ID
+        code: Code to execute
+        input_data: Input parameter list [{name, value, type}]
+        action_id: Action ID
+        version: Code version
+
+    Returns:
+        Test execution result with output
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "nodeId": node_id,
+        "code": code,
+    }
+    if input_data:
+        data["inputDatas"] = input_data
+    if action_id:
+        data["actionId"] = action_id
+    if version:
+        data["version"] = version
+    return session.workflow_call("flowNode/codeTest", data)
+
+
+def test_webhook(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    url: str,
+    method: str = "POST",
+    headers: Optional[list] = None,
+    body: str = "",
+    content_type: str = "application/json",
+    params: Optional[list] = None,
+    auth_id: str = "",
+    settings: Optional[dict] = None,
+) -> dict[str, Any]:
+    """Test a WebHook request.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: WebHook node ID
+        url: Target URL
+        method: HTTP method
+        headers: Request headers [{name, value}]
+        body: Request body (JSON string)
+        content_type: Content-Type header
+        params: URL parameters [{name, value}]
+        auth_id: Authentication config ID
+        settings: Additional settings
+
+    Returns:
+        WebHook response data
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "nodeId": node_id,
+        "url": url,
+        "method": method,
+        "contentType": content_type,
+    }
+    if headers:
+        data["headers"] = headers
+    if body:
+        data["body"] = body
+    if params:
+        data["params"] = params
+    if auth_id:
+        data["authId"] = auth_id
+    if settings:
+        data["settings"] = settings
+    return session.workflow_call("flowNode/webHookTestRequest", data)
+
+
+def test_aigc(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    prompt: str,
+    model: str = "",
+    system_message: str = "",
+    temperature: float = 0.7,
+    outputs: Optional[list] = None,
+    action_id: str = "",
+) -> dict[str, Any]:
+    """Test an AI text generation node.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: AI node ID
+        prompt: User prompt
+        model: AI model name
+        system_message: System message
+        temperature: Temperature (0-1)
+        outputs: Output field definitions
+        action_id: Action ID
+
+    Returns:
+        AI generation result
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "nodeId": node_id,
+        "prompt": prompt,
+        "temperature": temperature,
+    }
+    if model:
+        data["model"] = model
+    if system_message:
+        data["systemMessage"] = system_message
+    if outputs:
+        data["outputs"] = outputs
+    if action_id:
+        data["actionId"] = action_id
+    return session.workflow_call("flowNode/aigcTest", data)
+
+
+def test_basic_auth(
+    session: Session,
+    process_id: str,
+    user_name: str,
+    password: str,
+) -> dict[str, Any]:
+    """Test basic authentication credentials.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        user_name: Username
+        password: Password
+
+    Returns:
+        Auth test result
+    """
+    return session.workflow_call(
+        "flowNode/basicAuthTest",
+        {"processId": process_id, "userName": user_name, "password": password},
+    )
+
+
+# ── WebHook Data ─────────────────────────────────────────────────────────
+
+
+def get_webhook_data(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    select_node_id: str = "",
+) -> dict[str, Any]:
+    """Get received WebHook data for a node.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: WebHook node ID
+        select_node_id: Context node
+
+    Returns:
+        WebHook received data
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    return session.workflow_call("flowNode/getWebHookData", data)
+
+
+# ── Utilities ────────────────────────────────────────────────────────────
+
+
+def json_to_controls(
+    session: Session,
+    json_str: str,
+) -> dict[str, Any]:
+    """Convert JSON string to workflow controls.
+
+    Args:
+        session: Active session
+        json_str: JSON string to convert
+
+    Returns:
+        Converted controls list
+    """
+    return session.workflow_call(
+        "flowNode/jsonToControls",
+        {"json": json_str},
+    )
+
+
+def get_node_form_property(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    select_node_id: str = "",
+) -> dict[str, Any]:
+    """Get node form properties.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        select_node_id: Context node
+
+    Returns:
+        Form property config
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    return session.workflow_call("flowNode/getNodeFormProperty", data)
+
+
+def get_sub_process_list(
+    session: Session,
+    process_id: str,
+    select_node_id: str = "",
+) -> dict[str, Any]:
+    """Get available sub-processes.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        select_node_id: Context node
+
+    Returns:
+        Sub-process list
+    """
+    data: dict[str, Any] = {"processId": process_id}
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    return session.workflow_call("flowNode/getSubProcessList", data)
+
+
+# ── Code Templates ───────────────────────────────────────────────────────
+
+
+def get_code_template_list(
+    session: Session,
+    keyword: str = "",
+    source: int = 0,
+    template_type: int = 0,
+    page_index: int = 1,
+    page_size: int = 50,
+) -> dict[str, Any]:
+    """Get code template list.
+
+    Args:
+        session: Active session
+        keyword: Search keyword
+        source: Template source
+        template_type: Template type
+        page_index: Page number
+        page_size: Items per page
+
+    Returns:
+        Template list
+    """
+    data: dict[str, Any] = {"pageIndex": page_index, "pageSize": page_size}
+    if keyword:
+        data["keyword"] = keyword
+    if source:
+        data["source"] = source
+    if template_type:
+        data["type"] = template_type
+    return session.workflow_call("flowNode/getCodeTemplateList", data)
+
+
+def create_code_template(
+    session: Session,
+    name: str,
+    code: str,
+    template_type: int = 0,
+    source: int = 0,
+    input_data: Optional[list] = None,
+) -> dict[str, Any]:
+    """Create a code template.
+
+    Args:
+        session: Active session
+        name: Template name
+        code: Template code
+        template_type: Template type
+        source: Template source
+        input_data: Input parameters
+
+    Returns:
+        Created template info
+    """
+    data: dict[str, Any] = {"name": name, "code": code, "type": template_type, "source": source}
+    if input_data:
+        data["inputDatas"] = input_data
+    return session.workflow_call("flowNode/createCodeTemplate", data)
+
+
+def update_code_template(
+    session: Session,
+    template_id: str,
+    name: str = "",
+    code: str = "",
+    deleted: bool = False,
+    input_data: Optional[list] = None,
+) -> dict[str, Any]:
+    """Update or delete a code template.
+
+    Args:
+        session: Active session
+        template_id: Template ID
+        name: New name
+        code: New code
+        deleted: Set True to delete
+        input_data: Updated input parameters
+
+    Returns:
+        Update result
+    """
+    data: dict[str, Any] = {"id": template_id}
+    if name:
+        data["name"] = name
+    if code:
+        data["code"] = code
+    if deleted:
+        data["deleted"] = True
+    if input_data:
+        data["inputDatas"] = input_data
+    return session.workflow_call("flowNode/updateCodeTemplate", data)
+
+
+# ── App/Control Helpers ──────────────────────────────────────────────────
+
+
+def get_flow_app_dtos(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    select_node_id: str = "",
+    source_app_id: str = "",
+    data_source: int = 0,
+    enum_default: int = 0,
+    field_type: int = 0,
+) -> dict[str, Any]:
+    """Get available app/field data for a node configuration.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        select_node_id: Context node
+        source_app_id: Source app ID
+        data_source: Data source type
+        enum_default: Default enum
+        field_type: Field type filter
+
+    Returns:
+        Available app/field data
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    if source_app_id:
+        data["sourceAppId"] = source_app_id
+    if data_source:
+        data["dataSource"] = data_source
+    if enum_default:
+        data["enumDefault"] = enum_default
+    if field_type:
+        data["type"] = field_type
+    return session.workflow_call("flowNode/getFlowAppDtos", data)
+
+
+def get_start_event_deploy(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    app_id: str = "",
+    app_type: int = 0,
+    control_id: str = "",
+    select_node_id: str = "",
+) -> dict[str, Any]:
+    """Get start event deployment config.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Start node ID
+        app_id: App ID
+        app_type: App type
+        control_id: Control ID
+        select_node_id: Context node
+
+    Returns:
+        Start event configuration
+    """
+    data: dict[str, Any] = {"processId": process_id, "nodeId": node_id}
+    if app_id:
+        data["appId"] = app_id
+    if app_type:
+        data["appType"] = app_type
+    if control_id:
+        data["controlId"] = control_id
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    return session.workflow_call("flowNode/getStartEventDeploy", data)
+
+
+# ── Data Processing Convenience Functions ────────────────────────────────
+
+
+def save_action_node(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    action_id: str,
+    app_id: str,
+    fields: Optional[list] = None,
+    name: str = "",
+    app_type: int = 1,
+    select_node_id: str = "",
+    filters: Optional[list] = None,
+    operate_condition: Optional[list] = None,
+    sorts: Optional[list] = None,
+    execute_type: int = 0,
+) -> dict[str, Any]:
+    """Save configuration for a data ACTION node (type 6).
+
+    Used for: add record, edit record, delete record, create relation, etc.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        action_id: Operation type:
+            '1'=ADD, '2'=EDIT, '3'=DELETE, '5'=CREATE_RECORD,
+            '6'=REFRESH_SINGLE, '20'=RELATION
+        app_id: Target worksheet ID
+        fields: Field mapping [{fieldId, type, fieldValue, fieldValueId, nodeId}]
+        name: Node name
+        app_type: App type (1=SHEET default)
+        select_node_id: Source data node ID
+        filters: Filter conditions
+        operate_condition: Operation conditions
+        sorts: Sort rules
+        execute_type: Execution behavior (0=default)
+
+    Returns:
+        Save result
+    """
+    config: dict[str, Any] = {
+        "actionId": action_id,
+        "appId": app_id,
+        "appType": app_type,
+    }
+    if fields:
+        config["fields"] = fields
+    if select_node_id:
+        config["selectNodeId"] = select_node_id
+    if filters:
+        config["filters"] = filters
+    if operate_condition:
+        config["operateCondition"] = operate_condition
+    if sorts:
+        config["sorts"] = sorts
+    if execute_type:
+        config["executeType"] = execute_type
+    return save_node(session, process_id, node_id, NODE_TYPE["ACTION"], config, name=name)
+
+
+def save_search_node(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    action_id: str,
+    app_id: str = "",
+    fields: Optional[list] = None,
+    name: str = "",
+    select_node_id: str = "",
+    operate_condition: Optional[list] = None,
+    sorts: Optional[list] = None,
+    random: bool = False,
+    execute_type: int = 0,
+    filters: Optional[list] = None,
+) -> dict[str, Any]:
+    """Save configuration for a SEARCH node (type 7) - get single record.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        action_id: Search type:
+            '406'=WORKSHEET_FIND, '407'=BATCH_FIND,
+            '420'=RECORD_LINK_FIND, '421'=RECORD_UPDATE, '422'=RECORD_DELETE
+        app_id: Target worksheet ID (for WORKSHEET_FIND)
+        fields: Return field list
+        name: Node name
+        select_node_id: Source data node ID
+        operate_condition: Query conditions
+        sorts: Sort rules
+        random: Pick random record
+        execute_type: When not found: 0=abort, 1=create, 2=continue
+        filters: Filter groups
+
+    Returns:
+        Save result
+    """
+    config: dict[str, Any] = {"actionId": action_id}
+    if app_id:
+        config["appId"] = app_id
+    if fields:
+        config["fields"] = fields
+    if select_node_id:
+        config["selectNodeId"] = select_node_id
+    if operate_condition:
+        config["operateCondition"] = operate_condition
+    if sorts:
+        config["sorts"] = sorts
+    if random:
+        config["random"] = random
+    if execute_type:
+        config["executeType"] = execute_type
+    if filters:
+        config["filters"] = filters
+    return save_node(session, process_id, node_id, NODE_TYPE["SEARCH"], config, name=name)
+
+
+def save_get_more_record_node(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    action_id: str,
+    app_id: str = "",
+    fields: Optional[list] = None,
+    name: str = "",
+    select_node_id: str = "",
+    operate_condition: Optional[list] = None,
+    sorts: Optional[list] = None,
+    number_field_value: Optional[dict] = None,
+    filters: Optional[list] = None,
+    random: bool = False,
+) -> dict[str, Any]:
+    """Save configuration for a GET_MORE_RECORD node (type 13).
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        action_id: Operation type:
+            '400'=FROM_WORKSHEET, '401'=FROM_RECORD, '402'=FROM_ADD,
+            '403'=FROM_ARRAY, '404'=FROM_CODE_ARRAY,
+            '412'=BATCH_UPDATE, '413'=BATCH_DELETE, '415'=REFRESH_MULTIPLE
+        app_id: Target worksheet ID (for FROM_WORKSHEET, BATCH_UPDATE, BATCH_DELETE)
+        fields: Field mapping
+        name: Node name
+        select_node_id: Source node ID (for FROM_RECORD etc.)
+        operate_condition: Filter/query conditions
+        sorts: Sort rules
+        number_field_value: Record count limit config
+        filters: Filter groups
+        random: Pick random
+
+    Returns:
+        Save result
+    """
+    config: dict[str, Any] = {"actionId": action_id}
+    if app_id:
+        config["appId"] = app_id
+    if fields:
+        config["fields"] = fields
+    if select_node_id:
+        config["selectNodeId"] = select_node_id
+    if operate_condition:
+        config["operateCondition"] = operate_condition
+    if sorts:
+        config["sorts"] = sorts
+    if number_field_value:
+        config["numberFieldValue"] = number_field_value
+    if filters:
+        config["filters"] = filters
+    if random:
+        config["random"] = random
+    return save_node(session, process_id, node_id, NODE_TYPE["GET_MORE_RECORD"], config, name=name)
+
+
+def get_app_template_controls(
+    session: Session,
+    process_id: str,
+    node_id: str,
+    app_id: str,
+    app_type: int = 1,
+    select_node_id: str = "",
+    action_id: str = "",
+) -> dict[str, Any]:
+    """Get available worksheet controls/fields for node configuration.
+
+    Useful for discovering field IDs before configuring ACTION/SEARCH nodes.
+
+    Args:
+        session: Active session
+        process_id: Process ID
+        node_id: Node ID
+        app_id: Worksheet ID
+        app_type: App type (1=SHEET)
+        select_node_id: Context node
+        action_id: Action context
+
+    Returns:
+        Controls/fields list for the worksheet
+    """
+    data: dict[str, Any] = {
+        "processId": process_id,
+        "nodeId": node_id,
+        "appId": app_id,
+        "appType": app_type,
+    }
+    if select_node_id:
+        data["selectNodeId"] = select_node_id
+    if action_id:
+        data["actionId"] = action_id
+    return session.workflow_call("flowNode/getAppTemplateControls", data)