em_client/client/
mod.rs

1/* Copyright (c) Fortanix, Inc.
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#![allow(unused_extern_crates)]
7extern crate chrono;
8extern crate mime;
9extern crate url;
10extern crate uuid;
11
12use self::url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
13use futures;
14use futures::{future, stream};
15use futures::{Future, Stream};
16use hyper::client::{Request, Response};
17use hyper::header::{ContentType, Header, HeaderFormat, Headers};
18use hyper::method::Method;
19use hyper::Url;
20use mimetypes;
21use serde_json;
22use std::borrow::Cow;
23use std::error;
24use std::fmt;
25use std::io::{Error, ErrorKind, Read};
26use std::path::Path;
27use std::str;
28use std::str::FromStr;
29use std::string::ToString;
30use std::sync::Arc;
31use SHA256_BYTE_LENGTH;
32
33#[allow(unused_imports)]
34use std::collections::{BTreeMap, HashMap};
35
36use ApiError;
37use SimpleErrorType;
38
39use {
40    AccountsApi, AppApi, ApplicationConfigApi, ApprovalRequestsApi, AuthApi, BuildApi,
41    CertificateApi, DatasetApi, NodeApi, RegistryApi, SystemApi, TaskApi, ToolsApi, UsersApi,
42    WorkflowApi, WorkflowFinalApi, ZoneApi,
43};
44
45use mbedtls::hash;
46use models;
47
48define_encode_set! {
49    /// This encode set is used for object IDs
50    ///
51    /// Aside from the special characters defined in the `PATH_SEGMENT_ENCODE_SET`,
52    /// the vertical bar (|) is encoded.
53    pub ID_ENCODE_SET = [PATH_SEGMENT_ENCODE_SET] | {'|'}
54}
55
56/// Convert input into a base path, e.g. "http://example:123". Also checks the scheme as it goes.
57fn into_base_path(
58    input: &str,
59    correct_scheme: Option<&'static str>,
60) -> Result<String, ClientInitError> {
61    // First convert to Url, since a base path is a subset of Url.
62    let url = Url::from_str(input)?;
63
64    let scheme = url.scheme();
65
66    // Check the scheme if necessary
67    if let Some(correct_scheme) = correct_scheme {
68        if scheme != correct_scheme {
69            return Err(ClientInitError::InvalidScheme);
70        }
71    }
72
73    let host = url.host().ok_or_else(|| ClientInitError::MissingHost)?;
74    let port = url.port().map(|x| format!(":{}", x)).unwrap_or_default();
75    Ok(format!("{}://{}{}", scheme, host, port))
76}
77
78/// A client that implements the API by making HTTP calls out to a server.
79pub struct Client {
80    hyper_client: Arc<hyper::client::Client>,
81    base_path: String,
82    headers: Headers,
83    use_new_paths: bool,
84}
85
86impl fmt::Debug for Client {
87    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
88        write!(f, "Client {{ base_path: {} }}", self.base_path)
89    }
90}
91
92impl Clone for Client {
93    fn clone(&self) -> Self {
94        Client {
95            hyper_client: self.hyper_client.clone(),
96            base_path: self.base_path.clone(),
97            headers: self.headers.clone(),
98            use_new_paths: self.use_new_paths,
99        }
100    }
101}
102
103impl Client {
104    /// Create an HTTP client.
105    ///
106    /// # Arguments
107    /// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
108    pub fn try_new_http(base_path: &str) -> Result<Client, ClientInitError> {
109        Self::try_new_with_connector(base_path, Some("http"), hyper::net::HttpConnector)
110    }
111
112    /// Create a client with a custom implementation of hyper::net::NetworkConnector.
113    ///
114    /// Intended for use with custom implementations of connect for e.g. protocol logging
115    /// or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection,
116    /// this function should be used in conjunction with
117    /// `swagger::{http_connector, https_connector, https_mutual_connector}`.
118    ///
119    /// For ordinary tcp connections, prefer the use of `try_new_http`, `try_new_https`
120    /// and `try_new_https_mutual`, to avoid introducing a dependency on the underlying transport layer.
121    ///
122    /// # Arguments
123    ///
124    /// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
125    /// * `protocol` - Which protocol to use when constructing the request url, e.g. `Some("http")`
126    /// * `connector` - An instance of `C: hyper::net::NetworkConnection`
127    pub fn try_new_with_connector<C, S>(
128        base_path: &str,
129        protocol: Option<&'static str>,
130        connector: C,
131    ) -> Result<Client, ClientInitError>
132    where
133        C: hyper::net::NetworkConnector<Stream = S> + Send + Sync + 'static,
134        S: hyper::net::NetworkStream,
135    {
136        let hyper_client = hyper::Client::with_connector(connector);
137
138        Ok(Client {
139            hyper_client: Arc::new(hyper_client),
140            base_path: into_base_path(base_path, protocol)?,
141            headers: Headers::new(),
142            use_new_paths: false,
143        })
144    }
145
146    /// Constructor for creating a `Client` by passing in a pre-made `hyper` client.
147    ///
148    /// One should avoid relying on this function if possible, since it adds a dependency on the underlying transport
149    /// implementation, which it would be better to abstract away. Therefore, using this function may lead to a loss of
150    /// code generality, which may make it harder to move the application to a serverless environment, for example.
151    ///
152    /// The reason for this function's existence is to support legacy test code, which did mocking at the hyper layer.
153    /// This is not a recommended way to write new tests. If other reasons are found for using this function, they
154    /// should be mentioned here.
155    ///
156    /// This function is deprecated in the upstream openapi-generator which
157    /// uses newer hyper. However, the suggested replacement does not exist
158    /// in hyper 0.9.
159    pub fn try_new_with_hyper_client(
160        hyper_client: Arc<hyper::client::Client>,
161        base_path: &str,
162    ) -> Result<Client, ClientInitError> {
163        Ok(Client {
164            hyper_client: hyper_client,
165            base_path: into_base_path(base_path, None)?,
166            headers: Headers::new(),
167            use_new_paths: false,
168        })
169    }
170
171    pub fn headers(&mut self) -> &mut Headers {
172        &mut self.headers
173    }
174
175    pub fn uses_new_paths(&self) -> bool {
176        self.use_new_paths
177    }
178
179    pub fn set_use_new_paths(&mut self, use_new_paths: bool) {
180        self.use_new_paths = use_new_paths;
181    }
182
183    pub fn with_new_paths(self) -> Self {
184        Self {
185            use_new_paths: true,
186            ..self
187        }
188    }
189
190    fn remap_operation_path<'a>(&self, operation: &'a str) -> Cow<'a, str> {
191        if !self.use_new_paths {
192            return Cow::Borrowed(operation);
193        }
194        if let Some(path_without_v1) = operation.strip_prefix("/v1/") {
195            return Cow::Owned(format!(
196                "/api/v1/confidential_computing/{}",
197                path_without_v1
198            ));
199        }
200        return Cow::Borrowed(operation);
201    }
202}
203
204impl AccountsApi for Client {
205    type Error = ApiError;
206
207    fn create_account(
208        &self,
209        param_body: models::AccountRequest,
210    ) -> Result<models::Account, ApiError> {
211        let mut url = format!("{}/v1/accounts", self.base_path);
212
213        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
214
215        let query_string_str = query_string.finish();
216        if !query_string_str.is_empty() {
217            url += "?";
218            url += &query_string_str;
219        }
220
221        let url = match Url::from_str(&url) {
222            Ok(url) => url,
223            Err(err) => {
224                return Err(ApiError::new(
225                    format!("Unable to build URL: {}", err),
226                    SimpleErrorType::Permanent,
227                ))
228            }
229        };
230
231        let mut request = self.hyper_client.request(Method::Post, url);
232        request = request.headers(self.headers.clone());
233        // Body parameter
234        let body = serde_json::to_string(&param_body)
235            .expect("impossible to fail to serialize")
236            .into_bytes();
237        request = request.body(body.as_slice());
238
239        request = request.header(ContentType(mimetypes::requests::CREATE_ACCOUNT.clone()));
240
241        request
242            .send()
243            .map_err(|e| {
244                ApiError::new(
245                    format!("No response received: {}", e),
246                    SimpleErrorType::Permanent,
247                )
248            })
249            .and_then(|mut response| match response.status.to_u16() {
250                200 => {
251                    let mut body = Vec::new();
252                    response.read_to_end(&mut body).map_err(|e| {
253                        ApiError::new(
254                            format!("Failed to read response: {}", e),
255                            SimpleErrorType::Temporary,
256                        )
257                    })?;
258                    str::from_utf8(&body)
259                        .map_err(|e| {
260                            ApiError::new(
261                                format!("Response was not valid UTF8: {}", e),
262                                SimpleErrorType::Temporary,
263                            )
264                        })
265                        .and_then(|body| {
266                            serde_json::from_str::<models::Account>(body).map_err(|e| e.into())
267                        })
268                }
269                code => {
270                    let headers = response.headers.clone();
271                    let mut body = Vec::new();
272                    let result = response.read_to_end(&mut body);
273                    let err_type = match response.status.is_server_error() {
274                        false => SimpleErrorType::Permanent,
275                        true => SimpleErrorType::Temporary,
276                    };
277                    Err(ApiError::new(
278                        format!(
279                            "Unexpected response code {}:\n{:?}\n\n{}",
280                            code,
281                            headers,
282                            match result {
283                                Ok(_) => match str::from_utf8(&body) {
284                                    Ok(body) => Cow::from(body),
285                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
286                                },
287                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
288                            }
289                        ),
290                        err_type,
291                    ))
292                }
293            })
294    }
295
296    fn delete_account(&self, param_account_id: uuid::Uuid) -> Result<(), ApiError> {
297        let mut url = format!(
298            "{}/v1/accounts/{account_id}",
299            self.base_path,
300            account_id = utf8_percent_encode(&param_account_id.to_string(), ID_ENCODE_SET)
301        );
302
303        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
304
305        let query_string_str = query_string.finish();
306        if !query_string_str.is_empty() {
307            url += "?";
308            url += &query_string_str;
309        }
310
311        let url = match Url::from_str(&url) {
312            Ok(url) => url,
313            Err(err) => {
314                return Err(ApiError::new(
315                    format!("Unable to build URL: {}", err),
316                    SimpleErrorType::Permanent,
317                ))
318            }
319        };
320
321        let mut request = self.hyper_client.request(Method::Delete, url);
322        request = request.headers(self.headers.clone());
323
324        request
325            .send()
326            .map_err(|e| {
327                ApiError::new(
328                    format!("No response received: {}", e),
329                    SimpleErrorType::Permanent,
330                )
331            })
332            .and_then(|mut response| match response.status.to_u16() {
333                204 => {
334                    let mut body = Vec::new();
335                    response.read_to_end(&mut body).map_err(|e| {
336                        ApiError::new(
337                            format!("Failed to read response: {}", e),
338                            SimpleErrorType::Temporary,
339                        )
340                    })?;
341
342                    Ok(())
343                }
344                code => {
345                    let headers = response.headers.clone();
346                    let mut body = Vec::new();
347                    let result = response.read_to_end(&mut body);
348                    let err_type = match response.status.is_server_error() {
349                        false => SimpleErrorType::Permanent,
350                        true => SimpleErrorType::Temporary,
351                    };
352                    Err(ApiError::new(
353                        format!(
354                            "Unexpected response code {}:\n{:?}\n\n{}",
355                            code,
356                            headers,
357                            match result {
358                                Ok(_) => match str::from_utf8(&body) {
359                                    Ok(body) => Cow::from(body),
360                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
361                                },
362                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
363                            }
364                        ),
365                        err_type,
366                    ))
367                }
368            })
369    }
370
371    fn get_account(&self, param_account_id: uuid::Uuid) -> Result<models::Account, ApiError> {
372        let mut url = format!(
373            "{}/v1/accounts/{account_id}",
374            self.base_path,
375            account_id = utf8_percent_encode(&param_account_id.to_string(), ID_ENCODE_SET)
376        );
377
378        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
379
380        let query_string_str = query_string.finish();
381        if !query_string_str.is_empty() {
382            url += "?";
383            url += &query_string_str;
384        }
385
386        let url = match Url::from_str(&url) {
387            Ok(url) => url,
388            Err(err) => {
389                return Err(ApiError::new(
390                    format!("Unable to build URL: {}", err),
391                    SimpleErrorType::Permanent,
392                ))
393            }
394        };
395
396        let mut request = self.hyper_client.request(Method::Get, url);
397        request = request.headers(self.headers.clone());
398
399        request
400            .send()
401            .map_err(|e| {
402                ApiError::new(
403                    format!("No response received: {}", e),
404                    SimpleErrorType::Permanent,
405                )
406            })
407            .and_then(|mut response| match response.status.to_u16() {
408                200 => {
409                    let mut body = Vec::new();
410                    response.read_to_end(&mut body).map_err(|e| {
411                        ApiError::new(
412                            format!("Failed to read response: {}", e),
413                            SimpleErrorType::Temporary,
414                        )
415                    })?;
416                    str::from_utf8(&body)
417                        .map_err(|e| {
418                            ApiError::new(
419                                format!("Response was not valid UTF8: {}", e),
420                                SimpleErrorType::Temporary,
421                            )
422                        })
423                        .and_then(|body| {
424                            serde_json::from_str::<models::Account>(body).map_err(|e| e.into())
425                        })
426                }
427                code => {
428                    let headers = response.headers.clone();
429                    let mut body = Vec::new();
430                    let result = response.read_to_end(&mut body);
431                    let err_type = match response.status.is_server_error() {
432                        false => SimpleErrorType::Permanent,
433                        true => SimpleErrorType::Temporary,
434                    };
435                    Err(ApiError::new(
436                        format!(
437                            "Unexpected response code {}:\n{:?}\n\n{}",
438                            code,
439                            headers,
440                            match result {
441                                Ok(_) => match str::from_utf8(&body) {
442                                    Ok(body) => Cow::from(body),
443                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
444                                },
445                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
446                            }
447                        ),
448                        err_type,
449                    ))
450                }
451            })
452    }
453
454    fn get_accounts(&self) -> Result<models::AccountListResponse, ApiError> {
455        let mut url = format!("{}/v1/accounts", self.base_path);
456
457        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
458
459        let query_string_str = query_string.finish();
460        if !query_string_str.is_empty() {
461            url += "?";
462            url += &query_string_str;
463        }
464
465        let url = match Url::from_str(&url) {
466            Ok(url) => url,
467            Err(err) => {
468                return Err(ApiError::new(
469                    format!("Unable to build URL: {}", err),
470                    SimpleErrorType::Permanent,
471                ))
472            }
473        };
474
475        let mut request = self.hyper_client.request(Method::Get, url);
476        request = request.headers(self.headers.clone());
477
478        request
479            .send()
480            .map_err(|e| {
481                ApiError::new(
482                    format!("No response received: {}", e),
483                    SimpleErrorType::Permanent,
484                )
485            })
486            .and_then(|mut response| match response.status.to_u16() {
487                200 => {
488                    let mut body = Vec::new();
489                    response.read_to_end(&mut body).map_err(|e| {
490                        ApiError::new(
491                            format!("Failed to read response: {}", e),
492                            SimpleErrorType::Temporary,
493                        )
494                    })?;
495                    str::from_utf8(&body)
496                        .map_err(|e| {
497                            ApiError::new(
498                                format!("Response was not valid UTF8: {}", e),
499                                SimpleErrorType::Temporary,
500                            )
501                        })
502                        .and_then(|body| {
503                            serde_json::from_str::<models::AccountListResponse>(body)
504                                .map_err(|e| e.into())
505                        })
506                }
507                code => {
508                    let headers = response.headers.clone();
509                    let mut body = Vec::new();
510                    let result = response.read_to_end(&mut body);
511                    let err_type = match response.status.is_server_error() {
512                        false => SimpleErrorType::Permanent,
513                        true => SimpleErrorType::Temporary,
514                    };
515                    Err(ApiError::new(
516                        format!(
517                            "Unexpected response code {}:\n{:?}\n\n{}",
518                            code,
519                            headers,
520                            match result {
521                                Ok(_) => match str::from_utf8(&body) {
522                                    Ok(body) => Cow::from(body),
523                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
524                                },
525                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
526                            }
527                        ),
528                        err_type,
529                    ))
530                }
531            })
532    }
533
534    fn select_account(&self, param_account_id: uuid::Uuid) -> Result<(), ApiError> {
535        let mut url = format!(
536            "{}/v1/accounts/select_account/{account_id}",
537            self.base_path,
538            account_id = utf8_percent_encode(&param_account_id.to_string(), ID_ENCODE_SET)
539        );
540
541        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
542
543        let query_string_str = query_string.finish();
544        if !query_string_str.is_empty() {
545            url += "?";
546            url += &query_string_str;
547        }
548
549        let url = match Url::from_str(&url) {
550            Ok(url) => url,
551            Err(err) => {
552                return Err(ApiError::new(
553                    format!("Unable to build URL: {}", err),
554                    SimpleErrorType::Permanent,
555                ))
556            }
557        };
558
559        let mut request = self.hyper_client.request(Method::Post, url);
560        request = request.headers(self.headers.clone());
561
562        request
563            .send()
564            .map_err(|e| {
565                ApiError::new(
566                    format!("No response received: {}", e),
567                    SimpleErrorType::Permanent,
568                )
569            })
570            .and_then(|mut response| match response.status.to_u16() {
571                204 => {
572                    let mut body = Vec::new();
573                    response.read_to_end(&mut body).map_err(|e| {
574                        ApiError::new(
575                            format!("Failed to read response: {}", e),
576                            SimpleErrorType::Temporary,
577                        )
578                    })?;
579
580                    Ok(())
581                }
582                code => {
583                    let headers = response.headers.clone();
584                    let mut body = Vec::new();
585                    let result = response.read_to_end(&mut body);
586                    let err_type = match response.status.is_server_error() {
587                        false => SimpleErrorType::Permanent,
588                        true => SimpleErrorType::Temporary,
589                    };
590                    Err(ApiError::new(
591                        format!(
592                            "Unexpected response code {}:\n{:?}\n\n{}",
593                            code,
594                            headers,
595                            match result {
596                                Ok(_) => match str::from_utf8(&body) {
597                                    Ok(body) => Cow::from(body),
598                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
599                                },
600                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
601                            }
602                        ),
603                        err_type,
604                    ))
605                }
606            })
607    }
608
609    fn update_account(
610        &self,
611        param_account_id: uuid::Uuid,
612        param_body: models::AccountUpdateRequest,
613    ) -> Result<models::Account, ApiError> {
614        let mut url = format!(
615            "{}/v1/accounts/{account_id}",
616            self.base_path,
617            account_id = utf8_percent_encode(&param_account_id.to_string(), ID_ENCODE_SET)
618        );
619
620        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
621
622        let query_string_str = query_string.finish();
623        if !query_string_str.is_empty() {
624            url += "?";
625            url += &query_string_str;
626        }
627
628        let url = match Url::from_str(&url) {
629            Ok(url) => url,
630            Err(err) => {
631                return Err(ApiError::new(
632                    format!("Unable to build URL: {}", err),
633                    SimpleErrorType::Permanent,
634                ))
635            }
636        };
637
638        let mut request = self.hyper_client.request(Method::Patch, url);
639        request = request.headers(self.headers.clone());
640        let body = serde_json::to_string(&param_body)
641            .expect("impossible to fail to serialize")
642            .into_bytes();
643        request = request.body(body.as_slice());
644
645        request = request.header(ContentType(mimetypes::requests::UPDATE_ACCOUNT.clone()));
646
647        request
648            .send()
649            .map_err(|e| {
650                ApiError::new(
651                    format!("No response received: {}", e),
652                    SimpleErrorType::Permanent,
653                )
654            })
655            .and_then(|mut response| match response.status.to_u16() {
656                200 => {
657                    let mut body = Vec::new();
658                    response.read_to_end(&mut body).map_err(|e| {
659                        ApiError::new(
660                            format!("Failed to read response: {}", e),
661                            SimpleErrorType::Temporary,
662                        )
663                    })?;
664                    str::from_utf8(&body)
665                        .map_err(|e| {
666                            ApiError::new(
667                                format!("Response was not valid UTF8: {}", e),
668                                SimpleErrorType::Temporary,
669                            )
670                        })
671                        .and_then(|body| {
672                            serde_json::from_str::<models::Account>(body).map_err(|e| e.into())
673                        })
674                }
675                code => {
676                    let headers = response.headers.clone();
677                    let mut body = Vec::new();
678                    let result = response.read_to_end(&mut body);
679                    let err_type = match response.status.is_server_error() {
680                        false => SimpleErrorType::Permanent,
681                        true => SimpleErrorType::Temporary,
682                    };
683                    Err(ApiError::new(
684                        format!(
685                            "Unexpected response code {}:\n{:?}\n\n{}",
686                            code,
687                            headers,
688                            match result {
689                                Ok(_) => match str::from_utf8(&body) {
690                                    Ok(body) => Cow::from(body),
691                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
692                                },
693                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
694                            }
695                        ),
696                        err_type,
697                    ))
698                }
699            })
700    }
701}
702
703impl AppApi for Client {
704    type Error = ApiError;
705
706    fn add_application(&self, param_body: models::AppRequest) -> Result<models::App, ApiError> {
707        let mut url = format!("{}/v1/apps", self.base_path);
708
709        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
710
711        let query_string_str = query_string.finish();
712        if !query_string_str.is_empty() {
713            url += "?";
714            url += &query_string_str;
715        }
716
717        let url = match Url::from_str(&url) {
718            Ok(url) => url,
719            Err(err) => {
720                return Err(ApiError::new(
721                    format!("Unable to build URL: {}", err),
722                    SimpleErrorType::Permanent,
723                ))
724            }
725        };
726
727        let mut request = self.hyper_client.request(Method::Post, url);
728        request = request.headers(self.headers.clone());
729        // Body parameter
730        let body = serde_json::to_string(&param_body)
731            .expect("impossible to fail to serialize")
732            .into_bytes();
733        request = request.body(body.as_slice());
734
735        request = request.header(ContentType(mimetypes::requests::ADD_APPLICATION.clone()));
736
737        request
738            .send()
739            .map_err(|e| {
740                ApiError::new(
741                    format!("No response received: {}", e),
742                    SimpleErrorType::Permanent,
743                )
744            })
745            .and_then(|mut response| match response.status.to_u16() {
746                200 => {
747                    let mut body = Vec::new();
748                    response.read_to_end(&mut body).map_err(|e| {
749                        ApiError::new(
750                            format!("Failed to read response: {}", e),
751                            SimpleErrorType::Temporary,
752                        )
753                    })?;
754                    str::from_utf8(&body)
755                        .map_err(|e| {
756                            ApiError::new(
757                                format!("Response was not valid UTF8: {}", e),
758                                SimpleErrorType::Temporary,
759                            )
760                        })
761                        .and_then(|body| {
762                            serde_json::from_str::<models::App>(body).map_err(|e| e.into())
763                        })
764                }
765                code => {
766                    let headers = response.headers.clone();
767                    let mut body = Vec::new();
768                    let result = response.read_to_end(&mut body);
769                    let err_type = match response.status.is_server_error() {
770                        false => SimpleErrorType::Permanent,
771                        true => SimpleErrorType::Temporary,
772                    };
773                    Err(ApiError::new(
774                        format!(
775                            "Unexpected response code {}:\n{:?}\n\n{}",
776                            code,
777                            headers,
778                            match result {
779                                Ok(_) => match str::from_utf8(&body) {
780                                    Ok(body) => Cow::from(body),
781                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
782                                },
783                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
784                            }
785                        ),
786                        err_type,
787                    ))
788                }
789            })
790    }
791
792    fn delete_app(&self, param_app_id: uuid::Uuid) -> Result<(), ApiError> {
793        let mut url = format!(
794            "{}/v1/apps/{app_id}",
795            self.base_path,
796            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
797        );
798
799        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
800
801        let query_string_str = query_string.finish();
802        if !query_string_str.is_empty() {
803            url += "?";
804            url += &query_string_str;
805        }
806
807        let url = match Url::from_str(&url) {
808            Ok(url) => url,
809            Err(err) => {
810                return Err(ApiError::new(
811                    format!("Unable to build URL: {}", err),
812                    SimpleErrorType::Permanent,
813                ))
814            }
815        };
816
817        let mut request = self.hyper_client.request(Method::Delete, url);
818        request = request.headers(self.headers.clone());
819
820        request
821            .send()
822            .map_err(|e| {
823                ApiError::new(
824                    format!("No response received: {}", e),
825                    SimpleErrorType::Permanent,
826                )
827            })
828            .and_then(|mut response| match response.status.to_u16() {
829                204 => {
830                    let mut body = Vec::new();
831                    response.read_to_end(&mut body).map_err(|e| {
832                        ApiError::new(
833                            format!("Failed to read response: {}", e),
834                            SimpleErrorType::Temporary,
835                        )
836                    })?;
837
838                    Ok(())
839                }
840                code => {
841                    let headers = response.headers.clone();
842                    let mut body = Vec::new();
843                    let result = response.read_to_end(&mut body);
844                    let err_type = match response.status.is_server_error() {
845                        false => SimpleErrorType::Permanent,
846                        true => SimpleErrorType::Temporary,
847                    };
848                    Err(ApiError::new(
849                        format!(
850                            "Unexpected response code {}:\n{:?}\n\n{}",
851                            code,
852                            headers,
853                            match result {
854                                Ok(_) => match str::from_utf8(&body) {
855                                    Ok(body) => Cow::from(body),
856                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
857                                },
858                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
859                            }
860                        ),
861                        err_type,
862                    ))
863                }
864            })
865    }
866
867    fn get_all_apps(
868        &self,
869        param_name: Option<String>,
870        param_description: Option<String>,
871        param_all_search: Option<String>,
872        param_limit: Option<i32>,
873        param_offset: Option<i32>,
874        param_sort_by: Option<String>,
875    ) -> Result<models::GetAllAppsResponse, ApiError> {
876        let mut url = format!("{}/v1/apps", self.base_path);
877
878        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
879
880        if let Some(name) = param_name {
881            query_string.append_pair("name", &name.to_string());
882        }
883        if let Some(description) = param_description {
884            query_string.append_pair("description", &description.to_string());
885        }
886        if let Some(all_search) = param_all_search {
887            query_string.append_pair("all_search", &all_search.to_string());
888        }
889        if let Some(limit) = param_limit {
890            query_string.append_pair("limit", &limit.to_string());
891        }
892        if let Some(offset) = param_offset {
893            query_string.append_pair("offset", &offset.to_string());
894        }
895        if let Some(sort_by) = param_sort_by {
896            query_string.append_pair("sort_by", &sort_by.to_string());
897        }
898        let query_string_str = query_string.finish();
899        if !query_string_str.is_empty() {
900            url += "?";
901            url += &query_string_str;
902        }
903
904        let url = match Url::from_str(&url) {
905            Ok(url) => url,
906            Err(err) => {
907                return Err(ApiError::new(
908                    format!("Unable to build URL: {}", err),
909                    SimpleErrorType::Permanent,
910                ))
911            }
912        };
913
914        let mut request = self.hyper_client.request(Method::Get, url);
915        request = request.headers(self.headers.clone());
916
917        request
918            .send()
919            .map_err(|e| {
920                ApiError::new(
921                    format!("No response received: {}", e),
922                    SimpleErrorType::Permanent,
923                )
924            })
925            .and_then(|mut response| match response.status.to_u16() {
926                200 => {
927                    let mut body = Vec::new();
928                    response.read_to_end(&mut body).map_err(|e| {
929                        ApiError::new(
930                            format!("Failed to read response: {}", e),
931                            SimpleErrorType::Temporary,
932                        )
933                    })?;
934                    str::from_utf8(&body)
935                        .map_err(|e| {
936                            ApiError::new(
937                                format!("Response was not valid UTF8: {}", e),
938                                SimpleErrorType::Temporary,
939                            )
940                        })
941                        .and_then(|body| {
942                            serde_json::from_str::<models::GetAllAppsResponse>(body)
943                                .map_err(|e| e.into())
944                        })
945                }
946                code => {
947                    let headers = response.headers.clone();
948                    let mut body = Vec::new();
949                    let result = response.read_to_end(&mut body);
950                    let err_type = match response.status.is_server_error() {
951                        false => SimpleErrorType::Permanent,
952                        true => SimpleErrorType::Temporary,
953                    };
954                    Err(ApiError::new(
955                        format!(
956                            "Unexpected response code {}:\n{:?}\n\n{}",
957                            code,
958                            headers,
959                            match result {
960                                Ok(_) => match str::from_utf8(&body) {
961                                    Ok(body) => Cow::from(body),
962                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
963                                },
964                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
965                            }
966                        ),
967                        err_type,
968                    ))
969                }
970            })
971    }
972
973    fn get_app(&self, param_app_id: uuid::Uuid) -> Result<models::App, ApiError> {
974        let mut url = format!(
975            "{}/v1/apps/{app_id}",
976            self.base_path,
977            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
978        );
979
980        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
981
982        let query_string_str = query_string.finish();
983        if !query_string_str.is_empty() {
984            url += "?";
985            url += &query_string_str;
986        }
987
988        let url = match Url::from_str(&url) {
989            Ok(url) => url,
990            Err(err) => {
991                return Err(ApiError::new(
992                    format!("Unable to build URL: {}", err),
993                    SimpleErrorType::Permanent,
994                ))
995            }
996        };
997
998        let mut request = self.hyper_client.request(Method::Get, url);
999        request = request.headers(self.headers.clone());
1000
1001        request
1002            .send()
1003            .map_err(|e| {
1004                ApiError::new(
1005                    format!("No response received: {}", e),
1006                    SimpleErrorType::Permanent,
1007                )
1008            })
1009            .and_then(|mut response| match response.status.to_u16() {
1010                200 => {
1011                    let mut body = Vec::new();
1012                    response.read_to_end(&mut body).map_err(|e| {
1013                        ApiError::new(
1014                            format!("Failed to read response: {}", e),
1015                            SimpleErrorType::Temporary,
1016                        )
1017                    })?;
1018                    str::from_utf8(&body)
1019                        .map_err(|e| {
1020                            ApiError::new(
1021                                format!("Response was not valid UTF8: {}", e),
1022                                SimpleErrorType::Temporary,
1023                            )
1024                        })
1025                        .and_then(|body| {
1026                            serde_json::from_str::<models::App>(body).map_err(|e| e.into())
1027                        })
1028                }
1029                code => {
1030                    let headers = response.headers.clone();
1031                    let mut body = Vec::new();
1032                    let result = response.read_to_end(&mut body);
1033                    let err_type = match response.status.is_server_error() {
1034                        false => SimpleErrorType::Permanent,
1035                        true => SimpleErrorType::Temporary,
1036                    };
1037                    Err(ApiError::new(
1038                        format!(
1039                            "Unexpected response code {}:\n{:?}\n\n{}",
1040                            code,
1041                            headers,
1042                            match result {
1043                                Ok(_) => match str::from_utf8(&body) {
1044                                    Ok(body) => Cow::from(body),
1045                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1046                                },
1047                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1048                            }
1049                        ),
1050                        err_type,
1051                    ))
1052                }
1053            })
1054    }
1055
1056    fn get_app_certificate(
1057        &self,
1058        param_node_id: uuid::Uuid,
1059        param_app_id: uuid::Uuid,
1060    ) -> Result<models::Certificate, ApiError> {
1061        let mut url = format!(
1062            "{}/v1/apps/{app_id}/node/{node_id}/certificate",
1063            self.base_path,
1064            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET),
1065            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
1066        );
1067
1068        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1069
1070        let query_string_str = query_string.finish();
1071        if !query_string_str.is_empty() {
1072            url += "?";
1073            url += &query_string_str;
1074        }
1075
1076        let url = match Url::from_str(&url) {
1077            Ok(url) => url,
1078            Err(err) => {
1079                return Err(ApiError::new(
1080                    format!("Unable to build URL: {}", err),
1081                    SimpleErrorType::Permanent,
1082                ))
1083            }
1084        };
1085
1086        let mut request = self.hyper_client.request(Method::Get, url);
1087        request = request.headers(self.headers.clone());
1088
1089        request
1090            .send()
1091            .map_err(|e| {
1092                ApiError::new(
1093                    format!("No response received: {}", e),
1094                    SimpleErrorType::Permanent,
1095                )
1096            })
1097            .and_then(|mut response| match response.status.to_u16() {
1098                200 => {
1099                    let mut body = Vec::new();
1100                    response.read_to_end(&mut body).map_err(|e| {
1101                        ApiError::new(
1102                            format!("Failed to read response: {}", e),
1103                            SimpleErrorType::Temporary,
1104                        )
1105                    })?;
1106                    str::from_utf8(&body)
1107                        .map_err(|e| {
1108                            ApiError::new(
1109                                format!("Response was not valid UTF8: {}", e),
1110                                SimpleErrorType::Temporary,
1111                            )
1112                        })
1113                        .and_then(|body| {
1114                            serde_json::from_str::<models::Certificate>(body).map_err(|e| e.into())
1115                        })
1116                }
1117                code => {
1118                    let headers = response.headers.clone();
1119                    let mut body = Vec::new();
1120                    let result = response.read_to_end(&mut body);
1121                    let err_type = match response.status.is_server_error() {
1122                        false => SimpleErrorType::Permanent,
1123                        true => SimpleErrorType::Temporary,
1124                    };
1125                    Err(ApiError::new(
1126                        format!(
1127                            "Unexpected response code {}:\n{:?}\n\n{}",
1128                            code,
1129                            headers,
1130                            match result {
1131                                Ok(_) => match str::from_utf8(&body) {
1132                                    Ok(body) => Cow::from(body),
1133                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1134                                },
1135                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1136                            }
1137                        ),
1138                        err_type,
1139                    ))
1140                }
1141            })
1142    }
1143
1144    fn get_app_node_certificate_details(
1145        &self,
1146        param_node_id: uuid::Uuid,
1147        param_app_id: uuid::Uuid,
1148    ) -> Result<models::CertificateDetails, ApiError> {
1149        let mut url = format!(
1150            "{}/v1/apps/{app_id}/node/{node_id}/certificate-details",
1151            self.base_path,
1152            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET),
1153            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
1154        );
1155
1156        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1157
1158        let query_string_str = query_string.finish();
1159        if !query_string_str.is_empty() {
1160            url += "?";
1161            url += &query_string_str;
1162        }
1163
1164        let url = match Url::from_str(&url) {
1165            Ok(url) => url,
1166            Err(err) => {
1167                return Err(ApiError::new(
1168                    format!("Unable to build URL: {}", err),
1169                    SimpleErrorType::Permanent,
1170                ))
1171            }
1172        };
1173
1174        let mut request = self.hyper_client.request(Method::Get, url);
1175        request = request.headers(self.headers.clone());
1176
1177        request
1178            .send()
1179            .map_err(|e| {
1180                ApiError::new(
1181                    format!("No response received: {}", e),
1182                    SimpleErrorType::Permanent,
1183                )
1184            })
1185            .and_then(|mut response| match response.status.to_u16() {
1186                200 => {
1187                    let mut body = Vec::new();
1188                    response.read_to_end(&mut body).map_err(|e| {
1189                        ApiError::new(
1190                            format!("Failed to read response: {}", e),
1191                            SimpleErrorType::Temporary,
1192                        )
1193                    })?;
1194                    str::from_utf8(&body)
1195                        .map_err(|e| {
1196                            ApiError::new(
1197                                format!("Response was not valid UTF8: {}", e),
1198                                SimpleErrorType::Temporary,
1199                            )
1200                        })
1201                        .and_then(|body| {
1202                            serde_json::from_str::<models::CertificateDetails>(body)
1203                                .map_err(|e| e.into())
1204                        })
1205                }
1206                code => {
1207                    let headers = response.headers.clone();
1208                    let mut body = Vec::new();
1209                    let result = response.read_to_end(&mut body);
1210                    let err_type = match response.status.is_server_error() {
1211                        false => SimpleErrorType::Permanent,
1212                        true => SimpleErrorType::Temporary,
1213                    };
1214                    Err(ApiError::new(
1215                        format!(
1216                            "Unexpected response code {}:\n{:?}\n\n{}",
1217                            code,
1218                            headers,
1219                            match result {
1220                                Ok(_) => match str::from_utf8(&body) {
1221                                    Ok(body) => Cow::from(body),
1222                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1223                                },
1224                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1225                            }
1226                        ),
1227                        err_type,
1228                    ))
1229                }
1230            })
1231    }
1232
1233    fn get_apps_unique_labels(&self) -> Result<models::LabelsCount, ApiError> {
1234        let mut url = format!("{}/v1/apps/unique_labels/count", self.base_path);
1235
1236        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1237
1238        let query_string_str = query_string.finish();
1239        if !query_string_str.is_empty() {
1240            url += "?";
1241            url += &query_string_str;
1242        }
1243
1244        let url = match Url::from_str(&url) {
1245            Ok(url) => url,
1246            Err(err) => {
1247                return Err(ApiError::new(
1248                    format!("Unable to build URL: {}", err),
1249                    SimpleErrorType::Permanent,
1250                ))
1251            }
1252        };
1253
1254        let mut request = self.hyper_client.request(Method::Get, url);
1255        request = request.headers(self.headers.clone());
1256
1257        request
1258            .send()
1259            .map_err(|e| {
1260                ApiError::new(
1261                    format!("No response received: {}", e),
1262                    SimpleErrorType::Permanent,
1263                )
1264            })
1265            .and_then(|mut response| match response.status.to_u16() {
1266                200 => {
1267                    let mut body = Vec::new();
1268                    response.read_to_end(&mut body).map_err(|e| {
1269                        ApiError::new(
1270                            format!("Failed to read response: {}", e),
1271                            SimpleErrorType::Temporary,
1272                        )
1273                    })?;
1274                    str::from_utf8(&body)
1275                        .map_err(|e| {
1276                            ApiError::new(
1277                                format!("Response was not valid UTF8: {}", e),
1278                                SimpleErrorType::Temporary,
1279                            )
1280                        })
1281                        .and_then(|body| {
1282                            serde_json::from_str::<models::LabelsCount>(body).map_err(|e| e.into())
1283                        })
1284                }
1285                code => {
1286                    let headers = response.headers.clone();
1287                    let mut body = Vec::new();
1288                    let result = response.read_to_end(&mut body);
1289                    let err_type = match response.status.is_server_error() {
1290                        false => SimpleErrorType::Permanent,
1291                        true => SimpleErrorType::Temporary,
1292                    };
1293                    Err(ApiError::new(
1294                        format!(
1295                            "Unexpected response code {}:\n{:?}\n\n{}",
1296                            code,
1297                            headers,
1298                            match result {
1299                                Ok(_) => match str::from_utf8(&body) {
1300                                    Ok(body) => Cow::from(body),
1301                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1302                                },
1303                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1304                            }
1305                        ),
1306                        err_type,
1307                    ))
1308                }
1309            })
1310    }
1311
1312    fn update_app(
1313        &self,
1314        param_app_id: uuid::Uuid,
1315        param_body: models::AppBodyUpdateRequest,
1316    ) -> Result<models::App, ApiError> {
1317        let mut url = format!(
1318            "{}/v1/apps/{app_id}",
1319            self.base_path,
1320            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
1321        );
1322
1323        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1324
1325        let query_string_str = query_string.finish();
1326        if !query_string_str.is_empty() {
1327            url += "?";
1328            url += &query_string_str;
1329        }
1330
1331        let url = match Url::from_str(&url) {
1332            Ok(url) => url,
1333            Err(err) => {
1334                return Err(ApiError::new(
1335                    format!("Unable to build URL: {}", err),
1336                    SimpleErrorType::Permanent,
1337                ))
1338            }
1339        };
1340
1341        let mut request = self.hyper_client.request(Method::Patch, url);
1342        request = request.headers(self.headers.clone());
1343        let body = serde_json::to_string(&param_body)
1344            .expect("impossible to fail to serialize")
1345            .into_bytes();
1346        request = request.body(body.as_slice());
1347
1348        request = request.header(ContentType(mimetypes::requests::UPDATE_APP.clone()));
1349
1350        request
1351            .send()
1352            .map_err(|e| {
1353                ApiError::new(
1354                    format!("No response received: {}", e),
1355                    SimpleErrorType::Permanent,
1356                )
1357            })
1358            .and_then(|mut response| match response.status.to_u16() {
1359                200 => {
1360                    let mut body = Vec::new();
1361                    response.read_to_end(&mut body).map_err(|e| {
1362                        ApiError::new(
1363                            format!("Failed to read response: {}", e),
1364                            SimpleErrorType::Temporary,
1365                        )
1366                    })?;
1367                    str::from_utf8(&body)
1368                        .map_err(|e| {
1369                            ApiError::new(
1370                                format!("Response was not valid UTF8: {}", e),
1371                                SimpleErrorType::Temporary,
1372                            )
1373                        })
1374                        .and_then(|body| {
1375                            serde_json::from_str::<models::App>(body).map_err(|e| e.into())
1376                        })
1377                }
1378                code => {
1379                    let headers = response.headers.clone();
1380                    let mut body = Vec::new();
1381                    let result = response.read_to_end(&mut body);
1382                    let err_type = match response.status.is_server_error() {
1383                        false => SimpleErrorType::Permanent,
1384                        true => SimpleErrorType::Temporary,
1385                    };
1386                    Err(ApiError::new(
1387                        format!(
1388                            "Unexpected response code {}:\n{:?}\n\n{}",
1389                            code,
1390                            headers,
1391                            match result {
1392                                Ok(_) => match str::from_utf8(&body) {
1393                                    Ok(body) => Cow::from(body),
1394                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1395                                },
1396                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1397                            }
1398                        ),
1399                        err_type,
1400                    ))
1401                }
1402            })
1403    }
1404}
1405
1406impl ApplicationConfigApi for Client {
1407    type Error = ApiError;
1408
1409    fn create_application_config(
1410        &self,
1411        param_body: models::ApplicationConfig,
1412    ) -> Result<models::ApplicationConfigResponse, ApiError> {
1413        let mut url = format!("{}/v1/app_configs", self.base_path);
1414
1415        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1416
1417        let query_string_str = query_string.finish();
1418        if !query_string_str.is_empty() {
1419            url += "?";
1420            url += &query_string_str;
1421        }
1422
1423        let url = match Url::from_str(&url) {
1424            Ok(url) => url,
1425            Err(err) => {
1426                return Err(ApiError::new(
1427                    format!("Unable to build URL: {}", err),
1428                    SimpleErrorType::Permanent,
1429                ))
1430            }
1431        };
1432
1433        let mut request = self.hyper_client.request(Method::Post, url);
1434        request = request.headers(self.headers.clone());
1435        // Body parameter
1436        let body = serde_json::to_string(&param_body)
1437            .expect("impossible to fail to serialize")
1438            .into_bytes();
1439        request = request.body(body.as_slice());
1440
1441        request = request.header(ContentType(
1442            mimetypes::requests::CREATE_APPLICATION_CONFIG.clone(),
1443        ));
1444
1445        request
1446            .send()
1447            .map_err(|e| {
1448                ApiError::new(
1449                    format!("No response received: {}", e),
1450                    SimpleErrorType::Permanent,
1451                )
1452            })
1453            .and_then(|mut response| match response.status.to_u16() {
1454                200 => {
1455                    let mut body = Vec::new();
1456                    response.read_to_end(&mut body).map_err(|e| {
1457                        ApiError::new(
1458                            format!("Failed to read response: {}", e),
1459                            SimpleErrorType::Temporary,
1460                        )
1461                    })?;
1462                    str::from_utf8(&body)
1463                        .map_err(|e| {
1464                            ApiError::new(
1465                                format!("Response was not valid UTF8: {}", e),
1466                                SimpleErrorType::Temporary,
1467                            )
1468                        })
1469                        .and_then(|body| {
1470                            serde_json::from_str::<models::ApplicationConfigResponse>(body)
1471                                .map_err(|e| e.into())
1472                        })
1473                }
1474                code => {
1475                    let headers = response.headers.clone();
1476                    let mut body = Vec::new();
1477                    let result = response.read_to_end(&mut body);
1478                    let err_type = match response.status.is_server_error() {
1479                        false => SimpleErrorType::Permanent,
1480                        true => SimpleErrorType::Temporary,
1481                    };
1482                    Err(ApiError::new(
1483                        format!(
1484                            "Unexpected response code {}:\n{:?}\n\n{}",
1485                            code,
1486                            headers,
1487                            match result {
1488                                Ok(_) => match str::from_utf8(&body) {
1489                                    Ok(body) => Cow::from(body),
1490                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1491                                },
1492                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1493                            }
1494                        ),
1495                        err_type,
1496                    ))
1497                }
1498            })
1499    }
1500
1501    fn delete_application_config(&self, param_config_id: String) -> Result<(), ApiError> {
1502        let mut url = format!(
1503            "{}/v1/app_configs/{config_id}",
1504            self.base_path,
1505            config_id = utf8_percent_encode(&param_config_id.to_string(), ID_ENCODE_SET)
1506        );
1507
1508        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1509
1510        let query_string_str = query_string.finish();
1511        if !query_string_str.is_empty() {
1512            url += "?";
1513            url += &query_string_str;
1514        }
1515
1516        let url = match Url::from_str(&url) {
1517            Ok(url) => url,
1518            Err(err) => {
1519                return Err(ApiError::new(
1520                    format!("Unable to build URL: {}", err),
1521                    SimpleErrorType::Permanent,
1522                ))
1523            }
1524        };
1525
1526        let mut request = self.hyper_client.request(Method::Delete, url);
1527        request = request.headers(self.headers.clone());
1528
1529        request
1530            .send()
1531            .map_err(|e| {
1532                ApiError::new(
1533                    format!("No response received: {}", e),
1534                    SimpleErrorType::Permanent,
1535                )
1536            })
1537            .and_then(|mut response| match response.status.to_u16() {
1538                204 => {
1539                    let mut body = Vec::new();
1540                    response.read_to_end(&mut body).map_err(|e| {
1541                        ApiError::new(
1542                            format!("Failed to read response: {}", e),
1543                            SimpleErrorType::Temporary,
1544                        )
1545                    })?;
1546
1547                    Ok(())
1548                }
1549                code => {
1550                    let headers = response.headers.clone();
1551                    let mut body = Vec::new();
1552                    let result = response.read_to_end(&mut body);
1553                    let err_type = match response.status.is_server_error() {
1554                        false => SimpleErrorType::Permanent,
1555                        true => SimpleErrorType::Temporary,
1556                    };
1557                    Err(ApiError::new(
1558                        format!(
1559                            "Unexpected response code {}:\n{:?}\n\n{}",
1560                            code,
1561                            headers,
1562                            match result {
1563                                Ok(_) => match str::from_utf8(&body) {
1564                                    Ok(body) => Cow::from(body),
1565                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1566                                },
1567                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1568                            }
1569                        ),
1570                        err_type,
1571                    ))
1572                }
1573            })
1574    }
1575
1576    fn get_all_application_configs(
1577        &self,
1578        param_name: Option<String>,
1579        param_description: Option<String>,
1580        param_image_id: Option<uuid::Uuid>,
1581        param_limit: Option<i32>,
1582        param_offset: Option<i32>,
1583    ) -> Result<models::GetAllApplicationConfigsResponse, ApiError> {
1584        let mut url = format!("{}/v1/app_configs", self.base_path);
1585
1586        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1587
1588        if let Some(name) = param_name {
1589            query_string.append_pair("name", &name.to_string());
1590        }
1591        if let Some(description) = param_description {
1592            query_string.append_pair("description", &description.to_string());
1593        }
1594        if let Some(image_id) = param_image_id {
1595            query_string.append_pair("image_id", &image_id.to_string());
1596        }
1597        if let Some(limit) = param_limit {
1598            query_string.append_pair("limit", &limit.to_string());
1599        }
1600        if let Some(offset) = param_offset {
1601            query_string.append_pair("offset", &offset.to_string());
1602        }
1603        let query_string_str = query_string.finish();
1604        if !query_string_str.is_empty() {
1605            url += "?";
1606            url += &query_string_str;
1607        }
1608
1609        let url = match Url::from_str(&url) {
1610            Ok(url) => url,
1611            Err(err) => {
1612                return Err(ApiError::new(
1613                    format!("Unable to build URL: {}", err),
1614                    SimpleErrorType::Permanent,
1615                ))
1616            }
1617        };
1618
1619        let mut request = self.hyper_client.request(Method::Get, url);
1620        request = request.headers(self.headers.clone());
1621
1622        request
1623            .send()
1624            .map_err(|e| {
1625                ApiError::new(
1626                    format!("No response received: {}", e),
1627                    SimpleErrorType::Permanent,
1628                )
1629            })
1630            .and_then(|mut response| match response.status.to_u16() {
1631                200 => {
1632                    let mut body = Vec::new();
1633                    response.read_to_end(&mut body).map_err(|e| {
1634                        ApiError::new(
1635                            format!("Failed to read response: {}", e),
1636                            SimpleErrorType::Temporary,
1637                        )
1638                    })?;
1639                    str::from_utf8(&body)
1640                        .map_err(|e| {
1641                            ApiError::new(
1642                                format!("Response was not valid UTF8: {}", e),
1643                                SimpleErrorType::Temporary,
1644                            )
1645                        })
1646                        .and_then(|body| {
1647                            serde_json::from_str::<models::GetAllApplicationConfigsResponse>(body)
1648                                .map_err(|e| e.into())
1649                        })
1650                }
1651                code => {
1652                    let headers = response.headers.clone();
1653                    let mut body = Vec::new();
1654                    let result = response.read_to_end(&mut body);
1655                    let err_type = match response.status.is_server_error() {
1656                        false => SimpleErrorType::Permanent,
1657                        true => SimpleErrorType::Temporary,
1658                    };
1659                    Err(ApiError::new(
1660                        format!(
1661                            "Unexpected response code {}:\n{:?}\n\n{}",
1662                            code,
1663                            headers,
1664                            match result {
1665                                Ok(_) => match str::from_utf8(&body) {
1666                                    Ok(body) => Cow::from(body),
1667                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1668                                },
1669                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1670                            }
1671                        ),
1672                        err_type,
1673                    ))
1674                }
1675            })
1676    }
1677
1678    fn get_application_config(
1679        &self,
1680        param_config_id: String,
1681    ) -> Result<models::ApplicationConfigResponse, ApiError> {
1682        let mut url = format!(
1683            "{}/v1/app_configs/{config_id}",
1684            self.base_path,
1685            config_id = utf8_percent_encode(&param_config_id.to_string(), ID_ENCODE_SET)
1686        );
1687
1688        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1689
1690        let query_string_str = query_string.finish();
1691        if !query_string_str.is_empty() {
1692            url += "?";
1693            url += &query_string_str;
1694        }
1695
1696        let url = match Url::from_str(&url) {
1697            Ok(url) => url,
1698            Err(err) => {
1699                return Err(ApiError::new(
1700                    format!("Unable to build URL: {}", err),
1701                    SimpleErrorType::Permanent,
1702                ))
1703            }
1704        };
1705
1706        let mut request = self.hyper_client.request(Method::Get, url);
1707        request = request.headers(self.headers.clone());
1708
1709        request
1710            .send()
1711            .map_err(|e| {
1712                ApiError::new(
1713                    format!("No response received: {}", e),
1714                    SimpleErrorType::Permanent,
1715                )
1716            })
1717            .and_then(|mut response| match response.status.to_u16() {
1718                200 => {
1719                    let mut body = Vec::new();
1720                    response.read_to_end(&mut body).map_err(|e| {
1721                        ApiError::new(
1722                            format!("Failed to read response: {}", e),
1723                            SimpleErrorType::Temporary,
1724                        )
1725                    })?;
1726                    str::from_utf8(&body)
1727                        .map_err(|e| {
1728                            ApiError::new(
1729                                format!("Response was not valid UTF8: {}", e),
1730                                SimpleErrorType::Temporary,
1731                            )
1732                        })
1733                        .and_then(|body| {
1734                            serde_json::from_str::<models::ApplicationConfigResponse>(body)
1735                                .map_err(|e| e.into())
1736                        })
1737                }
1738                code => {
1739                    let headers = response.headers.clone();
1740                    let mut body = Vec::new();
1741                    let result = response.read_to_end(&mut body);
1742                    let err_type = match response.status.is_server_error() {
1743                        false => SimpleErrorType::Permanent,
1744                        true => SimpleErrorType::Temporary,
1745                    };
1746                    Err(ApiError::new(
1747                        format!(
1748                            "Unexpected response code {}:\n{:?}\n\n{}",
1749                            code,
1750                            headers,
1751                            match result {
1752                                Ok(_) => match str::from_utf8(&body) {
1753                                    Ok(body) => Cow::from(body),
1754                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1755                                },
1756                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1757                            }
1758                        ),
1759                        err_type,
1760                    ))
1761                }
1762            })
1763    }
1764
1765    fn get_runtime_application_config(
1766        &self,
1767        expected_hash: &[u8; 32],
1768    ) -> Result<models::RuntimeAppConfig, ApiError> {
1769        let mut operation_path = "/v1/runtime/app_configs";
1770        let mut url = format!(
1771            "{}{}",
1772            self.base_path,
1773            self.remap_operation_path(operation_path)
1774        );
1775
1776        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1777
1778        let query_string_str = query_string.finish();
1779        if !query_string_str.is_empty() {
1780            url += "?";
1781            url += &query_string_str;
1782        }
1783
1784        let url = match Url::from_str(&url) {
1785            Ok(url) => url,
1786            Err(err) => {
1787                return Err(ApiError::new(
1788                    format!("Unable to build URL: {}", err),
1789                    SimpleErrorType::Permanent,
1790                ))
1791            }
1792        };
1793
1794        let mut request = self.hyper_client.request(Method::Get, url);
1795        request = request.headers(self.headers.clone());
1796
1797        let raw_config = request
1798            .send()
1799            .map_err(|e| {
1800                ApiError::new(
1801                    format!("No response received: {}", e),
1802                    SimpleErrorType::Permanent,
1803                )
1804            })
1805            .and_then(|mut response| match response.status.to_u16() {
1806                200 => {
1807                    let mut body = Vec::new();
1808                    response.read_to_end(&mut body).map_err(|e| {
1809                        ApiError::new(
1810                            format!("Failed to read response: {}", e),
1811                            SimpleErrorType::Temporary,
1812                        )
1813                    })?;
1814                    String::from_utf8(body).map_err(|e| {
1815                        ApiError::new(
1816                            format!("Response was not valid UTF8: {}", e),
1817                            SimpleErrorType::Temporary,
1818                        )
1819                    })
1820                }
1821                code => {
1822                    let headers = response.headers.clone();
1823                    let mut body = Vec::new();
1824                    let result = response.read_to_end(&mut body);
1825                    let err_type = match response.status.is_server_error() {
1826                        false => SimpleErrorType::Permanent,
1827                        true => SimpleErrorType::Temporary,
1828                    };
1829                    Err(ApiError::new(
1830                        format!(
1831                            "Unexpected response code {}:\n{:?}\n\n{}",
1832                            code,
1833                            headers,
1834                            match result {
1835                                Ok(_) => match str::from_utf8(&body) {
1836                                    Ok(body) => Cow::from(body),
1837                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1838                                },
1839                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1840                            }
1841                        ),
1842                        err_type,
1843                    ))
1844                }
1845            })?;
1846
1847        deserialize_config_checked(&raw_config, expected_hash)
1848    }
1849
1850    fn get_specific_runtime_application_config(
1851        &self,
1852        param_config_id: String,
1853    ) -> Result<models::RuntimeAppConfig, ApiError> {
1854        let mut url = format!(
1855            "{}/v1/runtime/app_configs/{config_id}",
1856            self.base_path,
1857            config_id = utf8_percent_encode(&param_config_id.to_string(), ID_ENCODE_SET)
1858        );
1859
1860        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1861
1862        let query_string_str = query_string.finish();
1863        if !query_string_str.is_empty() {
1864            url += "?";
1865            url += &query_string_str;
1866        }
1867
1868        let url = match Url::from_str(&url) {
1869            Ok(url) => url,
1870            Err(err) => {
1871                return Err(ApiError::new(
1872                    format!("Unable to build URL: {}", err),
1873                    SimpleErrorType::Permanent,
1874                ))
1875            }
1876        };
1877
1878        let mut request = self.hyper_client.request(Method::Get, url);
1879        request = request.headers(self.headers.clone());
1880
1881        request
1882            .send()
1883            .map_err(|e| {
1884                ApiError::new(
1885                    format!("No response received: {}", e),
1886                    SimpleErrorType::Permanent,
1887                )
1888            })
1889            .and_then(|mut response| match response.status.to_u16() {
1890                200 => {
1891                    let mut body = Vec::new();
1892                    response.read_to_end(&mut body).map_err(|e| {
1893                        ApiError::new(
1894                            format!("Failed to read response: {}", e),
1895                            SimpleErrorType::Temporary,
1896                        )
1897                    })?;
1898                    str::from_utf8(&body)
1899                        .map_err(|e| {
1900                            ApiError::new(
1901                                format!("Response was not valid UTF8: {}", e),
1902                                SimpleErrorType::Temporary,
1903                            )
1904                        })
1905                        .and_then(|body| {
1906                            serde_json::from_str::<models::RuntimeAppConfig>(body)
1907                                .map_err(|e| e.into())
1908                        })
1909                }
1910                code => {
1911                    let headers = response.headers.clone();
1912                    let mut body = Vec::new();
1913                    let result = response.read_to_end(&mut body);
1914                    let err_type = match response.status.is_server_error() {
1915                        false => SimpleErrorType::Permanent,
1916                        true => SimpleErrorType::Temporary,
1917                    };
1918                    Err(ApiError::new(
1919                        format!(
1920                            "Unexpected response code {}:\n{:?}\n\n{}",
1921                            code,
1922                            headers,
1923                            match result {
1924                                Ok(_) => match str::from_utf8(&body) {
1925                                    Ok(body) => Cow::from(body),
1926                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
1927                                },
1928                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
1929                            }
1930                        ),
1931                        err_type,
1932                    ))
1933                }
1934            })
1935    }
1936
1937    fn update_application_config(
1938        &self,
1939        param_config_id: String,
1940        param_body: models::UpdateApplicationConfigRequest,
1941    ) -> Result<models::ApplicationConfigResponse, ApiError> {
1942        let mut url = format!(
1943            "{}/v1/app_configs/{config_id}",
1944            self.base_path,
1945            config_id = utf8_percent_encode(&param_config_id.to_string(), ID_ENCODE_SET)
1946        );
1947
1948        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
1949
1950        let query_string_str = query_string.finish();
1951        if !query_string_str.is_empty() {
1952            url += "?";
1953            url += &query_string_str;
1954        }
1955
1956        let url = match Url::from_str(&url) {
1957            Ok(url) => url,
1958            Err(err) => {
1959                return Err(ApiError::new(
1960                    format!("Unable to build URL: {}", err),
1961                    SimpleErrorType::Permanent,
1962                ))
1963            }
1964        };
1965
1966        let mut request = self.hyper_client.request(Method::Patch, url);
1967        request = request.headers(self.headers.clone());
1968        let body = serde_json::to_string(&param_body)
1969            .expect("impossible to fail to serialize")
1970            .into_bytes();
1971        request = request.body(body.as_slice());
1972
1973        request = request.header(ContentType(
1974            mimetypes::requests::UPDATE_APPLICATION_CONFIG.clone(),
1975        ));
1976
1977        request
1978            .send()
1979            .map_err(|e| {
1980                ApiError::new(
1981                    format!("No response received: {}", e),
1982                    SimpleErrorType::Permanent,
1983                )
1984            })
1985            .and_then(|mut response| match response.status.to_u16() {
1986                200 => {
1987                    let mut body = Vec::new();
1988                    response.read_to_end(&mut body).map_err(|e| {
1989                        ApiError::new(
1990                            format!("Failed to read response: {}", e),
1991                            SimpleErrorType::Temporary,
1992                        )
1993                    })?;
1994                    str::from_utf8(&body)
1995                        .map_err(|e| {
1996                            ApiError::new(
1997                                format!("Response was not valid UTF8: {}", e),
1998                                SimpleErrorType::Temporary,
1999                            )
2000                        })
2001                        .and_then(|body| {
2002                            serde_json::from_str::<models::ApplicationConfigResponse>(body)
2003                                .map_err(|e| e.into())
2004                        })
2005                }
2006                code => {
2007                    let headers = response.headers.clone();
2008                    let mut body = Vec::new();
2009                    let result = response.read_to_end(&mut body);
2010                    let err_type = match response.status.is_server_error() {
2011                        false => SimpleErrorType::Permanent,
2012                        true => SimpleErrorType::Temporary,
2013                    };
2014                    Err(ApiError::new(
2015                        format!(
2016                            "Unexpected response code {}:\n{:?}\n\n{}",
2017                            code,
2018                            headers,
2019                            match result {
2020                                Ok(_) => match str::from_utf8(&body) {
2021                                    Ok(body) => Cow::from(body),
2022                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2023                                },
2024                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2025                            }
2026                        ),
2027                        err_type,
2028                    ))
2029                }
2030            })
2031    }
2032}
2033
2034impl ApprovalRequestsApi for Client {
2035    type Error = ApiError;
2036
2037    fn approve_approval_request(
2038        &self,
2039        param_request_id: uuid::Uuid,
2040        param_body: Option<models::ApproveRequest>,
2041    ) -> Result<models::ApprovalRequest, ApiError> {
2042        let mut url = format!(
2043            "{}/v1/approval_requests/{request_id}/approve",
2044            self.base_path,
2045            request_id = utf8_percent_encode(&param_request_id.to_string(), ID_ENCODE_SET)
2046        );
2047
2048        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2049
2050        let query_string_str = query_string.finish();
2051        if !query_string_str.is_empty() {
2052            url += "?";
2053            url += &query_string_str;
2054        }
2055
2056        let url = match Url::from_str(&url) {
2057            Ok(url) => url,
2058            Err(err) => {
2059                return Err(ApiError::new(
2060                    format!("Unable to build URL: {}", err),
2061                    SimpleErrorType::Permanent,
2062                ))
2063            }
2064        };
2065
2066        let mut request = self.hyper_client.request(Method::Post, url);
2067        request = request.headers(self.headers.clone());
2068        // Body parameter
2069        let body = param_body.map(|ref body| {
2070            serde_json::to_string(body)
2071                .expect("impossible to fail to serialize")
2072                .into_bytes()
2073        });
2074
2075        if let Some(body) = body.as_ref() {
2076            request = request.body(body.as_slice());
2077        }
2078
2079        request = request.header(ContentType(
2080            mimetypes::requests::APPROVE_APPROVAL_REQUEST.clone(),
2081        ));
2082
2083        request
2084            .send()
2085            .map_err(|e| {
2086                ApiError::new(
2087                    format!("No response received: {}", e),
2088                    SimpleErrorType::Permanent,
2089                )
2090            })
2091            .and_then(|mut response| match response.status.to_u16() {
2092                200 => {
2093                    let mut body = Vec::new();
2094                    response.read_to_end(&mut body).map_err(|e| {
2095                        ApiError::new(
2096                            format!("Failed to read response: {}", e),
2097                            SimpleErrorType::Temporary,
2098                        )
2099                    })?;
2100                    str::from_utf8(&body)
2101                        .map_err(|e| {
2102                            ApiError::new(
2103                                format!("Response was not valid UTF8: {}", e),
2104                                SimpleErrorType::Temporary,
2105                            )
2106                        })
2107                        .and_then(|body| {
2108                            serde_json::from_str::<models::ApprovalRequest>(body)
2109                                .map_err(|e| e.into())
2110                        })
2111                }
2112                code => {
2113                    let headers = response.headers.clone();
2114                    let mut body = Vec::new();
2115                    let result = response.read_to_end(&mut body);
2116                    let err_type = match response.status.is_server_error() {
2117                        false => SimpleErrorType::Permanent,
2118                        true => SimpleErrorType::Temporary,
2119                    };
2120                    Err(ApiError::new(
2121                        format!(
2122                            "Unexpected response code {}:\n{:?}\n\n{}",
2123                            code,
2124                            headers,
2125                            match result {
2126                                Ok(_) => match str::from_utf8(&body) {
2127                                    Ok(body) => Cow::from(body),
2128                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2129                                },
2130                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2131                            }
2132                        ),
2133                        err_type,
2134                    ))
2135                }
2136            })
2137    }
2138
2139    fn create_approval_request(
2140        &self,
2141        param_body: models::ApprovalRequestRequest,
2142    ) -> Result<models::ApprovalRequest, ApiError> {
2143        let mut url = format!("{}/v1/approval_requests", self.base_path);
2144
2145        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2146
2147        let query_string_str = query_string.finish();
2148        if !query_string_str.is_empty() {
2149            url += "?";
2150            url += &query_string_str;
2151        }
2152
2153        let url = match Url::from_str(&url) {
2154            Ok(url) => url,
2155            Err(err) => {
2156                return Err(ApiError::new(
2157                    format!("Unable to build URL: {}", err),
2158                    SimpleErrorType::Permanent,
2159                ))
2160            }
2161        };
2162
2163        let mut request = self.hyper_client.request(Method::Post, url);
2164        request = request.headers(self.headers.clone());
2165        let body = serde_json::to_string(&param_body)
2166            .expect("impossible to fail to serialize")
2167            .into_bytes();
2168        request = request.body(body.as_slice());
2169
2170        request = request.header(ContentType(
2171            mimetypes::requests::CREATE_APPROVAL_REQUEST.clone(),
2172        ));
2173
2174        request
2175            .send()
2176            .map_err(|e| {
2177                ApiError::new(
2178                    format!("No response received: {}", e),
2179                    SimpleErrorType::Permanent,
2180                )
2181            })
2182            .and_then(|mut response| match response.status.to_u16() {
2183                201 => {
2184                    let mut body = Vec::new();
2185                    response.read_to_end(&mut body).map_err(|e| {
2186                        ApiError::new(
2187                            format!("Failed to read response: {}", e),
2188                            SimpleErrorType::Temporary,
2189                        )
2190                    })?;
2191                    str::from_utf8(&body)
2192                        .map_err(|e| {
2193                            ApiError::new(
2194                                format!("Response was not valid UTF8: {}", e),
2195                                SimpleErrorType::Temporary,
2196                            )
2197                        })
2198                        .and_then(|body| {
2199                            serde_json::from_str::<models::ApprovalRequest>(body)
2200                                .map_err(|e| e.into())
2201                        })
2202                }
2203                code => {
2204                    let headers = response.headers.clone();
2205                    let mut body = Vec::new();
2206                    let result = response.read_to_end(&mut body);
2207                    let err_type = match response.status.is_server_error() {
2208                        false => SimpleErrorType::Permanent,
2209                        true => SimpleErrorType::Temporary,
2210                    };
2211                    Err(ApiError::new(
2212                        format!(
2213                            "Unexpected response code {}:\n{:?}\n\n{}",
2214                            code,
2215                            headers,
2216                            match result {
2217                                Ok(_) => match str::from_utf8(&body) {
2218                                    Ok(body) => Cow::from(body),
2219                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2220                                },
2221                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2222                            }
2223                        ),
2224                        err_type,
2225                    ))
2226                }
2227            })
2228    }
2229
2230    fn delete_approval_request(&self, param_request_id: uuid::Uuid) -> Result<(), ApiError> {
2231        let mut url = format!(
2232            "{}/v1/approval_requests/{request_id}",
2233            self.base_path,
2234            request_id = utf8_percent_encode(&param_request_id.to_string(), ID_ENCODE_SET)
2235        );
2236
2237        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2238
2239        let query_string_str = query_string.finish();
2240        if !query_string_str.is_empty() {
2241            url += "?";
2242            url += &query_string_str;
2243        }
2244
2245        let url = match Url::from_str(&url) {
2246            Ok(url) => url,
2247            Err(err) => {
2248                return Err(ApiError::new(
2249                    format!("Unable to build URL: {}", err),
2250                    SimpleErrorType::Permanent,
2251                ))
2252            }
2253        };
2254
2255        let mut request = self.hyper_client.request(Method::Delete, url);
2256        request = request.headers(self.headers.clone());
2257
2258        request
2259            .send()
2260            .map_err(|e| {
2261                ApiError::new(
2262                    format!("No response received: {}", e),
2263                    SimpleErrorType::Permanent,
2264                )
2265            })
2266            .and_then(|mut response| match response.status.to_u16() {
2267                204 => {
2268                    let mut body = Vec::new();
2269                    response.read_to_end(&mut body).map_err(|e| {
2270                        ApiError::new(
2271                            format!("Failed to read response: {}", e),
2272                            SimpleErrorType::Temporary,
2273                        )
2274                    })?;
2275
2276                    Ok(())
2277                }
2278                code => {
2279                    let headers = response.headers.clone();
2280                    let mut body = Vec::new();
2281                    let result = response.read_to_end(&mut body);
2282                    let err_type = match response.status.is_server_error() {
2283                        false => SimpleErrorType::Permanent,
2284                        true => SimpleErrorType::Temporary,
2285                    };
2286                    Err(ApiError::new(
2287                        format!(
2288                            "Unexpected response code {}:\n{:?}\n\n{}",
2289                            code,
2290                            headers,
2291                            match result {
2292                                Ok(_) => match str::from_utf8(&body) {
2293                                    Ok(body) => Cow::from(body),
2294                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2295                                },
2296                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2297                            }
2298                        ),
2299                        err_type,
2300                    ))
2301                }
2302            })
2303    }
2304
2305    fn deny_approval_request(
2306        &self,
2307        param_request_id: uuid::Uuid,
2308        param_body: Option<models::DenyRequest>,
2309    ) -> Result<models::ApprovalRequest, ApiError> {
2310        let mut url = format!(
2311            "{}/v1/approval_requests/{request_id}/deny",
2312            self.base_path,
2313            request_id = utf8_percent_encode(&param_request_id.to_string(), ID_ENCODE_SET)
2314        );
2315
2316        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2317
2318        let query_string_str = query_string.finish();
2319        if !query_string_str.is_empty() {
2320            url += "?";
2321            url += &query_string_str;
2322        }
2323
2324        let url = match Url::from_str(&url) {
2325            Ok(url) => url,
2326            Err(err) => {
2327                return Err(ApiError::new(
2328                    format!("Unable to build URL: {}", err),
2329                    SimpleErrorType::Permanent,
2330                ))
2331            }
2332        };
2333
2334        let mut request = self.hyper_client.request(Method::Post, url);
2335        request = request.headers(self.headers.clone());
2336        let body = param_body.map(|ref body| {
2337            serde_json::to_string(body)
2338                .expect("impossible to fail to serialize")
2339                .into_bytes()
2340        });
2341
2342        if let Some(body) = body.as_ref() {
2343            request = request.body(body.as_slice());
2344        }
2345
2346        request = request.header(ContentType(
2347            mimetypes::requests::DENY_APPROVAL_REQUEST.clone(),
2348        ));
2349
2350        request
2351            .send()
2352            .map_err(|e| {
2353                ApiError::new(
2354                    format!("No response received: {}", e),
2355                    SimpleErrorType::Permanent,
2356                )
2357            })
2358            .and_then(|mut response| match response.status.to_u16() {
2359                200 => {
2360                    let mut body = Vec::new();
2361                    response.read_to_end(&mut body).map_err(|e| {
2362                        ApiError::new(
2363                            format!("Failed to read response: {}", e),
2364                            SimpleErrorType::Temporary,
2365                        )
2366                    })?;
2367                    str::from_utf8(&body)
2368                        .map_err(|e| {
2369                            ApiError::new(
2370                                format!("Response was not valid UTF8: {}", e),
2371                                SimpleErrorType::Temporary,
2372                            )
2373                        })
2374                        .and_then(|body| {
2375                            serde_json::from_str::<models::ApprovalRequest>(body)
2376                                .map_err(|e| e.into())
2377                        })
2378                }
2379                code => {
2380                    let headers = response.headers.clone();
2381                    let mut body = Vec::new();
2382                    let result = response.read_to_end(&mut body);
2383                    let err_type = match response.status.is_server_error() {
2384                        false => SimpleErrorType::Permanent,
2385                        true => SimpleErrorType::Temporary,
2386                    };
2387                    Err(ApiError::new(
2388                        format!(
2389                            "Unexpected response code {}:\n{:?}\n\n{}",
2390                            code,
2391                            headers,
2392                            match result {
2393                                Ok(_) => match str::from_utf8(&body) {
2394                                    Ok(body) => Cow::from(body),
2395                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2396                                },
2397                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2398                            }
2399                        ),
2400                        err_type,
2401                    ))
2402                }
2403            })
2404    }
2405
2406    fn get_all_approval_requests(
2407        &self,
2408        param_requester: Option<uuid::Uuid>,
2409        param_reviewer: Option<uuid::Uuid>,
2410        param_subject: Option<uuid::Uuid>,
2411        param_status: Option<String>,
2412        param_all_search: Option<String>,
2413        param_sort_by: Option<String>,
2414        param_limit: Option<i32>,
2415        param_offset: Option<i32>,
2416    ) -> Result<models::GetAllApprovalRequests, ApiError> {
2417        let mut url = format!("{}/v1/approval_requests", self.base_path);
2418
2419        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2420
2421        if let Some(requester) = param_requester {
2422            query_string.append_pair("requester", &requester.to_string());
2423        }
2424        if let Some(reviewer) = param_reviewer {
2425            query_string.append_pair("reviewer", &reviewer.to_string());
2426        }
2427        if let Some(subject) = param_subject {
2428            query_string.append_pair("subject", &subject.to_string());
2429        }
2430        if let Some(status) = param_status {
2431            query_string.append_pair("status", &status.to_string());
2432        }
2433        if let Some(all_search) = param_all_search {
2434            query_string.append_pair("all_search", &all_search.to_string());
2435        }
2436        if let Some(sort_by) = param_sort_by {
2437            query_string.append_pair("sort_by", &sort_by.to_string());
2438        }
2439        if let Some(limit) = param_limit {
2440            query_string.append_pair("limit", &limit.to_string());
2441        }
2442        if let Some(offset) = param_offset {
2443            query_string.append_pair("offset", &offset.to_string());
2444        }
2445        let query_string_str = query_string.finish();
2446        if !query_string_str.is_empty() {
2447            url += "?";
2448            url += &query_string_str;
2449        }
2450
2451        let url = match Url::from_str(&url) {
2452            Ok(url) => url,
2453            Err(err) => {
2454                return Err(ApiError::new(
2455                    format!("Unable to build URL: {}", err),
2456                    SimpleErrorType::Permanent,
2457                ))
2458            }
2459        };
2460
2461        let mut request = self.hyper_client.request(Method::Get, url);
2462        request = request.headers(self.headers.clone());
2463
2464        request
2465            .send()
2466            .map_err(|e| {
2467                ApiError::new(
2468                    format!("No response received: {}", e),
2469                    SimpleErrorType::Permanent,
2470                )
2471            })
2472            .and_then(|mut response| match response.status.to_u16() {
2473                200 => {
2474                    let mut body = Vec::new();
2475                    response.read_to_end(&mut body).map_err(|e| {
2476                        ApiError::new(
2477                            format!("Failed to read response: {}", e),
2478                            SimpleErrorType::Temporary,
2479                        )
2480                    })?;
2481                    str::from_utf8(&body)
2482                        .map_err(|e| {
2483                            ApiError::new(
2484                                format!("Response was not valid UTF8: {}", e),
2485                                SimpleErrorType::Temporary,
2486                            )
2487                        })
2488                        .and_then(|body| {
2489                            serde_json::from_str::<models::GetAllApprovalRequests>(body)
2490                                .map_err(|e| e.into())
2491                        })
2492                }
2493                code => {
2494                    let headers = response.headers.clone();
2495                    let mut body = Vec::new();
2496                    let result = response.read_to_end(&mut body);
2497                    let err_type = match response.status.is_server_error() {
2498                        false => SimpleErrorType::Permanent,
2499                        true => SimpleErrorType::Temporary,
2500                    };
2501                    Err(ApiError::new(
2502                        format!(
2503                            "Unexpected response code {}:\n{:?}\n\n{}",
2504                            code,
2505                            headers,
2506                            match result {
2507                                Ok(_) => match str::from_utf8(&body) {
2508                                    Ok(body) => Cow::from(body),
2509                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2510                                },
2511                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2512                            }
2513                        ),
2514                        err_type,
2515                    ))
2516                }
2517            })
2518    }
2519
2520    fn get_approval_request(
2521        &self,
2522        param_request_id: uuid::Uuid,
2523    ) -> Result<models::ApprovalRequest, ApiError> {
2524        let mut url = format!(
2525            "{}/v1/approval_requests/{request_id}",
2526            self.base_path,
2527            request_id = utf8_percent_encode(&param_request_id.to_string(), ID_ENCODE_SET)
2528        );
2529
2530        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2531
2532        let query_string_str = query_string.finish();
2533        if !query_string_str.is_empty() {
2534            url += "?";
2535            url += &query_string_str;
2536        }
2537
2538        let url = match Url::from_str(&url) {
2539            Ok(url) => url,
2540            Err(err) => {
2541                return Err(ApiError::new(
2542                    format!("Unable to build URL: {}", err),
2543                    SimpleErrorType::Permanent,
2544                ))
2545            }
2546        };
2547
2548        let mut request = self.hyper_client.request(Method::Get, url);
2549        request = request.headers(self.headers.clone());
2550
2551        request
2552            .send()
2553            .map_err(|e| {
2554                ApiError::new(
2555                    format!("No response received: {}", e),
2556                    SimpleErrorType::Permanent,
2557                )
2558            })
2559            .and_then(|mut response| match response.status.to_u16() {
2560                200 => {
2561                    let mut body = Vec::new();
2562                    response.read_to_end(&mut body).map_err(|e| {
2563                        ApiError::new(
2564                            format!("Failed to read response: {}", e),
2565                            SimpleErrorType::Temporary,
2566                        )
2567                    })?;
2568                    str::from_utf8(&body)
2569                        .map_err(|e| {
2570                            ApiError::new(
2571                                format!("Response was not valid UTF8: {}", e),
2572                                SimpleErrorType::Temporary,
2573                            )
2574                        })
2575                        .and_then(|body| {
2576                            serde_json::from_str::<models::ApprovalRequest>(body)
2577                                .map_err(|e| e.into())
2578                        })
2579                }
2580                code => {
2581                    let headers = response.headers.clone();
2582                    let mut body = Vec::new();
2583                    let result = response.read_to_end(&mut body);
2584                    let err_type = match response.status.is_server_error() {
2585                        false => SimpleErrorType::Permanent,
2586                        true => SimpleErrorType::Temporary,
2587                    };
2588                    Err(ApiError::new(
2589                        format!(
2590                            "Unexpected response code {}:\n{:?}\n\n{}",
2591                            code,
2592                            headers,
2593                            match result {
2594                                Ok(_) => match str::from_utf8(&body) {
2595                                    Ok(body) => Cow::from(body),
2596                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2597                                },
2598                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2599                            }
2600                        ),
2601                        err_type,
2602                    ))
2603                }
2604            })
2605    }
2606
2607    fn get_approval_request_result(
2608        &self,
2609        param_request_id: uuid::Uuid,
2610    ) -> Result<models::ApprovableResult, ApiError> {
2611        let mut url = format!(
2612            "{}/v1/approval_requests/{request_id}/result",
2613            self.base_path,
2614            request_id = utf8_percent_encode(&param_request_id.to_string(), ID_ENCODE_SET)
2615        );
2616
2617        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2618
2619        let query_string_str = query_string.finish();
2620        if !query_string_str.is_empty() {
2621            url += "?";
2622            url += &query_string_str;
2623        }
2624
2625        let url = match Url::from_str(&url) {
2626            Ok(url) => url,
2627            Err(err) => {
2628                return Err(ApiError::new(
2629                    format!("Unable to build URL: {}", err),
2630                    SimpleErrorType::Permanent,
2631                ))
2632            }
2633        };
2634
2635        let mut request = self.hyper_client.request(Method::Post, url);
2636        request = request.headers(self.headers.clone());
2637
2638        request
2639            .send()
2640            .map_err(|e| {
2641                ApiError::new(
2642                    format!("No response received: {}", e),
2643                    SimpleErrorType::Permanent,
2644                )
2645            })
2646            .and_then(|mut response| match response.status.to_u16() {
2647                200 => {
2648                    let mut body = Vec::new();
2649                    response.read_to_end(&mut body).map_err(|e| {
2650                        ApiError::new(
2651                            format!("Failed to read response: {}", e),
2652                            SimpleErrorType::Temporary,
2653                        )
2654                    })?;
2655                    str::from_utf8(&body)
2656                        .map_err(|e| {
2657                            ApiError::new(
2658                                format!("Response was not valid UTF8: {}", e),
2659                                SimpleErrorType::Temporary,
2660                            )
2661                        })
2662                        .and_then(|body| {
2663                            serde_json::from_str::<models::ApprovableResult>(body)
2664                                .map_err(|e| e.into())
2665                        })
2666                }
2667                code => {
2668                    let headers = response.headers.clone();
2669                    let mut body = Vec::new();
2670                    let result = response.read_to_end(&mut body);
2671                    let err_type = match response.status.is_server_error() {
2672                        false => SimpleErrorType::Permanent,
2673                        true => SimpleErrorType::Temporary,
2674                    };
2675                    Err(ApiError::new(
2676                        format!(
2677                            "Unexpected response code {}:\n{:?}\n\n{}",
2678                            code,
2679                            headers,
2680                            match result {
2681                                Ok(_) => match str::from_utf8(&body) {
2682                                    Ok(body) => Cow::from(body),
2683                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2684                                },
2685                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2686                            }
2687                        ),
2688                        err_type,
2689                    ))
2690                }
2691            })
2692    }
2693}
2694
2695impl AuthApi for Client {
2696    type Error = ApiError;
2697
2698    fn authenticate_user(
2699        &self,
2700        param_body: Option<models::AuthRequest>,
2701    ) -> Result<models::AuthResponse, ApiError> {
2702        let mut url = format!("{}/v1/sys/auth", self.base_path);
2703
2704        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2705
2706        let query_string_str = query_string.finish();
2707        if !query_string_str.is_empty() {
2708            url += "?";
2709            url += &query_string_str;
2710        }
2711
2712        let url = match Url::from_str(&url) {
2713            Ok(url) => url,
2714            Err(err) => {
2715                return Err(ApiError::new(
2716                    format!("Unable to build URL: {}", err),
2717                    SimpleErrorType::Permanent,
2718                ))
2719            }
2720        };
2721
2722        let mut request = self.hyper_client.request(Method::Post, url);
2723        request = request.headers(self.headers.clone());
2724        // Body parameter
2725        let body = param_body.map(|ref body| {
2726            serde_json::to_string(body)
2727                .expect("impossible to fail to serialize")
2728                .into_bytes()
2729        });
2730
2731        if let Some(body) = body.as_ref() {
2732            request = request.body(body.as_slice());
2733        }
2734
2735        request = request.header(ContentType(mimetypes::requests::AUTHENTICATE_USER.clone()));
2736
2737        request
2738            .send()
2739            .map_err(|e| {
2740                ApiError::new(
2741                    format!("No response received: {}", e),
2742                    SimpleErrorType::Permanent,
2743                )
2744            })
2745            .and_then(|mut response| match response.status.to_u16() {
2746                200 => {
2747                    let mut body = Vec::new();
2748                    response.read_to_end(&mut body).map_err(|e| {
2749                        ApiError::new(
2750                            format!("Failed to read response: {}", e),
2751                            SimpleErrorType::Temporary,
2752                        )
2753                    })?;
2754                    str::from_utf8(&body)
2755                        .map_err(|e| {
2756                            ApiError::new(
2757                                format!("Response was not valid UTF8: {}", e),
2758                                SimpleErrorType::Temporary,
2759                            )
2760                        })
2761                        .and_then(|body| {
2762                            serde_json::from_str::<models::AuthResponse>(body).map_err(|e| e.into())
2763                        })
2764                }
2765                code => {
2766                    let headers = response.headers.clone();
2767                    let mut body = Vec::new();
2768                    let result = response.read_to_end(&mut body);
2769                    let err_type = match response.status.is_server_error() {
2770                        false => SimpleErrorType::Permanent,
2771                        true => SimpleErrorType::Temporary,
2772                    };
2773                    Err(ApiError::new(
2774                        format!(
2775                            "Unexpected response code {}:\n{:?}\n\n{}",
2776                            code,
2777                            headers,
2778                            match result {
2779                                Ok(_) => match str::from_utf8(&body) {
2780                                    Ok(body) => Cow::from(body),
2781                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2782                                },
2783                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2784                            }
2785                        ),
2786                        err_type,
2787                    ))
2788                }
2789            })
2790    }
2791}
2792
2793impl BuildApi for Client {
2794    type Error = ApiError;
2795
2796    fn convert_app_build(
2797        &self,
2798        param_body: models::ConvertAppBuildRequest,
2799    ) -> Result<models::Build, ApiError> {
2800        let mut url = format!("{}/v1/builds/convert-app", self.base_path);
2801
2802        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2803
2804        let query_string_str = query_string.finish();
2805        if !query_string_str.is_empty() {
2806            url += "?";
2807            url += &query_string_str;
2808        }
2809
2810        let url = match Url::from_str(&url) {
2811            Ok(url) => url,
2812            Err(err) => {
2813                return Err(ApiError::new(
2814                    format!("Unable to build URL: {}", err),
2815                    SimpleErrorType::Permanent,
2816                ))
2817            }
2818        };
2819
2820        let mut request = self.hyper_client.request(Method::Post, url);
2821        request = request.headers(self.headers.clone());
2822        // Body parameter
2823        let body = serde_json::to_string(&param_body)
2824            .expect("impossible to fail to serialize")
2825            .into_bytes();
2826        request = request.body(body.as_slice());
2827
2828        request = request.header(ContentType(mimetypes::requests::CONVERT_APP_BUILD.clone()));
2829
2830        request
2831            .send()
2832            .map_err(|e| {
2833                ApiError::new(
2834                    format!("No response received: {}", e),
2835                    SimpleErrorType::Permanent,
2836                )
2837            })
2838            .and_then(|mut response| match response.status.to_u16() {
2839                200 => {
2840                    let mut body = Vec::new();
2841                    response.read_to_end(&mut body).map_err(|e| {
2842                        ApiError::new(
2843                            format!("Failed to read response: {}", e),
2844                            SimpleErrorType::Temporary,
2845                        )
2846                    })?;
2847                    str::from_utf8(&body)
2848                        .map_err(|e| {
2849                            ApiError::new(
2850                                format!("Response was not valid UTF8: {}", e),
2851                                SimpleErrorType::Temporary,
2852                            )
2853                        })
2854                        .and_then(|body| {
2855                            serde_json::from_str::<models::Build>(body).map_err(|e| e.into())
2856                        })
2857                }
2858                code => {
2859                    let headers = response.headers.clone();
2860                    let mut body = Vec::new();
2861                    let result = response.read_to_end(&mut body);
2862                    let err_type = match response.status.is_server_error() {
2863                        false => SimpleErrorType::Permanent,
2864                        true => SimpleErrorType::Temporary,
2865                    };
2866                    Err(ApiError::new(
2867                        format!(
2868                            "Unexpected response code {}:\n{:?}\n\n{}",
2869                            code,
2870                            headers,
2871                            match result {
2872                                Ok(_) => match str::from_utf8(&body) {
2873                                    Ok(body) => Cow::from(body),
2874                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2875                                },
2876                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2877                            }
2878                        ),
2879                        err_type,
2880                    ))
2881                }
2882            })
2883    }
2884
2885    fn create_build(
2886        &self,
2887        param_body: models::CreateBuildRequest,
2888    ) -> Result<models::Build, ApiError> {
2889        let mut url = format!("{}/v1/builds", self.base_path);
2890
2891        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2892
2893        let query_string_str = query_string.finish();
2894        if !query_string_str.is_empty() {
2895            url += "?";
2896            url += &query_string_str;
2897        }
2898
2899        let url = match Url::from_str(&url) {
2900            Ok(url) => url,
2901            Err(err) => {
2902                return Err(ApiError::new(
2903                    format!("Unable to build URL: {}", err),
2904                    SimpleErrorType::Permanent,
2905                ))
2906            }
2907        };
2908
2909        let mut request = self.hyper_client.request(Method::Post, url);
2910        request = request.headers(self.headers.clone());
2911        let body = serde_json::to_string(&param_body)
2912            .expect("impossible to fail to serialize")
2913            .into_bytes();
2914        request = request.body(body.as_slice());
2915
2916        request = request.header(ContentType(mimetypes::requests::CREATE_BUILD.clone()));
2917
2918        request
2919            .send()
2920            .map_err(|e| {
2921                ApiError::new(
2922                    format!("No response received: {}", e),
2923                    SimpleErrorType::Permanent,
2924                )
2925            })
2926            .and_then(|mut response| match response.status.to_u16() {
2927                200 => {
2928                    let mut body = Vec::new();
2929                    response.read_to_end(&mut body).map_err(|e| {
2930                        ApiError::new(
2931                            format!("Failed to read response: {}", e),
2932                            SimpleErrorType::Temporary,
2933                        )
2934                    })?;
2935                    str::from_utf8(&body)
2936                        .map_err(|e| {
2937                            ApiError::new(
2938                                format!("Response was not valid UTF8: {}", e),
2939                                SimpleErrorType::Temporary,
2940                            )
2941                        })
2942                        .and_then(|body| {
2943                            serde_json::from_str::<models::Build>(body).map_err(|e| e.into())
2944                        })
2945                }
2946                code => {
2947                    let headers = response.headers.clone();
2948                    let mut body = Vec::new();
2949                    let result = response.read_to_end(&mut body);
2950                    let err_type = match response.status.is_server_error() {
2951                        false => SimpleErrorType::Permanent,
2952                        true => SimpleErrorType::Temporary,
2953                    };
2954                    Err(ApiError::new(
2955                        format!(
2956                            "Unexpected response code {}:\n{:?}\n\n{}",
2957                            code,
2958                            headers,
2959                            match result {
2960                                Ok(_) => match str::from_utf8(&body) {
2961                                    Ok(body) => Cow::from(body),
2962                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
2963                                },
2964                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
2965                            }
2966                        ),
2967                        err_type,
2968                    ))
2969                }
2970            })
2971    }
2972
2973    fn delete_build(&self, param_build_id: uuid::Uuid) -> Result<(), ApiError> {
2974        let mut url = format!(
2975            "{}/v1/builds/{build_id}",
2976            self.base_path,
2977            build_id = utf8_percent_encode(&param_build_id.to_string(), ID_ENCODE_SET)
2978        );
2979
2980        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
2981
2982        let query_string_str = query_string.finish();
2983        if !query_string_str.is_empty() {
2984            url += "?";
2985            url += &query_string_str;
2986        }
2987
2988        let url = match Url::from_str(&url) {
2989            Ok(url) => url,
2990            Err(err) => {
2991                return Err(ApiError::new(
2992                    format!("Unable to build URL: {}", err),
2993                    SimpleErrorType::Permanent,
2994                ))
2995            }
2996        };
2997
2998        let mut request = self.hyper_client.request(Method::Delete, url);
2999        request = request.headers(self.headers.clone());
3000
3001        request
3002            .send()
3003            .map_err(|e| {
3004                ApiError::new(
3005                    format!("No response received: {}", e),
3006                    SimpleErrorType::Permanent,
3007                )
3008            })
3009            .and_then(|mut response| match response.status.to_u16() {
3010                204 => {
3011                    let mut body = Vec::new();
3012                    response.read_to_end(&mut body).map_err(|e| {
3013                        ApiError::new(
3014                            format!("Failed to read response: {}", e),
3015                            SimpleErrorType::Temporary,
3016                        )
3017                    })?;
3018
3019                    Ok(())
3020                }
3021                code => {
3022                    let headers = response.headers.clone();
3023                    let mut body = Vec::new();
3024                    let result = response.read_to_end(&mut body);
3025                    let err_type = match response.status.is_server_error() {
3026                        false => SimpleErrorType::Permanent,
3027                        true => SimpleErrorType::Temporary,
3028                    };
3029                    Err(ApiError::new(
3030                        format!(
3031                            "Unexpected response code {}:\n{:?}\n\n{}",
3032                            code,
3033                            headers,
3034                            match result {
3035                                Ok(_) => match str::from_utf8(&body) {
3036                                    Ok(body) => Cow::from(body),
3037                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3038                                },
3039                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3040                            }
3041                        ),
3042                        err_type,
3043                    ))
3044                }
3045            })
3046    }
3047
3048    fn get_all_builds(
3049        &self,
3050        param_all_search: Option<String>,
3051        param_docker_image_name: Option<String>,
3052        param_config_id: Option<String>,
3053        param_deployed_status: Option<String>,
3054        param_status: Option<String>,
3055        param_limit: Option<i32>,
3056        param_offset: Option<i32>,
3057        param_sort_by: Option<String>,
3058    ) -> Result<models::GetAllBuildsResponse, ApiError> {
3059        let mut url = format!("{}/v1/builds", self.base_path);
3060
3061        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3062
3063        if let Some(all_search) = param_all_search {
3064            query_string.append_pair("all_search", &all_search.to_string());
3065        }
3066        if let Some(docker_image_name) = param_docker_image_name {
3067            query_string.append_pair("docker_image_name", &docker_image_name.to_string());
3068        }
3069        if let Some(config_id) = param_config_id {
3070            query_string.append_pair("config_id", &config_id.to_string());
3071        }
3072        if let Some(deployed_status) = param_deployed_status {
3073            query_string.append_pair("deployed_status", &deployed_status.to_string());
3074        }
3075        if let Some(status) = param_status {
3076            query_string.append_pair("status", &status.to_string());
3077        }
3078        if let Some(limit) = param_limit {
3079            query_string.append_pair("limit", &limit.to_string());
3080        }
3081        if let Some(offset) = param_offset {
3082            query_string.append_pair("offset", &offset.to_string());
3083        }
3084        if let Some(sort_by) = param_sort_by {
3085            query_string.append_pair("sort_by", &sort_by.to_string());
3086        }
3087        let query_string_str = query_string.finish();
3088        if !query_string_str.is_empty() {
3089            url += "?";
3090            url += &query_string_str;
3091        }
3092
3093        let url = match Url::from_str(&url) {
3094            Ok(url) => url,
3095            Err(err) => {
3096                return Err(ApiError::new(
3097                    format!("Unable to build URL: {}", err),
3098                    SimpleErrorType::Permanent,
3099                ))
3100            }
3101        };
3102
3103        let mut request = self.hyper_client.request(Method::Get, url);
3104        request = request.headers(self.headers.clone());
3105
3106        request
3107            .send()
3108            .map_err(|e| {
3109                ApiError::new(
3110                    format!("No response received: {}", e),
3111                    SimpleErrorType::Permanent,
3112                )
3113            })
3114            .and_then(|mut response| match response.status.to_u16() {
3115                200 => {
3116                    let mut body = Vec::new();
3117                    response.read_to_end(&mut body).map_err(|e| {
3118                        ApiError::new(
3119                            format!("Failed to read response: {}", e),
3120                            SimpleErrorType::Temporary,
3121                        )
3122                    })?;
3123                    str::from_utf8(&body)
3124                        .map_err(|e| {
3125                            ApiError::new(
3126                                format!("Response was not valid UTF8: {}", e),
3127                                SimpleErrorType::Temporary,
3128                            )
3129                        })
3130                        .and_then(|body| {
3131                            serde_json::from_str::<models::GetAllBuildsResponse>(body)
3132                                .map_err(|e| e.into())
3133                        })
3134                }
3135                code => {
3136                    let headers = response.headers.clone();
3137                    let mut body = Vec::new();
3138                    let result = response.read_to_end(&mut body);
3139                    let err_type = match response.status.is_server_error() {
3140                        false => SimpleErrorType::Permanent,
3141                        true => SimpleErrorType::Temporary,
3142                    };
3143                    Err(ApiError::new(
3144                        format!(
3145                            "Unexpected response code {}:\n{:?}\n\n{}",
3146                            code,
3147                            headers,
3148                            match result {
3149                                Ok(_) => match str::from_utf8(&body) {
3150                                    Ok(body) => Cow::from(body),
3151                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3152                                },
3153                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3154                            }
3155                        ),
3156                        err_type,
3157                    ))
3158                }
3159            })
3160    }
3161
3162    fn get_build(&self, param_build_id: uuid::Uuid) -> Result<models::Build, ApiError> {
3163        let mut url = format!(
3164            "{}/v1/builds/{build_id}",
3165            self.base_path,
3166            build_id = utf8_percent_encode(&param_build_id.to_string(), ID_ENCODE_SET)
3167        );
3168
3169        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3170
3171        let query_string_str = query_string.finish();
3172        if !query_string_str.is_empty() {
3173            url += "?";
3174            url += &query_string_str;
3175        }
3176
3177        let url = match Url::from_str(&url) {
3178            Ok(url) => url,
3179            Err(err) => {
3180                return Err(ApiError::new(
3181                    format!("Unable to build URL: {}", err),
3182                    SimpleErrorType::Permanent,
3183                ))
3184            }
3185        };
3186
3187        let mut request = self.hyper_client.request(Method::Get, url);
3188        request = request.headers(self.headers.clone());
3189
3190        request
3191            .send()
3192            .map_err(|e| {
3193                ApiError::new(
3194                    format!("No response received: {}", e),
3195                    SimpleErrorType::Permanent,
3196                )
3197            })
3198            .and_then(|mut response| match response.status.to_u16() {
3199                200 => {
3200                    let mut body = Vec::new();
3201                    response.read_to_end(&mut body).map_err(|e| {
3202                        ApiError::new(
3203                            format!("Failed to read response: {}", e),
3204                            SimpleErrorType::Temporary,
3205                        )
3206                    })?;
3207                    str::from_utf8(&body)
3208                        .map_err(|e| {
3209                            ApiError::new(
3210                                format!("Response was not valid UTF8: {}", e),
3211                                SimpleErrorType::Temporary,
3212                            )
3213                        })
3214                        .and_then(|body| {
3215                            serde_json::from_str::<models::Build>(body).map_err(|e| e.into())
3216                        })
3217                }
3218                code => {
3219                    let headers = response.headers.clone();
3220                    let mut body = Vec::new();
3221                    let result = response.read_to_end(&mut body);
3222                    let err_type = match response.status.is_server_error() {
3223                        false => SimpleErrorType::Permanent,
3224                        true => SimpleErrorType::Temporary,
3225                    };
3226                    Err(ApiError::new(
3227                        format!(
3228                            "Unexpected response code {}:\n{:?}\n\n{}",
3229                            code,
3230                            headers,
3231                            match result {
3232                                Ok(_) => match str::from_utf8(&body) {
3233                                    Ok(body) => Cow::from(body),
3234                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3235                                },
3236                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3237                            }
3238                        ),
3239                        err_type,
3240                    ))
3241                }
3242            })
3243    }
3244
3245    fn get_build_deployments(
3246        &self,
3247        param_build_id: uuid::Uuid,
3248        param_status: Option<String>,
3249        param_all_search: Option<String>,
3250        param_sort_by: Option<String>,
3251        param_limit: Option<i32>,
3252        param_offset: Option<i32>,
3253    ) -> Result<models::GetAllBuildDeploymentsResponse, ApiError> {
3254        let mut url = format!(
3255            "{}/v1/builds/deployments/{build_id}",
3256            self.base_path,
3257            build_id = utf8_percent_encode(&param_build_id.to_string(), ID_ENCODE_SET)
3258        );
3259
3260        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3261
3262        if let Some(status) = param_status {
3263            query_string.append_pair("status", &status.to_string());
3264        }
3265        if let Some(all_search) = param_all_search {
3266            query_string.append_pair("all_search", &all_search.to_string());
3267        }
3268        if let Some(sort_by) = param_sort_by {
3269            query_string.append_pair("sort_by", &sort_by.to_string());
3270        }
3271        if let Some(limit) = param_limit {
3272            query_string.append_pair("limit", &limit.to_string());
3273        }
3274        if let Some(offset) = param_offset {
3275            query_string.append_pair("offset", &offset.to_string());
3276        }
3277        let query_string_str = query_string.finish();
3278        if !query_string_str.is_empty() {
3279            url += "?";
3280            url += &query_string_str;
3281        }
3282
3283        let url = match Url::from_str(&url) {
3284            Ok(url) => url,
3285            Err(err) => {
3286                return Err(ApiError::new(
3287                    format!("Unable to build URL: {}", err),
3288                    SimpleErrorType::Permanent,
3289                ))
3290            }
3291        };
3292
3293        let mut request = self.hyper_client.request(Method::Get, url);
3294        request = request.headers(self.headers.clone());
3295
3296        request
3297            .send()
3298            .map_err(|e| {
3299                ApiError::new(
3300                    format!("No response received: {}", e),
3301                    SimpleErrorType::Permanent,
3302                )
3303            })
3304            .and_then(|mut response| match response.status.to_u16() {
3305                200 => {
3306                    let mut body = Vec::new();
3307                    response.read_to_end(&mut body).map_err(|e| {
3308                        ApiError::new(
3309                            format!("Failed to read response: {}", e),
3310                            SimpleErrorType::Temporary,
3311                        )
3312                    })?;
3313                    str::from_utf8(&body)
3314                        .map_err(|e| {
3315                            ApiError::new(
3316                                format!("Response was not valid UTF8: {}", e),
3317                                SimpleErrorType::Temporary,
3318                            )
3319                        })
3320                        .and_then(|body| {
3321                            serde_json::from_str::<models::GetAllBuildDeploymentsResponse>(body)
3322                                .map_err(|e| e.into())
3323                        })
3324                }
3325                code => {
3326                    let headers = response.headers.clone();
3327                    let mut body = Vec::new();
3328                    let result = response.read_to_end(&mut body);
3329                    let err_type = match response.status.is_server_error() {
3330                        false => SimpleErrorType::Permanent,
3331                        true => SimpleErrorType::Temporary,
3332                    };
3333                    Err(ApiError::new(
3334                        format!(
3335                            "Unexpected response code {}:\n{:?}\n\n{}",
3336                            code,
3337                            headers,
3338                            match result {
3339                                Ok(_) => match str::from_utf8(&body) {
3340                                    Ok(body) => Cow::from(body),
3341                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3342                                },
3343                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3344                            }
3345                        ),
3346                        err_type,
3347                    ))
3348                }
3349            })
3350    }
3351
3352    fn update_build(
3353        &self,
3354        param_build_id: uuid::Uuid,
3355        param_body: models::BuildUpdateRequest,
3356    ) -> Result<models::Build, ApiError> {
3357        let mut url = format!(
3358            "{}/v1/builds/{build_id}",
3359            self.base_path,
3360            build_id = utf8_percent_encode(&param_build_id.to_string(), ID_ENCODE_SET)
3361        );
3362
3363        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3364
3365        let query_string_str = query_string.finish();
3366        if !query_string_str.is_empty() {
3367            url += "?";
3368            url += &query_string_str;
3369        }
3370
3371        let url = match Url::from_str(&url) {
3372            Ok(url) => url,
3373            Err(err) => {
3374                return Err(ApiError::new(
3375                    format!("Unable to build URL: {}", err),
3376                    SimpleErrorType::Permanent,
3377                ))
3378            }
3379        };
3380
3381        let mut request = self.hyper_client.request(Method::Patch, url);
3382        request = request.headers(self.headers.clone());
3383        let body = serde_json::to_string(&param_body)
3384            .expect("impossible to fail to serialize")
3385            .into_bytes();
3386        request = request.body(body.as_slice());
3387
3388        request = request.header(ContentType(mimetypes::requests::UPDATE_BUILD.clone()));
3389
3390        request
3391            .send()
3392            .map_err(|e| {
3393                ApiError::new(
3394                    format!("No response received: {}", e),
3395                    SimpleErrorType::Permanent,
3396                )
3397            })
3398            .and_then(|mut response| match response.status.to_u16() {
3399                200 => {
3400                    let mut body = Vec::new();
3401                    response.read_to_end(&mut body).map_err(|e| {
3402                        ApiError::new(
3403                            format!("Failed to read response: {}", e),
3404                            SimpleErrorType::Temporary,
3405                        )
3406                    })?;
3407                    str::from_utf8(&body)
3408                        .map_err(|e| {
3409                            ApiError::new(
3410                                format!("Response was not valid UTF8: {}", e),
3411                                SimpleErrorType::Temporary,
3412                            )
3413                        })
3414                        .and_then(|body| {
3415                            serde_json::from_str::<models::Build>(body).map_err(|e| e.into())
3416                        })
3417                }
3418                code => {
3419                    let headers = response.headers.clone();
3420                    let mut body = Vec::new();
3421                    let result = response.read_to_end(&mut body);
3422                    let err_type = match response.status.is_server_error() {
3423                        false => SimpleErrorType::Permanent,
3424                        true => SimpleErrorType::Temporary,
3425                    };
3426                    Err(ApiError::new(
3427                        format!(
3428                            "Unexpected response code {}:\n{:?}\n\n{}",
3429                            code,
3430                            headers,
3431                            match result {
3432                                Ok(_) => match str::from_utf8(&body) {
3433                                    Ok(body) => Cow::from(body),
3434                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3435                                },
3436                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3437                            }
3438                        ),
3439                        err_type,
3440                    ))
3441                }
3442            })
3443    }
3444}
3445
3446impl CertificateApi for Client {
3447    type Error = ApiError;
3448
3449    fn get_certificate(&self, param_cert_id: uuid::Uuid) -> Result<models::Certificate, ApiError> {
3450        let mut url = format!(
3451            "{}/v1/certificates/{cert_id}",
3452            self.base_path,
3453            cert_id = utf8_percent_encode(&param_cert_id.to_string(), ID_ENCODE_SET)
3454        );
3455
3456        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3457
3458        let query_string_str = query_string.finish();
3459        if !query_string_str.is_empty() {
3460            url += "?";
3461            url += &query_string_str;
3462        }
3463
3464        let url = match Url::from_str(&url) {
3465            Ok(url) => url,
3466            Err(err) => {
3467                return Err(ApiError::new(
3468                    format!("Unable to build URL: {}", err),
3469                    SimpleErrorType::Permanent,
3470                ))
3471            }
3472        };
3473
3474        let mut request = self.hyper_client.request(Method::Get, url);
3475        request = request.headers(self.headers.clone());
3476
3477        request
3478            .send()
3479            .map_err(|e| {
3480                ApiError::new(
3481                    format!("No response received: {}", e),
3482                    SimpleErrorType::Permanent,
3483                )
3484            })
3485            .and_then(|mut response| match response.status.to_u16() {
3486                200 => {
3487                    let mut body = Vec::new();
3488                    response.read_to_end(&mut body).map_err(|e| {
3489                        ApiError::new(
3490                            format!("Failed to read response: {}", e),
3491                            SimpleErrorType::Temporary,
3492                        )
3493                    })?;
3494                    str::from_utf8(&body)
3495                        .map_err(|e| {
3496                            ApiError::new(
3497                                format!("Response was not valid UTF8: {}", e),
3498                                SimpleErrorType::Temporary,
3499                            )
3500                        })
3501                        .and_then(|body| {
3502                            serde_json::from_str::<models::Certificate>(body).map_err(|e| e.into())
3503                        })
3504                }
3505                code => {
3506                    let headers = response.headers.clone();
3507                    let mut body = Vec::new();
3508                    let result = response.read_to_end(&mut body);
3509                    let err_type = match response.status.is_server_error() {
3510                        false => SimpleErrorType::Permanent,
3511                        true => SimpleErrorType::Temporary,
3512                    };
3513                    Err(ApiError::new(
3514                        format!(
3515                            "Unexpected response code {}:\n{:?}\n\n{}",
3516                            code,
3517                            headers,
3518                            match result {
3519                                Ok(_) => match str::from_utf8(&body) {
3520                                    Ok(body) => Cow::from(body),
3521                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3522                                },
3523                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3524                            }
3525                        ),
3526                        err_type,
3527                    ))
3528                }
3529            })
3530    }
3531
3532    fn new_certificate(
3533        &self,
3534        param_body: models::NewCertificateRequest,
3535    ) -> Result<models::TaskResult, ApiError> {
3536        let mut url = format!("{}/v1/certificates", self.base_path);
3537
3538        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3539
3540        let query_string_str = query_string.finish();
3541        if !query_string_str.is_empty() {
3542            url += "?";
3543            url += &query_string_str;
3544        }
3545
3546        let url = match Url::from_str(&url) {
3547            Ok(url) => url,
3548            Err(err) => {
3549                return Err(ApiError::new(
3550                    format!("Unable to build URL: {}", err),
3551                    SimpleErrorType::Permanent,
3552                ))
3553            }
3554        };
3555
3556        let mut request = self.hyper_client.request(Method::Post, url);
3557        request = request.headers(self.headers.clone());
3558        let body = serde_json::to_string(&param_body)
3559            .expect("impossible to fail to serialize")
3560            .into_bytes();
3561        request = request.body(body.as_slice());
3562
3563        request = request.header(ContentType(mimetypes::requests::NEW_CERTIFICATE.clone()));
3564
3565        request
3566            .send()
3567            .map_err(|e| {
3568                ApiError::new(
3569                    format!("No response received: {}", e),
3570                    SimpleErrorType::Permanent,
3571                )
3572            })
3573            .and_then(|mut response| match response.status.to_u16() {
3574                200 => {
3575                    let mut body = Vec::new();
3576                    response.read_to_end(&mut body).map_err(|e| {
3577                        ApiError::new(
3578                            format!("Failed to read response: {}", e),
3579                            SimpleErrorType::Temporary,
3580                        )
3581                    })?;
3582                    str::from_utf8(&body)
3583                        .map_err(|e| {
3584                            ApiError::new(
3585                                format!("Response was not valid UTF8: {}", e),
3586                                SimpleErrorType::Temporary,
3587                            )
3588                        })
3589                        .and_then(|body| {
3590                            serde_json::from_str::<models::TaskResult>(body).map_err(|e| e.into())
3591                        })
3592                }
3593                code => {
3594                    let headers = response.headers.clone();
3595                    let mut body = Vec::new();
3596                    let result = response.read_to_end(&mut body);
3597                    let err_type = match response.status.is_server_error() {
3598                        false => SimpleErrorType::Permanent,
3599                        true => SimpleErrorType::Temporary,
3600                    };
3601                    Err(ApiError::new(
3602                        format!(
3603                            "Unexpected response code {}:\n{:?}\n\n{}",
3604                            code,
3605                            headers,
3606                            match result {
3607                                Ok(_) => match str::from_utf8(&body) {
3608                                    Ok(body) => Cow::from(body),
3609                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3610                                },
3611                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3612                            }
3613                        ),
3614                        err_type,
3615                    ))
3616                }
3617            })
3618    }
3619}
3620
3621impl DatasetApi for Client {
3622    type Error = ApiError;
3623
3624    fn create_dataset(
3625        &self,
3626        param_body: models::CreateDatasetRequest,
3627    ) -> Result<models::Dataset, ApiError> {
3628        let mut url = format!("{}/v1/datasets", self.base_path);
3629
3630        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3631
3632        let query_string_str = query_string.finish();
3633        if !query_string_str.is_empty() {
3634            url += "?";
3635            url += &query_string_str;
3636        }
3637
3638        let url = match Url::from_str(&url) {
3639            Ok(url) => url,
3640            Err(err) => {
3641                return Err(ApiError::new(
3642                    format!("Unable to build URL: {}", err),
3643                    SimpleErrorType::Permanent,
3644                ))
3645            }
3646        };
3647
3648        let mut request = self.hyper_client.request(Method::Post, url);
3649        request = request.headers(self.headers.clone());
3650        // Body parameter
3651        let body = serde_json::to_string(&param_body)
3652            .expect("impossible to fail to serialize")
3653            .into_bytes();
3654        request = request.body(body.as_slice());
3655
3656        request = request.header(ContentType(mimetypes::requests::CREATE_DATASET.clone()));
3657
3658        request
3659            .send()
3660            .map_err(|e| {
3661                ApiError::new(
3662                    format!("No response received: {}", e),
3663                    SimpleErrorType::Permanent,
3664                )
3665            })
3666            .and_then(|mut response| match response.status.to_u16() {
3667                200 => {
3668                    let mut body = Vec::new();
3669                    response.read_to_end(&mut body).map_err(|e| {
3670                        ApiError::new(
3671                            format!("Failed to read response: {}", e),
3672                            SimpleErrorType::Temporary,
3673                        )
3674                    })?;
3675                    str::from_utf8(&body)
3676                        .map_err(|e| {
3677                            ApiError::new(
3678                                format!("Response was not valid UTF8: {}", e),
3679                                SimpleErrorType::Temporary,
3680                            )
3681                        })
3682                        .and_then(|body| {
3683                            serde_json::from_str::<models::Dataset>(body).map_err(|e| e.into())
3684                        })
3685                }
3686                code => {
3687                    let headers = response.headers.clone();
3688                    let mut body = Vec::new();
3689                    let result = response.read_to_end(&mut body);
3690                    let err_type = match response.status.is_server_error() {
3691                        false => SimpleErrorType::Permanent,
3692                        true => SimpleErrorType::Temporary,
3693                    };
3694                    Err(ApiError::new(
3695                        format!(
3696                            "Unexpected response code {}:\n{:?}\n\n{}",
3697                            code,
3698                            headers,
3699                            match result {
3700                                Ok(_) => match str::from_utf8(&body) {
3701                                    Ok(body) => Cow::from(body),
3702                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3703                                },
3704                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3705                            }
3706                        ),
3707                        err_type,
3708                    ))
3709                }
3710            })
3711    }
3712
3713    fn delete_dataset(&self, param_dataset_id: uuid::Uuid) -> Result<(), ApiError> {
3714        let mut url = format!(
3715            "{}/v1/datasets/{dataset_id}",
3716            self.base_path,
3717            dataset_id = utf8_percent_encode(&param_dataset_id.to_string(), ID_ENCODE_SET)
3718        );
3719
3720        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3721
3722        let query_string_str = query_string.finish();
3723        if !query_string_str.is_empty() {
3724            url += "?";
3725            url += &query_string_str;
3726        }
3727
3728        let url = match Url::from_str(&url) {
3729            Ok(url) => url,
3730            Err(err) => {
3731                return Err(ApiError::new(
3732                    format!("Unable to build URL: {}", err),
3733                    SimpleErrorType::Permanent,
3734                ))
3735            }
3736        };
3737
3738        let mut request = self.hyper_client.request(Method::Delete, url);
3739        request = request.headers(self.headers.clone());
3740
3741        request
3742            .send()
3743            .map_err(|e| {
3744                ApiError::new(
3745                    format!("No response received: {}", e),
3746                    SimpleErrorType::Permanent,
3747                )
3748            })
3749            .and_then(|mut response| match response.status.to_u16() {
3750                204 => {
3751                    let mut body = Vec::new();
3752                    response.read_to_end(&mut body).map_err(|e| {
3753                        ApiError::new(
3754                            format!("Failed to read response: {}", e),
3755                            SimpleErrorType::Temporary,
3756                        )
3757                    })?;
3758
3759                    Ok(())
3760                }
3761                code => {
3762                    let headers = response.headers.clone();
3763                    let mut body = Vec::new();
3764                    let result = response.read_to_end(&mut body);
3765                    let err_type = match response.status.is_server_error() {
3766                        false => SimpleErrorType::Permanent,
3767                        true => SimpleErrorType::Temporary,
3768                    };
3769                    Err(ApiError::new(
3770                        format!(
3771                            "Unexpected response code {}:\n{:?}\n\n{}",
3772                            code,
3773                            headers,
3774                            match result {
3775                                Ok(_) => match str::from_utf8(&body) {
3776                                    Ok(body) => Cow::from(body),
3777                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3778                                },
3779                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3780                            }
3781                        ),
3782                        err_type,
3783                    ))
3784                }
3785            })
3786    }
3787
3788    fn get_all_datasets(
3789        &self,
3790        param_name: Option<String>,
3791        param_description: Option<String>,
3792        param_limit: Option<i32>,
3793        param_offset: Option<i32>,
3794    ) -> Result<models::GetAllDatasetsResponse, ApiError> {
3795        let mut url = format!("{}/v1/datasets", self.base_path);
3796
3797        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3798
3799        if let Some(name) = param_name {
3800            query_string.append_pair("name", &name.to_string());
3801        }
3802        if let Some(description) = param_description {
3803            query_string.append_pair("description", &description.to_string());
3804        }
3805        if let Some(limit) = param_limit {
3806            query_string.append_pair("limit", &limit.to_string());
3807        }
3808        if let Some(offset) = param_offset {
3809            query_string.append_pair("offset", &offset.to_string());
3810        }
3811        let query_string_str = query_string.finish();
3812        if !query_string_str.is_empty() {
3813            url += "?";
3814            url += &query_string_str;
3815        }
3816
3817        let url = match Url::from_str(&url) {
3818            Ok(url) => url,
3819            Err(err) => {
3820                return Err(ApiError::new(
3821                    format!("Unable to build URL: {}", err),
3822                    SimpleErrorType::Permanent,
3823                ))
3824            }
3825        };
3826
3827        let mut request = self.hyper_client.request(Method::Get, url);
3828        request = request.headers(self.headers.clone());
3829
3830        request
3831            .send()
3832            .map_err(|e| {
3833                ApiError::new(
3834                    format!("No response received: {}", e),
3835                    SimpleErrorType::Permanent,
3836                )
3837            })
3838            .and_then(|mut response| match response.status.to_u16() {
3839                200 => {
3840                    let mut body = Vec::new();
3841                    response.read_to_end(&mut body).map_err(|e| {
3842                        ApiError::new(
3843                            format!("Failed to read response: {}", e),
3844                            SimpleErrorType::Temporary,
3845                        )
3846                    })?;
3847                    str::from_utf8(&body)
3848                        .map_err(|e| {
3849                            ApiError::new(
3850                                format!("Response was not valid UTF8: {}", e),
3851                                SimpleErrorType::Temporary,
3852                            )
3853                        })
3854                        .and_then(|body| {
3855                            serde_json::from_str::<models::GetAllDatasetsResponse>(body)
3856                                .map_err(|e| e.into())
3857                        })
3858                }
3859                code => {
3860                    let headers = response.headers.clone();
3861                    let mut body = Vec::new();
3862                    let result = response.read_to_end(&mut body);
3863                    let err_type = match response.status.is_server_error() {
3864                        false => SimpleErrorType::Permanent,
3865                        true => SimpleErrorType::Temporary,
3866                    };
3867                    Err(ApiError::new(
3868                        format!(
3869                            "Unexpected response code {}:\n{:?}\n\n{}",
3870                            code,
3871                            headers,
3872                            match result {
3873                                Ok(_) => match str::from_utf8(&body) {
3874                                    Ok(body) => Cow::from(body),
3875                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3876                                },
3877                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3878                            }
3879                        ),
3880                        err_type,
3881                    ))
3882                }
3883            })
3884    }
3885
3886    fn get_dataset(&self, param_dataset_id: uuid::Uuid) -> Result<models::Dataset, ApiError> {
3887        let mut url = format!(
3888            "{}/v1/datasets/{dataset_id}",
3889            self.base_path,
3890            dataset_id = utf8_percent_encode(&param_dataset_id.to_string(), ID_ENCODE_SET)
3891        );
3892
3893        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3894
3895        let query_string_str = query_string.finish();
3896        if !query_string_str.is_empty() {
3897            url += "?";
3898            url += &query_string_str;
3899        }
3900
3901        let url = match Url::from_str(&url) {
3902            Ok(url) => url,
3903            Err(err) => {
3904                return Err(ApiError::new(
3905                    format!("Unable to build URL: {}", err),
3906                    SimpleErrorType::Permanent,
3907                ))
3908            }
3909        };
3910
3911        let mut request = self.hyper_client.request(Method::Get, url);
3912        request = request.headers(self.headers.clone());
3913
3914        request
3915            .send()
3916            .map_err(|e| {
3917                ApiError::new(
3918                    format!("No response received: {}", e),
3919                    SimpleErrorType::Permanent,
3920                )
3921            })
3922            .and_then(|mut response| match response.status.to_u16() {
3923                200 => {
3924                    let mut body = Vec::new();
3925                    response.read_to_end(&mut body).map_err(|e| {
3926                        ApiError::new(
3927                            format!("Failed to read response: {}", e),
3928                            SimpleErrorType::Temporary,
3929                        )
3930                    })?;
3931                    str::from_utf8(&body)
3932                        .map_err(|e| {
3933                            ApiError::new(
3934                                format!("Response was not valid UTF8: {}", e),
3935                                SimpleErrorType::Temporary,
3936                            )
3937                        })
3938                        .and_then(|body| {
3939                            serde_json::from_str::<models::Dataset>(body).map_err(|e| e.into())
3940                        })
3941                }
3942                code => {
3943                    let headers = response.headers.clone();
3944                    let mut body = Vec::new();
3945                    let result = response.read_to_end(&mut body);
3946                    let err_type = match response.status.is_server_error() {
3947                        false => SimpleErrorType::Permanent,
3948                        true => SimpleErrorType::Temporary,
3949                    };
3950                    Err(ApiError::new(
3951                        format!(
3952                            "Unexpected response code {}:\n{:?}\n\n{}",
3953                            code,
3954                            headers,
3955                            match result {
3956                                Ok(_) => match str::from_utf8(&body) {
3957                                    Ok(body) => Cow::from(body),
3958                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
3959                                },
3960                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
3961                            }
3962                        ),
3963                        err_type,
3964                    ))
3965                }
3966            })
3967    }
3968
3969    fn update_dataset(
3970        &self,
3971        param_dataset_id: uuid::Uuid,
3972        param_body: models::DatasetUpdateRequest,
3973    ) -> Result<models::Dataset, ApiError> {
3974        let mut url = format!(
3975            "{}/v1/datasets/{dataset_id}",
3976            self.base_path,
3977            dataset_id = utf8_percent_encode(&param_dataset_id.to_string(), ID_ENCODE_SET)
3978        );
3979
3980        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
3981
3982        let query_string_str = query_string.finish();
3983        if !query_string_str.is_empty() {
3984            url += "?";
3985            url += &query_string_str;
3986        }
3987
3988        let url = match Url::from_str(&url) {
3989            Ok(url) => url,
3990            Err(err) => {
3991                return Err(ApiError::new(
3992                    format!("Unable to build URL: {}", err),
3993                    SimpleErrorType::Permanent,
3994                ))
3995            }
3996        };
3997
3998        let mut request = self.hyper_client.request(Method::Patch, url);
3999        request = request.headers(self.headers.clone());
4000        let body = serde_json::to_string(&param_body)
4001            .expect("impossible to fail to serialize")
4002            .into_bytes();
4003        request = request.body(body.as_slice());
4004
4005        request = request.header(ContentType(mimetypes::requests::UPDATE_DATASET.clone()));
4006
4007        request
4008            .send()
4009            .map_err(|e| {
4010                ApiError::new(
4011                    format!("No response received: {}", e),
4012                    SimpleErrorType::Permanent,
4013                )
4014            })
4015            .and_then(|mut response| match response.status.to_u16() {
4016                200 => {
4017                    let mut body = Vec::new();
4018                    response.read_to_end(&mut body).map_err(|e| {
4019                        ApiError::new(
4020                            format!("Failed to read response: {}", e),
4021                            SimpleErrorType::Temporary,
4022                        )
4023                    })?;
4024                    str::from_utf8(&body)
4025                        .map_err(|e| {
4026                            ApiError::new(
4027                                format!("Response was not valid UTF8: {}", e),
4028                                SimpleErrorType::Temporary,
4029                            )
4030                        })
4031                        .and_then(|body| {
4032                            serde_json::from_str::<models::Dataset>(body).map_err(|e| e.into())
4033                        })
4034                }
4035                code => {
4036                    let headers = response.headers.clone();
4037                    let mut body = Vec::new();
4038                    let result = response.read_to_end(&mut body);
4039                    let err_type = match response.status.is_server_error() {
4040                        false => SimpleErrorType::Permanent,
4041                        true => SimpleErrorType::Temporary,
4042                    };
4043                    Err(ApiError::new(
4044                        format!(
4045                            "Unexpected response code {}:\n{:?}\n\n{}",
4046                            code,
4047                            headers,
4048                            match result {
4049                                Ok(_) => match str::from_utf8(&body) {
4050                                    Ok(body) => Cow::from(body),
4051                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4052                                },
4053                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4054                            }
4055                        ),
4056                        err_type,
4057                    ))
4058                }
4059            })
4060    }
4061}
4062
4063impl NodeApi for Client {
4064    type Error = ApiError;
4065
4066    fn deactivate_node(&self, param_node_id: uuid::Uuid) -> Result<(), ApiError> {
4067        let mut url = format!(
4068            "{}/v1/nodes/{node_id}/deactivate",
4069            self.base_path,
4070            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET)
4071        );
4072
4073        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4074
4075        let query_string_str = query_string.finish();
4076        if !query_string_str.is_empty() {
4077            url += "?";
4078            url += &query_string_str;
4079        }
4080
4081        let url = match Url::from_str(&url) {
4082            Ok(url) => url,
4083            Err(err) => {
4084                return Err(ApiError::new(
4085                    format!("Unable to build URL: {}", err),
4086                    SimpleErrorType::Permanent,
4087                ))
4088            }
4089        };
4090
4091        let mut request = self.hyper_client.request(Method::Post, url);
4092        request = request.headers(self.headers.clone());
4093
4094        request
4095            .send()
4096            .map_err(|e| {
4097                ApiError::new(
4098                    format!("No response received: {}", e),
4099                    SimpleErrorType::Permanent,
4100                )
4101            })
4102            .and_then(|mut response| match response.status.to_u16() {
4103                204 => {
4104                    let mut body = Vec::new();
4105                    response.read_to_end(&mut body).map_err(|e| {
4106                        ApiError::new(
4107                            format!("Failed to read response: {}", e),
4108                            SimpleErrorType::Temporary,
4109                        )
4110                    })?;
4111
4112                    Ok(())
4113                }
4114                code => {
4115                    let headers = response.headers.clone();
4116                    let mut body = Vec::new();
4117                    let result = response.read_to_end(&mut body);
4118                    let err_type = match response.status.is_server_error() {
4119                        false => SimpleErrorType::Permanent,
4120                        true => SimpleErrorType::Temporary,
4121                    };
4122                    Err(ApiError::new(
4123                        format!(
4124                            "Unexpected response code {}:\n{:?}\n\n{}",
4125                            code,
4126                            headers,
4127                            match result {
4128                                Ok(_) => match str::from_utf8(&body) {
4129                                    Ok(body) => Cow::from(body),
4130                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4131                                },
4132                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4133                            }
4134                        ),
4135                        err_type,
4136                    ))
4137                }
4138            })
4139    }
4140
4141    fn get_all_nodes(
4142        &self,
4143        param_name: Option<String>,
4144        param_description: Option<String>,
4145        param_sgx_version: Option<String>,
4146        param_all_search: Option<String>,
4147        param_status: Option<String>,
4148        param_limit: Option<i32>,
4149        param_offset: Option<i32>,
4150        param_sort_by: Option<String>,
4151    ) -> Result<models::GetAllNodesResponse, ApiError> {
4152        let mut url = format!("{}/v1/nodes", self.base_path);
4153
4154        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4155
4156        if let Some(name) = param_name {
4157            query_string.append_pair("name", &name.to_string());
4158        }
4159        if let Some(description) = param_description {
4160            query_string.append_pair("description", &description.to_string());
4161        }
4162        if let Some(sgx_version) = param_sgx_version {
4163            query_string.append_pair("sgx_version", &sgx_version.to_string());
4164        }
4165        if let Some(all_search) = param_all_search {
4166            query_string.append_pair("all_search", &all_search.to_string());
4167        }
4168        if let Some(status) = param_status {
4169            query_string.append_pair("status", &status.to_string());
4170        }
4171        if let Some(limit) = param_limit {
4172            query_string.append_pair("limit", &limit.to_string());
4173        }
4174        if let Some(offset) = param_offset {
4175            query_string.append_pair("offset", &offset.to_string());
4176        }
4177        if let Some(sort_by) = param_sort_by {
4178            query_string.append_pair("sort_by", &sort_by.to_string());
4179        }
4180        let query_string_str = query_string.finish();
4181        if !query_string_str.is_empty() {
4182            url += "?";
4183            url += &query_string_str;
4184        }
4185
4186        let url = match Url::from_str(&url) {
4187            Ok(url) => url,
4188            Err(err) => {
4189                return Err(ApiError::new(
4190                    format!("Unable to build URL: {}", err),
4191                    SimpleErrorType::Permanent,
4192                ))
4193            }
4194        };
4195
4196        let mut request = self.hyper_client.request(Method::Get, url);
4197        request = request.headers(self.headers.clone());
4198
4199        request
4200            .send()
4201            .map_err(|e| {
4202                ApiError::new(
4203                    format!("No response received: {}", e),
4204                    SimpleErrorType::Permanent,
4205                )
4206            })
4207            .and_then(|mut response| match response.status.to_u16() {
4208                200 => {
4209                    let mut body = Vec::new();
4210                    response.read_to_end(&mut body).map_err(|e| {
4211                        ApiError::new(
4212                            format!("Failed to read response: {}", e),
4213                            SimpleErrorType::Temporary,
4214                        )
4215                    })?;
4216                    str::from_utf8(&body)
4217                        .map_err(|e| {
4218                            ApiError::new(
4219                                format!("Response was not valid UTF8: {}", e),
4220                                SimpleErrorType::Temporary,
4221                            )
4222                        })
4223                        .and_then(|body| {
4224                            serde_json::from_str::<models::GetAllNodesResponse>(body)
4225                                .map_err(|e| e.into())
4226                        })
4227                }
4228                code => {
4229                    let headers = response.headers.clone();
4230                    let mut body = Vec::new();
4231                    let result = response.read_to_end(&mut body);
4232                    let err_type = match response.status.is_server_error() {
4233                        false => SimpleErrorType::Permanent,
4234                        true => SimpleErrorType::Temporary,
4235                    };
4236                    Err(ApiError::new(
4237                        format!(
4238                            "Unexpected response code {}:\n{:?}\n\n{}",
4239                            code,
4240                            headers,
4241                            match result {
4242                                Ok(_) => match str::from_utf8(&body) {
4243                                    Ok(body) => Cow::from(body),
4244                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4245                                },
4246                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4247                            }
4248                        ),
4249                        err_type,
4250                    ))
4251                }
4252            })
4253    }
4254
4255    fn get_node(&self, param_node_id: uuid::Uuid) -> Result<models::Node, ApiError> {
4256        let mut url = format!(
4257            "{}/v1/nodes/{node_id}",
4258            self.base_path,
4259            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET)
4260        );
4261
4262        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4263
4264        let query_string_str = query_string.finish();
4265        if !query_string_str.is_empty() {
4266            url += "?";
4267            url += &query_string_str;
4268        }
4269
4270        let url = match Url::from_str(&url) {
4271            Ok(url) => url,
4272            Err(err) => {
4273                return Err(ApiError::new(
4274                    format!("Unable to build URL: {}", err),
4275                    SimpleErrorType::Permanent,
4276                ))
4277            }
4278        };
4279
4280        let mut request = self.hyper_client.request(Method::Get, url);
4281        request = request.headers(self.headers.clone());
4282
4283        request
4284            .send()
4285            .map_err(|e| {
4286                ApiError::new(
4287                    format!("No response received: {}", e),
4288                    SimpleErrorType::Permanent,
4289                )
4290            })
4291            .and_then(|mut response| match response.status.to_u16() {
4292                200 => {
4293                    let mut body = Vec::new();
4294                    response.read_to_end(&mut body).map_err(|e| {
4295                        ApiError::new(
4296                            format!("Failed to read response: {}", e),
4297                            SimpleErrorType::Temporary,
4298                        )
4299                    })?;
4300                    str::from_utf8(&body)
4301                        .map_err(|e| {
4302                            ApiError::new(
4303                                format!("Response was not valid UTF8: {}", e),
4304                                SimpleErrorType::Temporary,
4305                            )
4306                        })
4307                        .and_then(|body| {
4308                            serde_json::from_str::<models::Node>(body).map_err(|e| e.into())
4309                        })
4310                }
4311                code => {
4312                    let headers = response.headers.clone();
4313                    let mut body = Vec::new();
4314                    let result = response.read_to_end(&mut body);
4315                    let err_type = match response.status.is_server_error() {
4316                        false => SimpleErrorType::Permanent,
4317                        true => SimpleErrorType::Temporary,
4318                    };
4319                    Err(ApiError::new(
4320                        format!(
4321                            "Unexpected response code {}:\n{:?}\n\n{}",
4322                            code,
4323                            headers,
4324                            match result {
4325                                Ok(_) => match str::from_utf8(&body) {
4326                                    Ok(body) => Cow::from(body),
4327                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4328                                },
4329                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4330                            }
4331                        ),
4332                        err_type,
4333                    ))
4334                }
4335            })
4336    }
4337
4338    fn get_node_certificate(
4339        &self,
4340        param_node_id: uuid::Uuid,
4341    ) -> Result<models::Certificate, ApiError> {
4342        let mut url = format!(
4343            "{}/v1/nodes/{node_id}/certificate",
4344            self.base_path,
4345            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET)
4346        );
4347
4348        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4349
4350        let query_string_str = query_string.finish();
4351        if !query_string_str.is_empty() {
4352            url += "?";
4353            url += &query_string_str;
4354        }
4355
4356        let url = match Url::from_str(&url) {
4357            Ok(url) => url,
4358            Err(err) => {
4359                return Err(ApiError::new(
4360                    format!("Unable to build URL: {}", err),
4361                    SimpleErrorType::Permanent,
4362                ))
4363            }
4364        };
4365
4366        let mut request = self.hyper_client.request(Method::Get, url);
4367        request = request.headers(self.headers.clone());
4368
4369        request
4370            .send()
4371            .map_err(|e| {
4372                ApiError::new(
4373                    format!("No response received: {}", e),
4374                    SimpleErrorType::Permanent,
4375                )
4376            })
4377            .and_then(|mut response| match response.status.to_u16() {
4378                200 => {
4379                    let mut body = Vec::new();
4380                    response.read_to_end(&mut body).map_err(|e| {
4381                        ApiError::new(
4382                            format!("Failed to read response: {}", e),
4383                            SimpleErrorType::Temporary,
4384                        )
4385                    })?;
4386                    str::from_utf8(&body)
4387                        .map_err(|e| {
4388                            ApiError::new(
4389                                format!("Response was not valid UTF8: {}", e),
4390                                SimpleErrorType::Temporary,
4391                            )
4392                        })
4393                        .and_then(|body| {
4394                            serde_json::from_str::<models::Certificate>(body).map_err(|e| e.into())
4395                        })
4396                }
4397                code => {
4398                    let headers = response.headers.clone();
4399                    let mut body = Vec::new();
4400                    let result = response.read_to_end(&mut body);
4401                    let err_type = match response.status.is_server_error() {
4402                        false => SimpleErrorType::Permanent,
4403                        true => SimpleErrorType::Temporary,
4404                    };
4405                    Err(ApiError::new(
4406                        format!(
4407                            "Unexpected response code {}:\n{:?}\n\n{}",
4408                            code,
4409                            headers,
4410                            match result {
4411                                Ok(_) => match str::from_utf8(&body) {
4412                                    Ok(body) => Cow::from(body),
4413                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4414                                },
4415                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4416                            }
4417                        ),
4418                        err_type,
4419                    ))
4420                }
4421            })
4422    }
4423
4424    fn get_node_certificate_details(
4425        &self,
4426        param_node_id: uuid::Uuid,
4427    ) -> Result<models::CertificateDetails, ApiError> {
4428        let mut url = format!(
4429            "{}/v1/nodes/{node_id}/certificate-details",
4430            self.base_path,
4431            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET)
4432        );
4433
4434        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4435
4436        let query_string_str = query_string.finish();
4437        if !query_string_str.is_empty() {
4438            url += "?";
4439            url += &query_string_str;
4440        }
4441
4442        let url = match Url::from_str(&url) {
4443            Ok(url) => url,
4444            Err(err) => {
4445                return Err(ApiError::new(
4446                    format!("Unable to build URL: {}", err),
4447                    SimpleErrorType::Permanent,
4448                ))
4449            }
4450        };
4451
4452        let mut request = self.hyper_client.request(Method::Get, url);
4453        request = request.headers(self.headers.clone());
4454
4455        request
4456            .send()
4457            .map_err(|e| {
4458                ApiError::new(
4459                    format!("No response received: {}", e),
4460                    SimpleErrorType::Permanent,
4461                )
4462            })
4463            .and_then(|mut response| match response.status.to_u16() {
4464                200 => {
4465                    let mut body = Vec::new();
4466                    response.read_to_end(&mut body).map_err(|e| {
4467                        ApiError::new(
4468                            format!("Failed to read response: {}", e),
4469                            SimpleErrorType::Temporary,
4470                        )
4471                    })?;
4472                    str::from_utf8(&body)
4473                        .map_err(|e| {
4474                            ApiError::new(
4475                                format!("Response was not valid UTF8: {}", e),
4476                                SimpleErrorType::Temporary,
4477                            )
4478                        })
4479                        .and_then(|body| {
4480                            serde_json::from_str::<models::CertificateDetails>(body)
4481                                .map_err(|e| e.into())
4482                        })
4483                }
4484                code => {
4485                    let headers = response.headers.clone();
4486                    let mut body = Vec::new();
4487                    let result = response.read_to_end(&mut body);
4488                    let err_type = match response.status.is_server_error() {
4489                        false => SimpleErrorType::Permanent,
4490                        true => SimpleErrorType::Temporary,
4491                    };
4492                    Err(ApiError::new(
4493                        format!(
4494                            "Unexpected response code {}:\n{:?}\n\n{}",
4495                            code,
4496                            headers,
4497                            match result {
4498                                Ok(_) => match str::from_utf8(&body) {
4499                                    Ok(body) => Cow::from(body),
4500                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4501                                },
4502                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4503                            }
4504                        ),
4505                        err_type,
4506                    ))
4507                }
4508            })
4509    }
4510
4511    fn get_nodes_unique_labels(&self) -> Result<models::LabelsCount, ApiError> {
4512        let mut url = format!("{}/v1/nodes/unique_labels/count", self.base_path);
4513
4514        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4515
4516        let query_string_str = query_string.finish();
4517        if !query_string_str.is_empty() {
4518            url += "?";
4519            url += &query_string_str;
4520        }
4521
4522        let url = match Url::from_str(&url) {
4523            Ok(url) => url,
4524            Err(err) => {
4525                return Err(ApiError::new(
4526                    format!("Unable to build URL: {}", err),
4527                    SimpleErrorType::Permanent,
4528                ))
4529            }
4530        };
4531
4532        let mut request = self.hyper_client.request(Method::Get, url);
4533        request = request.headers(self.headers.clone());
4534
4535        request
4536            .send()
4537            .map_err(|e| {
4538                ApiError::new(
4539                    format!("No response received: {}", e),
4540                    SimpleErrorType::Permanent,
4541                )
4542            })
4543            .and_then(|mut response| match response.status.to_u16() {
4544                200 => {
4545                    let mut body = Vec::new();
4546                    response.read_to_end(&mut body).map_err(|e| {
4547                        ApiError::new(
4548                            format!("Failed to read response: {}", e),
4549                            SimpleErrorType::Temporary,
4550                        )
4551                    })?;
4552                    str::from_utf8(&body)
4553                        .map_err(|e| {
4554                            ApiError::new(
4555                                format!("Response was not valid UTF8: {}", e),
4556                                SimpleErrorType::Temporary,
4557                            )
4558                        })
4559                        .and_then(|body| {
4560                            serde_json::from_str::<models::LabelsCount>(body).map_err(|e| e.into())
4561                        })
4562                }
4563                code => {
4564                    let headers = response.headers.clone();
4565                    let mut body = Vec::new();
4566                    let result = response.read_to_end(&mut body);
4567                    let err_type = match response.status.is_server_error() {
4568                        false => SimpleErrorType::Permanent,
4569                        true => SimpleErrorType::Temporary,
4570                    };
4571                    Err(ApiError::new(
4572                        format!(
4573                            "Unexpected response code {}:\n{:?}\n\n{}",
4574                            code,
4575                            headers,
4576                            match result {
4577                                Ok(_) => match str::from_utf8(&body) {
4578                                    Ok(body) => Cow::from(body),
4579                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4580                                },
4581                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4582                            }
4583                        ),
4584                        err_type,
4585                    ))
4586                }
4587            })
4588    }
4589
4590    fn provision_node(
4591        &self,
4592        param_body: models::NodeProvisionRequest,
4593    ) -> Result<models::TaskResult, ApiError> {
4594        let mut url = format!("{}/v1/nodes", self.base_path);
4595
4596        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4597
4598        let query_string_str = query_string.finish();
4599        if !query_string_str.is_empty() {
4600            url += "?";
4601            url += &query_string_str;
4602        }
4603
4604        let url = match Url::from_str(&url) {
4605            Ok(url) => url,
4606            Err(err) => {
4607                return Err(ApiError::new(
4608                    format!("Unable to build URL: {}", err),
4609                    SimpleErrorType::Permanent,
4610                ))
4611            }
4612        };
4613
4614        let mut request = self.hyper_client.request(Method::Post, url);
4615        request = request.headers(self.headers.clone());
4616        let body = serde_json::to_string(&param_body)
4617            .expect("impossible to fail to serialize")
4618            .into_bytes();
4619        request = request.body(body.as_slice());
4620
4621        request = request.header(ContentType(mimetypes::requests::PROVISION_NODE.clone()));
4622
4623        request
4624            .send()
4625            .map_err(|e| {
4626                ApiError::new(
4627                    format!("No response received: {}", e),
4628                    SimpleErrorType::Permanent,
4629                )
4630            })
4631            .and_then(|mut response| match response.status.to_u16() {
4632                200 => {
4633                    let mut body = Vec::new();
4634                    response.read_to_end(&mut body).map_err(|e| {
4635                        ApiError::new(
4636                            format!("Failed to read response: {}", e),
4637                            SimpleErrorType::Temporary,
4638                        )
4639                    })?;
4640                    str::from_utf8(&body)
4641                        .map_err(|e| {
4642                            ApiError::new(
4643                                format!("Response was not valid UTF8: {}", e),
4644                                SimpleErrorType::Temporary,
4645                            )
4646                        })
4647                        .and_then(|body| {
4648                            serde_json::from_str::<models::TaskResult>(body).map_err(|e| e.into())
4649                        })
4650                }
4651                code => {
4652                    let headers = response.headers.clone();
4653                    let mut body = Vec::new();
4654                    let result = response.read_to_end(&mut body);
4655                    let err_type = match response.status.is_server_error() {
4656                        false => SimpleErrorType::Permanent,
4657                        true => SimpleErrorType::Temporary,
4658                    };
4659                    Err(ApiError::new(
4660                        format!(
4661                            "Unexpected response code {}:\n{:?}\n\n{}",
4662                            code,
4663                            headers,
4664                            match result {
4665                                Ok(_) => match str::from_utf8(&body) {
4666                                    Ok(body) => Cow::from(body),
4667                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4668                                },
4669                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4670                            }
4671                        ),
4672                        err_type,
4673                    ))
4674                }
4675            })
4676    }
4677
4678    fn update_node(
4679        &self,
4680        param_node_id: uuid::Uuid,
4681        param_body: models::NodeUpdateRequest,
4682    ) -> Result<models::Node, ApiError> {
4683        let mut url = format!(
4684            "{}/v1/nodes/{node_id}",
4685            self.base_path,
4686            node_id = utf8_percent_encode(&param_node_id.to_string(), ID_ENCODE_SET)
4687        );
4688
4689        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4690
4691        let query_string_str = query_string.finish();
4692        if !query_string_str.is_empty() {
4693            url += "?";
4694            url += &query_string_str;
4695        }
4696
4697        let url = match Url::from_str(&url) {
4698            Ok(url) => url,
4699            Err(err) => {
4700                return Err(ApiError::new(
4701                    format!("Unable to build URL: {}", err),
4702                    SimpleErrorType::Permanent,
4703                ))
4704            }
4705        };
4706
4707        let mut request = self.hyper_client.request(Method::Patch, url);
4708        request = request.headers(self.headers.clone());
4709        let body = serde_json::to_string(&param_body)
4710            .expect("impossible to fail to serialize")
4711            .into_bytes();
4712        request = request.body(body.as_slice());
4713
4714        request = request.header(ContentType(mimetypes::requests::UPDATE_NODE.clone()));
4715
4716        request
4717            .send()
4718            .map_err(|e| {
4719                ApiError::new(
4720                    format!("No response received: {}", e),
4721                    SimpleErrorType::Permanent,
4722                )
4723            })
4724            .and_then(|mut response| match response.status.to_u16() {
4725                200 => {
4726                    let mut body = Vec::new();
4727                    response.read_to_end(&mut body).map_err(|e| {
4728                        ApiError::new(
4729                            format!("Failed to read response: {}", e),
4730                            SimpleErrorType::Temporary,
4731                        )
4732                    })?;
4733                    str::from_utf8(&body)
4734                        .map_err(|e| {
4735                            ApiError::new(
4736                                format!("Response was not valid UTF8: {}", e),
4737                                SimpleErrorType::Temporary,
4738                            )
4739                        })
4740                        .and_then(|body| {
4741                            serde_json::from_str::<models::Node>(body).map_err(|e| e.into())
4742                        })
4743                }
4744                code => {
4745                    let headers = response.headers.clone();
4746                    let mut body = Vec::new();
4747                    let result = response.read_to_end(&mut body);
4748                    let err_type = match response.status.is_server_error() {
4749                        false => SimpleErrorType::Permanent,
4750                        true => SimpleErrorType::Temporary,
4751                    };
4752                    Err(ApiError::new(
4753                        format!(
4754                            "Unexpected response code {}:\n{:?}\n\n{}",
4755                            code,
4756                            headers,
4757                            match result {
4758                                Ok(_) => match str::from_utf8(&body) {
4759                                    Ok(body) => Cow::from(body),
4760                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4761                                },
4762                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4763                            }
4764                        ),
4765                        err_type,
4766                    ))
4767                }
4768            })
4769    }
4770
4771    fn update_node_status(
4772        &self,
4773        param_body: models::NodeStatusRequest,
4774    ) -> Result<models::NodeStatusResponse, ApiError> {
4775        let mut url = format!("{}/v1/node/status", self.base_path);
4776
4777        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4778
4779        let query_string_str = query_string.finish();
4780        if !query_string_str.is_empty() {
4781            url += "?";
4782            url += &query_string_str;
4783        }
4784
4785        let url = match Url::from_str(&url) {
4786            Ok(url) => url,
4787            Err(err) => {
4788                return Err(ApiError::new(
4789                    format!("Unable to build URL: {}", err),
4790                    SimpleErrorType::Permanent,
4791                ))
4792            }
4793        };
4794
4795        let mut request = self.hyper_client.request(Method::Post, url);
4796        request = request.headers(self.headers.clone());
4797        let body = serde_json::to_string(&param_body)
4798            .expect("impossible to fail to serialize")
4799            .into_bytes();
4800        request = request.body(body.as_slice());
4801
4802        request = request.header(ContentType(mimetypes::requests::UPDATE_NODE_STATUS.clone()));
4803
4804        request
4805            .send()
4806            .map_err(|e| {
4807                ApiError::new(
4808                    format!("No response received: {}", e),
4809                    SimpleErrorType::Permanent,
4810                )
4811            })
4812            .and_then(|mut response| match response.status.to_u16() {
4813                200 => {
4814                    let mut body = Vec::new();
4815                    response.read_to_end(&mut body).map_err(|e| {
4816                        ApiError::new(
4817                            format!("Failed to read response: {}", e),
4818                            SimpleErrorType::Temporary,
4819                        )
4820                    })?;
4821                    str::from_utf8(&body)
4822                        .map_err(|e| {
4823                            ApiError::new(
4824                                format!("Response was not valid UTF8: {}", e),
4825                                SimpleErrorType::Temporary,
4826                            )
4827                        })
4828                        .and_then(|body| {
4829                            serde_json::from_str::<models::NodeStatusResponse>(body)
4830                                .map_err(|e| e.into())
4831                        })
4832                }
4833                code => {
4834                    let headers = response.headers.clone();
4835                    let mut body = Vec::new();
4836                    let result = response.read_to_end(&mut body);
4837                    let err_type = match response.status.is_server_error() {
4838                        false => SimpleErrorType::Permanent,
4839                        true => SimpleErrorType::Temporary,
4840                    };
4841                    Err(ApiError::new(
4842                        format!(
4843                            "Unexpected response code {}:\n{:?}\n\n{}",
4844                            code,
4845                            headers,
4846                            match result {
4847                                Ok(_) => match str::from_utf8(&body) {
4848                                    Ok(body) => Cow::from(body),
4849                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4850                                },
4851                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4852                            }
4853                        ),
4854                        err_type,
4855                    ))
4856                }
4857            })
4858    }
4859}
4860
4861impl RegistryApi for Client {
4862    type Error = ApiError;
4863
4864    fn create_registry(
4865        &self,
4866        param_registry_request: models::RegistryRequest,
4867    ) -> Result<models::Registry, ApiError> {
4868        let mut url = format!("{}/v1/registry", self.base_path);
4869
4870        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4871
4872        let query_string_str = query_string.finish();
4873        if !query_string_str.is_empty() {
4874            url += "?";
4875            url += &query_string_str;
4876        }
4877
4878        let url = match Url::from_str(&url) {
4879            Ok(url) => url,
4880            Err(err) => {
4881                return Err(ApiError::new(
4882                    format!("Unable to build URL: {}", err),
4883                    SimpleErrorType::Permanent,
4884                ))
4885            }
4886        };
4887
4888        let mut request = self.hyper_client.request(Method::Post, url);
4889        request = request.headers(self.headers.clone());
4890        // Body parameter
4891        let body = serde_json::to_string(&param_registry_request)
4892            .expect("impossible to fail to serialize")
4893            .into_bytes();
4894        request = request.body(body.as_slice());
4895
4896        request = request.header(ContentType(mimetypes::requests::CREATE_REGISTRY.clone()));
4897
4898        request
4899            .send()
4900            .map_err(|e| {
4901                ApiError::new(
4902                    format!("No response received: {}", e),
4903                    SimpleErrorType::Permanent,
4904                )
4905            })
4906            .and_then(|mut response| match response.status.to_u16() {
4907                200 => {
4908                    let mut body = Vec::new();
4909                    response.read_to_end(&mut body).map_err(|e| {
4910                        ApiError::new(
4911                            format!("Failed to read response: {}", e),
4912                            SimpleErrorType::Temporary,
4913                        )
4914                    })?;
4915                    str::from_utf8(&body)
4916                        .map_err(|e| {
4917                            ApiError::new(
4918                                format!("Response was not valid UTF8: {}", e),
4919                                SimpleErrorType::Temporary,
4920                            )
4921                        })
4922                        .and_then(|body| {
4923                            serde_json::from_str::<models::Registry>(body).map_err(|e| e.into())
4924                        })
4925                }
4926                code => {
4927                    let headers = response.headers.clone();
4928                    let mut body = Vec::new();
4929                    let result = response.read_to_end(&mut body);
4930                    let err_type = match response.status.is_server_error() {
4931                        false => SimpleErrorType::Permanent,
4932                        true => SimpleErrorType::Temporary,
4933                    };
4934                    Err(ApiError::new(
4935                        format!(
4936                            "Unexpected response code {}:\n{:?}\n\n{}",
4937                            code,
4938                            headers,
4939                            match result {
4940                                Ok(_) => match str::from_utf8(&body) {
4941                                    Ok(body) => Cow::from(body),
4942                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
4943                                },
4944                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
4945                            }
4946                        ),
4947                        err_type,
4948                    ))
4949                }
4950            })
4951    }
4952
4953    fn delete_registry(&self, param_registry_id: uuid::Uuid) -> Result<(), ApiError> {
4954        let mut url = format!(
4955            "{}/v1/registry/{registry_id}",
4956            self.base_path,
4957            registry_id = utf8_percent_encode(&param_registry_id.to_string(), ID_ENCODE_SET)
4958        );
4959
4960        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
4961
4962        let query_string_str = query_string.finish();
4963        if !query_string_str.is_empty() {
4964            url += "?";
4965            url += &query_string_str;
4966        }
4967
4968        let url = match Url::from_str(&url) {
4969            Ok(url) => url,
4970            Err(err) => {
4971                return Err(ApiError::new(
4972                    format!("Unable to build URL: {}", err),
4973                    SimpleErrorType::Permanent,
4974                ))
4975            }
4976        };
4977
4978        let mut request = self.hyper_client.request(Method::Delete, url);
4979        request = request.headers(self.headers.clone());
4980
4981        request
4982            .send()
4983            .map_err(|e| {
4984                ApiError::new(
4985                    format!("No response received: {}", e),
4986                    SimpleErrorType::Permanent,
4987                )
4988            })
4989            .and_then(|mut response| match response.status.to_u16() {
4990                204 => {
4991                    let mut body = Vec::new();
4992                    response.read_to_end(&mut body).map_err(|e| {
4993                        ApiError::new(
4994                            format!("Failed to read response: {}", e),
4995                            SimpleErrorType::Temporary,
4996                        )
4997                    })?;
4998
4999                    Ok(())
5000                }
5001                code => {
5002                    let headers = response.headers.clone();
5003                    let mut body = Vec::new();
5004                    let result = response.read_to_end(&mut body);
5005                    let err_type = match response.status.is_server_error() {
5006                        false => SimpleErrorType::Permanent,
5007                        true => SimpleErrorType::Temporary,
5008                    };
5009                    Err(ApiError::new(
5010                        format!(
5011                            "Unexpected response code {}:\n{:?}\n\n{}",
5012                            code,
5013                            headers,
5014                            match result {
5015                                Ok(_) => match str::from_utf8(&body) {
5016                                    Ok(body) => Cow::from(body),
5017                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5018                                },
5019                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5020                            }
5021                        ),
5022                        err_type,
5023                    ))
5024                }
5025            })
5026    }
5027
5028    fn get_all_registries(&self) -> Result<Vec<models::Registry>, ApiError> {
5029        let mut url = format!("{}/v1/registry", self.base_path);
5030
5031        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5032
5033        let query_string_str = query_string.finish();
5034        if !query_string_str.is_empty() {
5035            url += "?";
5036            url += &query_string_str;
5037        }
5038
5039        let url = match Url::from_str(&url) {
5040            Ok(url) => url,
5041            Err(err) => {
5042                return Err(ApiError::new(
5043                    format!("Unable to build URL: {}", err),
5044                    SimpleErrorType::Permanent,
5045                ))
5046            }
5047        };
5048
5049        let mut request = self.hyper_client.request(Method::Get, url);
5050        request = request.headers(self.headers.clone());
5051
5052        request
5053            .send()
5054            .map_err(|e| {
5055                ApiError::new(
5056                    format!("No response received: {}", e),
5057                    SimpleErrorType::Permanent,
5058                )
5059            })
5060            .and_then(|mut response| match response.status.to_u16() {
5061                200 => {
5062                    let mut body = Vec::new();
5063                    response.read_to_end(&mut body).map_err(|e| {
5064                        ApiError::new(
5065                            format!("Failed to read response: {}", e),
5066                            SimpleErrorType::Temporary,
5067                        )
5068                    })?;
5069                    str::from_utf8(&body)
5070                        .map_err(|e| {
5071                            ApiError::new(
5072                                format!("Response was not valid UTF8: {}", e),
5073                                SimpleErrorType::Temporary,
5074                            )
5075                        })
5076                        .and_then(|body| {
5077                            serde_json::from_str::<Vec<models::Registry>>(body)
5078                                .map_err(|e| e.into())
5079                        })
5080                }
5081                code => {
5082                    let headers = response.headers.clone();
5083                    let mut body = Vec::new();
5084                    let result = response.read_to_end(&mut body);
5085                    let err_type = match response.status.is_server_error() {
5086                        false => SimpleErrorType::Permanent,
5087                        true => SimpleErrorType::Temporary,
5088                    };
5089                    Err(ApiError::new(
5090                        format!(
5091                            "Unexpected response code {}:\n{:?}\n\n{}",
5092                            code,
5093                            headers,
5094                            match result {
5095                                Ok(_) => match str::from_utf8(&body) {
5096                                    Ok(body) => Cow::from(body),
5097                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5098                                },
5099                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5100                            }
5101                        ),
5102                        err_type,
5103                    ))
5104                }
5105            })
5106    }
5107
5108    fn get_registry(&self, param_registry_id: uuid::Uuid) -> Result<models::Registry, ApiError> {
5109        let mut url = format!(
5110            "{}/v1/registry/{registry_id}",
5111            self.base_path,
5112            registry_id = utf8_percent_encode(&param_registry_id.to_string(), ID_ENCODE_SET)
5113        );
5114
5115        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5116
5117        let query_string_str = query_string.finish();
5118        if !query_string_str.is_empty() {
5119            url += "?";
5120            url += &query_string_str;
5121        }
5122
5123        let url = match Url::from_str(&url) {
5124            Ok(url) => url,
5125            Err(err) => {
5126                return Err(ApiError::new(
5127                    format!("Unable to build URL: {}", err),
5128                    SimpleErrorType::Permanent,
5129                ))
5130            }
5131        };
5132
5133        let mut request = self.hyper_client.request(Method::Get, url);
5134        request = request.headers(self.headers.clone());
5135
5136        request
5137            .send()
5138            .map_err(|e| {
5139                ApiError::new(
5140                    format!("No response received: {}", e),
5141                    SimpleErrorType::Permanent,
5142                )
5143            })
5144            .and_then(|mut response| match response.status.to_u16() {
5145                200 => {
5146                    let mut body = Vec::new();
5147                    response.read_to_end(&mut body).map_err(|e| {
5148                        ApiError::new(
5149                            format!("Failed to read response: {}", e),
5150                            SimpleErrorType::Temporary,
5151                        )
5152                    })?;
5153                    str::from_utf8(&body)
5154                        .map_err(|e| {
5155                            ApiError::new(
5156                                format!("Response was not valid UTF8: {}", e),
5157                                SimpleErrorType::Temporary,
5158                            )
5159                        })
5160                        .and_then(|body| {
5161                            serde_json::from_str::<models::Registry>(body).map_err(|e| e.into())
5162                        })
5163                }
5164                code => {
5165                    let headers = response.headers.clone();
5166                    let mut body = Vec::new();
5167                    let result = response.read_to_end(&mut body);
5168                    let err_type = match response.status.is_server_error() {
5169                        false => SimpleErrorType::Permanent,
5170                        true => SimpleErrorType::Temporary,
5171                    };
5172                    Err(ApiError::new(
5173                        format!(
5174                            "Unexpected response code {}:\n{:?}\n\n{}",
5175                            code,
5176                            headers,
5177                            match result {
5178                                Ok(_) => match str::from_utf8(&body) {
5179                                    Ok(body) => Cow::from(body),
5180                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5181                                },
5182                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5183                            }
5184                        ),
5185                        err_type,
5186                    ))
5187                }
5188            })
5189    }
5190
5191    fn get_registry_for_app(
5192        &self,
5193        param_app_id: uuid::Uuid,
5194    ) -> Result<models::AppRegistryResponse, ApiError> {
5195        let mut url = format!(
5196            "{}/v1/registry/app/{app_id}",
5197            self.base_path,
5198            app_id = utf8_percent_encode(&param_app_id.to_string(), ID_ENCODE_SET)
5199        );
5200
5201        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5202
5203        let query_string_str = query_string.finish();
5204        if !query_string_str.is_empty() {
5205            url += "?";
5206            url += &query_string_str;
5207        }
5208
5209        let url = match Url::from_str(&url) {
5210            Ok(url) => url,
5211            Err(err) => {
5212                return Err(ApiError::new(
5213                    format!("Unable to build URL: {}", err),
5214                    SimpleErrorType::Permanent,
5215                ))
5216            }
5217        };
5218
5219        let mut request = self.hyper_client.request(Method::Get, url);
5220        request = request.headers(self.headers.clone());
5221
5222        request
5223            .send()
5224            .map_err(|e| {
5225                ApiError::new(
5226                    format!("No response received: {}", e),
5227                    SimpleErrorType::Permanent,
5228                )
5229            })
5230            .and_then(|mut response| match response.status.to_u16() {
5231                200 => {
5232                    let mut body = Vec::new();
5233                    response.read_to_end(&mut body).map_err(|e| {
5234                        ApiError::new(
5235                            format!("Failed to read response: {}", e),
5236                            SimpleErrorType::Temporary,
5237                        )
5238                    })?;
5239                    str::from_utf8(&body)
5240                        .map_err(|e| {
5241                            ApiError::new(
5242                                format!("Response was not valid UTF8: {}", e),
5243                                SimpleErrorType::Temporary,
5244                            )
5245                        })
5246                        .and_then(|body| {
5247                            serde_json::from_str::<models::AppRegistryResponse>(body)
5248                                .map_err(|e| e.into())
5249                        })
5250                }
5251                code => {
5252                    let headers = response.headers.clone();
5253                    let mut body = Vec::new();
5254                    let result = response.read_to_end(&mut body);
5255                    let err_type = match response.status.is_server_error() {
5256                        false => SimpleErrorType::Permanent,
5257                        true => SimpleErrorType::Temporary,
5258                    };
5259                    Err(ApiError::new(
5260                        format!(
5261                            "Unexpected response code {}:\n{:?}\n\n{}",
5262                            code,
5263                            headers,
5264                            match result {
5265                                Ok(_) => match str::from_utf8(&body) {
5266                                    Ok(body) => Cow::from(body),
5267                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5268                                },
5269                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5270                            }
5271                        ),
5272                        err_type,
5273                    ))
5274                }
5275            })
5276    }
5277
5278    fn get_registry_for_image(
5279        &self,
5280        param_image_name: String,
5281    ) -> Result<models::ImageRegistryResponse, ApiError> {
5282        let mut url = format!("{}/v1/image/registry", self.base_path);
5283
5284        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5285        query_string.append_pair("image_name", &param_image_name.to_string());
5286
5287        let query_string_str = query_string.finish();
5288        if !query_string_str.is_empty() {
5289            url += "?";
5290            url += &query_string_str;
5291        }
5292
5293        let url = match Url::from_str(&url) {
5294            Ok(url) => url,
5295            Err(err) => {
5296                return Err(ApiError::new(
5297                    format!("Unable to build URL: {}", err),
5298                    SimpleErrorType::Permanent,
5299                ))
5300            }
5301        };
5302
5303        let mut request = self.hyper_client.request(Method::Get, url);
5304        request = request.headers(self.headers.clone());
5305
5306        request
5307            .send()
5308            .map_err(|e| {
5309                ApiError::new(
5310                    format!("No response received: {}", e),
5311                    SimpleErrorType::Permanent,
5312                )
5313            })
5314            .and_then(|mut response| match response.status.to_u16() {
5315                200 => {
5316                    let mut body = Vec::new();
5317                    response.read_to_end(&mut body).map_err(|e| {
5318                        ApiError::new(
5319                            format!("Failed to read response: {}", e),
5320                            SimpleErrorType::Temporary,
5321                        )
5322                    })?;
5323                    str::from_utf8(&body)
5324                        .map_err(|e| {
5325                            ApiError::new(
5326                                format!("Response was not valid UTF8: {}", e),
5327                                SimpleErrorType::Temporary,
5328                            )
5329                        })
5330                        .and_then(|body| {
5331                            serde_json::from_str::<models::ImageRegistryResponse>(body)
5332                                .map_err(|e| e.into())
5333                        })
5334                }
5335                code => {
5336                    let headers = response.headers.clone();
5337                    let mut body = Vec::new();
5338                    let result = response.read_to_end(&mut body);
5339                    let err_type = match response.status.is_server_error() {
5340                        false => SimpleErrorType::Permanent,
5341                        true => SimpleErrorType::Temporary,
5342                    };
5343                    Err(ApiError::new(
5344                        format!(
5345                            "Unexpected response code {}:\n{:?}\n\n{}",
5346                            code,
5347                            headers,
5348                            match result {
5349                                Ok(_) => match str::from_utf8(&body) {
5350                                    Ok(body) => Cow::from(body),
5351                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5352                                },
5353                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5354                            }
5355                        ),
5356                        err_type,
5357                    ))
5358                }
5359            })
5360    }
5361
5362    fn update_registry(
5363        &self,
5364        param_registry_id: uuid::Uuid,
5365        param_body: models::UpdateRegistryRequest,
5366    ) -> Result<models::Registry, ApiError> {
5367        let mut url = format!(
5368            "{}/v1/registry/{registry_id}",
5369            self.base_path,
5370            registry_id = utf8_percent_encode(&param_registry_id.to_string(), ID_ENCODE_SET)
5371        );
5372
5373        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5374
5375        let query_string_str = query_string.finish();
5376        if !query_string_str.is_empty() {
5377            url += "?";
5378            url += &query_string_str;
5379        }
5380
5381        let url = match Url::from_str(&url) {
5382            Ok(url) => url,
5383            Err(err) => {
5384                return Err(ApiError::new(
5385                    format!("Unable to build URL: {}", err),
5386                    SimpleErrorType::Permanent,
5387                ))
5388            }
5389        };
5390
5391        let mut request = self.hyper_client.request(Method::Patch, url);
5392        request = request.headers(self.headers.clone());
5393        let body = serde_json::to_string(&param_body)
5394            .expect("impossible to fail to serialize")
5395            .into_bytes();
5396        request = request.body(body.as_slice());
5397
5398        request = request.header(ContentType(mimetypes::requests::UPDATE_REGISTRY.clone()));
5399
5400        request
5401            .send()
5402            .map_err(|e| {
5403                ApiError::new(
5404                    format!("No response received: {}", e),
5405                    SimpleErrorType::Permanent,
5406                )
5407            })
5408            .and_then(|mut response| match response.status.to_u16() {
5409                200 => {
5410                    let mut body = Vec::new();
5411                    response.read_to_end(&mut body).map_err(|e| {
5412                        ApiError::new(
5413                            format!("Failed to read response: {}", e),
5414                            SimpleErrorType::Temporary,
5415                        )
5416                    })?;
5417                    str::from_utf8(&body)
5418                        .map_err(|e| {
5419                            ApiError::new(
5420                                format!("Response was not valid UTF8: {}", e),
5421                                SimpleErrorType::Temporary,
5422                            )
5423                        })
5424                        .and_then(|body| {
5425                            serde_json::from_str::<models::Registry>(body).map_err(|e| e.into())
5426                        })
5427                }
5428                code => {
5429                    let headers = response.headers.clone();
5430                    let mut body = Vec::new();
5431                    let result = response.read_to_end(&mut body);
5432                    let err_type = match response.status.is_server_error() {
5433                        false => SimpleErrorType::Permanent,
5434                        true => SimpleErrorType::Temporary,
5435                    };
5436                    Err(ApiError::new(
5437                        format!(
5438                            "Unexpected response code {}:\n{:?}\n\n{}",
5439                            code,
5440                            headers,
5441                            match result {
5442                                Ok(_) => match str::from_utf8(&body) {
5443                                    Ok(body) => Cow::from(body),
5444                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5445                                },
5446                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5447                            }
5448                        ),
5449                        err_type,
5450                    ))
5451                }
5452            })
5453    }
5454}
5455
5456impl SystemApi for Client {
5457    type Error = ApiError;
5458
5459    fn get_manager_version(&self) -> Result<models::VersionResponse, ApiError> {
5460        let mut url = format!("{}/v1/sys/version", self.base_path);
5461
5462        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5463
5464        let query_string_str = query_string.finish();
5465        if !query_string_str.is_empty() {
5466            url += "?";
5467            url += &query_string_str;
5468        }
5469
5470        let url = match Url::from_str(&url) {
5471            Ok(url) => url,
5472            Err(err) => {
5473                return Err(ApiError::new(
5474                    format!("Unable to build URL: {}", err),
5475                    SimpleErrorType::Permanent,
5476                ))
5477            }
5478        };
5479
5480        let mut request = self.hyper_client.request(Method::Get, url);
5481        request = request.headers(self.headers.clone());
5482
5483        request
5484            .send()
5485            .map_err(|e| {
5486                ApiError::new(
5487                    format!("No response received: {}", e),
5488                    SimpleErrorType::Permanent,
5489                )
5490            })
5491            .and_then(|mut response| match response.status.to_u16() {
5492                200 => {
5493                    let mut body = Vec::new();
5494                    response.read_to_end(&mut body).map_err(|e| {
5495                        ApiError::new(
5496                            format!("Failed to read response: {}", e),
5497                            SimpleErrorType::Temporary,
5498                        )
5499                    })?;
5500                    str::from_utf8(&body)
5501                        .map_err(|e| {
5502                            ApiError::new(
5503                                format!("Response was not valid UTF8: {}", e),
5504                                SimpleErrorType::Temporary,
5505                            )
5506                        })
5507                        .and_then(|body| {
5508                            serde_json::from_str::<models::VersionResponse>(body)
5509                                .map_err(|e| e.into())
5510                        })
5511                }
5512                code => {
5513                    let headers = response.headers.clone();
5514                    let mut body = Vec::new();
5515                    let result = response.read_to_end(&mut body);
5516                    let err_type = match response.status.is_server_error() {
5517                        false => SimpleErrorType::Permanent,
5518                        true => SimpleErrorType::Temporary,
5519                    };
5520                    Err(ApiError::new(
5521                        format!(
5522                            "Unexpected response code {}:\n{:?}\n\n{}",
5523                            code,
5524                            headers,
5525                            match result {
5526                                Ok(_) => match str::from_utf8(&body) {
5527                                    Ok(body) => Cow::from(body),
5528                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5529                                },
5530                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5531                            }
5532                        ),
5533                        err_type,
5534                    ))
5535                }
5536            })
5537    }
5538}
5539
5540impl TaskApi for Client {
5541    type Error = ApiError;
5542
5543    fn get_all_tasks(
5544        &self,
5545        param_task_type: Option<String>,
5546        param_status: Option<String>,
5547        param_requester: Option<String>,
5548        param_approver: Option<String>,
5549        param_all_search: Option<String>,
5550        param_limit: Option<i32>,
5551        param_offset: Option<i32>,
5552        param_sort_by: Option<String>,
5553        param_base_filters: Option<String>,
5554    ) -> Result<models::GetAllTasksResponse, ApiError> {
5555        let mut url = format!("{}/v1/tasks", self.base_path);
5556
5557        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5558
5559        if let Some(task_type) = param_task_type {
5560            query_string.append_pair("task_type", &task_type.to_string());
5561        }
5562        if let Some(status) = param_status {
5563            query_string.append_pair("status", &status.to_string());
5564        }
5565        if let Some(requester) = param_requester {
5566            query_string.append_pair("requester", &requester.to_string());
5567        }
5568        if let Some(approver) = param_approver {
5569            query_string.append_pair("approver", &approver.to_string());
5570        }
5571        if let Some(all_search) = param_all_search {
5572            query_string.append_pair("all_search", &all_search.to_string());
5573        }
5574        if let Some(limit) = param_limit {
5575            query_string.append_pair("limit", &limit.to_string());
5576        }
5577        if let Some(offset) = param_offset {
5578            query_string.append_pair("offset", &offset.to_string());
5579        }
5580        if let Some(sort_by) = param_sort_by {
5581            query_string.append_pair("sort_by", &sort_by.to_string());
5582        }
5583        if let Some(base_filters) = param_base_filters {
5584            query_string.append_pair("base_filters", &base_filters.to_string());
5585        }
5586        let query_string_str = query_string.finish();
5587        if !query_string_str.is_empty() {
5588            url += "?";
5589            url += &query_string_str;
5590        }
5591
5592        let url = match Url::from_str(&url) {
5593            Ok(url) => url,
5594            Err(err) => {
5595                return Err(ApiError::new(
5596                    format!("Unable to build URL: {}", err),
5597                    SimpleErrorType::Permanent,
5598                ))
5599            }
5600        };
5601
5602        let mut request = self.hyper_client.request(Method::Get, url);
5603        request = request.headers(self.headers.clone());
5604
5605        request
5606            .send()
5607            .map_err(|e| {
5608                ApiError::new(
5609                    format!("No response received: {}", e),
5610                    SimpleErrorType::Permanent,
5611                )
5612            })
5613            .and_then(|mut response| match response.status.to_u16() {
5614                200 => {
5615                    let mut body = Vec::new();
5616                    response.read_to_end(&mut body).map_err(|e| {
5617                        ApiError::new(
5618                            format!("Failed to read response: {}", e),
5619                            SimpleErrorType::Temporary,
5620                        )
5621                    })?;
5622                    str::from_utf8(&body)
5623                        .map_err(|e| {
5624                            ApiError::new(
5625                                format!("Response was not valid UTF8: {}", e),
5626                                SimpleErrorType::Temporary,
5627                            )
5628                        })
5629                        .and_then(|body| {
5630                            serde_json::from_str::<models::GetAllTasksResponse>(body)
5631                                .map_err(|e| e.into())
5632                        })
5633                }
5634                code => {
5635                    let headers = response.headers.clone();
5636                    let mut body = Vec::new();
5637                    let result = response.read_to_end(&mut body);
5638                    let err_type = match response.status.is_server_error() {
5639                        false => SimpleErrorType::Permanent,
5640                        true => SimpleErrorType::Temporary,
5641                    };
5642                    Err(ApiError::new(
5643                        format!(
5644                            "Unexpected response code {}:\n{:?}\n\n{}",
5645                            code,
5646                            headers,
5647                            match result {
5648                                Ok(_) => match str::from_utf8(&body) {
5649                                    Ok(body) => Cow::from(body),
5650                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5651                                },
5652                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5653                            }
5654                        ),
5655                        err_type,
5656                    ))
5657                }
5658            })
5659    }
5660
5661    fn get_task(&self, param_task_id: uuid::Uuid) -> Result<models::Task, ApiError> {
5662        let mut url = format!(
5663            "{}/v1/tasks/{task_id}",
5664            self.base_path,
5665            task_id = utf8_percent_encode(&param_task_id.to_string(), ID_ENCODE_SET)
5666        );
5667
5668        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5669
5670        let query_string_str = query_string.finish();
5671        if !query_string_str.is_empty() {
5672            url += "?";
5673            url += &query_string_str;
5674        }
5675
5676        let url = match Url::from_str(&url) {
5677            Ok(url) => url,
5678            Err(err) => {
5679                return Err(ApiError::new(
5680                    format!("Unable to build URL: {}", err),
5681                    SimpleErrorType::Permanent,
5682                ))
5683            }
5684        };
5685
5686        let mut request = self.hyper_client.request(Method::Get, url);
5687        request = request.headers(self.headers.clone());
5688
5689        request
5690            .send()
5691            .map_err(|e| {
5692                ApiError::new(
5693                    format!("No response received: {}", e),
5694                    SimpleErrorType::Permanent,
5695                )
5696            })
5697            .and_then(|mut response| match response.status.to_u16() {
5698                200 => {
5699                    let mut body = Vec::new();
5700                    response.read_to_end(&mut body).map_err(|e| {
5701                        ApiError::new(
5702                            format!("Failed to read response: {}", e),
5703                            SimpleErrorType::Temporary,
5704                        )
5705                    })?;
5706                    str::from_utf8(&body)
5707                        .map_err(|e| {
5708                            ApiError::new(
5709                                format!("Response was not valid UTF8: {}", e),
5710                                SimpleErrorType::Temporary,
5711                            )
5712                        })
5713                        .and_then(|body| {
5714                            serde_json::from_str::<models::Task>(body).map_err(|e| e.into())
5715                        })
5716                }
5717                code => {
5718                    let headers = response.headers.clone();
5719                    let mut body = Vec::new();
5720                    let result = response.read_to_end(&mut body);
5721                    let err_type = match response.status.is_server_error() {
5722                        false => SimpleErrorType::Permanent,
5723                        true => SimpleErrorType::Temporary,
5724                    };
5725                    Err(ApiError::new(
5726                        format!(
5727                            "Unexpected response code {}:\n{:?}\n\n{}",
5728                            code,
5729                            headers,
5730                            match result {
5731                                Ok(_) => match str::from_utf8(&body) {
5732                                    Ok(body) => Cow::from(body),
5733                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5734                                },
5735                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5736                            }
5737                        ),
5738                        err_type,
5739                    ))
5740                }
5741            })
5742    }
5743
5744    fn get_task_status(&self, param_task_id: uuid::Uuid) -> Result<models::TaskResult, ApiError> {
5745        let mut url = format!(
5746            "{}/v1/tasks/status/{task_id}",
5747            self.base_path,
5748            task_id = utf8_percent_encode(&param_task_id.to_string(), ID_ENCODE_SET)
5749        );
5750
5751        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5752
5753        let query_string_str = query_string.finish();
5754        if !query_string_str.is_empty() {
5755            url += "?";
5756            url += &query_string_str;
5757        }
5758
5759        let url = match Url::from_str(&url) {
5760            Ok(url) => url,
5761            Err(err) => {
5762                return Err(ApiError::new(
5763                    format!("Unable to build URL: {}", err),
5764                    SimpleErrorType::Permanent,
5765                ))
5766            }
5767        };
5768
5769        let mut request = self.hyper_client.request(Method::Get, url);
5770        request = request.headers(self.headers.clone());
5771
5772        request
5773            .send()
5774            .map_err(|e| {
5775                ApiError::new(
5776                    format!("No response received: {}", e),
5777                    SimpleErrorType::Permanent,
5778                )
5779            })
5780            .and_then(|mut response| match response.status.to_u16() {
5781                200 => {
5782                    let mut body = Vec::new();
5783                    response.read_to_end(&mut body).map_err(|e| {
5784                        ApiError::new(
5785                            format!("Failed to read response: {}", e),
5786                            SimpleErrorType::Temporary,
5787                        )
5788                    })?;
5789                    str::from_utf8(&body)
5790                        .map_err(|e| {
5791                            ApiError::new(
5792                                format!("Response was not valid UTF8: {}", e),
5793                                SimpleErrorType::Temporary,
5794                            )
5795                        })
5796                        .and_then(|body| {
5797                            serde_json::from_str::<models::TaskResult>(body).map_err(|e| e.into())
5798                        })
5799                }
5800                code => {
5801                    let headers = response.headers.clone();
5802                    let mut body = Vec::new();
5803                    let result = response.read_to_end(&mut body);
5804                    let err_type = match response.status.is_server_error() {
5805                        false => SimpleErrorType::Permanent,
5806                        true => SimpleErrorType::Temporary,
5807                    };
5808                    Err(ApiError::new(
5809                        format!(
5810                            "Unexpected response code {}:\n{:?}\n\n{}",
5811                            code,
5812                            headers,
5813                            match result {
5814                                Ok(_) => match str::from_utf8(&body) {
5815                                    Ok(body) => Cow::from(body),
5816                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5817                                },
5818                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5819                            }
5820                        ),
5821                        err_type,
5822                    ))
5823                }
5824            })
5825    }
5826
5827    fn update_task(
5828        &self,
5829        param_task_id: uuid::Uuid,
5830        param_body: models::TaskUpdateRequest,
5831    ) -> Result<models::TaskResult, ApiError> {
5832        let mut url = format!(
5833            "{}/v1/tasks/{task_id}",
5834            self.base_path,
5835            task_id = utf8_percent_encode(&param_task_id.to_string(), ID_ENCODE_SET)
5836        );
5837
5838        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5839
5840        let query_string_str = query_string.finish();
5841        if !query_string_str.is_empty() {
5842            url += "?";
5843            url += &query_string_str;
5844        }
5845
5846        let url = match Url::from_str(&url) {
5847            Ok(url) => url,
5848            Err(err) => {
5849                return Err(ApiError::new(
5850                    format!("Unable to build URL: {}", err),
5851                    SimpleErrorType::Permanent,
5852                ))
5853            }
5854        };
5855
5856        let mut request = self.hyper_client.request(Method::Patch, url);
5857        request = request.headers(self.headers.clone());
5858        let body = serde_json::to_string(&param_body)
5859            .expect("impossible to fail to serialize")
5860            .into_bytes();
5861        request = request.body(body.as_slice());
5862
5863        request = request.header(ContentType(mimetypes::requests::UPDATE_TASK.clone()));
5864
5865        request
5866            .send()
5867            .map_err(|e| {
5868                ApiError::new(
5869                    format!("No response received: {}", e),
5870                    SimpleErrorType::Permanent,
5871                )
5872            })
5873            .and_then(|mut response| match response.status.to_u16() {
5874                200 => {
5875                    let mut body = Vec::new();
5876                    response.read_to_end(&mut body).map_err(|e| {
5877                        ApiError::new(
5878                            format!("Failed to read response: {}", e),
5879                            SimpleErrorType::Temporary,
5880                        )
5881                    })?;
5882                    str::from_utf8(&body)
5883                        .map_err(|e| {
5884                            ApiError::new(
5885                                format!("Response was not valid UTF8: {}", e),
5886                                SimpleErrorType::Temporary,
5887                            )
5888                        })
5889                        .and_then(|body| {
5890                            serde_json::from_str::<models::TaskResult>(body).map_err(|e| e.into())
5891                        })
5892                }
5893                code => {
5894                    let headers = response.headers.clone();
5895                    let mut body = Vec::new();
5896                    let result = response.read_to_end(&mut body);
5897                    let err_type = match response.status.is_server_error() {
5898                        false => SimpleErrorType::Permanent,
5899                        true => SimpleErrorType::Temporary,
5900                    };
5901                    Err(ApiError::new(
5902                        format!(
5903                            "Unexpected response code {}:\n{:?}\n\n{}",
5904                            code,
5905                            headers,
5906                            match result {
5907                                Ok(_) => match str::from_utf8(&body) {
5908                                    Ok(body) => Cow::from(body),
5909                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
5910                                },
5911                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
5912                            }
5913                        ),
5914                        err_type,
5915                    ))
5916                }
5917            })
5918    }
5919}
5920
5921impl ToolsApi for Client {
5922    type Error = ApiError;
5923
5924    fn convert_app(
5925        &self,
5926        param_body: models::ConversionRequest,
5927    ) -> Result<models::ConversionResponse, ApiError> {
5928        let mut url = format!("{}/v1/tools/converter/convert-app", self.base_path);
5929
5930        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
5931
5932        let query_string_str = query_string.finish();
5933        if !query_string_str.is_empty() {
5934            url += "?";
5935            url += &query_string_str;
5936        }
5937
5938        let url = match Url::from_str(&url) {
5939            Ok(url) => url,
5940            Err(err) => {
5941                return Err(ApiError::new(
5942                    format!("Unable to build URL: {}", err),
5943                    SimpleErrorType::Permanent,
5944                ))
5945            }
5946        };
5947
5948        let mut request = self.hyper_client.request(Method::Post, url);
5949        request = request.headers(self.headers.clone());
5950        // Body parameter
5951        let body = serde_json::to_string(&param_body)
5952            .expect("impossible to fail to serialize")
5953            .into_bytes();
5954        request = request.body(body.as_slice());
5955
5956        request = request.header(ContentType(mimetypes::requests::CONVERT_APP.clone()));
5957
5958        request
5959            .send()
5960            .map_err(|e| {
5961                ApiError::new(
5962                    format!("No response received: {}", e),
5963                    SimpleErrorType::Permanent,
5964                )
5965            })
5966            .and_then(|mut response| match response.status.to_u16() {
5967                200 => {
5968                    let mut body = Vec::new();
5969                    response.read_to_end(&mut body).map_err(|e| {
5970                        ApiError::new(
5971                            format!("Failed to read response: {}", e),
5972                            SimpleErrorType::Temporary,
5973                        )
5974                    })?;
5975                    str::from_utf8(&body)
5976                        .map_err(|e| {
5977                            ApiError::new(
5978                                format!("Response was not valid UTF8: {}", e),
5979                                SimpleErrorType::Temporary,
5980                            )
5981                        })
5982                        .and_then(|body| {
5983                            serde_json::from_str::<models::ConversionResponse>(body)
5984                                .map_err(|e| e.into())
5985                        })
5986                }
5987                code => {
5988                    let headers = response.headers.clone();
5989                    let mut body = Vec::new();
5990                    let result = response.read_to_end(&mut body);
5991                    let err_type = match response.status.is_server_error() {
5992                        false => SimpleErrorType::Permanent,
5993                        true => SimpleErrorType::Temporary,
5994                    };
5995                    Err(ApiError::new(
5996                        format!(
5997                            "Unexpected response code {}:\n{:?}\n\n{}",
5998                            code,
5999                            headers,
6000                            match result {
6001                                Ok(_) => match str::from_utf8(&body) {
6002                                    Ok(body) => Cow::from(body),
6003                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6004                                },
6005                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6006                            }
6007                        ),
6008                        err_type,
6009                    ))
6010                }
6011            })
6012    }
6013}
6014
6015impl UsersApi for Client {
6016    type Error = ApiError;
6017
6018    fn accept_terms_and_conditions(&self) -> Result<(), ApiError> {
6019        let mut url = format!("{}/v1/users/terms_and_conditions", self.base_path);
6020
6021        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6022
6023        let query_string_str = query_string.finish();
6024        if !query_string_str.is_empty() {
6025            url += "?";
6026            url += &query_string_str;
6027        }
6028
6029        let url = match Url::from_str(&url) {
6030            Ok(url) => url,
6031            Err(err) => {
6032                return Err(ApiError::new(
6033                    format!("Unable to build URL: {}", err),
6034                    SimpleErrorType::Permanent,
6035                ))
6036            }
6037        };
6038
6039        let mut request = self.hyper_client.request(Method::Patch, url);
6040        request = request.headers(self.headers.clone());
6041
6042        request
6043            .send()
6044            .map_err(|e| {
6045                ApiError::new(
6046                    format!("No response received: {}", e),
6047                    SimpleErrorType::Permanent,
6048                )
6049            })
6050            .and_then(|mut response| match response.status.to_u16() {
6051                204 => {
6052                    let mut body = Vec::new();
6053                    response.read_to_end(&mut body).map_err(|e| {
6054                        ApiError::new(
6055                            format!("Failed to read response: {}", e),
6056                            SimpleErrorType::Temporary,
6057                        )
6058                    })?;
6059
6060                    Ok(())
6061                }
6062                code => {
6063                    let headers = response.headers.clone();
6064                    let mut body = Vec::new();
6065                    let result = response.read_to_end(&mut body);
6066                    let err_type = match response.status.is_server_error() {
6067                        false => SimpleErrorType::Permanent,
6068                        true => SimpleErrorType::Temporary,
6069                    };
6070                    Err(ApiError::new(
6071                        format!(
6072                            "Unexpected response code {}:\n{:?}\n\n{}",
6073                            code,
6074                            headers,
6075                            match result {
6076                                Ok(_) => match str::from_utf8(&body) {
6077                                    Ok(body) => Cow::from(body),
6078                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6079                                },
6080                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6081                            }
6082                        ),
6083                        err_type,
6084                    ))
6085                }
6086            })
6087    }
6088
6089    fn change_password(&self, param_body: models::PasswordChangeRequest) -> Result<(), ApiError> {
6090        let mut url = format!("{}/v1/users/change_password", self.base_path);
6091
6092        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6093
6094        let query_string_str = query_string.finish();
6095        if !query_string_str.is_empty() {
6096            url += "?";
6097            url += &query_string_str;
6098        }
6099
6100        let url = match Url::from_str(&url) {
6101            Ok(url) => url,
6102            Err(err) => {
6103                return Err(ApiError::new(
6104                    format!("Unable to build URL: {}", err),
6105                    SimpleErrorType::Permanent,
6106                ))
6107            }
6108        };
6109
6110        let mut request = self.hyper_client.request(Method::Post, url);
6111        request = request.headers(self.headers.clone());
6112        let body = serde_json::to_string(&param_body)
6113            .expect("impossible to fail to serialize")
6114            .into_bytes();
6115        request = request.body(body.as_slice());
6116
6117        request = request.header(ContentType(mimetypes::requests::CHANGE_PASSWORD.clone()));
6118
6119        request
6120            .send()
6121            .map_err(|e| {
6122                ApiError::new(
6123                    format!("No response received: {}", e),
6124                    SimpleErrorType::Permanent,
6125                )
6126            })
6127            .and_then(|mut response| match response.status.to_u16() {
6128                204 => {
6129                    let mut body = Vec::new();
6130                    response.read_to_end(&mut body).map_err(|e| {
6131                        ApiError::new(
6132                            format!("Failed to read response: {}", e),
6133                            SimpleErrorType::Temporary,
6134                        )
6135                    })?;
6136
6137                    Ok(())
6138                }
6139                code => {
6140                    let headers = response.headers.clone();
6141                    let mut body = Vec::new();
6142                    let result = response.read_to_end(&mut body);
6143                    let err_type = match response.status.is_server_error() {
6144                        false => SimpleErrorType::Permanent,
6145                        true => SimpleErrorType::Temporary,
6146                    };
6147                    Err(ApiError::new(
6148                        format!(
6149                            "Unexpected response code {}:\n{:?}\n\n{}",
6150                            code,
6151                            headers,
6152                            match result {
6153                                Ok(_) => match str::from_utf8(&body) {
6154                                    Ok(body) => Cow::from(body),
6155                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6156                                },
6157                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6158                            }
6159                        ),
6160                        err_type,
6161                    ))
6162                }
6163            })
6164    }
6165
6166    fn confirm_email(
6167        &self,
6168        param_body: models::ConfirmEmailRequest,
6169    ) -> Result<models::ConfirmEmailResponse, ApiError> {
6170        let mut url = format!("{}/v1/users/confirm_email", self.base_path);
6171
6172        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6173
6174        let query_string_str = query_string.finish();
6175        if !query_string_str.is_empty() {
6176            url += "?";
6177            url += &query_string_str;
6178        }
6179
6180        let url = match Url::from_str(&url) {
6181            Ok(url) => url,
6182            Err(err) => {
6183                return Err(ApiError::new(
6184                    format!("Unable to build URL: {}", err),
6185                    SimpleErrorType::Permanent,
6186                ))
6187            }
6188        };
6189
6190        let mut request = self.hyper_client.request(Method::Post, url);
6191        request = request.headers(self.headers.clone());
6192        let body = serde_json::to_string(&param_body)
6193            .expect("impossible to fail to serialize")
6194            .into_bytes();
6195        request = request.body(body.as_slice());
6196
6197        request = request.header(ContentType(mimetypes::requests::CONFIRM_EMAIL.clone()));
6198
6199        request
6200            .send()
6201            .map_err(|e| {
6202                ApiError::new(
6203                    format!("No response received: {}", e),
6204                    SimpleErrorType::Permanent,
6205                )
6206            })
6207            .and_then(|mut response| match response.status.to_u16() {
6208                200 => {
6209                    let mut body = Vec::new();
6210                    response.read_to_end(&mut body).map_err(|e| {
6211                        ApiError::new(
6212                            format!("Failed to read response: {}", e),
6213                            SimpleErrorType::Temporary,
6214                        )
6215                    })?;
6216                    str::from_utf8(&body)
6217                        .map_err(|e| {
6218                            ApiError::new(
6219                                format!("Response was not valid UTF8: {}", e),
6220                                SimpleErrorType::Temporary,
6221                            )
6222                        })
6223                        .and_then(|body| {
6224                            serde_json::from_str::<models::ConfirmEmailResponse>(body)
6225                                .map_err(|e| e.into())
6226                        })
6227                }
6228                code => {
6229                    let headers = response.headers.clone();
6230                    let mut body = Vec::new();
6231                    let result = response.read_to_end(&mut body);
6232                    let err_type = match response.status.is_server_error() {
6233                        false => SimpleErrorType::Permanent,
6234                        true => SimpleErrorType::Temporary,
6235                    };
6236                    Err(ApiError::new(
6237                        format!(
6238                            "Unexpected response code {}:\n{:?}\n\n{}",
6239                            code,
6240                            headers,
6241                            match result {
6242                                Ok(_) => match str::from_utf8(&body) {
6243                                    Ok(body) => Cow::from(body),
6244                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6245                                },
6246                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6247                            }
6248                        ),
6249                        err_type,
6250                    ))
6251                }
6252            })
6253    }
6254
6255    fn create_user(&self, param_body: models::SignupRequest) -> Result<models::User, ApiError> {
6256        let mut url = format!("{}/v1/users", self.base_path);
6257
6258        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6259
6260        let query_string_str = query_string.finish();
6261        if !query_string_str.is_empty() {
6262            url += "?";
6263            url += &query_string_str;
6264        }
6265
6266        let url = match Url::from_str(&url) {
6267            Ok(url) => url,
6268            Err(err) => {
6269                return Err(ApiError::new(
6270                    format!("Unable to build URL: {}", err),
6271                    SimpleErrorType::Permanent,
6272                ))
6273            }
6274        };
6275
6276        let mut request = self.hyper_client.request(Method::Post, url);
6277        request = request.headers(self.headers.clone());
6278        let body = serde_json::to_string(&param_body)
6279            .expect("impossible to fail to serialize")
6280            .into_bytes();
6281        request = request.body(body.as_slice());
6282
6283        request = request.header(ContentType(mimetypes::requests::CREATE_USER.clone()));
6284
6285        request
6286            .send()
6287            .map_err(|e| {
6288                ApiError::new(
6289                    format!("No response received: {}", e),
6290                    SimpleErrorType::Permanent,
6291                )
6292            })
6293            .and_then(|mut response| match response.status.to_u16() {
6294                201 => {
6295                    let mut body = Vec::new();
6296                    response.read_to_end(&mut body).map_err(|e| {
6297                        ApiError::new(
6298                            format!("Failed to read response: {}", e),
6299                            SimpleErrorType::Temporary,
6300                        )
6301                    })?;
6302                    str::from_utf8(&body)
6303                        .map_err(|e| {
6304                            ApiError::new(
6305                                format!("Response was not valid UTF8: {}", e),
6306                                SimpleErrorType::Temporary,
6307                            )
6308                        })
6309                        .and_then(|body| {
6310                            serde_json::from_str::<models::User>(body).map_err(|e| e.into())
6311                        })
6312                }
6313                code => {
6314                    let headers = response.headers.clone();
6315                    let mut body = Vec::new();
6316                    let result = response.read_to_end(&mut body);
6317                    let err_type = match response.status.is_server_error() {
6318                        false => SimpleErrorType::Permanent,
6319                        true => SimpleErrorType::Temporary,
6320                    };
6321                    Err(ApiError::new(
6322                        format!(
6323                            "Unexpected response code {}:\n{:?}\n\n{}",
6324                            code,
6325                            headers,
6326                            match result {
6327                                Ok(_) => match str::from_utf8(&body) {
6328                                    Ok(body) => Cow::from(body),
6329                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6330                                },
6331                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6332                            }
6333                        ),
6334                        err_type,
6335                    ))
6336                }
6337            })
6338    }
6339
6340    fn delete_user_account(&self, param_user_id: uuid::Uuid) -> Result<(), ApiError> {
6341        let mut url = format!(
6342            "{}/v1/users/{user_id}",
6343            self.base_path,
6344            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
6345        );
6346
6347        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6348
6349        let query_string_str = query_string.finish();
6350        if !query_string_str.is_empty() {
6351            url += "?";
6352            url += &query_string_str;
6353        }
6354
6355        let url = match Url::from_str(&url) {
6356            Ok(url) => url,
6357            Err(err) => {
6358                return Err(ApiError::new(
6359                    format!("Unable to build URL: {}", err),
6360                    SimpleErrorType::Permanent,
6361                ))
6362            }
6363        };
6364
6365        let mut request = self.hyper_client.request(Method::Delete, url);
6366        request = request.headers(self.headers.clone());
6367
6368        request
6369            .send()
6370            .map_err(|e| {
6371                ApiError::new(
6372                    format!("No response received: {}", e),
6373                    SimpleErrorType::Permanent,
6374                )
6375            })
6376            .and_then(|mut response| match response.status.to_u16() {
6377                204 => {
6378                    let mut body = Vec::new();
6379                    response.read_to_end(&mut body).map_err(|e| {
6380                        ApiError::new(
6381                            format!("Failed to read response: {}", e),
6382                            SimpleErrorType::Temporary,
6383                        )
6384                    })?;
6385
6386                    Ok(())
6387                }
6388                code => {
6389                    let headers = response.headers.clone();
6390                    let mut body = Vec::new();
6391                    let result = response.read_to_end(&mut body);
6392                    let err_type = match response.status.is_server_error() {
6393                        false => SimpleErrorType::Permanent,
6394                        true => SimpleErrorType::Temporary,
6395                    };
6396                    Err(ApiError::new(
6397                        format!(
6398                            "Unexpected response code {}:\n{:?}\n\n{}",
6399                            code,
6400                            headers,
6401                            match result {
6402                                Ok(_) => match str::from_utf8(&body) {
6403                                    Ok(body) => Cow::from(body),
6404                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6405                                },
6406                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6407                            }
6408                        ),
6409                        err_type,
6410                    ))
6411                }
6412            })
6413    }
6414
6415    fn delete_user_from_account(&self, param_user_id: uuid::Uuid) -> Result<(), ApiError> {
6416        let mut url = format!(
6417            "{}/v1/users/{user_id}/accounts",
6418            self.base_path,
6419            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
6420        );
6421
6422        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6423
6424        let query_string_str = query_string.finish();
6425        if !query_string_str.is_empty() {
6426            url += "?";
6427            url += &query_string_str;
6428        }
6429
6430        let url = match Url::from_str(&url) {
6431            Ok(url) => url,
6432            Err(err) => {
6433                return Err(ApiError::new(
6434                    format!("Unable to build URL: {}", err),
6435                    SimpleErrorType::Permanent,
6436                ))
6437            }
6438        };
6439
6440        let mut request = self.hyper_client.request(Method::Delete, url);
6441        request = request.headers(self.headers.clone());
6442
6443        request
6444            .send()
6445            .map_err(|e| {
6446                ApiError::new(
6447                    format!("No response received: {}", e),
6448                    SimpleErrorType::Permanent,
6449                )
6450            })
6451            .and_then(|mut response| match response.status.to_u16() {
6452                204 => {
6453                    let mut body = Vec::new();
6454                    response.read_to_end(&mut body).map_err(|e| {
6455                        ApiError::new(
6456                            format!("Failed to read response: {}", e),
6457                            SimpleErrorType::Temporary,
6458                        )
6459                    })?;
6460
6461                    Ok(())
6462                }
6463                code => {
6464                    let headers = response.headers.clone();
6465                    let mut body = Vec::new();
6466                    let result = response.read_to_end(&mut body);
6467                    let err_type = match response.status.is_server_error() {
6468                        false => SimpleErrorType::Permanent,
6469                        true => SimpleErrorType::Temporary,
6470                    };
6471                    Err(ApiError::new(
6472                        format!(
6473                            "Unexpected response code {}:\n{:?}\n\n{}",
6474                            code,
6475                            headers,
6476                            match result {
6477                                Ok(_) => match str::from_utf8(&body) {
6478                                    Ok(body) => Cow::from(body),
6479                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6480                                },
6481                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6482                            }
6483                        ),
6484                        err_type,
6485                    ))
6486                }
6487            })
6488    }
6489
6490    fn forgot_password(&self, param_body: models::ForgotPasswordRequest) -> Result<(), ApiError> {
6491        let mut url = format!("{}/v1/users/forgot_password", self.base_path);
6492
6493        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6494
6495        let query_string_str = query_string.finish();
6496        if !query_string_str.is_empty() {
6497            url += "?";
6498            url += &query_string_str;
6499        }
6500
6501        let url = match Url::from_str(&url) {
6502            Ok(url) => url,
6503            Err(err) => {
6504                return Err(ApiError::new(
6505                    format!("Unable to build URL: {}", err),
6506                    SimpleErrorType::Permanent,
6507                ))
6508            }
6509        };
6510
6511        let mut request = self.hyper_client.request(Method::Post, url);
6512        request = request.headers(self.headers.clone());
6513        let body = serde_json::to_string(&param_body)
6514            .expect("impossible to fail to serialize")
6515            .into_bytes();
6516        request = request.body(body.as_slice());
6517
6518        request = request.header(ContentType(mimetypes::requests::FORGOT_PASSWORD.clone()));
6519
6520        request
6521            .send()
6522            .map_err(|e| {
6523                ApiError::new(
6524                    format!("No response received: {}", e),
6525                    SimpleErrorType::Permanent,
6526                )
6527            })
6528            .and_then(|mut response| match response.status.to_u16() {
6529                204 => {
6530                    let mut body = Vec::new();
6531                    response.read_to_end(&mut body).map_err(|e| {
6532                        ApiError::new(
6533                            format!("Failed to read response: {}", e),
6534                            SimpleErrorType::Temporary,
6535                        )
6536                    })?;
6537
6538                    Ok(())
6539                }
6540                code => {
6541                    let headers = response.headers.clone();
6542                    let mut body = Vec::new();
6543                    let result = response.read_to_end(&mut body);
6544                    let err_type = match response.status.is_server_error() {
6545                        false => SimpleErrorType::Permanent,
6546                        true => SimpleErrorType::Temporary,
6547                    };
6548                    Err(ApiError::new(
6549                        format!(
6550                            "Unexpected response code {}:\n{:?}\n\n{}",
6551                            code,
6552                            headers,
6553                            match result {
6554                                Ok(_) => match str::from_utf8(&body) {
6555                                    Ok(body) => Cow::from(body),
6556                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6557                                },
6558                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6559                            }
6560                        ),
6561                        err_type,
6562                    ))
6563                }
6564            })
6565    }
6566
6567    fn get_all_users(
6568        &self,
6569        param_all_search: Option<String>,
6570        param_limit: Option<i32>,
6571        param_offset: Option<i32>,
6572        param_sort_by: Option<String>,
6573    ) -> Result<models::GetAllUsersResponse, ApiError> {
6574        let mut url = format!("{}/v1/users", self.base_path);
6575
6576        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6577
6578        if let Some(all_search) = param_all_search {
6579            query_string.append_pair("all_search", &all_search.to_string());
6580        }
6581        if let Some(limit) = param_limit {
6582            query_string.append_pair("limit", &limit.to_string());
6583        }
6584        if let Some(offset) = param_offset {
6585            query_string.append_pair("offset", &offset.to_string());
6586        }
6587        if let Some(sort_by) = param_sort_by {
6588            query_string.append_pair("sort_by", &sort_by.to_string());
6589        }
6590        let query_string_str = query_string.finish();
6591        if !query_string_str.is_empty() {
6592            url += "?";
6593            url += &query_string_str;
6594        }
6595
6596        let url = match Url::from_str(&url) {
6597            Ok(url) => url,
6598            Err(err) => {
6599                return Err(ApiError::new(
6600                    format!("Unable to build URL: {}", err),
6601                    SimpleErrorType::Permanent,
6602                ))
6603            }
6604        };
6605
6606        let mut request = self.hyper_client.request(Method::Get, url);
6607        request = request.headers(self.headers.clone());
6608
6609        request
6610            .send()
6611            .map_err(|e| {
6612                ApiError::new(
6613                    format!("No response received: {}", e),
6614                    SimpleErrorType::Permanent,
6615                )
6616            })
6617            .and_then(|mut response| match response.status.to_u16() {
6618                200 => {
6619                    let mut body = Vec::new();
6620                    response.read_to_end(&mut body).map_err(|e| {
6621                        ApiError::new(
6622                            format!("Failed to read response: {}", e),
6623                            SimpleErrorType::Temporary,
6624                        )
6625                    })?;
6626                    str::from_utf8(&body)
6627                        .map_err(|e| {
6628                            ApiError::new(
6629                                format!("Response was not valid UTF8: {}", e),
6630                                SimpleErrorType::Temporary,
6631                            )
6632                        })
6633                        .and_then(|body| {
6634                            serde_json::from_str::<models::GetAllUsersResponse>(body)
6635                                .map_err(|e| e.into())
6636                        })
6637                }
6638                code => {
6639                    let headers = response.headers.clone();
6640                    let mut body = Vec::new();
6641                    let result = response.read_to_end(&mut body);
6642                    let err_type = match response.status.is_server_error() {
6643                        false => SimpleErrorType::Permanent,
6644                        true => SimpleErrorType::Temporary,
6645                    };
6646                    Err(ApiError::new(
6647                        format!(
6648                            "Unexpected response code {}:\n{:?}\n\n{}",
6649                            code,
6650                            headers,
6651                            match result {
6652                                Ok(_) => match str::from_utf8(&body) {
6653                                    Ok(body) => Cow::from(body),
6654                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6655                                },
6656                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6657                            }
6658                        ),
6659                        err_type,
6660                    ))
6661                }
6662            })
6663    }
6664
6665    fn get_logged_in_user(&self) -> Result<models::User, ApiError> {
6666        let mut url = format!("{}/v1/user", self.base_path);
6667
6668        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6669
6670        let query_string_str = query_string.finish();
6671        if !query_string_str.is_empty() {
6672            url += "?";
6673            url += &query_string_str;
6674        }
6675
6676        let url = match Url::from_str(&url) {
6677            Ok(url) => url,
6678            Err(err) => {
6679                return Err(ApiError::new(
6680                    format!("Unable to build URL: {}", err),
6681                    SimpleErrorType::Permanent,
6682                ))
6683            }
6684        };
6685
6686        let mut request = self.hyper_client.request(Method::Get, url);
6687        request = request.headers(self.headers.clone());
6688
6689        request
6690            .send()
6691            .map_err(|e| {
6692                ApiError::new(
6693                    format!("No response received: {}", e),
6694                    SimpleErrorType::Permanent,
6695                )
6696            })
6697            .and_then(|mut response| match response.status.to_u16() {
6698                200 => {
6699                    let mut body = Vec::new();
6700                    response.read_to_end(&mut body).map_err(|e| {
6701                        ApiError::new(
6702                            format!("Failed to read response: {}", e),
6703                            SimpleErrorType::Temporary,
6704                        )
6705                    })?;
6706                    str::from_utf8(&body)
6707                        .map_err(|e| {
6708                            ApiError::new(
6709                                format!("Response was not valid UTF8: {}", e),
6710                                SimpleErrorType::Temporary,
6711                            )
6712                        })
6713                        .and_then(|body| {
6714                            serde_json::from_str::<models::User>(body).map_err(|e| e.into())
6715                        })
6716                }
6717                code => {
6718                    let headers = response.headers.clone();
6719                    let mut body = Vec::new();
6720                    let result = response.read_to_end(&mut body);
6721                    let err_type = match response.status.is_server_error() {
6722                        false => SimpleErrorType::Permanent,
6723                        true => SimpleErrorType::Temporary,
6724                    };
6725                    Err(ApiError::new(
6726                        format!(
6727                            "Unexpected response code {}:\n{:?}\n\n{}",
6728                            code,
6729                            headers,
6730                            match result {
6731                                Ok(_) => match str::from_utf8(&body) {
6732                                    Ok(body) => Cow::from(body),
6733                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6734                                },
6735                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6736                            }
6737                        ),
6738                        err_type,
6739                    ))
6740                }
6741            })
6742    }
6743
6744    fn get_user(&self, param_user_id: uuid::Uuid) -> Result<models::User, ApiError> {
6745        let mut url = format!(
6746            "{}/v1/users/{user_id}",
6747            self.base_path,
6748            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
6749        );
6750
6751        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6752
6753        let query_string_str = query_string.finish();
6754        if !query_string_str.is_empty() {
6755            url += "?";
6756            url += &query_string_str;
6757        }
6758
6759        let url = match Url::from_str(&url) {
6760            Ok(url) => url,
6761            Err(err) => {
6762                return Err(ApiError::new(
6763                    format!("Unable to build URL: {}", err),
6764                    SimpleErrorType::Permanent,
6765                ))
6766            }
6767        };
6768
6769        let mut request = self.hyper_client.request(Method::Get, url);
6770        request = request.headers(self.headers.clone());
6771
6772        request
6773            .send()
6774            .map_err(|e| {
6775                ApiError::new(
6776                    format!("No response received: {}", e),
6777                    SimpleErrorType::Permanent,
6778                )
6779            })
6780            .and_then(|mut response| match response.status.to_u16() {
6781                200 => {
6782                    let mut body = Vec::new();
6783                    response.read_to_end(&mut body).map_err(|e| {
6784                        ApiError::new(
6785                            format!("Failed to read response: {}", e),
6786                            SimpleErrorType::Temporary,
6787                        )
6788                    })?;
6789                    str::from_utf8(&body)
6790                        .map_err(|e| {
6791                            ApiError::new(
6792                                format!("Response was not valid UTF8: {}", e),
6793                                SimpleErrorType::Temporary,
6794                            )
6795                        })
6796                        .and_then(|body| {
6797                            serde_json::from_str::<models::User>(body).map_err(|e| e.into())
6798                        })
6799                }
6800                code => {
6801                    let headers = response.headers.clone();
6802                    let mut body = Vec::new();
6803                    let result = response.read_to_end(&mut body);
6804                    let err_type = match response.status.is_server_error() {
6805                        false => SimpleErrorType::Permanent,
6806                        true => SimpleErrorType::Temporary,
6807                    };
6808                    Err(ApiError::new(
6809                        format!(
6810                            "Unexpected response code {}:\n{:?}\n\n{}",
6811                            code,
6812                            headers,
6813                            match result {
6814                                Ok(_) => match str::from_utf8(&body) {
6815                                    Ok(body) => Cow::from(body),
6816                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6817                                },
6818                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6819                            }
6820                        ),
6821                        err_type,
6822                    ))
6823                }
6824            })
6825    }
6826
6827    fn invite_user(&self, param_body: models::InviteUserRequest) -> Result<models::User, ApiError> {
6828        let mut url = format!("{}/v1/users/invite", self.base_path);
6829
6830        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6831
6832        let query_string_str = query_string.finish();
6833        if !query_string_str.is_empty() {
6834            url += "?";
6835            url += &query_string_str;
6836        }
6837
6838        let url = match Url::from_str(&url) {
6839            Ok(url) => url,
6840            Err(err) => {
6841                return Err(ApiError::new(
6842                    format!("Unable to build URL: {}", err),
6843                    SimpleErrorType::Permanent,
6844                ))
6845            }
6846        };
6847
6848        let mut request = self.hyper_client.request(Method::Post, url);
6849        request = request.headers(self.headers.clone());
6850        let body = serde_json::to_string(&param_body)
6851            .expect("impossible to fail to serialize")
6852            .into_bytes();
6853        request = request.body(body.as_slice());
6854
6855        request = request.header(ContentType(mimetypes::requests::INVITE_USER.clone()));
6856
6857        request
6858            .send()
6859            .map_err(|e| {
6860                ApiError::new(
6861                    format!("No response received: {}", e),
6862                    SimpleErrorType::Permanent,
6863                )
6864            })
6865            .and_then(|mut response| match response.status.to_u16() {
6866                201 => {
6867                    let mut body = Vec::new();
6868                    response.read_to_end(&mut body).map_err(|e| {
6869                        ApiError::new(
6870                            format!("Failed to read response: {}", e),
6871                            SimpleErrorType::Temporary,
6872                        )
6873                    })?;
6874                    str::from_utf8(&body)
6875                        .map_err(|e| {
6876                            ApiError::new(
6877                                format!("Response was not valid UTF8: {}", e),
6878                                SimpleErrorType::Temporary,
6879                            )
6880                        })
6881                        .and_then(|body| {
6882                            serde_json::from_str::<models::User>(body).map_err(|e| e.into())
6883                        })
6884                }
6885                code => {
6886                    let headers = response.headers.clone();
6887                    let mut body = Vec::new();
6888                    let result = response.read_to_end(&mut body);
6889                    let err_type = match response.status.is_server_error() {
6890                        false => SimpleErrorType::Permanent,
6891                        true => SimpleErrorType::Temporary,
6892                    };
6893                    Err(ApiError::new(
6894                        format!(
6895                            "Unexpected response code {}:\n{:?}\n\n{}",
6896                            code,
6897                            headers,
6898                            match result {
6899                                Ok(_) => match str::from_utf8(&body) {
6900                                    Ok(body) => Cow::from(body),
6901                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6902                                },
6903                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6904                            }
6905                        ),
6906                        err_type,
6907                    ))
6908                }
6909            })
6910    }
6911
6912    fn process_invitations(
6913        &self,
6914        param_body: models::ProcessInviteRequest,
6915    ) -> Result<(), ApiError> {
6916        let mut url = format!("{}/v1/users/process_invite", self.base_path);
6917
6918        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6919
6920        let query_string_str = query_string.finish();
6921        if !query_string_str.is_empty() {
6922            url += "?";
6923            url += &query_string_str;
6924        }
6925
6926        let url = match Url::from_str(&url) {
6927            Ok(url) => url,
6928            Err(err) => {
6929                return Err(ApiError::new(
6930                    format!("Unable to build URL: {}", err),
6931                    SimpleErrorType::Permanent,
6932                ))
6933            }
6934        };
6935
6936        let mut request = self.hyper_client.request(Method::Post, url);
6937        request = request.headers(self.headers.clone());
6938        let body = serde_json::to_string(&param_body)
6939            .expect("impossible to fail to serialize")
6940            .into_bytes();
6941        request = request.body(body.as_slice());
6942
6943        request = request.header(ContentType(
6944            mimetypes::requests::PROCESS_INVITATIONS.clone(),
6945        ));
6946
6947        request
6948            .send()
6949            .map_err(|e| {
6950                ApiError::new(
6951                    format!("No response received: {}", e),
6952                    SimpleErrorType::Permanent,
6953                )
6954            })
6955            .and_then(|mut response| match response.status.to_u16() {
6956                204 => {
6957                    let mut body = Vec::new();
6958                    response.read_to_end(&mut body).map_err(|e| {
6959                        ApiError::new(
6960                            format!("Failed to read response: {}", e),
6961                            SimpleErrorType::Temporary,
6962                        )
6963                    })?;
6964
6965                    Ok(())
6966                }
6967                code => {
6968                    let headers = response.headers.clone();
6969                    let mut body = Vec::new();
6970                    let result = response.read_to_end(&mut body);
6971                    let err_type = match response.status.is_server_error() {
6972                        false => SimpleErrorType::Permanent,
6973                        true => SimpleErrorType::Temporary,
6974                    };
6975                    Err(ApiError::new(
6976                        format!(
6977                            "Unexpected response code {}:\n{:?}\n\n{}",
6978                            code,
6979                            headers,
6980                            match result {
6981                                Ok(_) => match str::from_utf8(&body) {
6982                                    Ok(body) => Cow::from(body),
6983                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
6984                                },
6985                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
6986                            }
6987                        ),
6988                        err_type,
6989                    ))
6990                }
6991            })
6992    }
6993
6994    fn resend_confirm_email(&self) -> Result<(), ApiError> {
6995        let mut url = format!("{}/v1/users/resend_confirm_email", self.base_path);
6996
6997        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
6998
6999        let query_string_str = query_string.finish();
7000        if !query_string_str.is_empty() {
7001            url += "?";
7002            url += &query_string_str;
7003        }
7004
7005        let url = match Url::from_str(&url) {
7006            Ok(url) => url,
7007            Err(err) => {
7008                return Err(ApiError::new(
7009                    format!("Unable to build URL: {}", err),
7010                    SimpleErrorType::Permanent,
7011                ))
7012            }
7013        };
7014
7015        let mut request = self.hyper_client.request(Method::Post, url);
7016        request = request.headers(self.headers.clone());
7017
7018        request
7019            .send()
7020            .map_err(|e| {
7021                ApiError::new(
7022                    format!("No response received: {}", e),
7023                    SimpleErrorType::Permanent,
7024                )
7025            })
7026            .and_then(|mut response| match response.status.to_u16() {
7027                204 => {
7028                    let mut body = Vec::new();
7029                    response.read_to_end(&mut body).map_err(|e| {
7030                        ApiError::new(
7031                            format!("Failed to read response: {}", e),
7032                            SimpleErrorType::Temporary,
7033                        )
7034                    })?;
7035
7036                    Ok(())
7037                }
7038                code => {
7039                    let headers = response.headers.clone();
7040                    let mut body = Vec::new();
7041                    let result = response.read_to_end(&mut body);
7042                    let err_type = match response.status.is_server_error() {
7043                        false => SimpleErrorType::Permanent,
7044                        true => SimpleErrorType::Temporary,
7045                    };
7046                    Err(ApiError::new(
7047                        format!(
7048                            "Unexpected response code {}:\n{:?}\n\n{}",
7049                            code,
7050                            headers,
7051                            match result {
7052                                Ok(_) => match str::from_utf8(&body) {
7053                                    Ok(body) => Cow::from(body),
7054                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7055                                },
7056                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7057                            }
7058                        ),
7059                        err_type,
7060                    ))
7061                }
7062            })
7063    }
7064
7065    fn resend_invitation(&self, param_user_id: uuid::Uuid) -> Result<(), ApiError> {
7066        let mut url = format!(
7067            "{}/v1/users/{user_id}/resend_invite",
7068            self.base_path,
7069            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
7070        );
7071
7072        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7073
7074        let query_string_str = query_string.finish();
7075        if !query_string_str.is_empty() {
7076            url += "?";
7077            url += &query_string_str;
7078        }
7079
7080        let url = match Url::from_str(&url) {
7081            Ok(url) => url,
7082            Err(err) => {
7083                return Err(ApiError::new(
7084                    format!("Unable to build URL: {}", err),
7085                    SimpleErrorType::Permanent,
7086                ))
7087            }
7088        };
7089
7090        let mut request = self.hyper_client.request(Method::Post, url);
7091        request = request.headers(self.headers.clone());
7092
7093        request
7094            .send()
7095            .map_err(|e| {
7096                ApiError::new(
7097                    format!("No response received: {}", e),
7098                    SimpleErrorType::Permanent,
7099                )
7100            })
7101            .and_then(|mut response| match response.status.to_u16() {
7102                204 => {
7103                    let mut body = Vec::new();
7104                    response.read_to_end(&mut body).map_err(|e| {
7105                        ApiError::new(
7106                            format!("Failed to read response: {}", e),
7107                            SimpleErrorType::Temporary,
7108                        )
7109                    })?;
7110
7111                    Ok(())
7112                }
7113                code => {
7114                    let headers = response.headers.clone();
7115                    let mut body = Vec::new();
7116                    let result = response.read_to_end(&mut body);
7117                    let err_type = match response.status.is_server_error() {
7118                        false => SimpleErrorType::Permanent,
7119                        true => SimpleErrorType::Temporary,
7120                    };
7121                    Err(ApiError::new(
7122                        format!(
7123                            "Unexpected response code {}:\n{:?}\n\n{}",
7124                            code,
7125                            headers,
7126                            match result {
7127                                Ok(_) => match str::from_utf8(&body) {
7128                                    Ok(body) => Cow::from(body),
7129                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7130                                },
7131                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7132                            }
7133                        ),
7134                        err_type,
7135                    ))
7136                }
7137            })
7138    }
7139
7140    fn reset_password(
7141        &self,
7142        param_user_id: uuid::Uuid,
7143        param_body: models::PasswordResetRequest,
7144    ) -> Result<(), ApiError> {
7145        let mut url = format!(
7146            "{}/v1/users/{user_id}/reset_password",
7147            self.base_path,
7148            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
7149        );
7150
7151        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7152
7153        let query_string_str = query_string.finish();
7154        if !query_string_str.is_empty() {
7155            url += "?";
7156            url += &query_string_str;
7157        }
7158
7159        let url = match Url::from_str(&url) {
7160            Ok(url) => url,
7161            Err(err) => {
7162                return Err(ApiError::new(
7163                    format!("Unable to build URL: {}", err),
7164                    SimpleErrorType::Permanent,
7165                ))
7166            }
7167        };
7168
7169        let mut request = self.hyper_client.request(Method::Post, url);
7170        request = request.headers(self.headers.clone());
7171        let body = serde_json::to_string(&param_body)
7172            .expect("impossible to fail to serialize")
7173            .into_bytes();
7174        request = request.body(body.as_slice());
7175
7176        request = request.header(ContentType(mimetypes::requests::RESET_PASSWORD.clone()));
7177
7178        request
7179            .send()
7180            .map_err(|e| {
7181                ApiError::new(
7182                    format!("No response received: {}", e),
7183                    SimpleErrorType::Permanent,
7184                )
7185            })
7186            .and_then(|mut response| match response.status.to_u16() {
7187                204 => {
7188                    let mut body = Vec::new();
7189                    response.read_to_end(&mut body).map_err(|e| {
7190                        ApiError::new(
7191                            format!("Failed to read response: {}", e),
7192                            SimpleErrorType::Temporary,
7193                        )
7194                    })?;
7195
7196                    Ok(())
7197                }
7198                code => {
7199                    let headers = response.headers.clone();
7200                    let mut body = Vec::new();
7201                    let result = response.read_to_end(&mut body);
7202                    let err_type = match response.status.is_server_error() {
7203                        false => SimpleErrorType::Permanent,
7204                        true => SimpleErrorType::Temporary,
7205                    };
7206                    Err(ApiError::new(
7207                        format!(
7208                            "Unexpected response code {}:\n{:?}\n\n{}",
7209                            code,
7210                            headers,
7211                            match result {
7212                                Ok(_) => match str::from_utf8(&body) {
7213                                    Ok(body) => Cow::from(body),
7214                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7215                                },
7216                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7217                            }
7218                        ),
7219                        err_type,
7220                    ))
7221                }
7222            })
7223    }
7224
7225    fn update_user(
7226        &self,
7227        param_user_id: uuid::Uuid,
7228        param_body: models::UpdateUserRequest,
7229    ) -> Result<models::User, ApiError> {
7230        let mut url = format!(
7231            "{}/v1/users/{user_id}",
7232            self.base_path,
7233            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
7234        );
7235
7236        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7237
7238        let query_string_str = query_string.finish();
7239        if !query_string_str.is_empty() {
7240            url += "?";
7241            url += &query_string_str;
7242        }
7243
7244        let url = match Url::from_str(&url) {
7245            Ok(url) => url,
7246            Err(err) => {
7247                return Err(ApiError::new(
7248                    format!("Unable to build URL: {}", err),
7249                    SimpleErrorType::Permanent,
7250                ))
7251            }
7252        };
7253
7254        let mut request = self.hyper_client.request(Method::Patch, url);
7255        request = request.headers(self.headers.clone());
7256        let body = serde_json::to_string(&param_body)
7257            .expect("impossible to fail to serialize")
7258            .into_bytes();
7259        request = request.body(body.as_slice());
7260
7261        request = request.header(ContentType(mimetypes::requests::UPDATE_USER.clone()));
7262
7263        request
7264            .send()
7265            .map_err(|e| {
7266                ApiError::new(
7267                    format!("No response received: {}", e),
7268                    SimpleErrorType::Permanent,
7269                )
7270            })
7271            .and_then(|mut response| match response.status.to_u16() {
7272                200 => {
7273                    let mut body = Vec::new();
7274                    response.read_to_end(&mut body).map_err(|e| {
7275                        ApiError::new(
7276                            format!("Failed to read response: {}", e),
7277                            SimpleErrorType::Temporary,
7278                        )
7279                    })?;
7280                    str::from_utf8(&body)
7281                        .map_err(|e| {
7282                            ApiError::new(
7283                                format!("Response was not valid UTF8: {}", e),
7284                                SimpleErrorType::Temporary,
7285                            )
7286                        })
7287                        .and_then(|body| {
7288                            serde_json::from_str::<models::User>(body).map_err(|e| e.into())
7289                        })
7290                }
7291                code => {
7292                    let headers = response.headers.clone();
7293                    let mut body = Vec::new();
7294                    let result = response.read_to_end(&mut body);
7295                    let err_type = match response.status.is_server_error() {
7296                        false => SimpleErrorType::Permanent,
7297                        true => SimpleErrorType::Temporary,
7298                    };
7299                    Err(ApiError::new(
7300                        format!(
7301                            "Unexpected response code {}:\n{:?}\n\n{}",
7302                            code,
7303                            headers,
7304                            match result {
7305                                Ok(_) => match str::from_utf8(&body) {
7306                                    Ok(body) => Cow::from(body),
7307                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7308                                },
7309                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7310                            }
7311                        ),
7312                        err_type,
7313                    ))
7314                }
7315            })
7316    }
7317
7318    fn validate_password_reset_token(
7319        &self,
7320        param_user_id: uuid::Uuid,
7321        param_body: models::ValidateTokenRequest,
7322    ) -> Result<models::ValidateTokenResponse, ApiError> {
7323        let mut url = format!(
7324            "{}/v1/users/{user_id}/validate_token",
7325            self.base_path,
7326            user_id = utf8_percent_encode(&param_user_id.to_string(), ID_ENCODE_SET)
7327        );
7328
7329        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7330
7331        let query_string_str = query_string.finish();
7332        if !query_string_str.is_empty() {
7333            url += "?";
7334            url += &query_string_str;
7335        }
7336
7337        let url = match Url::from_str(&url) {
7338            Ok(url) => url,
7339            Err(err) => {
7340                return Err(ApiError::new(
7341                    format!("Unable to build URL: {}", err),
7342                    SimpleErrorType::Permanent,
7343                ))
7344            }
7345        };
7346
7347        let mut request = self.hyper_client.request(Method::Post, url);
7348        request = request.headers(self.headers.clone());
7349        let body = serde_json::to_string(&param_body)
7350            .expect("impossible to fail to serialize")
7351            .into_bytes();
7352        request = request.body(body.as_slice());
7353
7354        request = request.header(ContentType(
7355            mimetypes::requests::VALIDATE_PASSWORD_RESET_TOKEN.clone(),
7356        ));
7357
7358        request
7359            .send()
7360            .map_err(|e| {
7361                ApiError::new(
7362                    format!("No response received: {}", e),
7363                    SimpleErrorType::Permanent,
7364                )
7365            })
7366            .and_then(|mut response| match response.status.to_u16() {
7367                200 => {
7368                    let mut body = Vec::new();
7369                    response.read_to_end(&mut body).map_err(|e| {
7370                        ApiError::new(
7371                            format!("Failed to read response: {}", e),
7372                            SimpleErrorType::Temporary,
7373                        )
7374                    })?;
7375                    str::from_utf8(&body)
7376                        .map_err(|e| {
7377                            ApiError::new(
7378                                format!("Response was not valid UTF8: {}", e),
7379                                SimpleErrorType::Temporary,
7380                            )
7381                        })
7382                        .and_then(|body| {
7383                            serde_json::from_str::<models::ValidateTokenResponse>(body)
7384                                .map_err(|e| e.into())
7385                        })
7386                }
7387                code => {
7388                    let headers = response.headers.clone();
7389                    let mut body = Vec::new();
7390                    let result = response.read_to_end(&mut body);
7391                    let err_type = match response.status.is_server_error() {
7392                        false => SimpleErrorType::Permanent,
7393                        true => SimpleErrorType::Temporary,
7394                    };
7395                    Err(ApiError::new(
7396                        format!(
7397                            "Unexpected response code {}:\n{:?}\n\n{}",
7398                            code,
7399                            headers,
7400                            match result {
7401                                Ok(_) => match str::from_utf8(&body) {
7402                                    Ok(body) => Cow::from(body),
7403                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7404                                },
7405                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7406                            }
7407                        ),
7408                        err_type,
7409                    ))
7410                }
7411            })
7412    }
7413}
7414
7415impl WorkflowApi for Client {
7416    type Error = ApiError;
7417
7418    fn create_workflow_graph(
7419        &self,
7420        param_body: models::CreateWorkflowGraph,
7421    ) -> Result<models::WorkflowGraph, ApiError> {
7422        let mut url = format!("{}/v1/workflows/draft/graphs", self.base_path);
7423
7424        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7425
7426        let query_string_str = query_string.finish();
7427        if !query_string_str.is_empty() {
7428            url += "?";
7429            url += &query_string_str;
7430        }
7431
7432        let url = match Url::from_str(&url) {
7433            Ok(url) => url,
7434            Err(err) => {
7435                return Err(ApiError::new(
7436                    format!("Unable to build URL: {}", err),
7437                    SimpleErrorType::Permanent,
7438                ))
7439            }
7440        };
7441
7442        let mut request = self.hyper_client.request(Method::Post, url);
7443        request = request.headers(self.headers.clone());
7444        // Body parameter
7445        let body = serde_json::to_string(&param_body)
7446            .expect("impossible to fail to serialize")
7447            .into_bytes();
7448        request = request.body(body.as_slice());
7449
7450        request = request.header(ContentType(
7451            mimetypes::requests::CREATE_WORKFLOW_GRAPH.clone(),
7452        ));
7453
7454        request
7455            .send()
7456            .map_err(|e| {
7457                ApiError::new(
7458                    format!("No response received: {}", e),
7459                    SimpleErrorType::Permanent,
7460                )
7461            })
7462            .and_then(|mut response| match response.status.to_u16() {
7463                200 => {
7464                    let mut body = Vec::new();
7465                    response.read_to_end(&mut body).map_err(|e| {
7466                        ApiError::new(
7467                            format!("Failed to read response: {}", e),
7468                            SimpleErrorType::Temporary,
7469                        )
7470                    })?;
7471                    str::from_utf8(&body)
7472                        .map_err(|e| {
7473                            ApiError::new(
7474                                format!("Response was not valid UTF8: {}", e),
7475                                SimpleErrorType::Temporary,
7476                            )
7477                        })
7478                        .and_then(|body| {
7479                            serde_json::from_str::<models::WorkflowGraph>(body)
7480                                .map_err(|e| e.into())
7481                        })
7482                }
7483                code => {
7484                    let headers = response.headers.clone();
7485                    let mut body = Vec::new();
7486                    let result = response.read_to_end(&mut body);
7487                    let err_type = match response.status.is_server_error() {
7488                        false => SimpleErrorType::Permanent,
7489                        true => SimpleErrorType::Temporary,
7490                    };
7491                    Err(ApiError::new(
7492                        format!(
7493                            "Unexpected response code {}:\n{:?}\n\n{}",
7494                            code,
7495                            headers,
7496                            match result {
7497                                Ok(_) => match str::from_utf8(&body) {
7498                                    Ok(body) => Cow::from(body),
7499                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7500                                },
7501                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7502                            }
7503                        ),
7504                        err_type,
7505                    ))
7506                }
7507            })
7508    }
7509
7510    fn delete_workflow_graph(&self, param_graph_id: uuid::Uuid) -> Result<(), ApiError> {
7511        let mut url = format!(
7512            "{}/v1/workflows/draft/graphs/{graph_id}",
7513            self.base_path,
7514            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET)
7515        );
7516
7517        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7518
7519        let query_string_str = query_string.finish();
7520        if !query_string_str.is_empty() {
7521            url += "?";
7522            url += &query_string_str;
7523        }
7524
7525        let url = match Url::from_str(&url) {
7526            Ok(url) => url,
7527            Err(err) => {
7528                return Err(ApiError::new(
7529                    format!("Unable to build URL: {}", err),
7530                    SimpleErrorType::Permanent,
7531                ))
7532            }
7533        };
7534
7535        let mut request = self.hyper_client.request(Method::Delete, url);
7536        request = request.headers(self.headers.clone());
7537
7538        request
7539            .send()
7540            .map_err(|e| {
7541                ApiError::new(
7542                    format!("No response received: {}", e),
7543                    SimpleErrorType::Permanent,
7544                )
7545            })
7546            .and_then(|mut response| match response.status.to_u16() {
7547                204 => {
7548                    let mut body = Vec::new();
7549                    response.read_to_end(&mut body).map_err(|e| {
7550                        ApiError::new(
7551                            format!("Failed to read response: {}", e),
7552                            SimpleErrorType::Temporary,
7553                        )
7554                    })?;
7555
7556                    Ok(())
7557                }
7558                code => {
7559                    let headers = response.headers.clone();
7560                    let mut body = Vec::new();
7561                    let result = response.read_to_end(&mut body);
7562                    let err_type = match response.status.is_server_error() {
7563                        false => SimpleErrorType::Permanent,
7564                        true => SimpleErrorType::Temporary,
7565                    };
7566                    Err(ApiError::new(
7567                        format!(
7568                            "Unexpected response code {}:\n{:?}\n\n{}",
7569                            code,
7570                            headers,
7571                            match result {
7572                                Ok(_) => match str::from_utf8(&body) {
7573                                    Ok(body) => Cow::from(body),
7574                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7575                                },
7576                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7577                            }
7578                        ),
7579                        err_type,
7580                    ))
7581                }
7582            })
7583    }
7584
7585    fn get_all_workflow_graphs(
7586        &self,
7587        param_name: Option<String>,
7588        param_description: Option<String>,
7589        param_all_search: Option<String>,
7590        param_parent_graph_id: Option<String>,
7591        param_sort_by: Option<String>,
7592        param_limit: Option<i32>,
7593        param_offset: Option<i32>,
7594    ) -> Result<models::GetAllWorkflowGraphsResponse, ApiError> {
7595        let mut url = format!("{}/v1/workflows/draft/graphs", self.base_path);
7596
7597        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7598
7599        if let Some(name) = param_name {
7600            query_string.append_pair("name", &name.to_string());
7601        }
7602        if let Some(description) = param_description {
7603            query_string.append_pair("description", &description.to_string());
7604        }
7605        if let Some(all_search) = param_all_search {
7606            query_string.append_pair("all_search", &all_search.to_string());
7607        }
7608        if let Some(parent_graph_id) = param_parent_graph_id {
7609            query_string.append_pair("parent_graph_id", &parent_graph_id.to_string());
7610        }
7611        if let Some(sort_by) = param_sort_by {
7612            query_string.append_pair("sort_by", &sort_by.to_string());
7613        }
7614        if let Some(limit) = param_limit {
7615            query_string.append_pair("limit", &limit.to_string());
7616        }
7617        if let Some(offset) = param_offset {
7618            query_string.append_pair("offset", &offset.to_string());
7619        }
7620        let query_string_str = query_string.finish();
7621        if !query_string_str.is_empty() {
7622            url += "?";
7623            url += &query_string_str;
7624        }
7625
7626        let url = match Url::from_str(&url) {
7627            Ok(url) => url,
7628            Err(err) => {
7629                return Err(ApiError::new(
7630                    format!("Unable to build URL: {}", err),
7631                    SimpleErrorType::Permanent,
7632                ))
7633            }
7634        };
7635
7636        let mut request = self.hyper_client.request(Method::Get, url);
7637        request = request.headers(self.headers.clone());
7638
7639        request
7640            .send()
7641            .map_err(|e| {
7642                ApiError::new(
7643                    format!("No response received: {}", e),
7644                    SimpleErrorType::Permanent,
7645                )
7646            })
7647            .and_then(|mut response| match response.status.to_u16() {
7648                200 => {
7649                    let mut body = Vec::new();
7650                    response.read_to_end(&mut body).map_err(|e| {
7651                        ApiError::new(
7652                            format!("Failed to read response: {}", e),
7653                            SimpleErrorType::Temporary,
7654                        )
7655                    })?;
7656                    str::from_utf8(&body)
7657                        .map_err(|e| {
7658                            ApiError::new(
7659                                format!("Response was not valid UTF8: {}", e),
7660                                SimpleErrorType::Temporary,
7661                            )
7662                        })
7663                        .and_then(|body| {
7664                            serde_json::from_str::<models::GetAllWorkflowGraphsResponse>(body)
7665                                .map_err(|e| e.into())
7666                        })
7667                }
7668                code => {
7669                    let headers = response.headers.clone();
7670                    let mut body = Vec::new();
7671                    let result = response.read_to_end(&mut body);
7672                    let err_type = match response.status.is_server_error() {
7673                        false => SimpleErrorType::Permanent,
7674                        true => SimpleErrorType::Temporary,
7675                    };
7676                    Err(ApiError::new(
7677                        format!(
7678                            "Unexpected response code {}:\n{:?}\n\n{}",
7679                            code,
7680                            headers,
7681                            match result {
7682                                Ok(_) => match str::from_utf8(&body) {
7683                                    Ok(body) => Cow::from(body),
7684                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7685                                },
7686                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7687                            }
7688                        ),
7689                        err_type,
7690                    ))
7691                }
7692            })
7693    }
7694
7695    fn get_workflow_graph(
7696        &self,
7697        param_graph_id: uuid::Uuid,
7698    ) -> Result<models::WorkflowGraph, ApiError> {
7699        let mut url = format!(
7700            "{}/v1/workflows/draft/graphs/{graph_id}",
7701            self.base_path,
7702            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET)
7703        );
7704
7705        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7706
7707        let query_string_str = query_string.finish();
7708        if !query_string_str.is_empty() {
7709            url += "?";
7710            url += &query_string_str;
7711        }
7712
7713        let url = match Url::from_str(&url) {
7714            Ok(url) => url,
7715            Err(err) => {
7716                return Err(ApiError::new(
7717                    format!("Unable to build URL: {}", err),
7718                    SimpleErrorType::Permanent,
7719                ))
7720            }
7721        };
7722
7723        let mut request = self.hyper_client.request(Method::Get, url);
7724        request = request.headers(self.headers.clone());
7725
7726        request
7727            .send()
7728            .map_err(|e| {
7729                ApiError::new(
7730                    format!("No response received: {}", e),
7731                    SimpleErrorType::Permanent,
7732                )
7733            })
7734            .and_then(|mut response| match response.status.to_u16() {
7735                200 => {
7736                    let mut body = Vec::new();
7737                    response.read_to_end(&mut body).map_err(|e| {
7738                        ApiError::new(
7739                            format!("Failed to read response: {}", e),
7740                            SimpleErrorType::Temporary,
7741                        )
7742                    })?;
7743                    str::from_utf8(&body)
7744                        .map_err(|e| {
7745                            ApiError::new(
7746                                format!("Response was not valid UTF8: {}", e),
7747                                SimpleErrorType::Temporary,
7748                            )
7749                        })
7750                        .and_then(|body| {
7751                            serde_json::from_str::<models::WorkflowGraph>(body)
7752                                .map_err(|e| e.into())
7753                        })
7754                }
7755                code => {
7756                    let headers = response.headers.clone();
7757                    let mut body = Vec::new();
7758                    let result = response.read_to_end(&mut body);
7759                    let err_type = match response.status.is_server_error() {
7760                        false => SimpleErrorType::Permanent,
7761                        true => SimpleErrorType::Temporary,
7762                    };
7763                    Err(ApiError::new(
7764                        format!(
7765                            "Unexpected response code {}:\n{:?}\n\n{}",
7766                            code,
7767                            headers,
7768                            match result {
7769                                Ok(_) => match str::from_utf8(&body) {
7770                                    Ok(body) => Cow::from(body),
7771                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7772                                },
7773                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7774                            }
7775                        ),
7776                        err_type,
7777                    ))
7778                }
7779            })
7780    }
7781
7782    fn update_workflow_graph(
7783        &self,
7784        param_graph_id: uuid::Uuid,
7785        param_body: models::UpdateWorkflowGraph,
7786    ) -> Result<models::WorkflowGraph, ApiError> {
7787        let mut url = format!(
7788            "{}/v1/workflows/draft/graphs/{graph_id}",
7789            self.base_path,
7790            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET)
7791        );
7792
7793        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7794
7795        let query_string_str = query_string.finish();
7796        if !query_string_str.is_empty() {
7797            url += "?";
7798            url += &query_string_str;
7799        }
7800
7801        let url = match Url::from_str(&url) {
7802            Ok(url) => url,
7803            Err(err) => {
7804                return Err(ApiError::new(
7805                    format!("Unable to build URL: {}", err),
7806                    SimpleErrorType::Permanent,
7807                ))
7808            }
7809        };
7810
7811        let mut request = self.hyper_client.request(Method::Put, url);
7812        request = request.headers(self.headers.clone());
7813        let body = serde_json::to_string(&param_body)
7814            .expect("impossible to fail to serialize")
7815            .into_bytes();
7816        request = request.body(body.as_slice());
7817
7818        request = request.header(ContentType(
7819            mimetypes::requests::UPDATE_WORKFLOW_GRAPH.clone(),
7820        ));
7821
7822        request
7823            .send()
7824            .map_err(|e| {
7825                ApiError::new(
7826                    format!("No response received: {}", e),
7827                    SimpleErrorType::Permanent,
7828                )
7829            })
7830            .and_then(|mut response| match response.status.to_u16() {
7831                200 => {
7832                    let mut body = Vec::new();
7833                    response.read_to_end(&mut body).map_err(|e| {
7834                        ApiError::new(
7835                            format!("Failed to read response: {}", e),
7836                            SimpleErrorType::Temporary,
7837                        )
7838                    })?;
7839                    str::from_utf8(&body)
7840                        .map_err(|e| {
7841                            ApiError::new(
7842                                format!("Response was not valid UTF8: {}", e),
7843                                SimpleErrorType::Temporary,
7844                            )
7845                        })
7846                        .and_then(|body| {
7847                            serde_json::from_str::<models::WorkflowGraph>(body)
7848                                .map_err(|e| e.into())
7849                        })
7850                }
7851                code => {
7852                    let headers = response.headers.clone();
7853                    let mut body = Vec::new();
7854                    let result = response.read_to_end(&mut body);
7855                    let err_type = match response.status.is_server_error() {
7856                        false => SimpleErrorType::Permanent,
7857                        true => SimpleErrorType::Temporary,
7858                    };
7859                    Err(ApiError::new(
7860                        format!(
7861                            "Unexpected response code {}:\n{:?}\n\n{}",
7862                            code,
7863                            headers,
7864                            match result {
7865                                Ok(_) => match str::from_utf8(&body) {
7866                                    Ok(body) => Cow::from(body),
7867                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7868                                },
7869                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7870                            }
7871                        ),
7872                        err_type,
7873                    ))
7874                }
7875            })
7876    }
7877}
7878
7879impl WorkflowFinalApi for Client {
7880    type Error = ApiError;
7881
7882    fn create_final_workflow_graph(
7883        &self,
7884        param_body: models::CreateFinalWorkflowGraph,
7885    ) -> Result<models::FinalWorkflow, ApiError> {
7886        let mut url = format!("{}/v1/workflows/final/graphs", self.base_path);
7887
7888        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7889
7890        let query_string_str = query_string.finish();
7891        if !query_string_str.is_empty() {
7892            url += "?";
7893            url += &query_string_str;
7894        }
7895
7896        let url = match Url::from_str(&url) {
7897            Ok(url) => url,
7898            Err(err) => {
7899                return Err(ApiError::new(
7900                    format!("Unable to build URL: {}", err),
7901                    SimpleErrorType::Permanent,
7902                ))
7903            }
7904        };
7905
7906        let mut request = self.hyper_client.request(Method::Post, url);
7907        request = request.headers(self.headers.clone());
7908        // Body parameter
7909        let body = serde_json::to_string(&param_body)
7910            .expect("impossible to fail to serialize")
7911            .into_bytes();
7912        request = request.body(body.as_slice());
7913
7914        request = request.header(ContentType(
7915            mimetypes::requests::CREATE_FINAL_WORKFLOW_GRAPH.clone(),
7916        ));
7917
7918        request
7919            .send()
7920            .map_err(|e| {
7921                ApiError::new(
7922                    format!("No response received: {}", e),
7923                    SimpleErrorType::Permanent,
7924                )
7925            })
7926            .and_then(|mut response| match response.status.to_u16() {
7927                200 => {
7928                    let mut body = Vec::new();
7929                    response.read_to_end(&mut body).map_err(|e| {
7930                        ApiError::new(
7931                            format!("Failed to read response: {}", e),
7932                            SimpleErrorType::Temporary,
7933                        )
7934                    })?;
7935                    str::from_utf8(&body)
7936                        .map_err(|e| {
7937                            ApiError::new(
7938                                format!("Response was not valid UTF8: {}", e),
7939                                SimpleErrorType::Temporary,
7940                            )
7941                        })
7942                        .and_then(|body| {
7943                            serde_json::from_str::<models::FinalWorkflow>(body)
7944                                .map_err(|e| e.into())
7945                        })
7946                }
7947                code => {
7948                    let headers = response.headers.clone();
7949                    let mut body = Vec::new();
7950                    let result = response.read_to_end(&mut body);
7951                    let err_type = match response.status.is_server_error() {
7952                        false => SimpleErrorType::Permanent,
7953                        true => SimpleErrorType::Temporary,
7954                    };
7955                    Err(ApiError::new(
7956                        format!(
7957                            "Unexpected response code {}:\n{:?}\n\n{}",
7958                            code,
7959                            headers,
7960                            match result {
7961                                Ok(_) => match str::from_utf8(&body) {
7962                                    Ok(body) => Cow::from(body),
7963                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
7964                                },
7965                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
7966                            }
7967                        ),
7968                        err_type,
7969                    ))
7970                }
7971            })
7972    }
7973
7974    fn delete_final_workflow_graph(
7975        &self,
7976        param_graph_id: uuid::Uuid,
7977        param_version: String,
7978    ) -> Result<(), ApiError> {
7979        let mut url = format!(
7980            "{}/v1/workflows/final/graphs/{graph_id}/{version}",
7981            self.base_path,
7982            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET),
7983            version = utf8_percent_encode(&param_version.to_string(), ID_ENCODE_SET)
7984        );
7985
7986        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
7987
7988        let query_string_str = query_string.finish();
7989        if !query_string_str.is_empty() {
7990            url += "?";
7991            url += &query_string_str;
7992        }
7993
7994        let url = match Url::from_str(&url) {
7995            Ok(url) => url,
7996            Err(err) => {
7997                return Err(ApiError::new(
7998                    format!("Unable to build URL: {}", err),
7999                    SimpleErrorType::Permanent,
8000                ))
8001            }
8002        };
8003
8004        let mut request = self.hyper_client.request(Method::Delete, url);
8005        request = request.headers(self.headers.clone());
8006
8007        request
8008            .send()
8009            .map_err(|e| {
8010                ApiError::new(
8011                    format!("No response received: {}", e),
8012                    SimpleErrorType::Permanent,
8013                )
8014            })
8015            .and_then(|mut response| match response.status.to_u16() {
8016                204 => {
8017                    let mut body = Vec::new();
8018                    response.read_to_end(&mut body).map_err(|e| {
8019                        ApiError::new(
8020                            format!("Failed to read response: {}", e),
8021                            SimpleErrorType::Temporary,
8022                        )
8023                    })?;
8024
8025                    Ok(())
8026                }
8027                code => {
8028                    let headers = response.headers.clone();
8029                    let mut body = Vec::new();
8030                    let result = response.read_to_end(&mut body);
8031                    let err_type = match response.status.is_server_error() {
8032                        false => SimpleErrorType::Permanent,
8033                        true => SimpleErrorType::Temporary,
8034                    };
8035                    Err(ApiError::new(
8036                        format!(
8037                            "Unexpected response code {}:\n{:?}\n\n{}",
8038                            code,
8039                            headers,
8040                            match result {
8041                                Ok(_) => match str::from_utf8(&body) {
8042                                    Ok(body) => Cow::from(body),
8043                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8044                                },
8045                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8046                            }
8047                        ),
8048                        err_type,
8049                    ))
8050                }
8051            })
8052    }
8053
8054    fn get_all_final_workflow_graphs(
8055        &self,
8056        param_name: Option<String>,
8057        param_description: Option<String>,
8058        param_all_search: Option<String>,
8059        param_sort_by: Option<String>,
8060        param_limit: Option<i32>,
8061        param_offset: Option<i32>,
8062    ) -> Result<models::GetAllFinalWorkflowGraphsResponse, ApiError> {
8063        let mut url = format!("{}/v1/workflows/final/graphs", self.base_path);
8064
8065        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8066
8067        if let Some(name) = param_name {
8068            query_string.append_pair("name", &name.to_string());
8069        }
8070        if let Some(description) = param_description {
8071            query_string.append_pair("description", &description.to_string());
8072        }
8073        if let Some(all_search) = param_all_search {
8074            query_string.append_pair("all_search", &all_search.to_string());
8075        }
8076        if let Some(sort_by) = param_sort_by {
8077            query_string.append_pair("sort_by", &sort_by.to_string());
8078        }
8079        if let Some(limit) = param_limit {
8080            query_string.append_pair("limit", &limit.to_string());
8081        }
8082        if let Some(offset) = param_offset {
8083            query_string.append_pair("offset", &offset.to_string());
8084        }
8085        let query_string_str = query_string.finish();
8086        if !query_string_str.is_empty() {
8087            url += "?";
8088            url += &query_string_str;
8089        }
8090
8091        let url = match Url::from_str(&url) {
8092            Ok(url) => url,
8093            Err(err) => {
8094                return Err(ApiError::new(
8095                    format!("Unable to build URL: {}", err),
8096                    SimpleErrorType::Permanent,
8097                ))
8098            }
8099        };
8100
8101        let mut request = self.hyper_client.request(Method::Get, url);
8102        request = request.headers(self.headers.clone());
8103
8104        request
8105            .send()
8106            .map_err(|e| {
8107                ApiError::new(
8108                    format!("No response received: {}", e),
8109                    SimpleErrorType::Permanent,
8110                )
8111            })
8112            .and_then(|mut response| match response.status.to_u16() {
8113                200 => {
8114                    let mut body = Vec::new();
8115                    response.read_to_end(&mut body).map_err(|e| {
8116                        ApiError::new(
8117                            format!("Failed to read response: {}", e),
8118                            SimpleErrorType::Temporary,
8119                        )
8120                    })?;
8121                    str::from_utf8(&body)
8122                        .map_err(|e| {
8123                            ApiError::new(
8124                                format!("Response was not valid UTF8: {}", e),
8125                                SimpleErrorType::Temporary,
8126                            )
8127                        })
8128                        .and_then(|body| {
8129                            serde_json::from_str::<models::GetAllFinalWorkflowGraphsResponse>(body)
8130                                .map_err(|e| e.into())
8131                        })
8132                }
8133                code => {
8134                    let headers = response.headers.clone();
8135                    let mut body = Vec::new();
8136                    let result = response.read_to_end(&mut body);
8137                    let err_type = match response.status.is_server_error() {
8138                        false => SimpleErrorType::Permanent,
8139                        true => SimpleErrorType::Temporary,
8140                    };
8141                    Err(ApiError::new(
8142                        format!(
8143                            "Unexpected response code {}:\n{:?}\n\n{}",
8144                            code,
8145                            headers,
8146                            match result {
8147                                Ok(_) => match str::from_utf8(&body) {
8148                                    Ok(body) => Cow::from(body),
8149                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8150                                },
8151                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8152                            }
8153                        ),
8154                        err_type,
8155                    ))
8156                }
8157            })
8158    }
8159
8160    fn get_final_workflow_graph(
8161        &self,
8162        param_graph_id: uuid::Uuid,
8163        param_version: String,
8164    ) -> Result<models::VersionInFinalWorkflow, ApiError> {
8165        let mut url = format!(
8166            "{}/v1/workflows/final/graphs/{graph_id}/{version}",
8167            self.base_path,
8168            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET),
8169            version = utf8_percent_encode(&param_version.to_string(), ID_ENCODE_SET)
8170        );
8171
8172        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8173
8174        let query_string_str = query_string.finish();
8175        if !query_string_str.is_empty() {
8176            url += "?";
8177            url += &query_string_str;
8178        }
8179
8180        let url = match Url::from_str(&url) {
8181            Ok(url) => url,
8182            Err(err) => {
8183                return Err(ApiError::new(
8184                    format!("Unable to build URL: {}", err),
8185                    SimpleErrorType::Permanent,
8186                ))
8187            }
8188        };
8189
8190        let mut request = self.hyper_client.request(Method::Get, url);
8191        request = request.headers(self.headers.clone());
8192
8193        request
8194            .send()
8195            .map_err(|e| {
8196                ApiError::new(
8197                    format!("No response received: {}", e),
8198                    SimpleErrorType::Permanent,
8199                )
8200            })
8201            .and_then(|mut response| match response.status.to_u16() {
8202                200 => {
8203                    let mut body = Vec::new();
8204                    response.read_to_end(&mut body).map_err(|e| {
8205                        ApiError::new(
8206                            format!("Failed to read response: {}", e),
8207                            SimpleErrorType::Temporary,
8208                        )
8209                    })?;
8210                    str::from_utf8(&body)
8211                        .map_err(|e| {
8212                            ApiError::new(
8213                                format!("Response was not valid UTF8: {}", e),
8214                                SimpleErrorType::Temporary,
8215                            )
8216                        })
8217                        .and_then(|body| {
8218                            serde_json::from_str::<models::VersionInFinalWorkflow>(body)
8219                                .map_err(|e| e.into())
8220                        })
8221                }
8222                code => {
8223                    let headers = response.headers.clone();
8224                    let mut body = Vec::new();
8225                    let result = response.read_to_end(&mut body);
8226                    let err_type = match response.status.is_server_error() {
8227                        false => SimpleErrorType::Permanent,
8228                        true => SimpleErrorType::Temporary,
8229                    };
8230                    Err(ApiError::new(
8231                        format!(
8232                            "Unexpected response code {}:\n{:?}\n\n{}",
8233                            code,
8234                            headers,
8235                            match result {
8236                                Ok(_) => match str::from_utf8(&body) {
8237                                    Ok(body) => Cow::from(body),
8238                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8239                                },
8240                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8241                            }
8242                        ),
8243                        err_type,
8244                    ))
8245                }
8246            })
8247    }
8248
8249    fn get_full_final_workflow_graph(
8250        &self,
8251        param_graph_id: uuid::Uuid,
8252    ) -> Result<models::FinalWorkflow, ApiError> {
8253        let mut url = format!(
8254            "{}/v1/workflows/final/graphs/{graph_id}",
8255            self.base_path,
8256            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET)
8257        );
8258
8259        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8260
8261        let query_string_str = query_string.finish();
8262        if !query_string_str.is_empty() {
8263            url += "?";
8264            url += &query_string_str;
8265        }
8266
8267        let url = match Url::from_str(&url) {
8268            Ok(url) => url,
8269            Err(err) => {
8270                return Err(ApiError::new(
8271                    format!("Unable to build URL: {}", err),
8272                    SimpleErrorType::Permanent,
8273                ))
8274            }
8275        };
8276
8277        let mut request = self.hyper_client.request(Method::Get, url);
8278        request = request.headers(self.headers.clone());
8279
8280        request
8281            .send()
8282            .map_err(|e| {
8283                ApiError::new(
8284                    format!("No response received: {}", e),
8285                    SimpleErrorType::Permanent,
8286                )
8287            })
8288            .and_then(|mut response| match response.status.to_u16() {
8289                200 => {
8290                    let mut body = Vec::new();
8291                    response.read_to_end(&mut body).map_err(|e| {
8292                        ApiError::new(
8293                            format!("Failed to read response: {}", e),
8294                            SimpleErrorType::Temporary,
8295                        )
8296                    })?;
8297                    str::from_utf8(&body)
8298                        .map_err(|e| {
8299                            ApiError::new(
8300                                format!("Response was not valid UTF8: {}", e),
8301                                SimpleErrorType::Temporary,
8302                            )
8303                        })
8304                        .and_then(|body| {
8305                            serde_json::from_str::<models::FinalWorkflow>(body)
8306                                .map_err(|e| e.into())
8307                        })
8308                }
8309                code => {
8310                    let headers = response.headers.clone();
8311                    let mut body = Vec::new();
8312                    let result = response.read_to_end(&mut body);
8313                    let err_type = match response.status.is_server_error() {
8314                        false => SimpleErrorType::Permanent,
8315                        true => SimpleErrorType::Temporary,
8316                    };
8317                    Err(ApiError::new(
8318                        format!(
8319                            "Unexpected response code {}:\n{:?}\n\n{}",
8320                            code,
8321                            headers,
8322                            match result {
8323                                Ok(_) => match str::from_utf8(&body) {
8324                                    Ok(body) => Cow::from(body),
8325                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8326                                },
8327                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8328                            }
8329                        ),
8330                        err_type,
8331                    ))
8332                }
8333            })
8334    }
8335
8336    fn update_final_workflow_graph(
8337        &self,
8338        param_graph_id: uuid::Uuid,
8339        param_body: models::CreateWorkflowVersionRequest,
8340    ) -> Result<models::VersionInFinalWorkflow, ApiError> {
8341        let mut url = format!(
8342            "{}/v1/workflows/final/graphs/{graph_id}",
8343            self.base_path,
8344            graph_id = utf8_percent_encode(&param_graph_id.to_string(), ID_ENCODE_SET)
8345        );
8346
8347        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8348
8349        let query_string_str = query_string.finish();
8350        if !query_string_str.is_empty() {
8351            url += "?";
8352            url += &query_string_str;
8353        }
8354
8355        let url = match Url::from_str(&url) {
8356            Ok(url) => url,
8357            Err(err) => {
8358                return Err(ApiError::new(
8359                    format!("Unable to build URL: {}", err),
8360                    SimpleErrorType::Permanent,
8361                ))
8362            }
8363        };
8364
8365        let mut request = self.hyper_client.request(Method::Post, url);
8366        request = request.headers(self.headers.clone());
8367        let body = serde_json::to_string(&param_body)
8368            .expect("impossible to fail to serialize")
8369            .into_bytes();
8370        request = request.body(body.as_slice());
8371
8372        request = request.header(ContentType(
8373            mimetypes::requests::UPDATE_FINAL_WORKFLOW_GRAPH.clone(),
8374        ));
8375
8376        request
8377            .send()
8378            .map_err(|e| {
8379                ApiError::new(
8380                    format!("No response received: {}", e),
8381                    SimpleErrorType::Permanent,
8382                )
8383            })
8384            .and_then(|mut response| match response.status.to_u16() {
8385                200 => {
8386                    let mut body = Vec::new();
8387                    response.read_to_end(&mut body).map_err(|e| {
8388                        ApiError::new(
8389                            format!("Failed to read response: {}", e),
8390                            SimpleErrorType::Temporary,
8391                        )
8392                    })?;
8393                    str::from_utf8(&body)
8394                        .map_err(|e| {
8395                            ApiError::new(
8396                                format!("Response was not valid UTF8: {}", e),
8397                                SimpleErrorType::Temporary,
8398                            )
8399                        })
8400                        .and_then(|body| {
8401                            serde_json::from_str::<models::VersionInFinalWorkflow>(body)
8402                                .map_err(|e| e.into())
8403                        })
8404                }
8405                code => {
8406                    let headers = response.headers.clone();
8407                    let mut body = Vec::new();
8408                    let result = response.read_to_end(&mut body);
8409                    let err_type = match response.status.is_server_error() {
8410                        false => SimpleErrorType::Permanent,
8411                        true => SimpleErrorType::Temporary,
8412                    };
8413                    Err(ApiError::new(
8414                        format!(
8415                            "Unexpected response code {}:\n{:?}\n\n{}",
8416                            code,
8417                            headers,
8418                            match result {
8419                                Ok(_) => match str::from_utf8(&body) {
8420                                    Ok(body) => Cow::from(body),
8421                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8422                                },
8423                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8424                            }
8425                        ),
8426                        err_type,
8427                    ))
8428                }
8429            })
8430    }
8431}
8432
8433impl ZoneApi for Client {
8434    type Error = ApiError;
8435
8436    fn get_zone(&self, param_zone_id: uuid::Uuid) -> Result<models::Zone, ApiError> {
8437        let mut url = format!(
8438            "{}/v1/zones/{zone_id}",
8439            self.base_path,
8440            zone_id = utf8_percent_encode(&param_zone_id.to_string(), ID_ENCODE_SET)
8441        );
8442
8443        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8444
8445        let query_string_str = query_string.finish();
8446        if !query_string_str.is_empty() {
8447            url += "?";
8448            url += &query_string_str;
8449        }
8450
8451        let url = match Url::from_str(&url) {
8452            Ok(url) => url,
8453            Err(err) => {
8454                return Err(ApiError::new(
8455                    format!("Unable to build URL: {}", err),
8456                    SimpleErrorType::Permanent,
8457                ))
8458            }
8459        };
8460
8461        let mut request = self.hyper_client.request(Method::Get, url);
8462        request = request.headers(self.headers.clone());
8463
8464        request
8465            .send()
8466            .map_err(|e| {
8467                ApiError::new(
8468                    format!("No response received: {}", e),
8469                    SimpleErrorType::Permanent,
8470                )
8471            })
8472            .and_then(|mut response| match response.status.to_u16() {
8473                200 => {
8474                    let mut body = Vec::new();
8475                    response.read_to_end(&mut body).map_err(|e| {
8476                        ApiError::new(
8477                            format!("Failed to read response: {}", e),
8478                            SimpleErrorType::Temporary,
8479                        )
8480                    })?;
8481                    str::from_utf8(&body)
8482                        .map_err(|e| {
8483                            ApiError::new(
8484                                format!("Response was not valid UTF8: {}", e),
8485                                SimpleErrorType::Temporary,
8486                            )
8487                        })
8488                        .and_then(|body| {
8489                            serde_json::from_str::<models::Zone>(body).map_err(|e| e.into())
8490                        })
8491                }
8492                code => {
8493                    let headers = response.headers.clone();
8494                    let mut body = Vec::new();
8495                    let result = response.read_to_end(&mut body);
8496                    let err_type = match response.status.is_server_error() {
8497                        false => SimpleErrorType::Permanent,
8498                        true => SimpleErrorType::Temporary,
8499                    };
8500                    Err(ApiError::new(
8501                        format!(
8502                            "Unexpected response code {}:\n{:?}\n\n{}",
8503                            code,
8504                            headers,
8505                            match result {
8506                                Ok(_) => match str::from_utf8(&body) {
8507                                    Ok(body) => Cow::from(body),
8508                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8509                                },
8510                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8511                            }
8512                        ),
8513                        err_type,
8514                    ))
8515                }
8516            })
8517    }
8518
8519    fn get_zone_join_token(
8520        &self,
8521        param_zone_id: uuid::Uuid,
8522    ) -> Result<models::ZoneJoinToken, ApiError> {
8523        let mut url = format!(
8524            "{}/v1/zones/{zone_id}/token",
8525            self.base_path,
8526            zone_id = utf8_percent_encode(&param_zone_id.to_string(), ID_ENCODE_SET)
8527        );
8528
8529        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8530
8531        let query_string_str = query_string.finish();
8532        if !query_string_str.is_empty() {
8533            url += "?";
8534            url += &query_string_str;
8535        }
8536
8537        let url = match Url::from_str(&url) {
8538            Ok(url) => url,
8539            Err(err) => {
8540                return Err(ApiError::new(
8541                    format!("Unable to build URL: {}", err),
8542                    SimpleErrorType::Permanent,
8543                ))
8544            }
8545        };
8546
8547        let mut request = self.hyper_client.request(Method::Get, url);
8548        request = request.headers(self.headers.clone());
8549
8550        request
8551            .send()
8552            .map_err(|e| {
8553                ApiError::new(
8554                    format!("No response received: {}", e),
8555                    SimpleErrorType::Permanent,
8556                )
8557            })
8558            .and_then(|mut response| match response.status.to_u16() {
8559                200 => {
8560                    let mut body = Vec::new();
8561                    response.read_to_end(&mut body).map_err(|e| {
8562                        ApiError::new(
8563                            format!("Failed to read response: {}", e),
8564                            SimpleErrorType::Temporary,
8565                        )
8566                    })?;
8567                    str::from_utf8(&body)
8568                        .map_err(|e| {
8569                            ApiError::new(
8570                                format!("Response was not valid UTF8: {}", e),
8571                                SimpleErrorType::Temporary,
8572                            )
8573                        })
8574                        .and_then(|body| {
8575                            serde_json::from_str::<models::ZoneJoinToken>(body)
8576                                .map_err(|e| e.into())
8577                        })
8578                }
8579                code => {
8580                    let headers = response.headers.clone();
8581                    let mut body = Vec::new();
8582                    let result = response.read_to_end(&mut body);
8583                    let err_type = match response.status.is_server_error() {
8584                        false => SimpleErrorType::Permanent,
8585                        true => SimpleErrorType::Temporary,
8586                    };
8587                    Err(ApiError::new(
8588                        format!(
8589                            "Unexpected response code {}:\n{:?}\n\n{}",
8590                            code,
8591                            headers,
8592                            match result {
8593                                Ok(_) => match str::from_utf8(&body) {
8594                                    Ok(body) => Cow::from(body),
8595                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8596                                },
8597                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8598                            }
8599                        ),
8600                        err_type,
8601                    ))
8602                }
8603            })
8604    }
8605
8606    fn get_zones(&self) -> Result<Vec<models::Zone>, ApiError> {
8607        let mut url = format!("{}/v1/zones", self.base_path);
8608
8609        let mut query_string = self::url::form_urlencoded::Serializer::new("".to_owned());
8610
8611        let query_string_str = query_string.finish();
8612        if !query_string_str.is_empty() {
8613            url += "?";
8614            url += &query_string_str;
8615        }
8616
8617        let url = match Url::from_str(&url) {
8618            Ok(url) => url,
8619            Err(err) => {
8620                return Err(ApiError::new(
8621                    format!("Unable to build URL: {}", err),
8622                    SimpleErrorType::Permanent,
8623                ))
8624            }
8625        };
8626
8627        let mut request = self.hyper_client.request(Method::Get, url);
8628        request = request.headers(self.headers.clone());
8629
8630        request
8631            .send()
8632            .map_err(|e| {
8633                ApiError::new(
8634                    format!("No response received: {}", e),
8635                    SimpleErrorType::Permanent,
8636                )
8637            })
8638            .and_then(|mut response| match response.status.to_u16() {
8639                200 => {
8640                    let mut body = Vec::new();
8641                    response.read_to_end(&mut body).map_err(|e| {
8642                        ApiError::new(
8643                            format!("Failed to read response: {}", e),
8644                            SimpleErrorType::Temporary,
8645                        )
8646                    })?;
8647                    str::from_utf8(&body)
8648                        .map_err(|e| {
8649                            ApiError::new(
8650                                format!("Response was not valid UTF8: {}", e),
8651                                SimpleErrorType::Temporary,
8652                            )
8653                        })
8654                        .and_then(|body| {
8655                            serde_json::from_str::<Vec<models::Zone>>(body).map_err(|e| e.into())
8656                        })
8657                }
8658                code => {
8659                    let headers = response.headers.clone();
8660                    let mut body = Vec::new();
8661                    let result = response.read_to_end(&mut body);
8662                    let err_type = match response.status.is_server_error() {
8663                        false => SimpleErrorType::Permanent,
8664                        true => SimpleErrorType::Temporary,
8665                    };
8666                    Err(ApiError::new(
8667                        format!(
8668                            "Unexpected response code {}:\n{:?}\n\n{}",
8669                            code,
8670                            headers,
8671                            match result {
8672                                Ok(_) => match str::from_utf8(&body) {
8673                                    Ok(body) => Cow::from(body),
8674                                    Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
8675                                },
8676                                Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
8677                            }
8678                        ),
8679                        err_type,
8680                    ))
8681                }
8682            })
8683    }
8684}
8685
8686#[derive(Debug)]
8687pub enum ClientInitError {
8688    InvalidScheme,
8689    InvalidUri(hyper::error::ParseError),
8690    MissingHost,
8691}
8692
8693impl From<hyper::error::ParseError> for ClientInitError {
8694    fn from(err: hyper::error::ParseError) -> ClientInitError {
8695        ClientInitError::InvalidUri(err)
8696    }
8697}
8698
8699impl fmt::Display for ClientInitError {
8700    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
8701        <Self as fmt::Debug>::fmt(self, f)
8702    }
8703}
8704
8705impl error::Error for ClientInitError {
8706    fn description(&self) -> &str {
8707        "Failed to produce a hyper client."
8708    }
8709}
8710
8711fn deserialize_config_checked(
8712    raw_config: &str,
8713    expected_hash: &[u8; SHA256_BYTE_LENGTH],
8714) -> Result<models::RuntimeAppConfig, ApiError> {
8715    let result = serde_json::from_str::<models::RuntimeAppConfig>(&raw_config).map_err(|e| {
8716        ApiError::new(
8717            format!("Failed to serialize RuntimeAppConfig to json: {}", e),
8718            SimpleErrorType::Permanent,
8719        )
8720    })?;
8721
8722    let hashed_config_part = serde_json::to_string(&result.config).map_err(|e| {
8723        ApiError::new(
8724            format!("Failed to serialize HashedConfig to json: {}", e),
8725            SimpleErrorType::Permanent,
8726        )
8727    })?;
8728
8729    let hash = compute_sha256(hashed_config_part.as_bytes()).map_err(|e| {
8730        ApiError::new(
8731            format!("Unable to hash app config: {}", e),
8732            SimpleErrorType::Permanent,
8733        )
8734    })?;
8735
8736    if hash != *expected_hash {
8737        Err(ApiError::new(
8738            format!(
8739                "App config hash mismatch. Expected {:?}, but got {:?}.",
8740                hash, expected_hash
8741            )
8742            .to_string(),
8743            SimpleErrorType::Permanent,
8744        ))
8745    } else {
8746        Ok(result)
8747    }
8748}
8749
8750fn compute_sha256(input: &[u8]) -> Result<[u8; SHA256_BYTE_LENGTH], ApiError> {
8751    use mbedtls::hash::{Md, Type};
8752    let mut digest = [0; SHA256_BYTE_LENGTH];
8753    Md::hash(Type::Sha256, input, &mut digest).map_err(|e| {
8754        ApiError::new(
8755            format!("Unable to hash app config: {}", e),
8756            SimpleErrorType::Permanent,
8757        )
8758    })?;
8759
8760    Ok(digest)
8761}
8762
8763#[cfg(test)]
8764mod tests {
8765    use crate::{ApplicationConfigApi, Client, Sha256Hash, SHA256_BYTE_LENGTH, SHA256_CHAR_LENGTH};
8766    use client::deserialize_config_checked;
8767    use std::convert::{From, TryFrom};
8768
8769    #[test]
8770    fn test_valid_hash() {
8771        let json_data = r#"{"config":{"app_config":{"/opt/fortanix/enclave-os/app-config/rw/harmonize.txt":{"contents":"WyB7ICJiZWZvcmUiOiAiTGl2aW5nIiwgImFmdGVyIjogIkhhcHB5IiB9LCB7ICJiZWZvcmUiOiAiRGVjZWFzZWQiLCAiYWZ0ZXIiOiAiVW5oYXBweSIgfV0="}},"labels":{"location":"East US"},"zone_ca":["-----BEGIN CERTIFICATE-----\nMIIFGDCCA4CgAwIBAgIUHQCD590cMmMiUisayBBbQOdCKNUwDQYJKoZIhvcNAQEL\nBQAwgZIxNTAzBgsrBgEEAYOEGgEDAQwkZTMzNThjYjQtNWY2ZS00ZDFjLWFkN2Mt\nZGFmODc0ZGNmNzc4MTUwMwYLKwYBBAGDhBoBAwIMJGI3ZTMxMDQ3LThmZmYtNDdh\nMi05ODY1LWJjZjQwYmRmYjdlMjEiMCAGA1UEAwwZRGVmYXVsdCBFbmNsYXZlIFpv\nbmUgUm9vdDAeFw0yNDExMTkxMTU3NTFaFw0yOTExMTkxMTU3NTFaMIGSMTUwMwYL\nKwYBBAGDhBoBAwEMJGUzMzU4Y2I0LTVmNmUtNGQxYy1hZDdjLWRhZjg3NGRjZjc3\nODE1MDMGCysGAQQBg4QaAQMCDCRiN2UzMTA0Ny04ZmZmLTQ3YTItOTg2NS1iY2Y0\nMGJkZmI3ZTIxIjAgBgNVBAMMGURlZmF1bHQgRW5jbGF2ZSBab25lIFJvb3QwggGi\nMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDFTQXxYCihCZNPmBOL83peXl8N\nX4z5xx6PYpMkPaDLffKYidSYx8BeYlq7J/fB074NmuoL/ArygWRCdTfylWPnIyvx\n9kWQEdiK5EW0p1+mtgXdV4H61b+QjE5Jrtp7liZE/fKMGRMpvd8Gx4WkZwDyZo2n\nhc5mimULHNFTm1fE+gwUcg2b9z95n6NA3XAx/2AROkaYWka5wq2D6qU+Lo+ZRaNM\neccovOQH/7VZUxvMTVpFZLiccqJjHpFJ4O+0648HzLLaefiFGYMuEhfUN8To6JuU\ns6pY3j0UbYciBaOsWRZk4KjxLBkKJd3YqFkdExAu4yGuw7qoEZWpJ2gOu04evPBr\n5fhnH7X65ndYv2bJqtCcGjuVlICtsgP1K/zjd5WtpFAUpJCeGZFKdk/iT2ehRKnX\nnMLM0rrZWCbgSooB/Mo8omZNwe3PUDQ0CBiIKjWCn6tXnGTjER7uyp2C1LcloqBZ\nKK1XS6pTUMqkYRZGbhK+oBAJstV7hyEDonpC0skCAwEAAaNkMGIwDwYDVR0TAQH/\nBAUwAwEB/zAPBgNVHQ8BAf8EBQMDB4YAMB8GA1UdIwQYMBaAFGCJitDjMB1j9w4w\nKSl4zomn0EsYMB0GA1UdDgQWBBRgiYrQ4zAdY/cOMCkpeM6Jp9BLGDANBgkqhkiG\n9w0BAQsFAAOCAYEAUhz55qRSdC57EMq+JpKveT38rlcPYyhpVVL7kWTyHnKZjUAa\nQ9bPDGvq3yAQwLnI9DUyjpAzJPqJVP/ZFM633RrTtqNYEykatvYH0tgWhRcCyIE2\nZuqp8vqukzwdcCpZmNDrKM+XYk6Y/XoMNgF7nkiaDyFBRti4F6CzPk+St5xO1cpW\nz0vDWX+TbaZpj/iP8DI5XfIfEVG1P15A/zg5z5YObCPmslZYDeG3j7D2cUF9QvwT\nKs+MZUYXSIKCYDwPsHF+wo9lEh+2qbczY4Pno0SjamyrbZh6nUQ4aFVA2+6L+Pom\nQKtoA+VxXkD4yayhkAEK9GLxXFknnerC09IEs9FePl2WW8TzSLH2orBT/W/+1762\nn+MUiMgkb/r/CULaPCP6kmlceLCRUhdVogInSGV7R7RGyCUZNx30Foy2EFDsC4zs\nCsKQ2rkYDYXKyJovnr8pTlKMLczlvBsDztwlVhsKHKd+qLz1G0fFBqOmI0ktXQnt\nzVHIOmasuRWcoVXl\n-----END CERTIFICATE-----\n"],"workflow":{"workflow_id":"93156096-5ed4-41ad-ae23-19e8fab1e0af","app_name":"app-1","port_map":{"input":{"input-1":{"dataset":{"id":"141c73d4-36f2-4185-bc75-40e2f7f4f235"}}},"output":{"output-1":{"dataset":{"id":"d63b3d7d-72a1-466d-8df2-8e18f3d647ea"}}}}}},"extra":{"connections":{}}}"#;
8772
8773        let expected_hash = Sha256Hash::try_from(
8774            "0d0374f1f982570abcbe0c687deb54a708d56744ff4b5356810352d9ec8ae495",
8775        )
8776        .unwrap();
8777        let result = deserialize_config_checked(json_data, &expected_hash.0);
8778
8779        assert!(result.is_ok())
8780    }
8781
8782    #[test]
8783    fn test_valid_hash_additional_fields_in_workflow() {
8784        let json_data = r#"{"config":{"app_config":{"TestKey":{"contents":"U29tZXRoaW5nIG9mIHZhbHVl"}},"labels":{},"zone_ca":["-----BEGIN CERTIFICATE-----\nMIIFGDCCA4CgAwIBAgIUbOw7KSJs9E1tYTVl0Y5UxZjnoXwwDQYJKoZIhvcNAQEL\nBQAwgZIxNTAzBgsrBgEEAYOEGgEDAQwkYzUyMzJjOTYtMjliYy00Yzg5LWFmY2Qt\nZWU4ZTc3MmRmNTEzMTUwMwYLKwYBBAGDhBoBAwIMJDA1YjJkY2FlLWI5MjktNDg2\nNy05ZDI0LWZjMTRmYzJhM2UwZTEiMCAGA1UEAwwZRGVmYXVsdCBFbmNsYXZlIFpv\nbmUgUm9vdDAeFw0yNDEwMTQxMDIyMjNaFw0yOTEwMTQxMDIyMjNaMIGSMTUwMwYL\nKwYBBAGDhBoBAwEMJGM1MjMyYzk2LTI5YmMtNGM4OS1hZmNkLWVlOGU3NzJkZjUx\nMzE1MDMGCysGAQQBg4QaAQMCDCQwNWIyZGNhZS1iOTI5LTQ4NjctOWQyNC1mYzE0\nZmMyYTNlMGUxIjAgBgNVBAMMGURlZmF1bHQgRW5jbGF2ZSBab25lIFJvb3QwggGi\nMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDbiPKi09IKYVN507z8l2hpWs92\nkFwhfxwtp2m4wL61AGNwjJKYj+sX7cUsxZn3mq3RFtBM5DHH//6Fk70nXdfST+jG\n2F1GXQXqnicLeqnFTvtPQW/tR4GqnpG5ck1vz99xmWDacgfYkcNImU2r8naojCUs\nOR6mnOiOAOHrVIscNhuyhbIS8wlYeXjXKUbt4xBMZSzQXM4/sG4PvPdfnov8GUUY\nZwv31roMZBMq28nuuD2FcHi+jnwNwBztX3SggsIBtqREEVtAyomXnIuGu3wzNvH7\nqnNFJb+WyAwtyfATK1QFgpIiwr/sttEc7SWSGrAJE1eJrda657o6pxEWMRUCNy01\nZgsseJQlRLoCrgbklpjmqny4w7kpN6u2lQ0whfU+0Y4PWhgpSzgqZsEnJ17/vs41\nX3Xm5stSlNftFMmJa4ugBjOgsKmcJnokmBlhV6UHP4r24Zxw8qhXHd6Ve6sFyE0/\nl4ix4VjRWGFms3XgPNwAYF2AQB+82ezS/XY7lO0CAwEAAaNkMGIwDwYDVR0TAQH/\nBAUwAwEB/zAPBgNVHQ8BAf8EBQMDB4YAMB8GA1UdIwQYMBaAFKYkCG35BodJnsGO\nsn8rLERR/gZ5MB0GA1UdDgQWBBSmJAht+QaHSZ7BjrJ/KyxEUf4GeTANBgkqhkiG\n9w0BAQsFAAOCAYEAEkwQiDoeWZSKg1juQWVH7ND7ynbMQWWii4Gzf7ljpA6WjTCC\nl4ZBfi1uzn5vQlLR6Hvtxt+RNPupolCmShPmi07Ykmch4K+vgX374HVJxyb4s39U\n1IpIwucNxgtKATU+uPQ92yL0bf5K6RmOjr3tKslOTicWk1LBoclVqfqubeMAF3Ir\nz3uPlbSFSWuEGmkGUS6VqpGfzzCVpztecOzQ3wMLMrd3/luugn0GzoKAjy5gAiIS\nFqTC6xeYMy6YSlOioPqxsOckPOtpwtXI5cvTWdcqGq+tAxejAYmFj02Ct4MbljKg\n1RDjE/wMYz9EdJY6qfIL3ygst4wDCqHTrBsCRpU4kkfo9EoY2aqYwx1DBH0iobVB\nl1iKSjY777mhIMMuFl9+nOP+uuj1VF9chbkkH6s/eLBOKS5mPCr5IzJ2fGGCWRJ5\nTLNdNknTwF9RjiQfnFes1dwn5U5CG1b0lVPekeK8XmLgrxLKSaSyufCtWiDuGnSw\nl9PSKFeq622R9rXy\n-----END CERTIFICATE-----\n"],"workflow":{"workflow_id":"daf9b79a-1519-43ac-a519-08ea32840894","app_name":"stlw0qv3t","port_map":{},"app_acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","app_group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}},"extra":{"connections":{}}}"#;
8785
8786        let expected_hash = Sha256Hash::try_from(
8787            "c79839b310ca6c8ab281d05a3f3e9ebeddb4aa3f669c2c302110dead30894ce9",
8788        )
8789        .unwrap();
8790        let result = deserialize_config_checked(json_data, &expected_hash.0);
8791
8792        assert!(result.is_ok())
8793    }
8794
8795    // commented out because changing config json manually and recomputing the hash using 'sha256sum' might produce faulty tests.
8796    /*#[test]
8797    fn test_valid_hash_with_data_sets() {
8798        // A modified version of RuntimeAppConfig with included datasets and sanitized personal data.
8799        // The expected hash in this case comes from running 'sha256sum` utility over the json.
8800        let json_data = r#"{"config":{"app_config":{},"labels":{"autoshutdown":"True","location":"East US","mxK4gaGv":"lLI6hgIA"},"zone_ca":["Certificate"],"workflow":{"workflow_id":"c375e923-1390-4440-b9e6-ad9977557e5e","app_name":"vZq7oNK9","port_map":{"input":{"2RAsgVoI":{"dataset":{"id":"e97447d5-6e1f-4cc8-9a56-cf4502f9ddd0","acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}}},"output":{"bZbrS5DR":{"dataset":{"id":"0e7af6ec-4268-40ec-b341-cd17037dfb25","acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}}}},"app_acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","app_group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}},"extra":{"connections":{"input":{"2RAsgVoI":{"dataset":{"location":"some-location","credentials":{"sdkms":{"credentials_url":"some-url","credentials_key_name":"some-key","sdkms_app_id":"0b73608a-0e2c-42e5-ba12-64f13e165120"}}}}},"output":{"bZbrS5DR":{"dataset":{"location":"some-location","credentials":{"sdkms":{"credentials_url":"some-url","credentials_key_name":"some-key","sdkms_app_id":"0b73608a-0e2c-42e5-ba12-64f13e165120"}}}}}}}}"#;
8801        let expected_hash = Sha256Hash::try_from("2f4886ff1efa09773e3b656fb5b9a31d0439fdeecbe12d61a6767651466cbbc4").unwrap();
8802        let result = deserialize_config_checked(json_data, &expected_hash.0);
8803        assert!(result.is_ok())
8804    }*/
8805
8806    #[test]
8807    fn test_valid_hash_with_application() {
8808        let json_data = r#"{"config":{"app_config":{},"labels":{"Um4J7P5P":"WSKsYIJs","autoshutdown":"True","location":"East US"},"zone_ca":["-----BEGIN CERTIFICATE-----\nMIIFGDCCA4CgAwIBAgIUbOw7KSJs9E1tYTVl0Y5UxZjnoXwwDQYJKoZIhvcNAQEL\nBQAwgZIxNTAzBgsrBgEEAYOEGgEDAQwkYzUyMzJjOTYtMjliYy00Yzg5LWFmY2Qt\nZWU4ZTc3MmRmNTEzMTUwMwYLKwYBBAGDhBoBAwIMJDA1YjJkY2FlLWI5MjktNDg2\nNy05ZDI0LWZjMTRmYzJhM2UwZTEiMCAGA1UEAwwZRGVmYXVsdCBFbmNsYXZlIFpv\nbmUgUm9vdDAeFw0yNDEwMTQxMDIyMjNaFw0yOTEwMTQxMDIyMjNaMIGSMTUwMwYL\nKwYBBAGDhBoBAwEMJGM1MjMyYzk2LTI5YmMtNGM4OS1hZmNkLWVlOGU3NzJkZjUx\nMzE1MDMGCysGAQQBg4QaAQMCDCQwNWIyZGNhZS1iOTI5LTQ4NjctOWQyNC1mYzE0\nZmMyYTNlMGUxIjAgBgNVBAMMGURlZmF1bHQgRW5jbGF2ZSBab25lIFJvb3QwggGi\nMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDbiPKi09IKYVN507z8l2hpWs92\nkFwhfxwtp2m4wL61AGNwjJKYj+sX7cUsxZn3mq3RFtBM5DHH//6Fk70nXdfST+jG\n2F1GXQXqnicLeqnFTvtPQW/tR4GqnpG5ck1vz99xmWDacgfYkcNImU2r8naojCUs\nOR6mnOiOAOHrVIscNhuyhbIS8wlYeXjXKUbt4xBMZSzQXM4/sG4PvPdfnov8GUUY\nZwv31roMZBMq28nuuD2FcHi+jnwNwBztX3SggsIBtqREEVtAyomXnIuGu3wzNvH7\nqnNFJb+WyAwtyfATK1QFgpIiwr/sttEc7SWSGrAJE1eJrda657o6pxEWMRUCNy01\nZgsseJQlRLoCrgbklpjmqny4w7kpN6u2lQ0whfU+0Y4PWhgpSzgqZsEnJ17/vs41\nX3Xm5stSlNftFMmJa4ugBjOgsKmcJnokmBlhV6UHP4r24Zxw8qhXHd6Ve6sFyE0/\nl4ix4VjRWGFms3XgPNwAYF2AQB+82ezS/XY7lO0CAwEAAaNkMGIwDwYDVR0TAQH/\nBAUwAwEB/zAPBgNVHQ8BAf8EBQMDB4YAMB8GA1UdIwQYMBaAFKYkCG35BodJnsGO\nsn8rLERR/gZ5MB0GA1UdDgQWBBSmJAht+QaHSZ7BjrJ/KyxEUf4GeTANBgkqhkiG\n9w0BAQsFAAOCAYEAEkwQiDoeWZSKg1juQWVH7ND7ynbMQWWii4Gzf7ljpA6WjTCC\nl4ZBfi1uzn5vQlLR6Hvtxt+RNPupolCmShPmi07Ykmch4K+vgX374HVJxyb4s39U\n1IpIwucNxgtKATU+uPQ92yL0bf5K6RmOjr3tKslOTicWk1LBoclVqfqubeMAF3Ir\nz3uPlbSFSWuEGmkGUS6VqpGfzzCVpztecOzQ3wMLMrd3/luugn0GzoKAjy5gAiIS\nFqTC6xeYMy6YSlOioPqxsOckPOtpwtXI5cvTWdcqGq+tAxejAYmFj02Ct4MbljKg\n1RDjE/wMYz9EdJY6qfIL3ygst4wDCqHTrBsCRpU4kkfo9EoY2aqYwx1DBH0iobVB\nl1iKSjY777mhIMMuFl9+nOP+uuj1VF9chbkkH6s/eLBOKS5mPCr5IzJ2fGGCWRJ5\nTLNdNknTwF9RjiQfnFes1dwn5U5CG1b0lVPekeK8XmLgrxLKSaSyufCtWiDuGnSw\nl9PSKFeq622R9rXy\n-----END CERTIFICATE-----\n"],"workflow":{"workflow_id":"c375e923-1390-4440-b9e6-ad9977557e5e","app_name":"chncthgm6","port_map":{"input":{"vZq7oNK9":{"application":{"acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}}}},"app_acct_id":"c5232c96-29bc-4c89-afcd-ee8e772df513","app_group_id":"5ce01a15-4c14-479c-834f-1ddd485dfeb2"}},"extra":{"connections":{"input":{"vZq7oNK9":{"application":{"workflow_domain":"vZq7oNK9.c375e923-1390-4440-b9e6-ad9977557e5e.workflow.fortanix.cloud"}}}}}}"#;
8809
8810        let expected_hash = Sha256Hash::try_from(
8811            "43fd2e42e40365622fa81d3a3037b6ae130b552dc5f026d8c4168f89c7ff20c8",
8812        )
8813        .unwrap();
8814        let result = deserialize_config_checked(json_data, &expected_hash.0);
8815
8816        assert!(result.is_ok())
8817    }
8818
8819    #[test]
8820    fn test_remap_operation_path() {
8821        let mut client = Client::try_new_http("http://example.com:1234").unwrap();
8822        assert_eq!(
8823            client.remap_operation_path("/v1/test/path/no_remap"),
8824            "/v1/test/path/no_remap"
8825        );
8826        assert_eq!(
8827            client.remap_operation_path("/v1/test/654389468329ferugfirwvbyr/no_remap"),
8828            "/v1/test/654389468329ferugfirwvbyr/no_remap"
8829        );
8830        client.set_use_new_paths(true);
8831        assert_eq!(
8832            client.remap_operation_path("/v1/something/path/remap"),
8833            "/api/v1/confidential_computing/something/path/remap"
8834        );
8835        assert_eq!(
8836            client.remap_operation_path("/v1/test/654389468329ferugfirwvbyr/remap"),
8837            "/api/v1/confidential_computing/test/654389468329ferugfirwvbyr/remap"
8838        );
8839    }
8840
8841    #[test]
8842    fn test_mock_use_new_paths() {
8843        // Request a new server from the pool
8844        let mut server = mockito::Server::new();
8845        let expected_hash = Sha256Hash::try_from(
8846            "43fd2e42e40365622fa81d3a3037b6ae130b552dc5f026d8c4168f89c7ff20c8",
8847        )
8848        .unwrap();
8849
8850        let url = server.url();
8851        let mut client = Client::try_new_http(&url).unwrap();
8852        // check that the old path is used before remap is enabled
8853        let mock_remap_path = server
8854            .mock("GET", "/v1/runtime/app_configs")
8855            .with_status(201)
8856            .create();
8857        let _ = client.get_runtime_application_config(&expected_hash);
8858        mock_remap_path.assert();
8859
8860        client.set_use_new_paths(true);
8861        // check that the new path is used after remap is enabled
8862        let mock_remap_path = server
8863            .mock("GET", "/api/v1/confidential_computing/runtime/app_configs")
8864            .with_status(201)
8865            .create();
8866
8867        let _ = client.get_runtime_application_config(&expected_hash);
8868        mock_remap_path.assert();
8869    }
8870}
em_client/client/mod.rs

em_client/client/
mod.rs
