1use super::{configuration, Error};
12use crate::apis::ResponseContent;
13
14#[derive(Debug, Clone, Serialize, Deserialize)]
16#[serde(untagged)]
17pub enum CreateInternetServiceError {
18 Status400(crate::models::ErrorResponse),
19 Status401(crate::models::ErrorResponse),
20 Status500(crate::models::ErrorResponse),
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum DeleteInternetServiceError {
28 Status400(crate::models::ErrorResponse),
29 Status401(crate::models::ErrorResponse),
30 Status500(crate::models::ErrorResponse),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum LinkInternetServiceError {
38 Status400(crate::models::ErrorResponse),
39 Status401(crate::models::ErrorResponse),
40 Status500(crate::models::ErrorResponse),
41 UnknownValue(serde_json::Value),
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum ReadInternetServicesError {
48 Status400(crate::models::ErrorResponse),
49 Status401(crate::models::ErrorResponse),
50 Status500(crate::models::ErrorResponse),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum UnlinkInternetServiceError {
58 Status400(crate::models::ErrorResponse),
59 Status401(crate::models::ErrorResponse),
60 Status500(crate::models::ErrorResponse),
61 UnknownValue(serde_json::Value),
62}
63
64pub fn create_internet_service(
66 configuration: &configuration::Configuration,
67 create_internet_service_request: Option<crate::models::CreateInternetServiceRequest>,
68) -> Result<crate::models::CreateInternetServiceResponse, Error<CreateInternetServiceError>> {
69 let local_var_configuration = configuration;
70
71 let local_var_client = &local_var_configuration.client;
72
73 let local_var_uri_str = format!(
74 "{}/CreateInternetService",
75 local_var_configuration.base_path
76 );
77 let mut local_var_req_builder =
78 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
79
80 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
81 let local_var_new_headers = match local_var_aws_v4_key.sign(
82 &local_var_uri_str,
83 "POST",
84 &serde_json::to_string(&create_internet_service_request)
85 .expect("param should serialize to string"),
86 ) {
87 Ok(new_headers) => new_headers,
88 Err(err) => return Err(Error::AWSV4SignatureError(err)),
89 };
90 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
91 local_var_req_builder =
92 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
93 }
94 }
95 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
96 local_var_req_builder =
97 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
98 }
99 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
100 let local_var_key = local_var_apikey.key.clone();
101 let local_var_value = match local_var_apikey.prefix {
102 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
103 None => local_var_key,
104 };
105 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
106 };
107 local_var_req_builder = local_var_req_builder.json(&create_internet_service_request);
108
109 let local_var_req = local_var_req_builder.build()?;
110 let local_var_resp = local_var_client.execute(local_var_req)?;
111
112 let local_var_status = local_var_resp.status();
113 let local_var_content = local_var_resp.text()?;
114
115 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
116 serde_json::from_str(&local_var_content).map_err(Error::from)
117 } else {
118 let local_var_entity: Option<CreateInternetServiceError> =
119 serde_json::from_str(&local_var_content).ok();
120 let local_var_error = ResponseContent {
121 status: local_var_status,
122 content: local_var_content,
123 entity: local_var_entity,
124 };
125 Err(Error::ResponseError(local_var_error))
126 }
127}
128
129pub fn delete_internet_service(
131 configuration: &configuration::Configuration,
132 delete_internet_service_request: Option<crate::models::DeleteInternetServiceRequest>,
133) -> Result<crate::models::DeleteInternetServiceResponse, Error<DeleteInternetServiceError>> {
134 let local_var_configuration = configuration;
135
136 let local_var_client = &local_var_configuration.client;
137
138 let local_var_uri_str = format!(
139 "{}/DeleteInternetService",
140 local_var_configuration.base_path
141 );
142 let mut local_var_req_builder =
143 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
144
145 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
146 let local_var_new_headers = match local_var_aws_v4_key.sign(
147 &local_var_uri_str,
148 "POST",
149 &serde_json::to_string(&delete_internet_service_request)
150 .expect("param should serialize to string"),
151 ) {
152 Ok(new_headers) => new_headers,
153 Err(err) => return Err(Error::AWSV4SignatureError(err)),
154 };
155 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
156 local_var_req_builder =
157 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
158 }
159 }
160 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
161 local_var_req_builder =
162 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
163 }
164 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
165 let local_var_key = local_var_apikey.key.clone();
166 let local_var_value = match local_var_apikey.prefix {
167 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
168 None => local_var_key,
169 };
170 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
171 };
172 local_var_req_builder = local_var_req_builder.json(&delete_internet_service_request);
173
174 let local_var_req = local_var_req_builder.build()?;
175 let local_var_resp = local_var_client.execute(local_var_req)?;
176
177 let local_var_status = local_var_resp.status();
178 let local_var_content = local_var_resp.text()?;
179
180 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
181 serde_json::from_str(&local_var_content).map_err(Error::from)
182 } else {
183 let local_var_entity: Option<DeleteInternetServiceError> =
184 serde_json::from_str(&local_var_content).ok();
185 let local_var_error = ResponseContent {
186 status: local_var_status,
187 content: local_var_content,
188 entity: local_var_entity,
189 };
190 Err(Error::ResponseError(local_var_error))
191 }
192}
193
194pub fn link_internet_service(
196 configuration: &configuration::Configuration,
197 link_internet_service_request: Option<crate::models::LinkInternetServiceRequest>,
198) -> Result<crate::models::LinkInternetServiceResponse, Error<LinkInternetServiceError>> {
199 let local_var_configuration = configuration;
200
201 let local_var_client = &local_var_configuration.client;
202
203 let local_var_uri_str = format!("{}/LinkInternetService", local_var_configuration.base_path);
204 let mut local_var_req_builder =
205 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
206
207 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
208 let local_var_new_headers = match local_var_aws_v4_key.sign(
209 &local_var_uri_str,
210 "POST",
211 &serde_json::to_string(&link_internet_service_request)
212 .expect("param should serialize to string"),
213 ) {
214 Ok(new_headers) => new_headers,
215 Err(err) => return Err(Error::AWSV4SignatureError(err)),
216 };
217 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
218 local_var_req_builder =
219 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
220 }
221 }
222 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
223 local_var_req_builder =
224 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
225 }
226 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
227 let local_var_key = local_var_apikey.key.clone();
228 let local_var_value = match local_var_apikey.prefix {
229 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
230 None => local_var_key,
231 };
232 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
233 };
234 local_var_req_builder = local_var_req_builder.json(&link_internet_service_request);
235
236 let local_var_req = local_var_req_builder.build()?;
237 let local_var_resp = local_var_client.execute(local_var_req)?;
238
239 let local_var_status = local_var_resp.status();
240 let local_var_content = local_var_resp.text()?;
241
242 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
243 serde_json::from_str(&local_var_content).map_err(Error::from)
244 } else {
245 let local_var_entity: Option<LinkInternetServiceError> =
246 serde_json::from_str(&local_var_content).ok();
247 let local_var_error = ResponseContent {
248 status: local_var_status,
249 content: local_var_content,
250 entity: local_var_entity,
251 };
252 Err(Error::ResponseError(local_var_error))
253 }
254}
255
256pub fn read_internet_services(
258 configuration: &configuration::Configuration,
259 read_internet_services_request: Option<crate::models::ReadInternetServicesRequest>,
260) -> Result<crate::models::ReadInternetServicesResponse, Error<ReadInternetServicesError>> {
261 let local_var_configuration = configuration;
262
263 let local_var_client = &local_var_configuration.client;
264
265 let local_var_uri_str = format!("{}/ReadInternetServices", local_var_configuration.base_path);
266 let mut local_var_req_builder =
267 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
268
269 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
270 let local_var_new_headers = match local_var_aws_v4_key.sign(
271 &local_var_uri_str,
272 "POST",
273 &serde_json::to_string(&read_internet_services_request)
274 .expect("param should serialize to string"),
275 ) {
276 Ok(new_headers) => new_headers,
277 Err(err) => return Err(Error::AWSV4SignatureError(err)),
278 };
279 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
280 local_var_req_builder =
281 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
282 }
283 }
284 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
285 local_var_req_builder =
286 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
287 }
288 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
289 let local_var_key = local_var_apikey.key.clone();
290 let local_var_value = match local_var_apikey.prefix {
291 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
292 None => local_var_key,
293 };
294 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
295 };
296 local_var_req_builder = local_var_req_builder.json(&read_internet_services_request);
297
298 let local_var_req = local_var_req_builder.build()?;
299 let local_var_resp = local_var_client.execute(local_var_req)?;
300
301 let local_var_status = local_var_resp.status();
302 let local_var_content = local_var_resp.text()?;
303
304 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
305 serde_json::from_str(&local_var_content).map_err(Error::from)
306 } else {
307 let local_var_entity: Option<ReadInternetServicesError> =
308 serde_json::from_str(&local_var_content).ok();
309 let local_var_error = ResponseContent {
310 status: local_var_status,
311 content: local_var_content,
312 entity: local_var_entity,
313 };
314 Err(Error::ResponseError(local_var_error))
315 }
316}
317
318pub fn unlink_internet_service(
320 configuration: &configuration::Configuration,
321 unlink_internet_service_request: Option<crate::models::UnlinkInternetServiceRequest>,
322) -> Result<crate::models::UnlinkInternetServiceResponse, Error<UnlinkInternetServiceError>> {
323 let local_var_configuration = configuration;
324
325 let local_var_client = &local_var_configuration.client;
326
327 let local_var_uri_str = format!(
328 "{}/UnlinkInternetService",
329 local_var_configuration.base_path
330 );
331 let mut local_var_req_builder =
332 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
333
334 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
335 let local_var_new_headers = match local_var_aws_v4_key.sign(
336 &local_var_uri_str,
337 "POST",
338 &serde_json::to_string(&unlink_internet_service_request)
339 .expect("param should serialize to string"),
340 ) {
341 Ok(new_headers) => new_headers,
342 Err(err) => return Err(Error::AWSV4SignatureError(err)),
343 };
344 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
345 local_var_req_builder =
346 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
347 }
348 }
349 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
350 local_var_req_builder =
351 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
352 }
353 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
354 let local_var_key = local_var_apikey.key.clone();
355 let local_var_value = match local_var_apikey.prefix {
356 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
357 None => local_var_key,
358 };
359 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
360 };
361 local_var_req_builder = local_var_req_builder.json(&unlink_internet_service_request);
362
363 let local_var_req = local_var_req_builder.build()?;
364 let local_var_resp = local_var_client.execute(local_var_req)?;
365
366 let local_var_status = local_var_resp.status();
367 let local_var_content = local_var_resp.text()?;
368
369 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
370 serde_json::from_str(&local_var_content).map_err(Error::from)
371 } else {
372 let local_var_entity: Option<UnlinkInternetServiceError> =
373 serde_json::from_str(&local_var_content).ok();
374 let local_var_error = ResponseContent {
375 status: local_var_status,
376 content: local_var_content,
377 entity: local_var_entity,
378 };
379 Err(Error::ResponseError(local_var_error))
380 }
381}