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