@josephyan/qingflow-app-user-mcp 1.1.27 → 1.1.29

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@1.1.27
+npm install @josephyan/qingflow-app-user-mcp@1.1.29
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@1.1.27 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@1.1.29 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "1.1.27",
+  "version": "1.1.29",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "1.1.27"
+version = "1.1.29"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -157,6 +157,7 @@ MATCH_TYPE_ACCURACY = 1
 MATCH_TYPE_QUESTION = 2
 JUDGE_EQUAL = 0
 JUDGE_UNEQUAL = 1
+JUDGE_INCLUDE = 2
 JUDGE_GREATER_OR_EQUAL = 5
 JUDGE_LESS_OR_EQUAL = 7
 JUDGE_EQUAL_ANY = 9
@@ -6855,6 +6856,11 @@ class AiBuilderFacade:
             if (field_id := _coerce_nonnegative_int(entry.get("field_id"))) is not None
         }
         query_conditions = _extract_view_query_conditions_config(config, question_entries_by_id=question_entries_by_id)
+        filter_groups = _public_view_filter_groups_from_match_rules(
+            config.get("viewgraphLimit") if isinstance(config, dict) else [],
+            question_entries_by_id=question_entries_by_id,
+        )
+        filters = filter_groups[0] if len(filter_groups) == 1 else []
         return {
             "status": "success",
             "error_code": None,
@@ -6870,6 +6876,9 @@ class AiBuilderFacade:
             "warnings": warnings,
             "verification": verification,
             "verified": all(bool(value) for value in verification.values()),
+            "filters": filters,
+            "filter_groups": filter_groups,
+            "filter_logic": "or" if len(filter_groups) > 1 else ("and" if filter_groups else "none"),
             "query_conditions": query_conditions,
             "buttons_config": buttons_config,
             "associated_resources_config": associated_resources_config,
@@ -12580,7 +12589,8 @@ def _match_mapping_operator_to_judge_type(operator: Any, *, reason_path: str) ->
         "le": JUDGE_LESS_OR_EQUAL,
         "<=": JUDGE_LESS_OR_EQUAL,
         "less_or_equal": JUDGE_LESS_OR_EQUAL,
-        "contains": JUDGE_FUZZY_MATCH,
+        "contains": JUDGE_INCLUDE,
+        "include": JUDGE_INCLUDE,
         "like": JUDGE_FUZZY_MATCH,
         "fuzzy": JUDGE_FUZZY_MATCH,
         "fuzzy_match": JUDGE_FUZZY_MATCH,
@@ -21152,6 +21162,20 @@ def _merge_view_summary_with_config(
             question_entries_by_id=query_question_entries_by_id,
         )
         config_enriched = True
+    if "viewgraphLimit" in config:
+        filter_question_entries_by_id = dict(question_entries_by_id)
+        for entry in canonical_question_entries:
+            field_id = _coerce_nonnegative_int(entry.get("field_id"))
+            if field_id is not None:
+                filter_question_entries_by_id[field_id] = entry
+        filter_groups = _public_view_filter_groups_from_match_rules(
+            config.get("viewgraphLimit"),
+            question_entries_by_id=filter_question_entries_by_id,
+        )
+        summary["filter_groups"] = filter_groups
+        summary["filters"] = filter_groups[0] if len(filter_groups) == 1 else []
+        summary["filter_logic"] = "or" if len(filter_groups) > 1 else ("and" if filter_groups else "none")
+        config_enriched = True
     if any(key in config for key in ("asosChartVisible", "asosChartConfig", "asosChartIdList", "limitType")):
         summary["associated_resources_config"] = _extract_view_associated_resources_config(config)
         config_enriched = True
@@ -22331,7 +22355,7 @@ def _translate_flow_condition_rule(*, field: dict[str, Any], rule: dict[str, Any
         base["judgeType"] = JUDGE_INCLUDE_ANY if field_type in INCLUDE_ANY_FLOW_FIELD_TYPES else JUDGE_EQUAL_ANY
         base["judgeValues"] = [_stringify_condition_value(value) for value in values]
     elif operator == "contains":
-        base["judgeType"] = JUDGE_FUZZY_MATCH
+        base["judgeType"] = JUDGE_INCLUDE
         base["judgeValues"] = [_stringify_condition_value(values[0])]
     elif operator == "gte":
         base["judgeType"] = JUDGE_GREATER_OR_EQUAL
@@ -24098,7 +24122,7 @@ def _translate_view_filter_rule(*, field: dict[str, Any], rule: dict[str, Any])
         payload["judgeType"] = JUDGE_INCLUDE_ANY if field_type in INCLUDE_ANY_FLOW_FIELD_TYPES else JUDGE_EQUAL_ANY
         payload["judgeValues"] = judge_values
     elif operator == "contains":
-        payload["judgeType"] = JUDGE_FUZZY_MATCH
+        payload["judgeType"] = JUDGE_INCLUDE
         payload["judgeValues"] = judge_values[:1] if judge_values else []
     elif operator == "gte":
         payload["judgeType"] = JUDGE_GREATER_OR_EQUAL
@@ -24122,7 +24146,8 @@ def _resolve_view_filter_values(
 ) -> tuple[list[str], list[dict[str, Any]], dict[str, Any] | None]:
     field_type = str(field.get("type") or FieldType.text.value)
     if field_type not in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
-        return [_stringify_condition_value(value) for value in values], _build_view_filter_value_details(values), None
+        string_values = [_stringify_condition_value(value) for value in values]
+        return string_values, _build_view_filter_scalar_value_details(values), None
 
     option_details = [
         item
@@ -24202,6 +24227,23 @@ def _build_view_filter_value_details(values: list[Any]) -> list[dict[str, Any]]:
     return details
 
 
+def _build_view_filter_scalar_value_details(values: list[Any]) -> list[dict[str, Any]]:
+    details: list[dict[str, Any]] = []
+    for value in values:
+        if isinstance(value, dict):
+            raw_value = value.get("value")
+            if raw_value is None:
+                raw_value = value.get("dataValue")
+            if raw_value is None:
+                raw_value = value.get("id")
+            if raw_value is None:
+                continue
+            details.append(_coerce_view_filter_value_detail({"value": _stringify_condition_value(raw_value)}))
+            continue
+        details.append(_coerce_view_filter_value_detail({"value": _stringify_condition_value(value)}))
+    return details
+
+
 def _coerce_view_filter_value_detail(value: dict[str, Any]) -> dict[str, Any]:
     item_id = value.get("id")
     item_value = value.get("value")
@@ -24229,9 +24271,16 @@ def _normalize_view_filter_groups_for_compare(groups: Any) -> list[list[dict[str
                 continue
             normalized_details = []
             for detail in raw_rule.get("judgeValueDetails") or []:
-                if not isinstance(detail, dict) or detail.get("id") is None:
+                if not isinstance(detail, dict):
+                    continue
+                item_id = detail.get("id")
+                item_value = detail.get("value")
+                if item_id is None and item_value is None:
                     continue
-                normalized_details.append({"id": detail.get("id"), "value": str(detail.get("value") or detail.get("id"))})
+                normalized_detail = {"value": str(item_value if item_value is not None else item_id)}
+                if item_id is not None:
+                    normalized_detail["id"] = item_id
+                normalized_details.append(normalized_detail)
             normalized_rules.append(
                 {
                     "queId": _coerce_positive_int(raw_rule.get("queId")) or 0,
@@ -24283,6 +24332,78 @@ def _view_filter_groups_equivalent(expected: Any, actual: Any) -> bool:
     return _view_filter_groups_signature(expected) == _view_filter_groups_signature(actual)
 
 
+def _public_view_filter_groups_from_match_rules(
+    groups: Any,
+    *,
+    question_entries_by_id: dict[int, dict[str, Any]] | None = None,
+) -> list[list[dict[str, Any]]]:
+    question_entries_by_id = question_entries_by_id or {}
+    public_groups: list[list[dict[str, Any]]] = []
+    for raw_group in groups or []:
+        if not isinstance(raw_group, list):
+            continue
+        public_group: list[dict[str, Any]] = []
+        for raw_rule in raw_group:
+            if not isinstance(raw_rule, dict):
+                continue
+            que_id = _coerce_positive_int(raw_rule.get("queId")) or 0
+            field_name = str((question_entries_by_id.get(que_id) or {}).get("name") or raw_rule.get("queTitle") or "").strip()
+            if not field_name:
+                continue
+            values = _public_view_filter_values_from_rule(raw_rule)
+            operator = _public_view_filter_operator_from_judge_type(raw_rule.get("judgeType"), values=values)
+            item: dict[str, Any] = {
+                "field_name": field_name,
+                "operator": operator,
+            }
+            if operator not in {"is_empty", "not_empty"}:
+                if operator == "in":
+                    item["values"] = values
+                elif len(values) == 1:
+                    item["value"] = values[0]
+                elif values:
+                    item["values"] = values
+            public_group.append(item)
+        if public_group:
+            public_groups.append(public_group)
+    return public_groups
+
+
+def _public_view_filter_values_from_rule(rule: dict[str, Any]) -> list[str]:
+    detail_values: list[str] = []
+    for detail in rule.get("judgeValueDetails") or []:
+        if not isinstance(detail, dict):
+            continue
+        value = detail.get("value")
+        if value is None:
+            value = detail.get("id")
+        if value is None:
+            continue
+        text = str(value).strip()
+        if text:
+            detail_values.append(text)
+    if detail_values:
+        return detail_values
+    return [str(value) for value in (rule.get("judgeValues") or []) if str(value).strip()]
+
+
+def _public_view_filter_operator_from_judge_type(judge_type: Any, *, values: list[str]) -> str:
+    numeric = _coerce_positive_int(judge_type)
+    if numeric == JUDGE_EQUAL:
+        return "eq" if values else "is_empty"
+    if numeric == JUDGE_UNEQUAL:
+        return "neq" if values else "not_empty"
+    if numeric in {JUDGE_INCLUDE, JUDGE_FUZZY_MATCH}:
+        return "contains"
+    if numeric == JUDGE_GREATER_OR_EQUAL:
+        return "gte"
+    if numeric == JUDGE_LESS_OR_EQUAL:
+        return "lte"
+    if numeric in {JUDGE_EQUAL_ANY, JUDGE_INCLUDE_ANY}:
+        return "in"
+    return f"raw:{numeric}" if numeric is not None else "raw"
+
+
 def _infer_status_field_id(fields: list[dict[str, Any]]) -> str | None:
     preferred_names = {"status", "状态", "订单状态", "审批状态", "流程状态"}
     for field in fields: