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 AddKeyToServerError {
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 CreateKeyError {
34 Status400(models::GetFinances400Response),
35 Status401(models::GetFinances401Response),
36 Status403(models::GetAccountStatus403Response),
37 Status409(models::CreateDatabaseBackup409Response),
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 DeleteKeyError {
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)]
58#[serde(untagged)]
59pub enum DeleteKeyFromServerError {
60 Status400(models::GetFinances400Response),
61 Status401(models::GetFinances401Response),
62 Status403(models::GetAccountStatus403Response),
63 Status404(models::GetImage404Response),
64 Status429(models::GetFinances429Response),
65 Status500(models::GetFinances500Response),
66 UnknownValue(serde_json::Value)
67}
68
69#[derive(Debug, Clone, Serialize, Deserialize)]
71#[serde(untagged)]
72pub enum GetKeyError {
73 Status400(models::GetFinances400Response),
74 Status401(models::GetFinances401Response),
75 Status403(models::GetAccountStatus403Response),
76 Status404(models::GetImage404Response),
77 Status429(models::GetFinances429Response),
78 Status500(models::GetFinances500Response),
79 UnknownValue(serde_json::Value)
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum GetKeysError {
86 Status400(models::GetFinances400Response),
87 Status401(models::GetFinances401Response),
88 Status403(models::GetAccountStatus403Response),
89 Status404(models::GetImage404Response),
90 Status429(models::GetFinances429Response),
91 Status500(models::GetFinances500Response),
92 UnknownValue(serde_json::Value)
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum UpdateKeyError {
99 Status400(models::GetFinances400Response),
100 Status401(models::GetFinances401Response),
101 Status403(models::GetAccountStatus403Response),
102 Status404(models::GetImage404Response),
103 Status429(models::GetFinances429Response),
104 Status500(models::GetFinances500Response),
105 UnknownValue(serde_json::Value)
106}
107
108pub async fn add_key_to_server(
111 configuration: &configuration::Configuration,
112 server_id: i32,
113 add_key_to_server_request: models::AddKeyToServerRequest
114) -> Result<(), Error<AddKeyToServerError>> {
115 let p_path_server_id = server_id;
117 let p_body_add_key_to_server_request = add_key_to_server_request;
118
119 let uri_str = format!(
120 "{}/api/v1/servers/{server_id}/ssh-keys",
121 configuration.base_path,
122 server_id = p_path_server_id
123 );
124 let mut req_builder = configuration
125 .client
126 .request(reqwest::Method::POST, &uri_str);
127
128 if let Some(ref user_agent) = configuration.user_agent {
129 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
130 }
131 if let Some(ref token) = configuration.bearer_access_token {
132 req_builder = req_builder.bearer_auth(token.to_owned());
133 };
134 req_builder = req_builder.json(&p_body_add_key_to_server_request);
135
136 let req = req_builder.build()?;
137 let resp = configuration.client.execute(req).await?;
138
139 let status = resp.status();
140
141 if !status.is_client_error() && !status.is_server_error() {
142 Ok(())
143 } else {
144 let content = resp.text().await?;
145 let entity: Option<AddKeyToServerError> = serde_json::from_str(&content).ok();
146 Err(Error::ResponseError(ResponseContent {
147 status,
148 content,
149 entity
150 }))
151 }
152}
153
154pub async fn create_key(
157 configuration: &configuration::Configuration,
158 create_key_request: models::CreateKeyRequest
159) -> Result<models::CreateKey201Response, Error<CreateKeyError>> {
160 let p_body_create_key_request = create_key_request;
162
163 let uri_str = format!("{}/api/v1/ssh-keys", configuration.base_path);
164 let mut req_builder = configuration
165 .client
166 .request(reqwest::Method::POST, &uri_str);
167
168 if let Some(ref user_agent) = configuration.user_agent {
169 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
170 }
171 if let Some(ref token) = configuration.bearer_access_token {
172 req_builder = req_builder.bearer_auth(token.to_owned());
173 };
174 req_builder = req_builder.json(&p_body_create_key_request);
175
176 let req = req_builder.build()?;
177 let resp = configuration.client.execute(req).await?;
178
179 let status = resp.status();
180 let content_type = resp
181 .headers()
182 .get("content-type")
183 .and_then(|v| v.to_str().ok())
184 .unwrap_or("application/octet-stream");
185 let content_type = super::ContentType::from(content_type);
186
187 if !status.is_client_error() && !status.is_server_error() {
188 let content = resp.text().await?;
189 match content_type {
190 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
191 ContentType::Text => {
192 return Err(Error::from(serde_json::Error::custom(
193 "Received `text/plain` content type response that cannot be converted to `models::CreateKey201Response`"
194 )));
195 }
196 ContentType::Unsupported(unknown_type) => {
197 return Err(Error::from(serde_json::Error::custom(format!(
198 "Received `{unknown_type}` content type response that cannot be converted to `models::CreateKey201Response`"
199 ))));
200 }
201 }
202 } else {
203 let content = resp.text().await?;
204 let entity: Option<CreateKeyError> = serde_json::from_str(&content).ok();
205 Err(Error::ResponseError(ResponseContent {
206 status,
207 content,
208 entity
209 }))
210 }
211}
212
213pub async fn delete_key(
216 configuration: &configuration::Configuration,
217 ssh_key_id: i32
218) -> Result<(), Error<DeleteKeyError>> {
219 let p_path_ssh_key_id = ssh_key_id;
221
222 let uri_str = format!(
223 "{}/api/v1/ssh-keys/{ssh_key_id}",
224 configuration.base_path,
225 ssh_key_id = p_path_ssh_key_id
226 );
227 let mut req_builder = configuration
228 .client
229 .request(reqwest::Method::DELETE, &uri_str);
230
231 if let Some(ref user_agent) = configuration.user_agent {
232 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
233 }
234 if let Some(ref token) = configuration.bearer_access_token {
235 req_builder = req_builder.bearer_auth(token.to_owned());
236 };
237
238 let req = req_builder.build()?;
239 let resp = configuration.client.execute(req).await?;
240
241 let status = resp.status();
242
243 if !status.is_client_error() && !status.is_server_error() {
244 Ok(())
245 } else {
246 let content = resp.text().await?;
247 let entity: Option<DeleteKeyError> = serde_json::from_str(&content).ok();
248 Err(Error::ResponseError(ResponseContent {
249 status,
250 content,
251 entity
252 }))
253 }
254}
255
256pub async fn delete_key_from_server(
259 configuration: &configuration::Configuration,
260 server_id: i32,
261 ssh_key_id: i32
262) -> Result<(), Error<DeleteKeyFromServerError>> {
263 let p_path_server_id = server_id;
265 let p_path_ssh_key_id = ssh_key_id;
266
267 let uri_str = format!(
268 "{}/api/v1/servers/{server_id}/ssh-keys/{ssh_key_id}",
269 configuration.base_path,
270 server_id = p_path_server_id,
271 ssh_key_id = p_path_ssh_key_id
272 );
273 let mut req_builder = configuration
274 .client
275 .request(reqwest::Method::DELETE, &uri_str);
276
277 if let Some(ref user_agent) = configuration.user_agent {
278 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
279 }
280 if let Some(ref token) = configuration.bearer_access_token {
281 req_builder = req_builder.bearer_auth(token.to_owned());
282 };
283
284 let req = req_builder.build()?;
285 let resp = configuration.client.execute(req).await?;
286
287 let status = resp.status();
288
289 if !status.is_client_error() && !status.is_server_error() {
290 Ok(())
291 } else {
292 let content = resp.text().await?;
293 let entity: Option<DeleteKeyFromServerError> = serde_json::from_str(&content).ok();
294 Err(Error::ResponseError(ResponseContent {
295 status,
296 content,
297 entity
298 }))
299 }
300}
301
302pub async fn get_key(
305 configuration: &configuration::Configuration,
306 ssh_key_id: i32
307) -> Result<models::GetKey200Response, Error<GetKeyError>> {
308 let p_path_ssh_key_id = ssh_key_id;
310
311 let uri_str = format!(
312 "{}/api/v1/ssh-keys/{ssh_key_id}",
313 configuration.base_path,
314 ssh_key_id = p_path_ssh_key_id
315 );
316 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
317
318 if let Some(ref user_agent) = configuration.user_agent {
319 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
320 }
321 if let Some(ref token) = configuration.bearer_access_token {
322 req_builder = req_builder.bearer_auth(token.to_owned());
323 };
324
325 let req = req_builder.build()?;
326 let resp = configuration.client.execute(req).await?;
327
328 let status = resp.status();
329 let content_type = resp
330 .headers()
331 .get("content-type")
332 .and_then(|v| v.to_str().ok())
333 .unwrap_or("application/octet-stream");
334 let content_type = super::ContentType::from(content_type);
335
336 if !status.is_client_error() && !status.is_server_error() {
337 let content = resp.text().await?;
338 match content_type {
339 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
340 ContentType::Text => {
341 return Err(Error::from(serde_json::Error::custom(
342 "Received `text/plain` content type response that cannot be converted to `models::GetKey200Response`"
343 )));
344 }
345 ContentType::Unsupported(unknown_type) => {
346 return Err(Error::from(serde_json::Error::custom(format!(
347 "Received `{unknown_type}` content type response that cannot be converted to `models::GetKey200Response`"
348 ))));
349 }
350 }
351 } else {
352 let content = resp.text().await?;
353 let entity: Option<GetKeyError> = serde_json::from_str(&content).ok();
354 Err(Error::ResponseError(ResponseContent {
355 status,
356 content,
357 entity
358 }))
359 }
360}
361
362pub async fn get_keys(
365 configuration: &configuration::Configuration
366) -> Result<models::GetKeys200Response, Error<GetKeysError>> {
367 let uri_str = format!("{}/api/v1/ssh-keys", configuration.base_path);
368 let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
369
370 if let Some(ref user_agent) = configuration.user_agent {
371 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
372 }
373 if let Some(ref token) = configuration.bearer_access_token {
374 req_builder = req_builder.bearer_auth(token.to_owned());
375 };
376
377 let req = req_builder.build()?;
378 let resp = configuration.client.execute(req).await?;
379
380 let status = resp.status();
381 let content_type = resp
382 .headers()
383 .get("content-type")
384 .and_then(|v| v.to_str().ok())
385 .unwrap_or("application/octet-stream");
386 let content_type = super::ContentType::from(content_type);
387
388 if !status.is_client_error() && !status.is_server_error() {
389 let content = resp.text().await?;
390 match content_type {
391 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
392 ContentType::Text => {
393 return Err(Error::from(serde_json::Error::custom(
394 "Received `text/plain` content type response that cannot be converted to `models::GetKeys200Response`"
395 )));
396 }
397 ContentType::Unsupported(unknown_type) => {
398 return Err(Error::from(serde_json::Error::custom(format!(
399 "Received `{unknown_type}` content type response that cannot be converted to `models::GetKeys200Response`"
400 ))));
401 }
402 }
403 } else {
404 let content = resp.text().await?;
405 let entity: Option<GetKeysError> = serde_json::from_str(&content).ok();
406 Err(Error::ResponseError(ResponseContent {
407 status,
408 content,
409 entity
410 }))
411 }
412}
413
414pub async fn update_key(
417 configuration: &configuration::Configuration,
418 ssh_key_id: i32,
419 update_key_request: models::UpdateKeyRequest
420) -> Result<models::GetKey200Response, Error<UpdateKeyError>> {
421 let p_path_ssh_key_id = ssh_key_id;
423 let p_body_update_key_request = update_key_request;
424
425 let uri_str = format!(
426 "{}/api/v1/ssh-keys/{ssh_key_id}",
427 configuration.base_path,
428 ssh_key_id = p_path_ssh_key_id
429 );
430 let mut req_builder = configuration
431 .client
432 .request(reqwest::Method::PATCH, &uri_str);
433
434 if let Some(ref user_agent) = configuration.user_agent {
435 req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
436 }
437 if let Some(ref token) = configuration.bearer_access_token {
438 req_builder = req_builder.bearer_auth(token.to_owned());
439 };
440 req_builder = req_builder.json(&p_body_update_key_request);
441
442 let req = req_builder.build()?;
443 let resp = configuration.client.execute(req).await?;
444
445 let status = resp.status();
446 let content_type = resp
447 .headers()
448 .get("content-type")
449 .and_then(|v| v.to_str().ok())
450 .unwrap_or("application/octet-stream");
451 let content_type = super::ContentType::from(content_type);
452
453 if !status.is_client_error() && !status.is_server_error() {
454 let content = resp.text().await?;
455 match content_type {
456 ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
457 ContentType::Text => {
458 return Err(Error::from(serde_json::Error::custom(
459 "Received `text/plain` content type response that cannot be converted to `models::GetKey200Response`"
460 )));
461 }
462 ContentType::Unsupported(unknown_type) => {
463 return Err(Error::from(serde_json::Error::custom(format!(
464 "Received `{unknown_type}` content type response that cannot be converted to `models::GetKey200Response`"
465 ))));
466 }
467 }
468 } else {
469 let content = resp.text().await?;
470 let entity: Option<UpdateKeyError> = serde_json::from_str(&content).ok();
471 Err(Error::ResponseError(ResponseContent {
472 status,
473 content,
474 entity
475 }))
476 }
477}