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

em_client/client/
mod.rs
