moduforge_transform/
node_step.rs1use 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#[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#[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>, }
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#[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}