@josephyan/qingflow-cli 1.0.10 → 1.1.1

package/src/qingflow_mcp/solution/compiler/icon_utils.py

@@ -5,6 +5,215 @@ import re
 
 
 DEFAULT_ICON_COLOR = "qing-orange"
+WORKSPACE_ICON_COLORS: tuple[str, ...] = (
+    "qing-orange",
+    "yellow",
+    "green",
+    "emerald",
+    "blue",
+    "azure",
+    "indigo",
+    "qing-purple",
+    "purple",
+    "pink",
+    "red",
+    "orange",
+)
+WORKSPACE_ICON_NAMES: tuple[str, ...] = (
+    "user",
+    "user-group",
+    "user-remove",
+    "user-add",
+    "user-circle",
+    "base-camera",
+    "view-grid",
+    "inbox",
+    "inbox-in",
+    "share",
+    "sitemap",
+    "airplane",
+    "template",
+    "music-note",
+    "movie-play",
+    "clock",
+    "document",
+    "document-search",
+    "clipboard-check",
+    "document-download",
+    "document-text",
+    "clipboard-copy",
+    "presentation-chart-bar",
+    "chart-square-bar",
+    "database",
+    "server",
+    "calendar",
+    "mail",
+    "annotation",
+    "chat",
+    "bell",
+    "key",
+    "shopping-bag",
+    "download",
+    "eye",
+    "eye-off",
+    "emoji-happy",
+    "emoji-sad",
+    "sun",
+    "moon",
+    "cloud",
+    "lightning-bolt",
+    "fire",
+    "star",
+    "sparkles",
+    "heart",
+    "cake",
+    "gift",
+    "light-bulb",
+    "exclamation",
+    "cog",
+    "thumb-up",
+    "thumb-down",
+    "cloud-download",
+    "cloud-upload",
+    "printer",
+    "phone-incoming",
+    "phone-missed-call",
+    "terminal",
+    "search-circle",
+    "x-circle",
+    "check-circle",
+    "exclamation-circle",
+    "question-mark-circle",
+    "information-circle",
+    "academic-cap",
+    "briefcase",
+    "home",
+    "phone",
+    "photograph",
+    "puzzle",
+    "color-swatch",
+    "lock-open",
+    "lock-closed",
+    "shield-check",
+    "shield-exclamation",
+    "currency-dollar",
+    "currency-yen",
+    "globe",
+    "at-symbol",
+    "slack",
+    "microphone",
+    "speakerphone",
+    "trash",
+    "book-open",
+    "truck",
+    "filter",
+    "essetional-filter-search",
+    "essetional-filter-tick",
+    "table",
+    "calculator",
+    "location-radar",
+    "essetional-weight",
+    "school-award",
+    "comp-cloud-connection",
+    "comp-cloud-remove",
+    "comp-cpu-charge",
+    "comp-cpu-setting",
+    "comp-cpu",
+    "comp-devices",
+    "comp-driver-2",
+    "comp-driver-refresh",
+    "location-global",
+    "location-location",
+    "location-map",
+    "location-gps",
+    "essetional-ranking",
+    "chart-bar",
+    "business-graph",
+    "business-status-up",
+    "business-trend-down",
+    "business-trend-up",
+    "business-presention-chart",
+    "business-favorite-chart",
+    "business-health",
+    "receipt-refund",
+    "receipt-tax",
+    "money-receipt-2-1",
+    "money-transaction-minus",
+    "action-hourglass-full",
+    "action-work",
+    "bug-f",
+    "essetional-pet",
+    "files-folder",
+    "badge-check",
+    "money-wallet-1",
+    "money-ticket",
+    "money-money",
+    "money-tag",
+    "money-wallet-2",
+    "business-personalcard",
+    "car-airplane",
+    "car-bus",
+    "car-car",
+    "car-driving",
+    "car-gas-station",
+    "car-smart-car",
+    "car-ship",
+    "location-map-1",
+    "location-route-square",
+    "cone",
+    "design-brush-4",
+    "paint-roll",
+    "wrench-f",
+    "essetional-reserve",
+    "essetional-broom",
+    "design-brush-2",
+    "essetional-judge",
+    "design-bucket",
+    "palette",
+    "comp-electricity",
+    "vial",
+    "beaker",
+    "leaf-f",
+    "cursor-click",
+    "solid-search-alt-2",
+    "md-library",
+    "building-3",
+    "office-building",
+    "building-hospital",
+    "school",
+    "store",
+    "video-camera-vintage-f",
+    "comp-monitor",
+    "delivery-truck",
+    "delivery-box-1",
+    "delivery-box-add",
+    "delivery-box-remove",
+    "settings-setting-3",
+    "document-duplicate",
+    "essetional-flag-2",
+    "flag",
+    "icon-currency-dollar",
+    "clipboard-list",
+    "save-as",
+    "wifi",
+    "status-online",
+    "scissors",
+    "globe-alt",
+    "ban",
+    "finger-print",
+    "qrcode",
+    "paper-clip",
+    "translate",
+    "cube-transparent",
+    "variable",
+    "switch-vertical",
+    "sports-baseball",
+    "sports-basketball",
+    "sports-soccer",
+    "sports-football",
+    "sports-volleyball",
+)
+GENERIC_WORKSPACE_ICON_NAMES: tuple[str, ...] = ("template",)
 DEFAULT_ICON_STYLE_POOL: tuple[tuple[str, str], ...] = (
     ("briefcase", "qing-orange"),
     ("calendar", "emerald"),
@@ -115,6 +324,91 @@ def parse_workspace_icon(value: str | None) -> tuple[str | None, str | None, str
     return normalize_workspace_icon_name(stripped), None, None
 
 
+def workspace_icon_config(value: str | None) -> dict[str, str | None]:
+    icon_name, icon_color, icon_text = parse_workspace_icon(value)
+    raw = str(value).strip() if value not in (None, "") else None
+    return {
+        "icon_name": icon_name,
+        "icon_color": icon_color,
+        "icon_text": icon_text,
+        "raw": raw,
+    }
+
+
+def workspace_icon_catalog_payload() -> dict[str, object]:
+    return {
+        "icon_names": list(WORKSPACE_ICON_NAMES),
+        "icon_colors": list(WORKSPACE_ICON_COLORS),
+        "generic_icon_names": list(GENERIC_WORKSPACE_ICON_NAMES),
+        "notes": [
+            "Use explicit icon + color for app/package/portal creation.",
+            "Do not use template for newly created workspace resources.",
+            "The CLI validates candidates only; it does not infer an icon from business names.",
+        ],
+        "common_examples": {
+            "employee": ["business-personalcard", "user-group", "user"],
+            "task": ["clipboard-check", "action-work"],
+            "worklog": ["clock", "action-hourglass-full"],
+            "order": ["delivery-box-1", "shopping-bag"],
+            "payment": ["money-receipt-2-1", "money-wallet-1"],
+            "opportunity": ["business-graph", "business-trend-up"],
+            "dashboard": ["view-grid", "chart-square-bar", "presentation-chart-bar"],
+        },
+    }
+
+
+def validate_workspace_icon_choice(
+    *,
+    icon: str | None,
+    color: str | None,
+    require_explicit: bool,
+    disallow_generic: bool,
+) -> tuple[bool, str | None, str | None, dict[str, object]]:
+    normalized_icon = _normalize_workspace_icon_candidate(icon)
+    normalized_color = str(color or "").strip() or None
+    details: dict[str, object] = {
+        "icon": icon,
+        "normalized_icon": normalized_icon,
+        "color": color,
+        "icon_catalog_command": "qingflow --json builder icon catalog",
+    }
+    if require_explicit and not normalized_icon:
+        return False, "WORKSPACE_ICON_REQUIRED", "icon is required when creating a workspace resource", details
+    if require_explicit and not normalized_color:
+        return False, "WORKSPACE_ICON_COLOR_REQUIRED", "color is required when creating a workspace resource", details
+    if normalized_icon and normalized_icon not in WORKSPACE_ICON_NAMES:
+        details["allowed_icon_names"] = list(WORKSPACE_ICON_NAMES)
+        return False, "WORKSPACE_ICON_NOT_FOUND", "icon is not in the workspace icon catalog", details
+    if normalized_color and normalized_color not in WORKSPACE_ICON_COLORS:
+        details["allowed_icon_colors"] = list(WORKSPACE_ICON_COLORS)
+        return False, "WORKSPACE_ICON_COLOR_NOT_FOUND", "color is not in the workspace icon color catalog", details
+    if disallow_generic and normalized_icon in GENERIC_WORKSPACE_ICON_NAMES:
+        details["generic_icon_names"] = list(GENERIC_WORKSPACE_ICON_NAMES)
+        return False, "GENERIC_WORKSPACE_ICON_NOT_ALLOWED", "template is a generic icon and is not allowed for new workspace resources", details
+    return True, None, None, details
+
+
+def _normalize_workspace_icon_candidate(icon: str | None) -> str | None:
+    if not icon:
+        return None
+    raw = str(icon).strip()
+    if not raw:
+        return None
+    if _looks_like_icon_json(raw):
+        try:
+            payload = json.loads(raw)
+        except Exception:
+            return None
+        return _normalize_workspace_icon_candidate(payload.get("iconName"))
+    normalized = raw.lower()
+    if normalized in WORKSPACE_ICON_NAMES:
+        return normalized
+    legacy = LEGACY_EX_ICON_MAP.get(normalized)
+    if legacy in WORKSPACE_ICON_NAMES:
+        return legacy
+    return normalized
+
+
 def encode_workspace_icon_with_defaults(
     *,
     icon: str | None,

package/src/qingflow_mcp/solution/executor.py

@@ -14,7 +14,6 @@ from ..tools.qingbi_report_tools import QingbiReportTools
 from ..tools.record_tools import RecordTools
 from ..tools.role_tools import RoleTools
 from ..tools.view_tools import ViewTools
-from ..tools.workflow_tools import WorkflowTools
 from ..tools.workspace_tools import WorkspaceTools
 from .compiler import CompiledEntity, CompiledRole, CompiledSolution
 from .compiler.form_compiler import QUESTION_TYPE_MAP
@@ -36,7 +35,6 @@ class SolutionExecutor:
         role_tools: RoleTools,
         app_tools: AppTools,
         record_tools: RecordTools,
-        workflow_tools: WorkflowTools,
         view_tools: ViewTools,
         chart_tools: QingbiReportTools,
         portal_tools: PortalTools,
@@ -47,7 +45,6 @@ class SolutionExecutor:
         self.role_tools = role_tools
         self.app_tools = app_tools
         self.record_tools = record_tools
-        self.workflow_tools = workflow_tools
         self.view_tools = view_tools
         self.chart_tools = chart_tools
         self.portal_tools = portal_tools
@@ -419,123 +416,10 @@ class SolutionExecutor:
     def _build_workflow(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         if entity.workflow_plan is None:
             return
-        app_key = self._get_app_key(store, entity.entity_id)
-        workflow_edit_version_no = self._ensure_edit_version(
-            profile,
-            entity.entity_id,
-            store,
-            app_key=app_key,
-            force_new=True,
-        )
-        node_artifacts = store.get_artifact("apps", entity.entity_id, {}).get("workflow_nodes", {})
-        existing_nodes = self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-        current_nodes = _coerce_workflow_nodes(existing_nodes)
-        existing_nodes_by_name = {
-            node.get("auditNodeName"): int(node_id)
-            for node_id, node in current_nodes.items()
-            if isinstance(node, dict) and node.get("auditNodeName")
-        }
-        applicant_node_id = next(
-            (
-                int(node_id)
-                for node_id, node in current_nodes.items()
-                if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
-            ),
-            None,
+        raise RuntimeError(
+            "Legacy auditNode workflow execution was removed. "
+            "Pass {app_key, spec} to solution_build_flow or use qingflow builder flow apply."
         )
-        if applicant_node_id is not None:
-            node_artifacts.setdefault("__applicant__", applicant_node_id)
-
-        desired_global_settings = deepcopy(entity.workflow_plan["global_settings"])
-        explicit_global_settings = _has_explicit_workflow_global_settings(desired_global_settings)
-        current_global_settings: dict[str, Any] = {}
-        if explicit_global_settings:
-            current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-        else:
-            try:
-                current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-            except (QingflowApiError, RuntimeError) as error:
-                api_error = QingflowApiError(**_coerce_nested_error_payload(error))
-                if api_error.http_status != 404:
-                    raise
-                current_global_settings = {}
-        if explicit_global_settings:
-            global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
-            global_settings.update(desired_global_settings)
-            global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
-            self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
-        for action in entity.workflow_plan["actions"]:
-            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is not None:
-                continue
-            if action["action"] == "add_node":
-                if action.get("node_type") == "branch":
-                    existing_branch_id = node_artifacts.get(action["node_id"])
-                    if existing_branch_id is not None and not _workflow_node_is_branch(current_nodes, existing_branch_id):
-                        existing_branch_id = None
-                    if existing_branch_id is not None:
-                        for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, existing_branch_id), start=1):
-                            node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-                        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                        apps_artifact["workflow_nodes"] = node_artifacts
-                        store.set_artifact("apps", entity.entity_id, apps_artifact)
-                        continue
-                existing_node_id = node_artifacts.get(action["node_id"]) or existing_nodes_by_name.get(action.get("node_name"))
-                if existing_node_id is not None:
-                    node_artifacts[action["node_id"]] = existing_node_id
-                    apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                    apps_artifact["workflow_nodes"] = node_artifacts
-                    store.set_artifact("apps", entity.entity_id, apps_artifact)
-                    continue
-            before_node_ids = set(current_nodes)
-            payload = self._resolve_workflow_payload(action["payload"], node_artifacts)
-            if workflow_edit_version_no is not None:
-                payload["editVersionNo"] = int(workflow_edit_version_no)
-            if action["action"] == "create_sub_branch":
-                result = self.workflow_tools.workflow_create_sub_branch(profile=profile, app_key=app_key, payload=payload)
-            elif action["action"] == "update_node":
-                target_node_id = node_artifacts.get(action["node_id"])
-                if target_node_id is None:
-                    raise RuntimeError(f"workflow lane '{action['node_id']}' could not be resolved before update")
-                result = self.workflow_tools.workflow_update_node(
-                    profile=profile,
-                    app_key=app_key,
-                    audit_node_id=target_node_id,
-                    payload=payload,
-                )
-            else:
-                result = self.workflow_tools.workflow_add_node(profile=profile, app_key=app_key, payload=payload)
-            expected_type = 1 if action.get("node_type") == "branch" else None
-            audit_node_id = _extract_workflow_node_id(result.get("result"), expected_type=expected_type)
-            if action.get("node_type") == "branch" or action["action"] == "create_sub_branch":
-                current_nodes = _coerce_workflow_nodes(
-                    self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-                )
-            if audit_node_id is not None:
-                node_artifacts[action["node_id"]] = audit_node_id
-            if action.get("node_type") == "branch":
-                branch_node_id = node_artifacts.get(action["node_id"]) or _find_created_branch_node_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    prev_id=payload.get("prevId"),
-                )
-                if branch_node_id is not None:
-                    node_artifacts[action["node_id"]] = branch_node_id
-                for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, branch_node_id), start=1):
-                    node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is None:
-                created_lane_id = audit_node_id or _find_created_sub_branch_lane_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    branch_node_id=payload.get("auditNodeId"),
-                )
-                if created_lane_id is not None:
-                    node_artifacts[action["node_id"]] = created_lane_id
-                apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                apps_artifact["workflow_nodes"] = node_artifacts
-                store.set_artifact("apps", entity.entity_id, apps_artifact)
-        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-        apps_artifact["workflow_nodes"] = node_artifacts
-        store.set_artifact("apps", entity.entity_id, apps_artifact)
 
     def _build_views(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         app_key = self._get_app_key(store, entity.entity_id)
@@ -2097,20 +1981,6 @@ def _find_created_sub_branch_lane_id(
     return candidates[0] if candidates else None
 
 
-def _has_explicit_workflow_global_settings(global_settings: dict[str, Any] | None) -> bool:
-    if not isinstance(global_settings, dict):
-        return False
-    for key, value in global_settings.items():
-        if key == "editVersionNo":
-            continue
-        if value is None:
-            continue
-        if isinstance(value, (list, dict)) and not value:
-            continue
-        return True
-    return False
-
-
 def _is_navigation_plugin_unavailable(error: QingflowApiError) -> bool:
     try:
         backend_code = int(error.backend_code)