@josephyan/qingflow-cli 0.2.0-beta.74 → 0.2.0-beta.76

package/src/qingflow_mcp/builder_facade/service.py

@@ -57,6 +57,7 @@ from .models import (
     PortalListResponse,
     PortalReadSummaryResponse,
     PortalSectionPatch,
+    PublicDepartmentScopeMode,
     PublicFieldType,
     PublicRelationMode,
     PublicChartType,
@@ -1599,29 +1600,34 @@ class AiBuilderFacade:
                         transport_error=api_error,
                     ),
                 )
-            return finalize(response)
+            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=True, response=response))
         button = _normalize_custom_button_detail(readback.get("result") if isinstance(readback.get("result"), dict) else {})
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "created custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_verified": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "edit_version_no": edit_version_no,
-                "button": button,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "created custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_verified": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "button": button,
+                },
+            )
         )
 
     def app_custom_button_update(
@@ -1707,29 +1713,34 @@ class AiBuilderFacade:
                         transport_error=api_error,
                     ),
                 )
-            return finalize(response)
+            return finalize(self._append_publish_result(profile=profile, app_key=app_key, publish=True, response=response))
         button = _normalize_custom_button_detail(readback.get("result") if isinstance(readback.get("result"), dict) else {})
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "updated custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_verified": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "edit_version_no": edit_version_no,
-                "button": button,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "updated custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_verified": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "button": button,
+                },
+            )
         )
 
     def app_custom_button_delete(self, *, profile: str, app_key: str, button_id: int) -> JSONObject:
@@ -1748,27 +1759,42 @@ class AiBuilderFacade:
         def finalize(response: JSONObject) -> JSONObject:
             return _apply_permission_outcomes(response, *permission_outcomes)
 
+        edit_version_no, edit_context_error = self._ensure_app_edit_context(
+            profile=profile,
+            app_key=app_key,
+            normalized_args=normalized_args,
+            failure_code="CUSTOM_BUTTON_DELETE_FAILED",
+        )
+        if edit_context_error is not None:
+            return finalize(edit_context_error)
+
         self.buttons.custom_button_delete(profile=profile, app_key=app_key, button_id=button_id)
         return finalize(
-            {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "deleted custom button",
-                "normalized_args": normalized_args,
-                "missing_fields": [],
-                "allowed_values": {},
-                "details": {},
-                "request_id": None,
-                "suggested_next_call": None,
-                "noop": False,
-                "warnings": [],
-                "verification": {"custom_button_deleted": True},
-                "verified": True,
-                "app_key": app_key,
-                "button_id": button_id,
-                "deleted": True,
-            }
+            self._append_publish_result(
+                profile=profile,
+                app_key=app_key,
+                publish=True,
+                response={
+                    "status": "success",
+                    "error_code": None,
+                    "recoverable": False,
+                    "message": "deleted custom button",
+                    "normalized_args": normalized_args,
+                    "missing_fields": [],
+                    "allowed_values": {},
+                    "details": {},
+                    "request_id": None,
+                    "suggested_next_call": None,
+                    "noop": False,
+                    "warnings": [],
+                    "verification": {"custom_button_deleted": True},
+                    "verified": True,
+                    "app_key": app_key,
+                    "button_id": button_id,
+                    "edit_version_no": edit_version_no,
+                    "deleted": True,
+                },
+            )
         )
 
     def _resolve_app_matches_in_visible_apps(
@@ -3593,6 +3619,7 @@ class AiBuilderFacade:
             existing_field = next((field for field in current_fields if str(field.get("name") or "") == patch.name), None)
             if existing_field is not None:
                 if _field_matches_patch(existing_field, patch):
+                    _merge_existing_field_with_patch(existing_field, patch)
                     continue
                 return _failed(
                     "DUPLICATE_FIELD",
@@ -8145,6 +8172,133 @@ def _normalize_relation_mode(value: Any) -> str:
     return _relation_mode_from_optional_data_num(value)
 
 
+def _normalize_department_scope_mode(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, int):
+        if value == 1:
+            return PublicDepartmentScopeMode.all.value
+        if value == 2:
+            return PublicDepartmentScopeMode.custom.value
+        return None
+    normalized = str(value).strip().lower()
+    if normalized in {"all", "workspace_all", "workspace-all", "default", "default_all", "default-all", "1"}:
+        return PublicDepartmentScopeMode.all.value
+    if normalized in {"custom", "explicit", "selected", "2"}:
+        return PublicDepartmentScopeMode.custom.value
+    return normalized or None
+
+
+def _normalize_department_scope(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    raw_departments = value.get("departments", value.get("depart", value.get("departs")))
+    departments: list[dict[str, Any]] = []
+    if isinstance(raw_departments, list):
+        for item in raw_departments:
+            if isinstance(item, dict):
+                dept_id = _coerce_positive_int(item.get("dept_id", item.get("deptId", item.get("id"))))
+                dept_name = str(
+                    item.get("dept_name", item.get("deptName", item.get("name", item.get("value")))) or ""
+                ).strip() or None
+            else:
+                dept_id = _coerce_positive_int(item)
+                dept_name = None
+            if dept_id is None and dept_name is None:
+                continue
+            entry: dict[str, Any] = {}
+            if dept_id is not None:
+                entry["dept_id"] = dept_id
+            if dept_name is not None:
+                entry["dept_name"] = dept_name
+            departments.append(entry)
+    normalized_mode = _normalize_department_scope_mode(value.get("mode"))
+    if normalized_mode is None:
+        normalized_mode = PublicDepartmentScopeMode.custom.value if departments else PublicDepartmentScopeMode.all.value
+    return {
+        "mode": normalized_mode,
+        "departments": departments,
+        "include_sub_departs": (
+            None
+            if value.get("include_sub_departs", value.get("includeSubDeparts")) is None
+            else bool(value.get("include_sub_departs", value.get("includeSubDeparts")))
+        ),
+    }
+
+
+def _normalize_department_scope_from_question(question: dict[str, Any]) -> dict[str, Any] | None:
+    scope_type = _coerce_positive_int(question.get("deptSelectScopeType"))
+    scope = question.get("deptSelectScope") if isinstance(question.get("deptSelectScope"), dict) else {}
+    if not isinstance(scope, dict):
+        scope = {}
+    if isinstance(scope.get("dynamic"), list) and scope.get("dynamic"):
+        return None
+    if isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList"):
+        return None
+    if scope_type == 1:
+        return {
+            "mode": PublicDepartmentScopeMode.all.value,
+            "departments": [],
+            "include_sub_departs": None
+            if scope.get("includeSubDeparts") is None
+            else bool(scope.get("includeSubDeparts")),
+        }
+    if scope_type == 2:
+        departments: list[dict[str, Any]] = []
+        for item in cast(list[Any], scope.get("depart") or []):
+            if not isinstance(item, dict):
+                continue
+            dept_id = _coerce_positive_int(item.get("deptId", item.get("id")))
+            dept_name = str(item.get("deptName", item.get("name", item.get("value"))) or "").strip() or None
+            if dept_id is None and dept_name is None:
+                continue
+            entry: dict[str, Any] = {}
+            if dept_id is not None:
+                entry["dept_id"] = dept_id
+            if dept_name is not None:
+                entry["dept_name"] = dept_name
+            departments.append(entry)
+        return {
+            "mode": PublicDepartmentScopeMode.custom.value,
+            "departments": departments,
+            "include_sub_departs": None
+            if scope.get("includeSubDeparts") is None
+            else bool(scope.get("includeSubDeparts")),
+        }
+    return None
+
+
+def _serialize_department_scope_for_question(value: Any) -> tuple[int, dict[str, Any]]:
+    normalized = _normalize_department_scope(value)
+    if normalized is None or normalized.get("mode") == PublicDepartmentScopeMode.all.value:
+        scope: dict[str, Any] = {"depart": [], "dynamic": []}
+        if normalized is not None and normalized.get("include_sub_departs") is not None:
+            scope["includeSubDeparts"] = bool(normalized.get("include_sub_departs"))
+        return 1, scope
+    departments = []
+    for item in cast(list[Any], normalized.get("departments") or []):
+        if not isinstance(item, dict):
+            continue
+        dept_id = _coerce_positive_int(item.get("dept_id"))
+        dept_name = str(item.get("dept_name") or "").strip() or None
+        if dept_id is None and dept_name is None:
+            continue
+        entry: dict[str, Any] = {}
+        if dept_id is not None:
+            entry["deptId"] = dept_id
+        if dept_name is not None:
+            entry["deptName"] = dept_name
+        departments.append(entry)
+    scope = {"depart": departments, "dynamic": []}
+    if normalized.get("include_sub_departs") is not None:
+        scope["includeSubDeparts"] = bool(normalized.get("include_sub_departs"))
+    return 2, scope
+
+
+def _department_scope_equal(left: Any, right: Any) -> bool:
+    return _normalize_department_scope(left) == _normalize_department_scope(right)
+
+
 def _is_relation_target_metadata_read_restricted_api_error(error: QingflowApiError) -> bool:
     return error.backend_code in {40002, 40027, 40161}
 
@@ -8311,8 +8465,10 @@ def _hydrate_relation_field_configs(
         field["config"] = config
         display_selector = field.get("display_field") if isinstance(field.get("display_field"), dict) else None
         visible_selector_payloads = [item for item in cast(list[Any], field.get("visible_fields") or []) if isinstance(item, dict)]
-        if display_selector is None and not visible_selector_payloads:
-            continue
+        if display_selector is None:
+            raise ValueError("relation field requires display_field")
+        if not visible_selector_payloads:
+            raise ValueError("relation field requires visible_fields")
         target_fields = target_field_cache.get(target_app_key)
         if target_fields is None:
             try:
@@ -8349,7 +8505,31 @@ def _hydrate_relation_field_configs(
                 )
                 continue
         if not target_fields:
-            raise ValueError(f"target relation app '{target_app_key}' has no readable fields")
+            display_field = _normalize_relation_target_stub(
+                display_selector,
+                fallback_name=str((display_selector or {}).get("name") or "").strip() or None,
+            )
+            visible_fields = [
+                _normalize_relation_target_stub(item, fallback_name=str(item.get("name") or "").strip() or None)
+                for item in visible_selector_payloads
+            ]
+            _apply_relation_target_selection(
+                field=field,
+                config=config,
+                display_field=display_field,
+                visible_fields=visible_fields,
+            )
+            degraded_entries.append(
+                {
+                    "field_name": field.get("name"),
+                    "target_app_key": target_app_key,
+                    "display_field": deepcopy(field.get("display_field") or {}),
+                    "visible_fields": deepcopy(field.get("visible_fields") or []),
+                    "relation_mode": field.get("relation_mode"),
+                    "transport_error": None,
+                }
+            )
+            continue
         display_field = _resolve_relation_target_field(
             target_fields=target_fields,
             selector_payload=display_selector,
@@ -8454,6 +8634,10 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         }
         field["visible_fields"] = visible_fields
         field["field_name_show"] = bool(reference.get("fieldNameShow", True))
+    if field_type == FieldType.department:
+        department_scope = _normalize_department_scope_from_question(question)
+        if department_scope is not None:
+            field["department_scope"] = department_scope
     if field_type == FieldType.code_block:
         code_block_config = question.get("codeBlockConfig") if isinstance(question.get("codeBlockConfig"), dict) else {}
         field["code_block_config"] = {
@@ -9075,6 +9259,8 @@ def _compact_public_field_read(*, field: dict[str, Any], layout: dict[str, Any])
         payload["relation_mode"] = _normalize_relation_mode(field.get("relation_mode"))
         payload["display_field"] = deepcopy(field.get("display_field"))
         payload["visible_fields"] = deepcopy(field.get("visible_fields") or [])
+    if field.get("type") == FieldType.department.value and field.get("department_scope") is not None:
+        payload["department_scope"] = deepcopy(field.get("department_scope"))
     if field.get("type") == FieldType.code_block.value:
         payload["code_block_config"] = deepcopy(field.get("code_block_config") or {})
         if field.get("auto_trigger") is not None:
@@ -9155,6 +9341,7 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
         "display_field": patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None,
         "visible_fields": [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields],
         "relation_mode": patch.relation_mode.value if patch.relation_mode is not None else None,
+        "department_scope": patch.department_scope.model_dump(mode="json", exclude_none=True) if patch.department_scope is not None else None,
         "remote_lookup_config": remote_lookup_config,
         "_explicit_remote_lookup_config": remote_lookup_config is not None,
         "q_linker_binding": q_linker_binding,
@@ -9173,6 +9360,23 @@ def _field_patch_to_internal(patch: FieldPatch) -> dict[str, Any]:
 
 
 def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
+    field_display_selector = field.get("display_field")
+    patch_display_selector = patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None
+    field_visible_selectors = field.get("visible_fields")
+    patch_visible_selectors = [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields]
+    if (
+        str(field.get("type") or "") == FieldType.relation.value
+        and patch.type == PublicFieldType.relation
+        and (field.get("target_app_key") or None) == patch.target_app_key
+        and field_display_selector is None
+        and not list(field_visible_selectors or [])
+    ):
+        relation_selector_match = True
+    else:
+        relation_selector_match = (
+            _field_selector_payload_equal(field_display_selector, patch_display_selector)
+            and _field_selector_list_equal(field_visible_selectors, patch_visible_selectors)
+        )
     return (
         str(field.get("name") or "") == patch.name
         and str(field.get("type") or "") == patch.type.value
@@ -9180,9 +9384,12 @@ def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
         and (field.get("description") or None) == patch.description
         and list(field.get("options") or []) == list(patch.options)
         and (field.get("target_app_key") or None) == patch.target_app_key
-        and _field_selector_payload_equal(field.get("display_field"), patch.display_field.model_dump(mode="json", exclude_none=True) if patch.display_field is not None else None)
-        and _field_selector_list_equal(field.get("visible_fields"), [selector.model_dump(mode="json", exclude_none=True) for selector in patch.visible_fields])
+        and relation_selector_match
         and _normalize_relation_mode(field.get("relation_mode")) == _normalize_relation_mode(patch.relation_mode.value if patch.relation_mode is not None else None)
+        and (
+            patch.department_scope is None
+            or _department_scope_equal(field.get("department_scope"), patch.department_scope.model_dump(mode="json", exclude_none=True))
+        )
         and _remote_lookup_config_equal(field.get("remote_lookup_config"), patch.remote_lookup_config.model_dump(mode="json", exclude_none=True) if patch.remote_lookup_config is not None else None)
         and _q_linker_binding_equal(field.get("q_linker_binding"), patch.q_linker_binding.model_dump(mode="json", exclude_none=True) if patch.q_linker_binding is not None else None)
         and _code_block_config_equal(field.get("code_block_config"), patch.code_block_config.model_dump(mode="json", exclude_none=True) if patch.code_block_config is not None else None)
@@ -9194,6 +9401,24 @@ def _field_matches_patch(field: dict[str, Any], patch: FieldPatch) -> bool:
     )
 
 
+def _merge_existing_field_with_patch(field: dict[str, Any], patch: FieldPatch) -> None:
+    if str(field.get("type") or "") == FieldType.relation.value and patch.type == PublicFieldType.relation:
+        if not str(field.get("target_app_key") or "").strip() and patch.target_app_key:
+            field["target_app_key"] = patch.target_app_key
+        if not isinstance(field.get("display_field"), dict) and patch.display_field is not None:
+            field["display_field"] = patch.display_field.model_dump(mode="json", exclude_none=True)
+        if not list(field.get("visible_fields") or []) and patch.visible_fields:
+            field["visible_fields"] = [
+                selector.model_dump(mode="json", exclude_none=True)
+                for selector in patch.visible_fields
+            ]
+        if field.get("relation_mode") is None and patch.relation_mode is not None:
+            field["relation_mode"] = patch.relation_mode.value
+    if str(field.get("type") or "") == FieldType.department.value and patch.type == PublicFieldType.department:
+        if field.get("department_scope") is None and patch.department_scope is not None:
+            field["department_scope"] = patch.department_scope.model_dump(mode="json", exclude_none=True)
+
+
 def _field_selector_payload_equal(left: Any, right: Any) -> bool:
     if left is None and right is None:
         return True
@@ -9374,6 +9599,8 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         field["visible_fields"] = list(payload["visible_fields"])
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+    if "department_scope" in payload:
+        field["department_scope"] = payload["department_scope"]
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
@@ -10884,6 +11111,10 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
             reference["referQueId"] = field.get("target_field_que_id")
         reference["optionalDataNum"] = _relation_mode_to_optional_data_num(field.get("relation_mode"))
         question["referenceConfig"] = reference
+    if field.get("type") == FieldType.department.value:
+        scope_type, scope_payload = _serialize_department_scope_for_question(field.get("department_scope"))
+        question["deptSelectScopeType"] = scope_type
+        question["deptSelectScope"] = scope_payload
     if field.get("type") == FieldType.code_block.value:
         code_block_config = _normalize_code_block_config(field.get("code_block_config") or field.get("config") or {}) or {
             "config_mode": 1,