Fix workflow editor condition compatibility

Author: Y1fe1Zh0u

src/backend/bisheng/api/services/external_workflow.py

@@ -20,6 +20,7 @@
 from bisheng.workflow.common.node import BaseNodeData, NodeType
 from bisheng.workflow.edges.edges import EdgeBase
 from bisheng.workflow.graph.workflow import Workflow
+from bisheng.workflow.authoring.editor_compat import normalize_workflow_editor_graph
 from bisheng.workflow.authoring.registry import create_graph_node_payload
 from bisheng.workflow.nodes.condition.conidition_case import ConditionCases
 
@@ -686,17 +687,7 @@ def _build_scaffold_node(cls,
 
     @classmethod
     def _normalize_editor_node_types(cls, graph_data: dict) -> dict:
-        for node in graph_data.get('nodes', []):
-            if not isinstance(node, dict):
-                continue
-            node_data = node.get('data')
-            if not isinstance(node_data, dict):
-                continue
-            node_type = node_data.get('type')
-            if not node_type:
-                continue
-            node['type'] = cls._EDITOR_NOTE_NODE_TYPE if node_type == cls._NOTE_NODE_TYPE else cls._EDITOR_FLOW_NODE_TYPE
-        return graph_data
+        return normalize_workflow_editor_graph(graph_data, in_place=True)
 
     @classmethod
     def _ensure_create_graph_scaffold(cls, graph_data: dict) -> dict:
@@ -939,6 +930,10 @@ def _normalize_condition_cases(cls, condition_cases: list[dict]) -> list[dict]:
                 normalized_case = ConditionCases(**raw_case).model_dump()
             except Exception as exc:
                 cls._raise_workflow_error(f'Invalid condition case at index {index}: {exc}')
+            for condition in normalized_case.get('conditions') or []:
+                right_value_type = condition.get('right_value_type')
+                if right_value_type != 'ref':
+                    condition['right_value_type'] = 'input'
             case_id = normalized_case['id']
             if case_id in seen_case_ids:
                 cls._raise_workflow_error(f'Duplicate condition case id: {case_id}')

src/backend/bisheng/api/services/flow.py

@@ -33,34 +33,14 @@
 from bisheng.user.domain.models.user import UserDao
 from bisheng.user.domain.models.user_role import UserRoleDao
 from bisheng.utils import get_request_ip
+from bisheng.workflow.authoring.editor_compat import normalize_workflow_editor_graph
 
 
 class FlowService(BaseService):
 
     @staticmethod
     def _normalize_workflow_editor_graph(graph_data: Optional[dict]) -> Optional[dict]:
-        if not isinstance(graph_data, dict):
-            return graph_data
-
-        nodes = graph_data.get('nodes')
-        if not isinstance(nodes, list):
-            return graph_data
-
-        normalized_graph = copy.deepcopy(graph_data)
-        for node in normalized_graph.get('nodes', []):
-            if not isinstance(node, dict):
-                continue
-            node_data = node.get('data')
-            if not isinstance(node_data, dict):
-                continue
-            node_type = node_data.get('type')
-            if not node_type:
-                continue
-            if node.get('type') in {'flowNode', 'noteNode'}:
-                continue
-            node['type'] = 'noteNode' if node_type == 'note' else 'flowNode'
-
-        return normalized_graph
+        return normalize_workflow_editor_graph(graph_data)
 
     @classmethod
     def get_version_list_by_flow(cls, user: UserPayload, flow_id: str) -> UnifiedResponseModel[List[FlowVersionRead]]:

src/backend/bisheng/workflow/authoring/editor_compat.py

@@ -0,0 +1,85 @@
+import copy
+from typing import Any, Optional
+
+
+_EDITOR_FLOW_NODE_TYPE = 'flowNode'
+_EDITOR_NOTE_NODE_TYPE = 'noteNode'
+_CONDITION_NODE_TYPE = 'condition'
+_CONDITION_PARAM_KEY = 'condition'
+_EDITOR_CONDITION_RIGHT_VALUE_TYPES = {'input', 'ref'}
+
+
+def _normalize_editor_condition_cases(condition_cases: Any) -> Any:
+    if not isinstance(condition_cases, list):
+        return condition_cases
+
+    normalized_cases = []
+    for raw_case in condition_cases:
+        if not isinstance(raw_case, dict):
+            normalized_cases.append(raw_case)
+            continue
+
+        case = copy.deepcopy(raw_case)
+        conditions = case.get('conditions')
+        if isinstance(conditions, list):
+            normalized_conditions = []
+            for raw_condition in conditions:
+                if not isinstance(raw_condition, dict):
+                    normalized_conditions.append(raw_condition)
+                    continue
+
+                condition = copy.deepcopy(raw_condition)
+                condition.setdefault('left_label', '')
+                condition.setdefault('right_label', '')
+                if condition.get('left_var') is None:
+                    condition['left_var'] = ''
+                if condition.get('right_value') is None:
+                    condition['right_value'] = ''
+                if condition.get('comparison_operation') is None:
+                    condition['comparison_operation'] = ''
+
+                right_value_type = condition.get('right_value_type')
+                if right_value_type not in _EDITOR_CONDITION_RIGHT_VALUE_TYPES:
+                    condition['right_value_type'] = 'ref' if right_value_type == 'ref' else 'input'
+
+                normalized_conditions.append(condition)
+            case['conditions'] = normalized_conditions
+
+        normalized_cases.append(case)
+
+    return normalized_cases
+
+
+def normalize_workflow_editor_graph(graph_data: Optional[dict], *, in_place: bool = False) -> Optional[dict]:
+    if not isinstance(graph_data, dict):
+        return graph_data
+
+    nodes = graph_data.get('nodes')
+    if not isinstance(nodes, list):
+        return graph_data
+
+    normalized_graph = graph_data if in_place else copy.deepcopy(graph_data)
+    for node in normalized_graph.get('nodes', []):
+        if not isinstance(node, dict):
+            continue
+
+        node_data = node.get('data')
+        if not isinstance(node_data, dict):
+            continue
+
+        node_type = node_data.get('type')
+        if node_type:
+            if node.get('type') not in {_EDITOR_FLOW_NODE_TYPE, _EDITOR_NOTE_NODE_TYPE}:
+                node['type'] = _EDITOR_NOTE_NODE_TYPE if node_type == 'note' else _EDITOR_FLOW_NODE_TYPE
+
+            if node_type == _CONDITION_NODE_TYPE:
+                for group in node_data.get('group_params', []):
+                    if not isinstance(group, dict):
+                        continue
+                    for param in group.get('params', []):
+                        if not isinstance(param, dict):
+                            continue
+                        if param.get('key') == _CONDITION_PARAM_KEY:
+                            param['value'] = _normalize_editor_condition_cases(param.get('value') or [])
+
+    return normalized_graph

src/backend/bisheng/workflow/nodes/condition/conidition_case.py

@@ -11,9 +11,11 @@
 class ConditionOne(BaseModel):
     id: str = Field(..., description='Unique id for condition')
     left_var: str = Field(..., description='Left variable')
+    left_label: str = Field('', description='Left variable label for editor display')
     comparison_operation: str = Field(..., description='Compare type')
     right_value_type: str = Field(..., description='Right value type')
     right_value: str = Field(..., description='Right value')
+    right_label: str = Field('', description='Right variable label for editor display')
     variable_key_value: Dict = Field(default={}, description='variable key value')
 
     def evaluate(self, node_instance: BaseNode) -> bool:

src/backend/test/test_external_workflow_service.py

@@ -347,15 +347,67 @@ def test_normalize_workflow_editor_graph_rewrites_legacy_node_types(self):
                     'name': 'End',
                     'group_params': [],
                 },
+            }, {
+                'id': 'condition-1',
+                'type': 'condition',
+                'position': {'x': 160, 'y': 0},
+                'data': {
+                    'id': 'condition-1',
+                    'type': 'condition',
+                    'name': 'Condition',
+                    'group_params': [{
+                        'params': [{
+                            'key': 'condition',
+                            'type': 'condition',
+                            'value': [{
+                                'id': 'case_a',
+                                'operator': 'and',
+                                'conditions': [{
+                                    'id': 'rule_1',
+                                    'left_var': 'code_1.score',
+                                    'comparison_operation': 'greater_than',
+                                    'right_value_type': 'const',
+                                    'right_value': '80',
+                                }],
+                            }],
+                        }],
+                    }],
+                },
             }],
             'edges': [],
         }
 
         normalized = FlowService._normalize_workflow_editor_graph(graph)
 
-        self.assertEqual([node['type'] for node in normalized['nodes']], ['flowNode', 'flowNode'])
-        self.assertEqual([node['data']['type'] for node in normalized['nodes']], ['start', 'end'])
-        self.assertEqual([node['type'] for node in graph['nodes']], ['start', 'end'])
+        self.assertEqual([node['type'] for node in normalized['nodes']], ['flowNode', 'flowNode', 'flowNode'])
+        self.assertEqual([node['data']['type'] for node in normalized['nodes']], ['start', 'end', 'condition'])
+        self.assertEqual([node['type'] for node in graph['nodes']], ['start', 'end', 'condition'])
+        condition_item = normalized['nodes'][2]['data']['group_params'][0]['params'][0]['value'][0]['conditions'][0]
+        self.assertEqual(condition_item['right_value_type'], 'input')
+        self.assertEqual(condition_item['left_label'], '')
+        self.assertEqual(condition_item['right_label'], '')
+
+    def test_normalize_condition_cases_keeps_editor_friendly_shape(self):
+        normalized = ExternalWorkflowService._normalize_condition_cases([{
+            'id': 'case_a',
+            'operator': 'and',
+            'conditions': [{
+                'id': 'rule_1',
+                'left_var': 'code_1.score',
+                'left_label': 'Score/priority_score',
+                'comparison_operation': 'greater_than_or_equal',
+                'right_value_type': 'const',
+                'right_value': '90',
+                'right_label': '',
+                'variable_key_value': {},
+            }],
+            'variable_key_value': {},
+        }])
+
+        condition_item = normalized[0]['conditions'][0]
+        self.assertEqual(condition_item['left_label'], 'Score/priority_score')
+        self.assertEqual(condition_item['right_label'], '')
+        self.assertEqual(condition_item['right_value_type'], 'input')
 
     def test_get_existing_external_draft_version_limits_recent_versions(self):
         captured = {'statements': []}