@josephyan/qingflow-cli 0.2.0-beta.55 → 0.2.0-beta.56

package/src/qingflow_mcp/ops/files.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .base import normalize_exception, success_result, tool_payload
+
+
+class FileOperations:
+    def __init__(self, tools: Any) -> None:
+        self._tools = tools
+
+    def get_upload_info(
+        self,
+        *,
+        profile: str,
+        upload_kind: str,
+        file_name: str,
+        file_size: int,
+        upload_mark: str | None,
+        content_type: str | None,
+        bucket_type: str | None,
+        path_id: int | None,
+        file_related_url: str | None,
+    ) -> dict:
+        try:
+            raw = self._tools.file.file_get_upload_info(
+                profile=profile,
+                upload_kind=upload_kind,
+                file_name=file_name,
+                file_size=file_size,
+                upload_mark=upload_mark,
+                content_type=content_type,
+                bucket_type=bucket_type,
+                path_id=path_id,
+                file_related_url=file_related_url,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "UPLOAD_INFO_READY",
+            "已获取上传信息",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            meta={"profile": profile, "request_route": raw.get("request_route") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def upload_local(
+        self,
+        *,
+        profile: str,
+        upload_kind: str,
+        file_path: str,
+        upload_mark: str | None,
+        content_type: str | None,
+        bucket_type: str | None,
+        path_id: int | None,
+        file_related_url: str | None,
+    ) -> dict:
+        try:
+            raw = self._tools.file.file_upload_local(
+                profile=profile,
+                upload_kind=upload_kind,
+                file_path=file_path,
+                upload_mark=upload_mark,
+                content_type=content_type,
+                bucket_type=bucket_type,
+                path_id=path_id,
+                file_related_url=file_related_url,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "FILE_UPLOADED",
+            "已完成本地文件上传",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            meta={"profile": profile, "request_route": raw.get("request_route") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )

package/src/qingflow_mcp/ops/imports.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .base import normalize_exception, success_result, tool_payload
+
+
+class ImportOperations:
+    def __init__(self, tools: Any) -> None:
+        self._tools = tools
+
+    def schema(self, *, profile: str, app_key: str, output_profile: str = "normal") -> dict:
+        try:
+            raw = self._tools.imports.record_import_schema_get(
+                profile=profile,
+                app_key=app_key,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "IMPORT_SCHEMA_READY",
+            "已读取导入字段结构",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def template(self, *, profile: str, app_key: str, download_to_path: str | None) -> dict:
+        try:
+            raw = self._tools.imports.record_import_template_get(
+                profile=profile,
+                app_key=app_key,
+                download_to_path=download_to_path,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "IMPORT_TEMPLATE_READY",
+            "已获取导入模板",
+            data=tool_payload(raw),
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def verify(self, *, profile: str, app_key: str, file_path: str) -> dict:
+        try:
+            raw = self._tools.imports.record_import_verify(profile=profile, app_key=app_key, file_path=file_path)
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "IMPORT_VERIFIED",
+            "已完成导入预检",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def repair(
+        self,
+        *,
+        profile: str,
+        verification_id: str,
+        authorized_file_modification: bool,
+        output_path: str | None,
+        selected_repairs: list[str],
+    ) -> dict:
+        try:
+            raw = self._tools.imports.record_import_repair_local(
+                profile=profile,
+                verification_id=verification_id,
+                authorized_file_modification=authorized_file_modification,
+                output_path=output_path,
+                selected_repairs=selected_repairs,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "IMPORT_FILE_REPAIRED",
+            "已完成导入文件修复",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def start(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        verification_id: str,
+        being_enter_auditing: bool | None,
+        view_key: str | None,
+    ) -> dict:
+        try:
+            raw = self._tools.imports.record_import_start(
+                profile=profile,
+                app_key=app_key,
+                verification_id=verification_id,
+                being_enter_auditing=being_enter_auditing,
+                view_key=view_key,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "IMPORT_STARTED",
+            "已启动导入任务",
+            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def status(self, *, profile: str, app_key: str, import_id: str | None, process_id_str: str | None) -> dict:
+        try:
+            raw = self._tools.imports.record_import_status_get(
+                profile=profile,
+                app_key=app_key,
+                import_id=import_id,
+                process_id_str=process_id_str,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        data = tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw
+        if isinstance(data, dict) and raw.get("status") is not None:
+            data = dict(data)
+            data["status"] = raw.get("status")
+            data["raw_status"] = raw.get("status")
+        return success_result(
+            "IMPORT_STATUS_READY",
+            "已读取导入状态",
+            data=data,
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )

package/src/qingflow_mcp/ops/records.py

@@ -0,0 +1,415 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .base import normalize_exception, success_result, tool_payload
+
+
+class RecordOperations:
+    def __init__(self, tools: Any) -> None:
+        self._tools = tools
+
+    def schema(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        mode: str,
+        view_id: str | None,
+        record_id: int | None,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            if mode == "applicant":
+                raw = self._tools.record.record_schema_get(
+                    profile=profile,
+                    app_key=app_key,
+                    schema_mode="applicant",
+                    output_profile=output_profile,
+                )
+            elif mode == "browse":
+                raw = self._tools.record.record_browse_schema_get_public(
+                    profile=profile,
+                    app_key=app_key,
+                    view_id=view_id,
+                    output_profile=output_profile,
+                )
+            elif mode == "insert":
+                raw = self._tools.record.record_insert_schema_get_public(
+                    profile=profile,
+                    app_key=app_key,
+                    output_profile=output_profile,
+                )
+            elif mode == "update":
+                raw = self._tools.record.record_update_schema_get_public(
+                    profile=profile,
+                    app_key=app_key,
+                    record_id=record_id,
+                    output_profile=output_profile,
+                )
+            elif mode == "import":
+                raw = self._tools.imports.record_import_schema_get(
+                    profile=profile,
+                    app_key=app_key,
+                    output_profile=output_profile,
+                )
+            else:
+                raw = self._tools.code_block.record_code_block_schema_get_public(
+                    profile=profile,
+                    app_key=app_key,
+                    output_profile=output_profile,
+                )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "RECORD_SCHEMA_READY",
+            "已读取表结构",
+            data={"mode": mode, "schema": tool_payload(raw)},
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def list(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        columns: list[Any],
+        where: list[Any],
+        order_by: list[Any],
+        limit: int,
+        page: int,
+        view_id: str | None,
+        list_type: int | None,
+        view_key: str | None,
+        view_name: str | None,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_list(
+                profile=profile,
+                app_key=app_key,
+                columns=columns,
+                where=where,
+                order_by=order_by,
+                limit=limit,
+                page=page,
+                view_id=view_id,
+                list_type=list_type,
+                view_key=view_key,
+                view_name=view_name,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        data = tool_payload(raw)
+        return success_result(
+            "RECORDS_LISTED",
+            "已读取记录列表",
+            data=data if isinstance(data, dict) else {"items": data},
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        columns: list[Any],
+        view_id: str | None,
+        workflow_node_id: int | None,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_get_public(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                columns=columns,
+                view_id=view_id,
+                workflow_node_id=workflow_node_id,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "RECORD_SHOWN",
+            "已读取单条记录",
+            data={"record": tool_payload(raw), "record_id": record_id},
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def create(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        fields: dict[str, Any],
+        verify_write: bool,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_insert_public(
+                profile=profile,
+                app_key=app_key,
+                fields=fields,
+                verify_write=verify_write,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        data = tool_payload(raw)
+        return success_result(
+            "RECORD_CREATED",
+            "已新增记录",
+            data={
+                "record_id": _extract_record_id(data),
+                "record_ids": _extract_record_ids(data),
+                "result": data,
+            },
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def update(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int | None,
+        fields: dict[str, Any],
+        verify_write: bool,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_update_public(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                fields=fields,
+                verify_write=verify_write,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        data = tool_payload(raw)
+        return success_result(
+            "RECORD_UPDATED",
+            "已更新记录",
+            data={
+                "record_id": _extract_record_id(data) or record_id,
+                "record_ids": _extract_record_ids(data) or [record_id],
+                "result": data,
+            },
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def delete(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int | None,
+        record_ids: list[int],
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_delete_public(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                record_ids=record_ids,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        data = tool_payload(raw)
+        removed = _extract_record_ids(data) or ([record_id] if record_id else record_ids)
+        return success_result(
+            "RECORDS_DELETED",
+            "已删除记录",
+            data={"record_ids": removed, "result": data},
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def analyze(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        dimensions: list[Any],
+        metrics: list[Any],
+        filters: list[Any],
+        sort: list[Any],
+        limit: int,
+        strict_full: bool,
+        view_id: str | None,
+        list_type: int | None,
+        view_key: str | None,
+        view_name: str | None,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_analyze(
+                profile=profile,
+                app_key=app_key,
+                dimensions=dimensions,
+                metrics=metrics,
+                filters=filters,
+                sort=sort,
+                limit=limit,
+                strict_full=strict_full,
+                view_id=view_id,
+                list_type=list_type,
+                view_key=view_key,
+                view_name=view_name,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "RECORDS_ANALYZED",
+            "已完成数据分析",
+            data=tool_payload(raw),
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def run_code(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        code_block_field: str,
+        role: int,
+        workflow_node_id: int | None,
+        answers: list[Any],
+        fields: dict[str, Any],
+        manual: bool,
+        verify_writeback: bool,
+        force_refresh_form: bool,
+        output_profile: str = "normal",
+    ) -> dict:
+        try:
+            raw = self._tools.code_block.record_code_block_run(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                code_block_field=code_block_field,
+                role=role,
+                workflow_node_id=workflow_node_id,
+                answers=answers,
+                fields=fields,
+                manual=manual,
+                verify_writeback=verify_writeback,
+                force_refresh_form=force_refresh_form,
+                output_profile=output_profile,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "CODE_BLOCK_EXECUTED",
+            "已执行代码块字段",
+            data=tool_payload(raw),
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
+            legacy=raw,
+        )
+
+    def member_candidates(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        field_id: int,
+        keyword: str,
+        page_num: int,
+        page_size: int,
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_member_candidates(
+                profile=profile,
+                app_key=app_key,
+                field_id=field_id,
+                keyword=keyword,
+                page_num=page_num,
+                page_size=page_size,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "RECORD_MEMBER_CANDIDATES_READY",
+            "已读取成员候选范围",
+            data=tool_payload(raw),
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+    def department_candidates(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        field_id: int,
+        keyword: str,
+        page_num: int,
+        page_size: int,
+    ) -> dict:
+        try:
+            raw = self._tools.record.record_department_candidates(
+                profile=profile,
+                app_key=app_key,
+                field_id=field_id,
+                keyword=keyword,
+                page_num=page_num,
+                page_size=page_size,
+            )
+        except Exception as error:  # noqa: BLE001
+            return normalize_exception(error)
+        return success_result(
+            "RECORD_DEPARTMENT_CANDIDATES_READY",
+            "已读取部门候选范围",
+            data=tool_payload(raw),
+            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
+            meta={"profile": profile},
+            legacy=raw,
+        )
+
+
+def _extract_record_id(data: Any) -> int | None:
+    if not isinstance(data, dict):
+        return None
+    value = data.get("record_id")
+    if isinstance(value, int):
+        return value
+    resource = data.get("resource")
+    if isinstance(resource, dict) and isinstance(resource.get("record_id"), int):
+        return resource.get("record_id")
+    return None
+
+
+def _extract_record_ids(data: Any) -> list[int]:
+    if not isinstance(data, dict):
+        return []
+    value = data.get("record_ids")
+    if isinstance(value, list):
+        return [item for item in value if isinstance(item, int)]
+    resource = data.get("resource")
+    if isinstance(resource, dict) and isinstance(resource.get("record_ids"), list):
+        return [item for item in resource["record_ids"] if isinstance(item, int)]
+    record_id = _extract_record_id(data)
+    return [record_id] if record_id is not None else []