moduforge_transform/
node_step.rs

1use std::sync::Arc;
2
3use moduforge_model::{
4    node::Node, node_type::NodeEnum, schema::Schema, tree::Tree, types::NodeId,
5};
6
7use super::{
8    step::{Step, StepResult},
9    transform::TransformError,
10};
11use serde::{Deserialize, Serialize};
12/// 添加节点的步骤
13#[derive(Debug, Serialize, Deserialize, Clone)]
14pub struct AddNodeStep {
15    nodes: NodeEnum,
16}
17impl AddNodeStep {
18    pub fn new(nodes: NodeEnum) -> Self {
19        AddNodeStep { nodes }
20    }
21}
22impl Step for AddNodeStep {
23    fn name(&self) -> String {
24        "add_node_step".to_string()
25    }
26    fn apply(
27        &self,
28        dart: &mut Tree,
29        schema: Arc<Schema>,
30    ) -> Result<StepResult, TransformError> {
31        let _ = schema;
32        let _ = dart.add(self.nodes.clone());
33        Ok(StepResult::ok())
34    }
35    fn serialize(&self) -> Option<Vec<u8>> {
36        serde_json::to_vec(self).ok()
37    }
38}
39/// 删除节点的步骤
40#[derive(Debug, Serialize, Deserialize, Clone)]
41pub struct RemoveNodeStep {
42    parent_id: NodeId,
43    node_ids: Vec<NodeId>,
44}
45impl RemoveNodeStep {
46    pub fn new(
47        parent_id: NodeId,
48        node_ids: Vec<NodeId>,
49    ) -> Self {
50        RemoveNodeStep { parent_id, node_ids }
51    }
52}
53impl Step for RemoveNodeStep {
54    fn name(&self) -> String {
55        "remove_node_step".to_string()
56    }
57    fn apply(
58        &self,
59        dart: &mut Tree,
60        schema: Arc<Schema>,
61    ) -> Result<StepResult, TransformError> {
62        let _ = schema;
63        let result = dart.node(&self.parent_id) - self.node_ids.clone();
64        match result {
65            Ok(_) => Ok(StepResult::ok()),
66            Err(e) => Ok(StepResult::fail(e.to_string())),
67        }
68    }
69    fn serialize(&self) -> Option<Vec<u8>> {
70        serde_json::to_vec(self).ok()
71    }
72}
73
74#[derive(Debug, Serialize, Deserialize, Clone)]
75pub struct MoveNodeStep {
76    source_parent_id: NodeId,
77    target_parent_id: NodeId,
78    node_id: NodeId,
79    position: Option<usize>, // 目标位置,None 表示追加到末尾
80}
81
82impl MoveNodeStep {
83    pub fn new(
84        source_parent_id: NodeId,
85        target_parent_id: NodeId,
86        node_id: NodeId,
87        position: Option<usize>,
88    ) -> Self {
89        MoveNodeStep { source_parent_id, target_parent_id, node_id, position }
90    }
91}
92
93impl Step for MoveNodeStep {
94    fn name(&self) -> String {
95        "move_node_step".to_string()
96    }
97    fn apply(
98        &self,
99        dart: &mut Tree,
100        schema: Arc<Schema>,
101    ) -> Result<StepResult, TransformError> {
102        let _ = schema;
103
104        match dart.move_node(
105            &self.source_parent_id,
106            &self.target_parent_id,
107            &self.node_id,
108            self.position,
109        ) {
110            Ok(()) => Ok(StepResult::ok()),
111            Err(err) => Err(TransformError::new(err.to_string())),
112        }
113    }
114    fn serialize(&self) -> Option<Vec<u8>> {
115        serde_json::to_vec(self).ok()
116    }
117}
118
119/// 替换节点
120#[derive(Debug, Serialize, Deserialize, Clone)]
121pub struct ReplaceNodeStep {
122    node_id: NodeId,
123    nodes: Vec<Node>,
124}
125impl ReplaceNodeStep {
126    pub fn new(
127        node_id: NodeId,
128        nodes: Vec<Node>,
129    ) -> Self {
130        ReplaceNodeStep { node_id, nodes }
131    }
132}
133impl Step for ReplaceNodeStep {
134    fn name(&self) -> String {
135        "replace_node_step".to_string()
136    }
137    fn apply(
138        &self,
139        dart: &mut Tree,
140        schema: Arc<Schema>,
141    ) -> Result<StepResult, TransformError> {
142        let _ = schema;
143
144        match dart.replace_node(self.node_id.clone(), &self.nodes) {
145            Ok(()) => Ok(StepResult::ok()),
146            Err(err) => Err(TransformError::new(err.to_string())),
147        }
148    }
149    fn serialize(&self) -> Option<Vec<u8>> {
150        serde_json::to_vec(self).ok()
151    }
152}