1use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::ResponseContent;
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CreateSubnetError {
20 Status400(crate::models::ErrorResponse),
21 Status401(crate::models::ErrorResponse),
22 Status409(crate::models::ErrorResponse),
23 Status500(crate::models::ErrorResponse),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum DeleteSubnetError {
31 Status400(crate::models::ErrorResponse),
32 Status401(crate::models::ErrorResponse),
33 Status500(crate::models::ErrorResponse),
34 UnknownValue(serde_json::Value),
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum ReadSubnetsError {
41 Status400(crate::models::ErrorResponse),
42 Status401(crate::models::ErrorResponse),
43 Status500(crate::models::ErrorResponse),
44 UnknownValue(serde_json::Value),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(untagged)]
50pub enum UpdateSubnetError {
51 Status400(crate::models::ErrorResponse),
52 Status401(crate::models::ErrorResponse),
53 Status500(crate::models::ErrorResponse),
54 UnknownValue(serde_json::Value),
55}
56
57pub fn create_subnet(
59 configuration: &configuration::Configuration,
60 create_subnet_request: Option<crate::models::CreateSubnetRequest>,
61) -> Result<crate::models::CreateSubnetResponse, Error<CreateSubnetError>> {
62 let local_var_configuration = configuration;
63
64 let local_var_client = &local_var_configuration.client;
65
66 let local_var_uri_str = format!("{}/CreateSubnet", local_var_configuration.base_path);
67 let mut local_var_req_builder =
68 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
69
70 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
71 let local_var_new_headers = match local_var_aws_v4_key.sign(
72 &local_var_uri_str,
73 "POST",
74 &serde_json::to_string(&create_subnet_request)
75 .expect("param should serialize to string"),
76 ) {
77 Ok(new_headers) => new_headers,
78 Err(err) => return Err(Error::AWSV4SignatureError(err)),
79 };
80 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
81 local_var_req_builder =
82 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
83 }
84 }
85 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
86 local_var_req_builder =
87 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
88 }
89 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
90 let local_var_key = local_var_apikey.key.clone();
91 let local_var_value = match local_var_apikey.prefix {
92 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
93 None => local_var_key,
94 };
95 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
96 };
97 local_var_req_builder = local_var_req_builder.json(&create_subnet_request);
98
99 let local_var_req = local_var_req_builder.build()?;
100 let mut local_var_resp = local_var_client.execute(local_var_req)?;
101
102 let local_var_status = local_var_resp.status();
103 let local_var_content = local_var_resp.text()?;
104
105 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
106 serde_json::from_str(&local_var_content).map_err(Error::from)
107 } else {
108 let local_var_entity: Option<CreateSubnetError> =
109 serde_json::from_str(&local_var_content).ok();
110 let local_var_error = ResponseContent {
111 status: local_var_status,
112 content: local_var_content,
113 entity: local_var_entity,
114 };
115 Err(Error::ResponseError(local_var_error))
116 }
117}
118
119pub fn delete_subnet(
121 configuration: &configuration::Configuration,
122 delete_subnet_request: Option<crate::models::DeleteSubnetRequest>,
123) -> Result<crate::models::DeleteSubnetResponse, Error<DeleteSubnetError>> {
124 let local_var_configuration = configuration;
125
126 let local_var_client = &local_var_configuration.client;
127
128 let local_var_uri_str = format!("{}/DeleteSubnet", local_var_configuration.base_path);
129 let mut local_var_req_builder =
130 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
131
132 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
133 let local_var_new_headers = match local_var_aws_v4_key.sign(
134 &local_var_uri_str,
135 "POST",
136 &serde_json::to_string(&delete_subnet_request)
137 .expect("param should serialize to string"),
138 ) {
139 Ok(new_headers) => new_headers,
140 Err(err) => return Err(Error::AWSV4SignatureError(err)),
141 };
142 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
143 local_var_req_builder =
144 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
145 }
146 }
147 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
148 local_var_req_builder =
149 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
150 }
151 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
152 let local_var_key = local_var_apikey.key.clone();
153 let local_var_value = match local_var_apikey.prefix {
154 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
155 None => local_var_key,
156 };
157 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
158 };
159 local_var_req_builder = local_var_req_builder.json(&delete_subnet_request);
160
161 let local_var_req = local_var_req_builder.build()?;
162 let mut local_var_resp = local_var_client.execute(local_var_req)?;
163
164 let local_var_status = local_var_resp.status();
165 let local_var_content = local_var_resp.text()?;
166
167 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
168 serde_json::from_str(&local_var_content).map_err(Error::from)
169 } else {
170 let local_var_entity: Option<DeleteSubnetError> =
171 serde_json::from_str(&local_var_content).ok();
172 let local_var_error = ResponseContent {
173 status: local_var_status,
174 content: local_var_content,
175 entity: local_var_entity,
176 };
177 Err(Error::ResponseError(local_var_error))
178 }
179}
180
181pub fn read_subnets(
183 configuration: &configuration::Configuration,
184 read_subnets_request: Option<crate::models::ReadSubnetsRequest>,
185) -> Result<crate::models::ReadSubnetsResponse, Error<ReadSubnetsError>> {
186 let local_var_configuration = configuration;
187
188 let local_var_client = &local_var_configuration.client;
189
190 let local_var_uri_str = format!("{}/ReadSubnets", local_var_configuration.base_path);
191 let mut local_var_req_builder =
192 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
193
194 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
195 let local_var_new_headers = match local_var_aws_v4_key.sign(
196 &local_var_uri_str,
197 "POST",
198 &serde_json::to_string(&read_subnets_request)
199 .expect("param should serialize to string"),
200 ) {
201 Ok(new_headers) => new_headers,
202 Err(err) => return Err(Error::AWSV4SignatureError(err)),
203 };
204 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
205 local_var_req_builder =
206 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
207 }
208 }
209 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
210 local_var_req_builder =
211 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
212 }
213 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
214 let local_var_key = local_var_apikey.key.clone();
215 let local_var_value = match local_var_apikey.prefix {
216 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
217 None => local_var_key,
218 };
219 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
220 };
221 local_var_req_builder = local_var_req_builder.json(&read_subnets_request);
222
223 let local_var_req = local_var_req_builder.build()?;
224 let mut local_var_resp = local_var_client.execute(local_var_req)?;
225
226 let local_var_status = local_var_resp.status();
227 let local_var_content = local_var_resp.text()?;
228
229 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
230 serde_json::from_str(&local_var_content).map_err(Error::from)
231 } else {
232 let local_var_entity: Option<ReadSubnetsError> =
233 serde_json::from_str(&local_var_content).ok();
234 let local_var_error = ResponseContent {
235 status: local_var_status,
236 content: local_var_content,
237 entity: local_var_entity,
238 };
239 Err(Error::ResponseError(local_var_error))
240 }
241}
242
243pub fn update_subnet(
245 configuration: &configuration::Configuration,
246 update_subnet_request: Option<crate::models::UpdateSubnetRequest>,
247) -> Result<crate::models::UpdateSubnetResponse, Error<UpdateSubnetError>> {
248 let local_var_configuration = configuration;
249
250 let local_var_client = &local_var_configuration.client;
251
252 let local_var_uri_str = format!("{}/UpdateSubnet", local_var_configuration.base_path);
253 let mut local_var_req_builder =
254 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
255
256 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
257 let local_var_new_headers = match local_var_aws_v4_key.sign(
258 &local_var_uri_str,
259 "POST",
260 &serde_json::to_string(&update_subnet_request)
261 .expect("param should serialize to string"),
262 ) {
263 Ok(new_headers) => new_headers,
264 Err(err) => return Err(Error::AWSV4SignatureError(err)),
265 };
266 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
267 local_var_req_builder =
268 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
269 }
270 }
271 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
272 local_var_req_builder =
273 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
274 }
275 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
276 let local_var_key = local_var_apikey.key.clone();
277 let local_var_value = match local_var_apikey.prefix {
278 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
279 None => local_var_key,
280 };
281 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
282 };
283 local_var_req_builder = local_var_req_builder.json(&update_subnet_request);
284
285 let local_var_req = local_var_req_builder.build()?;
286 let mut local_var_resp = local_var_client.execute(local_var_req)?;
287
288 let local_var_status = local_var_resp.status();
289 let local_var_content = local_var_resp.text()?;
290
291 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
292 serde_json::from_str(&local_var_content).map_err(Error::from)
293 } else {
294 let local_var_entity: Option<UpdateSubnetError> =
295 serde_json::from_str(&local_var_content).ok();
296 let local_var_error = ResponseContent {
297 status: local_var_status,
298 content: local_var_content,
299 entity: local_var_entity,
300 };
301 Err(Error::ResponseError(local_var_error))
302 }
303}