@qingflow-tech/qingflow-app-builder-mcp 1.0.2 → 1.0.4

package/src/qingflow_mcp/tools/resource_read_tools.py

@@ -7,7 +7,6 @@ from ..errors import QingflowApiError, raise_tool_error
 from ..json_types import JSONObject
 from ..list_type_labels import SYSTEM_VIEW_DEFINITIONS
 from .app_tools import _analysis_supported_for_view_type
-from .app_tools import AppTools
 from .base import ToolBase, tool_cn_name
 from .qingbi_report_tools import QingbiReportTools
 
@@ -25,7 +24,6 @@ class ResourceReadTools(ToolBase):
     def __init__(self, sessions, backend) -> None:
         """执行内部辅助逻辑。"""
         super().__init__(sessions, backend)
-        self.apps = AppTools(sessions, backend)
         self.charts = QingbiReportTools(sessions, backend)
 
     @tool_cn_name("资源读取-门户列表")
@@ -98,6 +96,9 @@ class ResourceReadTools(ToolBase):
                 )
             )
         if system_view is not None:
+            export_capability = _view_export_capability_payload(
+                supported=_export_supported_for_view_type(system_view["view_type"])
+            )
             return self._run(
                 profile,
                 lambda session_profile, _context: {
@@ -108,11 +109,17 @@ class ResourceReadTools(ToolBase):
                         {
                             "code": "VIEW_APP_KEY_UNRESOLVED",
                             "message": f"view_get could not resolve app_key for system view `{view_id}`; keep using the app_key from the parent app context.",
-                        }
+                        },
+                        {
+                            "code": "VIEW_EXPORT_APP_CONTEXT_REQUIRED",
+                            "message": f"view_get supports exporting `{view_id}`, but the export call still needs the parent app context `app_key`.",
+                        },
                     ],
                     "verification": {
                         "view_exists": True,
                         "descriptor_only": True,
+                        "export_route_supported": export_capability["supported"],
+                        "export_permission_verified": export_capability["permission_verified"],
                     },
                     "data": {
                         "app_key": None,
@@ -122,11 +129,13 @@ class ResourceReadTools(ToolBase):
                         "view_type": system_view["view_type"],
                         "visible_columns": [],
                         "analysis_supported": system_view["analysis_supported"],
+                        "export_capability": export_capability,
                     },
                 },
             )
 
         def runner(session_profile, context):
+            raw_view_type = None
             warnings: list[JSONObject] = []
             verification = {
                 "view_exists": True,
@@ -152,10 +161,17 @@ class ResourceReadTools(ToolBase):
                 str(base_info.get("viewgraphType") or "").strip()
                 or str(config.get("viewgraphType") or config.get("viewType") or "").strip()
             )
+            export_capability = _view_export_capability_payload(
+                supported=_export_supported_for_view_type(raw_view_type or None)
+            )
+            verification["export_route_supported"] = export_capability["supported"]
+            verification["export_permission_verified"] = export_capability["permission_verified"]
             resolved_app_key = str(base_info.get("appKey") or config.get("appKey") or "").strip() or None
+            if not resolved_app_key:
+                resolved_app_key = self._resolve_app_key_from_view_form(context=context, view_key=view_key)
             if not resolved_app_key:
                 resolved_app_key = self._resolve_app_key_from_form_id(
-                    profile=profile,
+                    context=context,
                     form_id=_coerce_positive_int(base_info.get("formId") or config.get("formId")),
                 )
             if not resolved_app_key:
@@ -165,6 +181,13 @@ class ResourceReadTools(ToolBase):
                         "message": f"view_get could not resolve app_key for `{view_id}` from view metadata; keep using the app_key from the parent app or portal context.",
                     }
                 )
+                if export_capability["supported"]:
+                    warnings.append(
+                        {
+                            "code": "VIEW_EXPORT_APP_CONTEXT_REQUIRED",
+                            "message": f"view_get supports exporting `{view_id}`, but the export call still needs an explicit `app_key` from the parent app context.",
+                        }
+                    )
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -186,6 +209,7 @@ class ResourceReadTools(ToolBase):
                         if str(item.get("queTitle") or item.get("title") or "").strip()
                     ],
                     "analysis_supported": _analysis_supported_for_view_type(raw_view_type or None),
+                    "export_capability": export_capability,
                 },
             }
 
@@ -198,25 +222,56 @@ class ResourceReadTools(ToolBase):
 
         def runner(session_profile, _context):
             base = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
-            data = self.charts.qingbi_report_get_data(profile=profile, chart_id=chart_id, payload={}).get("result") or {}
-            data_config = data.get("config") if isinstance(data, dict) and isinstance(data.get("config"), dict) else {}
+            warnings: list[JSONObject] = []
+            verification = {
+                "chart_exists": True,
+                "chart_data_loaded": False,
+                "chart_config_loaded": False,
+            }
+            data: Any = None
+            data_config: dict[str, Any] = {}
+            try:
+                data = self.charts.qingbi_report_get_data(profile=profile, chart_id=chart_id, payload={}).get("result") or {}
+                verification["chart_data_loaded"] = True
+                if isinstance(data, dict) and isinstance(data.get("config"), dict):
+                    data_config = deepcopy(data.get("config"))
+                    verification["chart_config_loaded"] = True
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = error if isinstance(error, QingflowApiError) else None
+                warnings.append(
+                    {
+                        "code": "CHART_DATA_UNAVAILABLE",
+                        "message": "chart_get could not load chart data; returning chart metadata and config when available.",
+                        "backend_code": api_error.backend_code if api_error is not None else None,
+                        "http_status": api_error.http_status if api_error is not None else None,
+                    }
+                )
+            if not data_config:
+                try:
+                    config_result = self.charts.qingbi_report_get_config(profile=profile, chart_id=chart_id).get("result") or {}
+                except (QingflowApiError, RuntimeError):
+                    config_result = {}
+                if isinstance(config_result, dict) and config_result:
+                    data_config = deepcopy(config_result)
+                    verification["chart_config_loaded"] = True
+            data_payload: dict[str, Any] = {
+                "chart_id": chart_id,
+                "chart_name": str(base.get("chartName") or base.get("name") or chart_id).strip() or chart_id,
+                "chart_type": str(base.get("chartType") or data_config.get("chartType") or "").strip() or None,
+                "data_source_type": str(base.get("dataSourceType") or "").strip() or None,
+                "data_source_id": str(base.get("dataSourceId") or "").strip() or None,
+            }
+            if verification["chart_data_loaded"]:
+                data_payload["data"] = deepcopy(data) if isinstance(data, dict) else {"value": data}
+            if data_config and not verification["chart_data_loaded"]:
+                data_payload["config"] = deepcopy(data_config)
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
-                "warnings": [],
-                "verification": {
-                    "chart_exists": True,
-                    "chart_data_loaded": True,
-                },
-                "data": {
-                    "chart_id": chart_id,
-                    "chart_name": str(base.get("chartName") or base.get("name") or chart_id).strip() or chart_id,
-                    "chart_type": str(base.get("chartType") or data_config.get("chartType") or "").strip() or None,
-                    "data_source_type": str(base.get("dataSourceType") or "").strip() or None,
-                    "data_source_id": str(base.get("dataSourceId") or "").strip() or None,
-                    "data": deepcopy(data) if isinstance(data, dict) else {"value": data},
-                },
+                "warnings": warnings,
+                "verification": verification,
+                "data": data_payload,
             }
 
         return self._run(profile, runner)
@@ -236,25 +291,54 @@ class ResourceReadTools(ToolBase):
         if not chart_id:
             raise_tool_error(QingflowApiError.config_error("chart_id is required"))
 
-    def _resolve_app_key_from_form_id(self, *, profile: str, form_id: int | None) -> str | None:
+    def _resolve_app_key_from_view_form(self, *, context: Any, view_key: str) -> str | None:
+        try:
+            form_payload = self.backend.request("GET", context, f"/view/{view_key}/form")
+        except QingflowApiError:
+            return None
+        if not isinstance(form_payload, dict):
+            return None
+        app_key = str(form_payload.get("appKey") or "").strip()
+        return app_key or None
+
+    def _resolve_app_key_from_form_id(self, *, context: Any, form_id: int | None) -> str | None:
         """执行内部辅助逻辑。"""
         if form_id is None:
             return None
         try:
-            payload = self.apps.app_list(profile=profile)
+            payload = self.backend.request("GET", context, "/tag/apps")
         except QingflowApiError:
-            return None
-        items = payload.get("items")
-        if not isinstance(items, list):
-            return None
-        for item in items:
-            if not isinstance(item, dict):
-                continue
-            if _coerce_positive_int(item.get("form_id")) != form_id:
-                continue
-            app_key = str(item.get("app_key") or "").strip()
-            if app_key:
-                return app_key
+            payload = None
+        app_key = _find_visible_app_key_by_form_id(payload, form_id=form_id)
+        if app_key:
+            return app_key
+        page_num = 1
+        page_size = 200
+        while page_num <= 20:
+            try:
+                page = self.backend.request(
+                    "GET",
+                    context,
+                    "/app/item",
+                    params={"pageNum": page_num, "pageSize": page_size},
+                )
+            except QingflowApiError:
+                return None
+            items = page.get("list") if isinstance(page, dict) else []
+            if not isinstance(items, list) or not items:
+                return None
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                if _coerce_positive_int(item.get("formId") or item.get("form_id")) != form_id:
+                    continue
+                app_key = str(item.get("appKey") or item.get("app_key") or "").strip()
+                if app_key:
+                    return app_key
+            total = _coerce_positive_int(page.get("total")) if isinstance(page, dict) else None
+            if total is not None and page_num * page_size >= total:
+                break
+            page_num += 1
         return None
 
 
@@ -404,6 +488,21 @@ def _lookup_system_view_descriptor(view_id: str) -> dict[str, Any] | None:
     return None
 
 
+def _view_export_capability_payload(*, supported: bool) -> JSONObject:
+    return {
+        "supported": supported,
+        "tool": "record_export_start",
+        "format": "xlsx",
+        "async": True,
+        "requires_app_key": True,
+        "permission_verified": False,
+    }
+
+
+def _export_supported_for_view_type(view_type: str | None) -> bool:
+    return _analysis_supported_for_view_type(view_type)
+
+
 def _normalize_view_type(view_type: Any) -> str | None:
     value = str(view_type or "").strip()
     if not value:
@@ -419,3 +518,25 @@ def _coerce_positive_int(value: Any) -> int | None:
     except (TypeError, ValueError):
         return None
     return number if number > 0 else None
+
+
+def _find_visible_app_key_by_form_id(payload: Any, *, form_id: int) -> str | None:
+    if isinstance(payload, list):
+        for item in payload:
+            resolved = _find_visible_app_key_by_form_id(item, form_id=form_id)
+            if resolved:
+                return resolved
+        return None
+    if not isinstance(payload, dict):
+        return None
+    candidate_form_id = _coerce_positive_int(payload.get("formId") or payload.get("form_id"))
+    if candidate_form_id == form_id:
+        app_key = str(payload.get("appKey") or payload.get("app_key") or "").strip()
+        if app_key:
+            return app_key
+    for value in payload.values():
+        if isinstance(value, (list, dict)):
+            resolved = _find_visible_app_key_by_form_id(value, form_id=form_id)
+            if resolved:
+                return resolved
+    return None