1use serde::{Deserialize, Serialize};
2
3use manta_backend_dispatcher::types::{
4 Component as FrontEndComponent,
5 ComponentArrayPostArray as FrontEndComponentArrayPostArray,
6 ComponentCreate as FrontEndComponentCreate,
7 NodeMetadataArray as FrontEndNodeMetadataArray,
8};
9
10#[derive(Debug, Serialize, Deserialize, Clone)]
11pub struct ComponentArray {
12 #[serde(skip_serializing_if = "Option::is_none")]
13 #[serde(rename = "Components")]
14 pub components: Option<Vec<Component>>,
15}
16
17impl From<FrontEndNodeMetadataArray> for ComponentArray {
18 fn from(value: FrontEndNodeMetadataArray) -> Self {
19 let component_vec_opt: Option<Vec<Component>> =
20 if let Some(components) = value.components {
21 let mut component_vec: Vec<Component> =
22 Vec::with_capacity(components.len());
23
24 components
25 .into_iter()
26 .for_each(|component: FrontEndComponent| {
27 component_vec.push(Component::from(component))
28 });
29
30 Some(component_vec)
31 } else {
32 None
33 };
34
35 ComponentArray {
36 components: component_vec_opt,
37 }
38 }
39}
40
41impl Into<FrontEndNodeMetadataArray> for ComponentArray {
42 fn into(self) -> FrontEndNodeMetadataArray {
43 let component_vec_opt: Option<Vec<FrontEndComponent>> =
44 if let Some(components) = self.components {
45 let mut component_vec: Vec<FrontEndComponent> =
46 Vec::with_capacity(components.len());
47
48 components.into_iter().for_each(|component: Component| {
49 component_vec.push(component.into())
50 });
51
52 Some(component_vec)
53 } else {
54 None
55 };
56
57 FrontEndNodeMetadataArray {
58 components: component_vec_opt,
59 }
60 }
61}
62
63#[derive(Debug, Serialize, Deserialize, Clone)]
64pub struct Component {
65 #[serde(skip_serializing_if = "Option::is_none")]
66 #[serde(rename = "ID")]
67 pub id: Option<String>,
68 #[serde(skip_serializing_if = "Option::is_none")]
69 #[serde(rename = "Type")]
70 pub r#type: Option<String>,
71 #[serde(skip_serializing_if = "Option::is_none")]
72 #[serde(rename = "State")]
73 pub state: Option<String>,
74 #[serde(skip_serializing_if = "Option::is_none")]
75 #[serde(rename = "Flag")]
76 pub flag: Option<String>,
77 #[serde(skip_serializing_if = "Option::is_none")]
78 #[serde(rename = "Enabled")]
79 pub enabled: Option<bool>,
80 #[serde(skip_serializing_if = "Option::is_none")]
81 #[serde(rename = "SoftwareStatus")]
82 pub software_status: Option<String>,
83 #[serde(skip_serializing_if = "Option::is_none")]
84 #[serde(rename = "Role")]
85 pub role: Option<String>,
86 #[serde(skip_serializing_if = "Option::is_none")]
87 #[serde(rename = "SubRole")]
88 pub sub_role: Option<String>,
89 #[serde(skip_serializing_if = "Option::is_none")]
90 #[serde(rename = "NID")]
91 pub nid: Option<usize>,
92 #[serde(skip_serializing_if = "Option::is_none")]
93 #[serde(rename = "Subtype")]
94 pub subtype: Option<String>,
95 #[serde(skip_serializing_if = "Option::is_none")]
96 #[serde(rename = "NetType")]
97 pub net_type: Option<String>,
98 #[serde(skip_serializing_if = "Option::is_none")]
99 #[serde(rename = "Arch")]
100 pub arch: Option<String>,
101 #[serde(skip_serializing_if = "Option::is_none")]
102 #[serde(rename = "Class")]
103 pub class: Option<String>,
104 #[serde(skip_serializing_if = "Option::is_none")]
105 #[serde(rename = "ReservationDisabled")]
106 pub reservation_disabled: Option<bool>,
107 #[serde(skip_serializing_if = "Option::is_none")]
108 #[serde(rename = "Locked")]
109 pub locked: Option<bool>,
110}
111
112impl From<FrontEndComponent> for Component {
113 fn from(value: FrontEndComponent) -> Self {
114 Component {
115 id: value.id,
116 r#type: value.r#type,
117 state: value.state,
118 flag: value.flag,
119 enabled: value.enabled,
120 software_status: value.software_status,
121 role: value.role,
122 sub_role: value.sub_role,
123 nid: value.nid,
124 subtype: value.subtype,
125 net_type: value.net_type,
126 arch: value.arch,
127 class: value.class,
128 reservation_disabled: value.reservation_disabled,
129 locked: value.locked,
130 }
131 }
132}
133
134impl Into<FrontEndComponent> for Component {
135 fn into(self) -> FrontEndComponent {
136 FrontEndComponent {
137 id: self.id,
138 r#type: self.r#type,
139 state: self.state,
140 flag: self.flag,
141 enabled: self.enabled,
142 software_status: self.software_status,
143 role: self.role,
144 sub_role: self.sub_role,
145 nid: self.nid,
146 subtype: self.subtype,
147 net_type: self.net_type,
148 arch: self.arch,
149 class: self.class,
150 reservation_disabled: self.reservation_disabled,
151 locked: self.locked,
152 }
153 }
154}
155
156#[derive(Debug, Serialize, Deserialize, Clone)]
157pub struct ComponentArrayPostQuery {
158 #[serde(skip_serializing_if = "Option::is_none")]
159 #[serde(rename(serialize = "ComponentIDs"))]
160 pub component_ids: Option<Vec<String>>,
161 #[serde(skip_serializing_if = "Option::is_none")]
162 pub partition: Option<String>,
163 #[serde(skip_serializing_if = "Option::is_none")]
164 pub group: Option<String>,
165 #[serde(skip_serializing_if = "Option::is_none")]
166 #[serde(rename(serialize = "stateonly"))]
167 pub state_only: Option<bool>,
168 #[serde(skip_serializing_if = "Option::is_none")]
169 #[serde(rename(serialize = "flagonly"))]
170 pub falg_only: Option<bool>,
171 #[serde(skip_serializing_if = "Option::is_none")]
172 #[serde(rename(serialize = "roleonly"))]
173 pub role_only: Option<bool>,
174 #[serde(skip_serializing_if = "Option::is_none")]
175 #[serde(rename(serialize = "nidonly"))]
176 pub nid_only: Option<bool>,
177 #[serde(skip_serializing_if = "Option::is_none")]
178 pub r#type: Option<String>,
179 #[serde(skip_serializing_if = "Option::is_none")]
180 pub state: Option<String>,
181 #[serde(skip_serializing_if = "Option::is_none")]
182 pub flag: Option<String>,
183 #[serde(skip_serializing_if = "Option::is_none")]
184 pub enabled: Option<String>,
185 #[serde(skip_serializing_if = "Option::is_none")]
186 #[serde(rename(serialize = "softwarestatus"))]
187 pub software_status: Option<String>,
188 #[serde(skip_serializing_if = "Option::is_none")]
189 pub role: Option<String>,
190 #[serde(skip_serializing_if = "Option::is_none")]
191 pub subrole: Option<String>,
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub subtype: Option<String>,
194 #[serde(skip_serializing_if = "Option::is_none")]
195 pub arch: Option<String>,
196 #[serde(skip_serializing_if = "Option::is_none")]
197 pub class: Option<String>,
198 #[serde(skip_serializing_if = "Option::is_none")]
199 pub nid: Option<String>,
200 #[serde(skip_serializing_if = "Option::is_none")]
201 pub nid_start: Option<String>,
202 #[serde(skip_serializing_if = "Option::is_none")]
203 pub nid_end: Option<String>,
204}
205
206#[derive(Debug, Serialize, Deserialize, Clone)]
207pub struct ComponentArrayPostByNidQuery {
208 #[serde(rename(serialize = "NIDRanges"))]
209 pub nid_ranges: Vec<String>,
210 #[serde(skip_serializing_if = "Option::is_none")]
211 pub partition: Option<String>,
212 #[serde(skip_serializing_if = "Option::is_none")]
213 #[serde(rename(serialize = "stateonly"))]
214 pub state_only: Option<bool>,
215 #[serde(skip_serializing_if = "Option::is_none")]
216 #[serde(rename(serialize = "flagonly"))]
217 pub falg_only: Option<bool>,
218 #[serde(skip_serializing_if = "Option::is_none")]
219 #[serde(rename(serialize = "roleonly"))]
220 pub role_only: Option<bool>,
221 #[serde(skip_serializing_if = "Option::is_none")]
222 #[serde(rename(serialize = "nidonly"))]
223 pub nid_only: Option<bool>,
224}
225
226#[derive(Debug, Serialize, Deserialize, Clone)]
227pub struct ComponentArrayPostArray {
228 #[serde(rename(serialize = "Components"))]
229 pub components: Vec<ComponentCreate>,
230 #[serde(skip_serializing_if = "Option::is_none")]
231 #[serde(rename(serialize = "Force"))]
232 pub force: Option<bool>,
233}
234
235impl From<FrontEndComponentArrayPostArray> for ComponentArrayPostArray {
236 fn from(value: FrontEndComponentArrayPostArray) -> Self {
237 let mut component_vec: Vec<ComponentCreate> =
238 Vec::with_capacity(value.components.len());
239
240 value
241 .components
242 .into_iter()
243 .for_each(|c| component_vec.push(c.into()));
244
245 ComponentArrayPostArray {
246 components: component_vec,
247 force: value.force,
248 }
249 }
250}
251
252impl Into<FrontEndComponentArrayPostArray> for ComponentArrayPostArray {
253 fn into(self) -> FrontEndComponentArrayPostArray {
254 let mut component_vec: Vec<FrontEndComponentCreate> =
255 Vec::with_capacity(self.components.len());
256
257 self
258 .components
259 .into_iter()
260 .for_each(|c| component_vec.push(c.into()));
261
262 FrontEndComponentArrayPostArray {
263 components: component_vec,
264 force: self.force,
265 }
266 }
267}
268
269#[derive(Debug, Serialize, Deserialize, Clone)]
270pub struct ComponentCreate {
271 #[serde(rename(serialize = "ID"))]
272 id: String,
273 #[serde(rename(serialize = "State"))]
274 state: String,
275 #[serde(skip_serializing_if = "Option::is_none")]
276 #[serde(rename(serialize = "Flag"))]
277 flag: Option<String>,
278 #[serde(skip_serializing_if = "Option::is_none")]
279 #[serde(rename(serialize = "Enabled"))]
280 enabled: Option<bool>,
281 #[serde(skip_serializing_if = "Option::is_none")]
282 #[serde(rename(serialize = "SoftwareStatus"))]
283 software_status: Option<String>,
284 #[serde(skip_serializing_if = "Option::is_none")]
285 #[serde(rename(serialize = "Role"))]
286 role: Option<String>,
287 #[serde(skip_serializing_if = "Option::is_none")]
288 #[serde(rename(serialize = "SubRole"))]
289 sub_role: Option<String>,
290 #[serde(skip_serializing_if = "Option::is_none")]
291 #[serde(rename(serialize = "NID"))]
292 nid: Option<usize>,
293 #[serde(skip_serializing_if = "Option::is_none")]
294 #[serde(rename(serialize = "Subtype"))]
295 subtype: Option<String>,
296 #[serde(skip_serializing_if = "Option::is_none")]
297 #[serde(rename(serialize = "NetType"))]
298 net_type: Option<String>,
299 #[serde(skip_serializing_if = "Option::is_none")]
300 #[serde(rename(serialize = "Arch"))]
301 arch: Option<String>,
302 #[serde(skip_serializing_if = "Option::is_none")]
303 #[serde(rename(serialize = "Class"))]
304 class: Option<String>,
305}
306
307impl From<FrontEndComponentCreate> for ComponentCreate {
308 fn from(value: FrontEndComponentCreate) -> Self {
309 ComponentCreate {
310 id: value.id,
311 state: value.state,
312 flag: value.flag,
313 enabled: value.enabled,
314 software_status: value.software_status,
315 role: value.role,
316 sub_role: value.sub_role,
317 nid: value.nid,
318 subtype: value.subtype,
319 net_type: value.net_type,
320 arch: value.arch,
321 class: value.class,
322 }
323 }
324}
325
326impl Into<FrontEndComponentCreate> for ComponentCreate {
327 fn into(self) -> FrontEndComponentCreate {
328 FrontEndComponentCreate {
329 id: self.id,
330 state: self.state,
331 flag: self.flag,
332 enabled: self.enabled,
333 software_status: self.software_status,
334 role: self.role,
335 sub_role: self.sub_role,
336 nid: self.nid,
337 subtype: self.subtype,
338 net_type: self.net_type,
339 arch: self.arch,
340 class: self.class,
341 }
342 }
343}
344
345#[derive(Debug, Serialize, Deserialize, Clone)]
346pub struct ComponentPut {
347 component: ComponentCreate,
348 #[serde(skip_serializing_if = "Option::is_none")]
349 #[serde(rename(serialize = "Force"))]
350 force: Option<bool>,
351}