clientapi_pve/models/
cluster_config_addnode_request.rs1use crate::models;
12use serde::{Deserialize, Serialize};
13
14#[derive(Clone, Default, Debug, PartialEq)]
15pub struct ClusterConfigAddnodeRequest {
16
17
18 pub apiversion: Option<i64>,
20
21 pub force: Option<models::PveBoolean>,
23
24 pub new_node_ip: Option<String>,
26
27 pub nodeid: Option<i64>,
29
30 pub votes: Option<i64>,
32
33 pub links: Option<std::collections::HashMap<u32, models::PveLinkField>>,
35}
36
37impl ClusterConfigAddnodeRequest {
38 pub fn new() -> ClusterConfigAddnodeRequest {
39 ClusterConfigAddnodeRequest {
40
41 apiversion: None,
42
43 force: None,
44
45 new_node_ip: None,
46
47 nodeid: None,
48
49 votes: None,
50
51 links: None,
52 }
53 }
54}
55
56
57impl serde::Serialize for ClusterConfigAddnodeRequest {
59 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
60 use serde::ser::Error;
61 let mut map = serde_json::Map::new();
62
63 {
64 let _v = serde_json::to_value(&self.apiversion).map_err(Error::custom)?;
65 if !_v.is_null() {
66 map.insert("apiversion".to_string(), _v);
67 }
68 }
69
70 {
71 let _v = serde_json::to_value(&self.force).map_err(Error::custom)?;
72 if !_v.is_null() {
73 map.insert("force".to_string(), _v);
74 }
75 }
76
77 {
78 let _v = serde_json::to_value(&self.new_node_ip).map_err(Error::custom)?;
79 if !_v.is_null() {
80 map.insert("new_node_ip".to_string(), _v);
81 }
82 }
83
84 {
85 let _v = serde_json::to_value(&self.nodeid).map_err(Error::custom)?;
86 if !_v.is_null() {
87 map.insert("nodeid".to_string(), _v);
88 }
89 }
90
91 {
92 let _v = serde_json::to_value(&self.votes).map_err(Error::custom)?;
93 if !_v.is_null() {
94 map.insert("votes".to_string(), _v);
95 }
96 }
97
98 if let Some(ref _m) = self.links {
99 for (_idx, _val) in _m.iter() {
100 map.insert(format!("link{}", _idx), serde_json::to_value(_val).map_err(Error::custom)?);
101 }
102 }
103 serde_json::Value::Object(map).serialize(serializer)
104 }
105}
106
107impl<'de> serde::Deserialize<'de> for ClusterConfigAddnodeRequest {
108 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
109 use serde::de::Error;
110 let mut raw: serde_json::Map<String, serde_json::Value> =
111 serde::Deserialize::deserialize(deserializer)?;
112 let mut __links: std::collections::HashMap<u32, models::PveLinkField> = std::collections::HashMap::new();
113 {
114 let _prefix = "link";
115 let _keys: Vec<String> = raw.keys()
116 .filter(|k| {
117 if let Some(_suffix) = k.strip_prefix(_prefix) {
118 !_suffix.is_empty() && _suffix.chars().all(|c| c.is_ascii_digit())
119 } else {
120 false
121 }
122 })
123 .cloned()
124 .collect();
125 for _key in _keys {
126 let _suffix = _key.strip_prefix(_prefix).unwrap();
127 let _idx: u32 = _suffix.parse().map_err(Error::custom)?;
128 let _value = raw.remove(&_key).unwrap();
129 let _item: models::PveLinkField = serde_json::from_value(_value).map_err(Error::custom)?;
130 __links.insert(_idx, _item);
131 }
132 }
133 Ok(ClusterConfigAddnodeRequest {
134
135 apiversion: serde_json::from_value(raw.remove("apiversion").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
136
137 force: serde_json::from_value(raw.remove("force").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
138
139 new_node_ip: serde_json::from_value(raw.remove("new_node_ip").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
140
141 nodeid: serde_json::from_value(raw.remove("nodeid").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
142
143 votes: serde_json::from_value(raw.remove("votes").unwrap_or(serde_json::Value::Null)).map_err(Error::custom)?,
144
145 links: if __links.is_empty() { None } else { Some(__links) },
146 })
147 }
148}
149
150