1use reqwest;
12use serde::{Deserialize, Serialize, de::Error as _};
13
14use super::{ContentType, Error, configuration};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum CreateDedicatedServerError {
21 Status400(models::GetFinances400Response),
22 Status401(models::GetFinances401Response),
23 Status403(models::GetAccountStatus403Response),
24 Status404(models::GetImage404Response),
25 Status429(models::GetFinances429Response),
26 Status500(models::GetFinances500Response),
27 UnknownValue(serde_json::Value)
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum DeleteDedicatedServerError {
34 Status400(models::GetFinances400Response),
35 Status401(models::GetFinances401Response),
36 Status403(models::GetAccountStatus403Response),
37 Status404(models::GetImage404Response),
38 Status429(models::GetFinances429Response),
39 Status500(models::GetFinances500Response),
40 UnknownValue(serde_json::Value)
41}
42
43#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(untagged)]
46pub enum GetDedicatedServerError {
47 Status400(models::GetFinances400Response),
48 Status401(models::GetFinances401Response),
49 Status403(models::GetAccountStatus403Response),
50 Status404(models::GetImage404Response),
51 Status429(models::GetFinances429Response),
52 Status500(models::GetFinances500Response),
53 UnknownValue(serde_json::Value)
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum GetDedicatedServerPresetAdditionalServicesError {
61 Status400(models::GetFinances400Response),
62 Status401(models::GetFinances401Response),
63 Status403(models::GetAccountStatus403Response),
64 Status404(models::GetImage404Response),
65 Status429(models::GetFinances429Response),
66 Status500(models::GetFinances500Response),
67 UnknownValue(serde_json::Value)
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(untagged)]
73pub enum GetDedicatedServersError {
74 Status400(models::GetFinances400Response),
75 Status401(models::GetFinances401Response),
76 Status403(models::GetAccountStatus403Response),
77 Status404(models::GetImage404Response),
78 Status429(models::GetFinances429Response),
79 Status500(models::GetFinances500Response),
80 UnknownValue(serde_json::Value)
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum GetDedicatedServersPresetsError {
87 Status400(models::GetFinances400Response),
88 Status401(models::GetFinances401Response),
89 Status403(models::GetAccountStatus403Response),
90 Status404(models::GetImage404Response),
91 Status429(models::GetFinances429Response),
92 Status500(models::GetFinances500Response),
93 UnknownValue(serde_json::Value)
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize)]
98#[serde(untagged)]
99pub enum UpdateDedicatedServerError {
100 Status400(models::GetFinances400Response),
101 Status401(models::GetFinances401Response),
102 Status403(models::GetAccountStatus403Response),
103 Status404(models::GetImage404Response),
104 Status429(models::GetFinances429Response),
105 Status500(models::GetFinances500Response),
106 UnknownValue(serde_json::Value)
107}
108
109pub async fn create_dedicated_server(
114 configuration: &configuration::Configuration,
115 create_dedicated_server: models::CreateDedicatedServer
116) -> Result<models::CreateDedicatedServer201Response, Error<CreateDedicatedServerError>> {
117 let p_body_create_dedicated_server = create_dedicated_server;
119
120 let uri_str = format!("{}/api/v1/dedicated-servers", configuration.base_path);
121 let mut req_builder = configuration
122 .client
123 .request(reqwest::Method::POST, &uri_str);
124
125 if let Some(ref user_agent) = configuration.user_agent {
126 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
127 }
128 if let Some(ref token) = configuration.bearer_access_token {
129 req_builder = req_builder.bearer_auth(token.to_owned());
130 };
131 req_builder = req_builder.json(&p_body_create_dedicated_server);
132
133 let req = req_builder.build()?;
134 let resp = configuration.client.execute(req).await?;
135
136 let status = resp.status();
137 let content_type = resp
138 .headers()
139 .get("content-type")
140 .and_then(|v| v.to_str().ok())
141 .unwrap_or("application/octet-stream");
142 let content_type = super::ContentType::from(content_type);
143
144 if !status.is_client_error() && !status.is_server_error() {
145 let content = resp.text().await?;
146 match content_type {
147 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
148 ContentType::Text => {
149 return Err(Error::from(serde_json::Error::custom(
150 "Received `text/plain` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
151 )));
152 }
153 ContentType::Unsupported(unknown_type) => {
154 return Err(Error::from(serde_json::Error::custom(format!(
155 "Received `{unknown_type}` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
156 ))));
157 }
158 }
159 } else {
160 let content = resp.text().await?;
161 let entity: Option<CreateDedicatedServerError> = serde_json::from_str(&content).ok();
162 Err(Error::ResponseError(ResponseContent {
163 status,
164 content,
165 entity
166 }))
167 }
168}
169
170pub async fn delete_dedicated_server(
173 configuration: &configuration::Configuration,
174 dedicated_id: i32
175) -> Result<(), Error<DeleteDedicatedServerError>> {
176 let p_path_dedicated_id = dedicated_id;
178
179 let uri_str = format!(
180 "{}/api/v1/dedicated-servers/{dedicated_id}",
181 configuration.base_path,
182 dedicated_id = p_path_dedicated_id
183 );
184 let mut req_builder = configuration
185 .client
186 .request(reqwest::Method::DELETE, &uri_str);
187
188 if let Some(ref user_agent) = configuration.user_agent {
189 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
190 }
191 if let Some(ref token) = configuration.bearer_access_token {
192 req_builder = req_builder.bearer_auth(token.to_owned());
193 };
194
195 let req = req_builder.build()?;
196 let resp = configuration.client.execute(req).await?;
197
198 let status = resp.status();
199
200 if !status.is_client_error() && !status.is_server_error() {
201 Ok(())
202 } else {
203 let content = resp.text().await?;
204 let entity: Option<DeleteDedicatedServerError> = serde_json::from_str(&content).ok();
205 Err(Error::ResponseError(ResponseContent {
206 status,
207 content,
208 entity
209 }))
210 }
211}
212
213pub async fn get_dedicated_server(
216 configuration: &configuration::Configuration,
217 dedicated_id: i32
218) -> Result<models::CreateDedicatedServer201Response, Error<GetDedicatedServerError>> {
219 let p_path_dedicated_id = dedicated_id;
221
222 let uri_str = format!(
223 "{}/api/v1/dedicated-servers/{dedicated_id}",
224 configuration.base_path,
225 dedicated_id = p_path_dedicated_id
226 );
227 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
228
229 if let Some(ref user_agent) = configuration.user_agent {
230 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
231 }
232 if let Some(ref token) = configuration.bearer_access_token {
233 req_builder = req_builder.bearer_auth(token.to_owned());
234 };
235
236 let req = req_builder.build()?;
237 let resp = configuration.client.execute(req).await?;
238
239 let status = resp.status();
240 let content_type = resp
241 .headers()
242 .get("content-type")
243 .and_then(|v| v.to_str().ok())
244 .unwrap_or("application/octet-stream");
245 let content_type = super::ContentType::from(content_type);
246
247 if !status.is_client_error() && !status.is_server_error() {
248 let content = resp.text().await?;
249 match content_type {
250 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
251 ContentType::Text => {
252 return Err(Error::from(serde_json::Error::custom(
253 "Received `text/plain` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
254 )));
255 }
256 ContentType::Unsupported(unknown_type) => {
257 return Err(Error::from(serde_json::Error::custom(format!(
258 "Received `{unknown_type}` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
259 ))));
260 }
261 }
262 } else {
263 let content = resp.text().await?;
264 let entity: Option<GetDedicatedServerError> = serde_json::from_str(&content).ok();
265 Err(Error::ResponseError(ResponseContent {
266 status,
267 content,
268 entity
269 }))
270 }
271}
272
273pub async fn get_dedicated_server_preset_additional_services(
277 configuration: &configuration::Configuration,
278 preset_id: i32
279) -> Result<
280 models::GetDedicatedServerPresetAdditionalServices200Response,
281 Error<GetDedicatedServerPresetAdditionalServicesError>
282> {
283 let p_path_preset_id = preset_id;
285
286 let uri_str = format!(
287 "{}/api/v1/presets/dedicated-servers/{preset_id}/additional-services",
288 configuration.base_path,
289 preset_id = p_path_preset_id
290 );
291 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
292
293 if let Some(ref user_agent) = configuration.user_agent {
294 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
295 }
296 if let Some(ref token) = configuration.bearer_access_token {
297 req_builder = req_builder.bearer_auth(token.to_owned());
298 };
299
300 let req = req_builder.build()?;
301 let resp = configuration.client.execute(req).await?;
302
303 let status = resp.status();
304 let content_type = resp
305 .headers()
306 .get("content-type")
307 .and_then(|v| v.to_str().ok())
308 .unwrap_or("application/octet-stream");
309 let content_type = super::ContentType::from(content_type);
310
311 if !status.is_client_error() && !status.is_server_error() {
312 let content = resp.text().await?;
313 match content_type {
314 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
315 ContentType::Text => {
316 return Err(Error::from(serde_json::Error::custom(
317 "Received `text/plain` content type response that cannot be converted to `models::GetDedicatedServerPresetAdditionalServices200Response`"
318 )));
319 }
320 ContentType::Unsupported(unknown_type) => {
321 return Err(Error::from(serde_json::Error::custom(format!(
322 "Received `{unknown_type}` content type response that cannot be converted to `models::GetDedicatedServerPresetAdditionalServices200Response`"
323 ))));
324 }
325 }
326 } else {
327 let content = resp.text().await?;
328 let entity: Option<GetDedicatedServerPresetAdditionalServicesError> =
329 serde_json::from_str(&content).ok();
330 Err(Error::ResponseError(ResponseContent {
331 status,
332 content,
333 entity
334 }))
335 }
336}
337
338pub async fn get_dedicated_servers(
342 configuration: &configuration::Configuration
343) -> Result<models::GetDedicatedServers200Response, Error<GetDedicatedServersError>> {
344 let uri_str = format!("{}/api/v1/dedicated-servers", configuration.base_path);
345 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
346
347 if let Some(ref user_agent) = configuration.user_agent {
348 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
349 }
350 if let Some(ref token) = configuration.bearer_access_token {
351 req_builder = req_builder.bearer_auth(token.to_owned());
352 };
353
354 let req = req_builder.build()?;
355 let resp = configuration.client.execute(req).await?;
356
357 let status = resp.status();
358 let content_type = resp
359 .headers()
360 .get("content-type")
361 .and_then(|v| v.to_str().ok())
362 .unwrap_or("application/octet-stream");
363 let content_type = super::ContentType::from(content_type);
364
365 if !status.is_client_error() && !status.is_server_error() {
366 let content = resp.text().await?;
367 match content_type {
368 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
369 ContentType::Text => {
370 return Err(Error::from(serde_json::Error::custom(
371 "Received `text/plain` content type response that cannot be converted to `models::GetDedicatedServers200Response`"
372 )));
373 }
374 ContentType::Unsupported(unknown_type) => {
375 return Err(Error::from(serde_json::Error::custom(format!(
376 "Received `{unknown_type}` content type response that cannot be converted to `models::GetDedicatedServers200Response`"
377 ))));
378 }
379 }
380 } else {
381 let content = resp.text().await?;
382 let entity: Option<GetDedicatedServersError> = serde_json::from_str(&content).ok();
383 Err(Error::ResponseError(ResponseContent {
384 status,
385 content,
386 entity
387 }))
388 }
389}
390
391pub async fn get_dedicated_servers_presets(
394 configuration: &configuration::Configuration,
395 location: Option<&str>
396) -> Result<models::GetDedicatedServersPresets200Response, Error<GetDedicatedServersPresetsError>>
397{
398 let p_query_location = location;
400
401 let uri_str = format!(
402 "{}/api/v1/presets/dedicated-servers",
403 configuration.base_path
404 );
405 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
406
407 if let Some(ref param_value) = p_query_location {
408 req_builder = req_builder.query(&[("location", ¶m_value.to_string())]);
409 }
410 if let Some(ref user_agent) = configuration.user_agent {
411 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
412 }
413 if let Some(ref token) = configuration.bearer_access_token {
414 req_builder = req_builder.bearer_auth(token.to_owned());
415 };
416
417 let req = req_builder.build()?;
418 let resp = configuration.client.execute(req).await?;
419
420 let status = resp.status();
421 let content_type = resp
422 .headers()
423 .get("content-type")
424 .and_then(|v| v.to_str().ok())
425 .unwrap_or("application/octet-stream");
426 let content_type = super::ContentType::from(content_type);
427
428 if !status.is_client_error() && !status.is_server_error() {
429 let content = resp.text().await?;
430 match content_type {
431 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
432 ContentType::Text => {
433 return Err(Error::from(serde_json::Error::custom(
434 "Received `text/plain` content type response that cannot be converted to `models::GetDedicatedServersPresets200Response`"
435 )));
436 }
437 ContentType::Unsupported(unknown_type) => {
438 return Err(Error::from(serde_json::Error::custom(format!(
439 "Received `{unknown_type}` content type response that cannot be converted to `models::GetDedicatedServersPresets200Response`"
440 ))));
441 }
442 }
443 } else {
444 let content = resp.text().await?;
445 let entity: Option<GetDedicatedServersPresetsError> = serde_json::from_str(&content).ok();
446 Err(Error::ResponseError(ResponseContent {
447 status,
448 content,
449 entity
450 }))
451 }
452}
453
454pub async fn update_dedicated_server(
457 configuration: &configuration::Configuration,
458 dedicated_id: i32,
459 update_dedicated_server_request: Option<models::UpdateDedicatedServerRequest>
460) -> Result<models::CreateDedicatedServer201Response, Error<UpdateDedicatedServerError>> {
461 let p_path_dedicated_id = dedicated_id;
463 let p_body_update_dedicated_server_request = update_dedicated_server_request;
464
465 let uri_str = format!(
466 "{}/api/v1/dedicated-servers/{dedicated_id}",
467 configuration.base_path,
468 dedicated_id = p_path_dedicated_id
469 );
470 let mut req_builder = configuration
471 .client
472 .request(reqwest::Method::PATCH, &uri_str);
473
474 if let Some(ref user_agent) = configuration.user_agent {
475 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
476 }
477 if let Some(ref token) = configuration.bearer_access_token {
478 req_builder = req_builder.bearer_auth(token.to_owned());
479 };
480 req_builder = req_builder.json(&p_body_update_dedicated_server_request);
481
482 let req = req_builder.build()?;
483 let resp = configuration.client.execute(req).await?;
484
485 let status = resp.status();
486 let content_type = resp
487 .headers()
488 .get("content-type")
489 .and_then(|v| v.to_str().ok())
490 .unwrap_or("application/octet-stream");
491 let content_type = super::ContentType::from(content_type);
492
493 if !status.is_client_error() && !status.is_server_error() {
494 let content = resp.text().await?;
495 match content_type {
496 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
497 ContentType::Text => {
498 return Err(Error::from(serde_json::Error::custom(
499 "Received `text/plain` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
500 )));
501 }
502 ContentType::Unsupported(unknown_type) => {
503 return Err(Error::from(serde_json::Error::custom(format!(
504 "Received `{unknown_type}` content type response that cannot be converted to `models::CreateDedicatedServer201Response`"
505 ))));
506 }
507 }
508 } else {
509 let content = resp.text().await?;
510 let entity: Option<UpdateDedicatedServerError> = serde_json::from_str(&content).ok();
511 Err(Error::ResponseError(ResponseContent {
512 status,
513 content,
514 entity
515 }))
516 }
517}