第一次提交

backend/app/services/data_transformer.py

@@ -0,0 +1,255 @@
+"""
+数据转换服务
+支持字段映射、数据过滤、数据转换等功能
+"""
+from typing import Dict, Any, List, Optional, Union
+import json
+import re
+
+
+class DataTransformer:
+    """数据转换器"""
+    
+    @staticmethod
+    def get_nested_value(data: Dict[str, Any], path: str) -> Any:
+        """
+        从嵌套字典中获取值
+        
+        Args:
+            data: 数据字典
+            path: 路径，如 'user.name' 或 'items[0].price'
+            
+        Returns:
+            值，如果不存在返回None
+        """
+        try:
+            # 处理混合路径，如 items[0].price
+            if '[' in path and ']' in path:
+                # 先处理数组索引部分
+                bracket_match = re.search(r'(\w+)\[(\d+)\]', path)
+                if bracket_match:
+                    array_key = bracket_match.group(1)
+                    array_index = int(bracket_match.group(2))
+                    rest_path = path[bracket_match.end():]
+                    
+                    # 获取数组
+                    if array_key in data and isinstance(data[array_key], list):
+                        if array_index < len(data[array_key]):
+                            array_item = data[array_key][array_index]
+                            # 如果还有后续路径，继续获取
+                            if rest_path.startswith('.'):
+                                return DataTransformer.get_nested_value(array_item, rest_path[1:])
+                            else:
+                                return array_item
+                    return None
+            
+            # 处理嵌套路径，如 user.name
+            keys = path.split('.')
+            value = data
+            for key in keys:
+                if isinstance(value, dict):
+                    value = value.get(key)
+                elif isinstance(value, list) and key.isdigit():
+                    value = value[int(key)] if int(key) < len(value) else None
+                else:
+                    return None
+                if value is None:
+                    return None
+            return value
+        except (KeyError, IndexError, TypeError, AttributeError):
+            return None
+    
+    @staticmethod
+    def set_nested_value(data: Dict[str, Any], path: str, value: Any) -> None:
+        """
+        在嵌套字典中设置值
+        
+        Args:
+            data: 数据字典
+            path: 路径，如 'user.name'
+            value: 要设置的值
+        """
+        keys = path.split('.')
+        current = data
+        
+        # 创建嵌套结构
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            current = current[key]
+        
+        # 设置值
+        current[keys[-1]] = value
+    
+    @staticmethod
+    def transform_mapping(input_data: Dict[str, Any], mapping: Dict[str, str]) -> Dict[str, Any]:
+        """
+        字段映射转换
+        
+        Args:
+            input_data: 输入数据
+            mapping: 映射规则，格式: {"target_key": "source_key"}
+            
+        Returns:
+            转换后的数据
+        """
+        result = {}
+        for target_key, source_key in mapping.items():
+            value = DataTransformer.get_nested_value(input_data, source_key)
+            if value is not None:
+                # 如果目标键包含点或方括号，使用嵌套设置
+                if '.' in target_key or '[' in target_key:
+                    DataTransformer.set_nested_value(result, target_key, value)
+                else:
+                    # 简单键直接设置
+                    result[target_key] = value
+        return result
+    
+    @staticmethod
+    def transform_filter(input_data: Dict[str, Any], filter_rules: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        数据过滤
+        
+        Args:
+            input_data: 输入数据
+            filter_rules: 过滤规则列表，格式: [{"field": "key", "operator": ">", "value": 10}]
+            
+        Returns:
+            过滤后的数据
+        """
+        result = {}
+        
+        for rule in filter_rules:
+            field = rule.get('field')
+            operator = rule.get('operator', '==')
+            value = rule.get('value')
+            
+            if not field:
+                continue
+            
+            field_value = DataTransformer.get_nested_value(input_data, field)
+            
+            # 应用过滤规则
+            should_include = False
+            if operator == '==' and field_value == value:
+                should_include = True
+            elif operator == '!=' and field_value != value:
+                should_include = True
+            elif operator == '>' and field_value > value:
+                should_include = True
+            elif operator == '>=' and field_value >= value:
+                should_include = True
+            elif operator == '<' and field_value < value:
+                should_include = True
+            elif operator == '<=' and field_value <= value:
+                should_include = True
+            elif operator == 'in' and field_value in value:
+                should_include = True
+            elif operator == 'not in' and field_value not in value:
+                should_include = True
+            
+            if should_include:
+                # 包含该字段
+                if field in input_data:
+                    result[field] = input_data[field]
+                else:
+                    # 如果是嵌套字段，需要重建结构
+                    DataTransformer.set_nested_value(result, field, field_value)
+        
+        return result if result else input_data
+    
+    @staticmethod
+    def transform_compute(input_data: Dict[str, Any], compute_rules: Dict[str, str]) -> Dict[str, Any]:
+        """
+        数据计算转换
+        
+        Args:
+            input_data: 输入数据
+            compute_rules: 计算规则，格式: {"result": "{a} + {b}"}
+            
+        Returns:
+            转换后的数据
+        """
+        result = input_data.copy()
+        
+        for target_key, expression in compute_rules.items():
+            try:
+                # 替换变量
+                computed_expression = expression
+                for key, value in input_data.items():
+                    placeholder = f'{{{key}}}'
+                    if placeholder in computed_expression:
+                        if isinstance(value, (dict, list)):
+                            computed_expression = computed_expression.replace(
+                                placeholder, 
+                                json.dumps(value, ensure_ascii=False)
+                            )
+                        else:
+                            computed_expression = computed_expression.replace(
+                                placeholder, 
+                                str(value)
+                            )
+                
+                # 安全评估表达式
+                safe_dict = {
+                    '__builtins__': {},
+                    'abs': abs,
+                    'min': min,
+                    'max': max,
+                    'sum': sum,
+                    'len': len,
+                }
+                
+                # 添加输入数据中的值
+                for key, value in input_data.items():
+                    if isinstance(value, (str, int, float, bool, type(None))):
+                        safe_dict[key] = value
+                
+                computed_value = eval(computed_expression, safe_dict)
+                result[target_key] = computed_value
+            except Exception as e:
+                # 计算失败，跳过该字段
+                result[target_key] = None
+        
+        return result
+    
+    @staticmethod
+    def transform_data(
+        input_data: Dict[str, Any],
+        mapping: Optional[Dict[str, str]] = None,
+        filter_rules: Optional[List[Dict[str, Any]]] = None,
+        compute_rules: Optional[Dict[str, str]] = None,
+        mode: str = 'mapping'
+    ) -> Dict[str, Any]:
+        """
+        数据转换（综合方法）
+        
+        Args:
+            input_data: 输入数据
+            mapping: 字段映射规则
+            filter_rules: 过滤规则
+            compute_rules: 计算规则
+            mode: 转换模式 ('mapping', 'filter', 'compute', 'all')
+            
+        Returns:
+            转换后的数据
+        """
+        result = input_data.copy()
+        
+        if mode == 'mapping' or mode == 'all':
+            if mapping:
+                result = DataTransformer.transform_mapping(result, mapping)
+        
+        if mode == 'filter' or mode == 'all':
+            if filter_rules:
+                result = DataTransformer.transform_filter(result, filter_rules)
+        
+        if mode == 'compute' or mode == 'all':
+            if compute_rules:
+                result = DataTransformer.transform_compute(result, compute_rules)
+        
+        return result
+
+
+# 全局实例
+data_transformer = DataTransformer()