first commit

sync_state_machine/domain/material/__init__.py

@@ -0,0 +1,6 @@
+"""Material domain"""
+from .sync_node import MaterialSyncNode
+from .sync_strategy import MaterialSyncStrategy
+from .jsonl_handler import MaterialJsonlHandler
+
+__all__ = ["MaterialSyncNode", "MaterialSyncStrategy", "MaterialJsonlHandler"]

sync_state_machine/domain/material/api_handler.py

@@ -0,0 +1,355 @@
+"""
+Material API Handler (V2)
+
+职责：
+- 加载物资列表（依赖 Project）
+- 物资创建/更新/删除（批量接口）
+"""
+
+from typing import List, Dict, Any
+from ...datasource.api.handler import BaseApiHandler
+from ...datasource.task_result import TaskResult
+from ...common.sync_node import SyncNode
+from ...datasource.api.errors import (
+    ERROR_NODE_DATA_NONE,
+    ERROR_VALIDATION_FAILED,
+    ERROR_PROJECT_ID_NOT_FOUND
+)
+from .sync_node import MaterialSyncNode
+from schemas.material.material import MaterialResponse, MaterialCreate, MaterialUpdate, MaterialPlanUpdate
+
+
+class MaterialApiHandler(BaseApiHandler):
+    """物资 API Handler"""
+    
+    def __init__(self):
+        super().__init__()
+        self._node_type = "material"
+        self._node_class = MaterialSyncNode
+        self._schema = MaterialResponse
+        self.update_schemas = [MaterialCreate, MaterialUpdate, MaterialPlanUpdate]
+    
+    async def load(self) -> List[SyncNode]:
+        """
+        加载物资列表
+        
+        依赖 Project
+        使用 GET /material/list?project_id={id} 接口
+        """
+        try:
+            projects = self._collection.filter(node_type="project")
+            project_ids = [p.data_id for p in projects if p.data_id]
+            
+            if not project_ids:
+                print("⚠️  No projects found, skipping material load")
+                return []
+            
+            all_materials = []
+            for project_id in project_ids:
+                try:
+                    materials = await api_get_material_list(self.api_client, project_id)
+                    
+                    for material in materials:
+                        # 已验证的 Pydantic model，转换为 dict
+                        material_data = material.model_dump()
+                        all_materials.append(self._create_node(material_data))
+                
+                except Exception as e:
+                    print(f"❌ Failed to load materials for project {project_id}: {e}")
+                    continue
+            
+            return all_materials
+        
+        except Exception as e:
+            print(f"❌ Failed to load materials: {e}")
+            return []
+    
+    async def create_all(self, nodes: List[SyncNode]) -> List[TaskResult]:
+        """批量创建物资"""
+        results = []
+        for node in nodes:
+            result = await self._create_single(node)
+            results.append(result)
+        return results
+    
+    async def update_all(self, nodes: List[SyncNode]) -> List[TaskResult]:
+        """
+        批量更新物资
+        
+        支持两种更新类型：
+        1. MaterialUpdate - 基础信息更新
+        2. MaterialPlanUpdate - 计划信息更新
+        
+        更新逻辑：
+        - 对每种 schema，检查是否有差异
+        - 如果有差异，调用对应 API
+        """
+        from pydantic import ValidationError
+        
+        results = []
+        for node in nodes:
+            data = node.get_data()
+            if not data:
+                results.append(TaskResult.failed(node_id=node.node_id, error=ERROR_NODE_DATA_NONE))
+                continue
+            
+            origin_data = node.get_origin_data() or {}
+            biz_id = node.data_id or data.get("id")
+            if not biz_id:
+                results.append(TaskResult.failed(node_id=node.node_id, error="Missing biz_id for update"))
+                continue
+            
+            node_updated = False
+            error = None
+            
+            # 1. 基础信息更新 (MaterialUpdate)
+            base_diff = self._get_schema_diff(MaterialUpdate, data, origin_data, node.node_id)
+            if base_diff:
+                try:
+                    update_model = MaterialUpdate.model_validate(data)
+                    push_id = self._generate_push_id()
+                    await api_update_material(self.api_client, update_model, push_id, biz_id)
+                    node_updated = True
+                except ValidationError as e:
+                    error = f"{ERROR_VALIDATION_FAILED}: {e}"
+            
+            # 2. 计划信息更新 (MaterialPlanUpdate)
+            plan_diff = self._get_schema_diff(MaterialPlanUpdate, data, origin_data, node.node_id)
+            if not error and plan_diff:
+                try:
+                    plan_model = MaterialPlanUpdate.model_validate(data)
+                    push_id = self._generate_push_id()
+                    # 需要调用对应的计划更新 API
+                    await api_update_material_plan(
+                        self.api_client,
+                        plan_model.model_dump(exclude_unset=True),
+                        push_id,
+                        biz_id
+                    )
+                    node_updated = True
+                except ValidationError as e:
+                    error = f"{ERROR_VALIDATION_FAILED}: {e}"
+            
+            # 汇总结果
+            if error:
+                results.append(TaskResult.failed(node_id=node.node_id, error=error))
+            elif node_updated:
+                results.append(TaskResult.success(node_id=node.node_id))
+            else:
+                # 没有任何字段需要更新
+                results.append(TaskResult.skipped(node_id=node.node_id, reason="No updatable fields changed"))
+        
+        return results
+    
+    async def delete_all(self, nodes: List[SyncNode]) -> List[TaskResult]:
+        """批量删除物资"""
+        results = []
+        for node in nodes:
+            result = await self._delete_single(node)
+            results.append(result)
+        return results
+    
+    async def _create_single(self, node: SyncNode) -> TaskResult:
+        """创建物资"""
+        try:
+            data = node.get_data()
+            if not data:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error=ERROR_NODE_DATA_NONE
+                )
+            
+            push_id = self._generate_push_id()
+            
+            project_id = node.context.get("project_id")
+            if not project_id:
+                project_id = data.get("project_id")
+            
+            if not project_id:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error=ERROR_PROJECT_ID_NOT_FOUND
+                )
+            
+            # 验证并转换为 Pydantic model
+            from pydantic import ValidationError
+            create_data = {"project_id": project_id, **data}
+            try:
+                create_model = MaterialCreate.model_validate(create_data)
+            except ValidationError as e:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error=f"{ERROR_VALIDATION_FAILED}: {e}"
+                )
+            
+            response = await api_create_material(self.api_client, create_model, push_id)
+            if self.poll_mode == "sync":
+                created_id = self._extract_created_id_from_response(response)
+                if not created_id:
+                    return TaskResult.failed(
+                        node_id=node.node_id,
+                        error="Missing created_id in create response"
+                    )
+                return TaskResult.success(node_id=node.node_id, data_id=created_id)
+            else:
+                return TaskResult.in_progress(node_id=node.node_id, task_id=push_id)
+        
+        except Exception as e:
+            return TaskResult.failed(
+                node_id=node.node_id,
+                error=f"Create failed: {str(e)}"
+            )
+    
+    async def _update_single(self, node: SyncNode) -> TaskResult:
+        """更新物资"""
+        if not self.api_client:
+            return TaskResult.failed(
+                node_id=node.node_id,
+                error="api_client not initialized"
+            )
+        
+        try:
+            data = node.get_data()
+            if not data:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error="Node data is None or validation failed"
+                )
+            
+            push_id = self._generate_push_id()
+            biz_id = node.data_id or data.get("id")
+            if not biz_id:
+                return TaskResult.failed(node_id=node.node_id, error="Missing biz_id for update")
+            
+            # 验证并转换为 Pydantic model
+            from pydantic import ValidationError
+            try:
+                update_model = MaterialUpdate.model_validate(data)
+            except ValidationError as e:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error=f"{ERROR_VALIDATION_FAILED}: {e}"
+                )
+            
+            await api_update_material(self.api_client, update_model, push_id, biz_id)
+            return TaskResult.success(node_id=node.node_id)
+        
+        except Exception as e:
+            return TaskResult.failed(
+                node_id=node.node_id,
+                error=f"Update failed: {str(e)}"
+            )
+    
+    async def _delete_single(self, node: SyncNode) -> TaskResult:
+        """删除物资"""
+        try:
+            push_id = self._generate_push_id()
+            biz_id = node.data_id
+            if not biz_id:
+                return TaskResult.failed(node_id=node.node_id, error="Missing biz_id for delete")
+            
+            request_data = {
+                "push_id": push_id,
+                "biz_id": biz_id,
+            }
+            
+            response = await self.api_client.request(
+                method="DELETE",
+                endpoint="/material/delete",
+                data=request_data
+            )
+            
+            if response.get("code") == 200:
+                return TaskResult.success(node_id=node.node_id)
+            else:
+                return TaskResult.failed(
+                    node_id=node.node_id,
+                    error=f"API returned error: {response.get('message', 'Unknown error')}"
+                )
+        
+        except Exception as e:
+            return TaskResult.failed(
+                node_id=node.node_id,
+                error=f"Delete failed: {str(e)}"
+            )
+    
+    def _create_node(self, data: Dict[str, Any]) -> SyncNode:
+        """
+        创建物资同步节点
+        
+        设置 project_id 和 material_id 到 context
+        """
+        node = self._create_basic_node(data, depend_ids=[])
+        
+        if data.get("project_id"):
+            node.context["project_id"] = data["project_id"]
+        node.context["material_id"] = node.data_id
+        
+        return node
+
+
+# ========== 静态 API 函数 ==========
+
+async def api_get_material(client, material_id: str) -> Dict[str, Any]:
+    """获取单个物资数据 GET /material"""
+    response = await client.request(
+        method="GET",
+        endpoint="/material",
+        params={"material_id": material_id}
+    )
+    if response.get("code") != 200:
+        raise Exception(f"API error: {response.get('message', 'Unknown error')}")
+    return response.get("data", {})
+
+
+# ========== 静态 API 函数 ==========
+
+async def api_get_material_list(client, project_id: str) -> List[MaterialResponse]:
+    """GET /material/list - 获取物资列表"""
+    response = await client.request(
+        method="GET",
+        endpoint="/material/list",
+        params={"project_id": project_id}
+    )
+    if response.get("code") != 200:
+        raise Exception(f"API error: {response.get('message', 'Unknown error')}")
+    
+    items = response.get("data", [])
+    
+    # 验证每个返回项
+    from pydantic import ValidationError
+    validated_items = []
+    for item in items:
+        try:
+            validated_item = MaterialResponse.model_validate(item)
+            validated_items.append(validated_item)
+        except ValidationError as e:
+            print(f"⚠️ Skipping invalid material item: {e}")
+            continue
+    
+    return validated_items
+
+
+async def api_create_material(client, data: MaterialCreate, push_id: str) -> Dict[str, Any]:
+    """创建物资 POST /material/create"""
+    request_data = {"push_id": push_id, "data": data.model_dump()}
+    response = await client.request(method="POST", endpoint="/material/create", data=request_data)
+    if response.get("code") != 200:
+        raise Exception(f"API error: {response.get('message', 'Unknown error')}")
+    return response
+
+
+async def api_update_material(client, data: MaterialUpdate, push_id: str, biz_id: str) -> None:
+    """更新物资 PUT /material/update"""
+    request_data = {"push_id": push_id, "biz_id": biz_id, "data": data.model_dump(exclude_unset=True)}
+    response = await client.request(method="PUT", endpoint="/material/update", data=request_data)
+    if response.get("code") != 200:
+        raise Exception(f"API error: {response.get('message', 'Unknown error')}")
+
+
+async def api_update_material_plan(client, data: Dict[str, Any], push_id: str, biz_id: str) -> None:
+    """更新物资计划 PUT /material/plan"""
+    request_data = {"push_id": push_id, "biz_id": biz_id, "data": data}
+    response = await client.request(method="PUT", endpoint="/material/plan", data=request_data)
+    if response.get("code") != 200:
+        raise Exception(f"API error: {response.get('message', 'Unknown error')}")

sync_state_machine/domain/material/jsonl_handler.py

@@ -0,0 +1,10 @@
+"""Material Domain - JSONL Handler"""
+from ...datasource import BaseJsonlHandler, JsonlDataSource
+from .sync_node import MaterialSyncNode
+from schemas.material.material import MaterialResponse
+
+
+class MaterialJsonlHandler(BaseJsonlHandler):
+    """物资 JSONL Handler"""
+    def __init__(self, datasource: JsonlDataSource):
+        super().__init__(datasource, "material", MaterialSyncNode, MaterialResponse)

sync_state_machine/domain/material/register.py

@@ -0,0 +1,17 @@
+"""Material domain registration"""
+from ...common.registry import DomainRegistry
+from schemas.material.material import MaterialResponse
+from .sync_node import MaterialSyncNode
+from .sync_strategy import MaterialSyncStrategy
+from .jsonl_handler import MaterialJsonlHandler
+from .api_handler import MaterialApiHandler
+
+# 注册 material domain
+DomainRegistry.register(
+    node_type="material",
+    schema=MaterialResponse,
+    node_class=MaterialSyncNode,
+    strategy_class=MaterialSyncStrategy,
+    jsonl_handler_class=MaterialJsonlHandler,
+    api_handler_class=MaterialApiHandler,
+)

sync_state_machine/domain/material/sync_node.py

@@ -0,0 +1,11 @@
+from ...common.sync_node import SyncNode
+from schemas.material.material import MaterialResponse
+
+
+class MaterialSyncNode(SyncNode[MaterialResponse]):
+    """物资同步节点"""
+    node_type = "material"
+    schema = MaterialResponse
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)

sync_state_machine/domain/material/sync_strategy.py

@@ -0,0 +1,20 @@
+from ...sync_system.strategy import DefaultSyncStrategy
+from ...sync_system.config import StrategyConfig, OrphanAction, UpdateDirection
+from schemas.material.material import MaterialResponse
+
+
+class MaterialSyncStrategy(DefaultSyncStrategy[MaterialResponse]):
+    """
+    Material 同步策略（合同子业务）。
+    """
+
+    schema = MaterialResponse
+
+    default_config = StrategyConfig(
+        auto_bind=True,
+        auto_bind_fields=["contract_id", "material_type"],
+        depend_fields={"contract_id": "contract", "project_id": "project"},
+        local_orphan_action=OrphanAction.CREATE_REMOTE,
+        remote_orphan_action=OrphanAction.NONE,
+        update_direction=UpdateDirection.PUSH,
+    )