use async_trait::async_trait;
use futures::{Stream, future, future::BoxFuture, stream, future::TryFutureExt, future::FutureExt, stream::StreamExt};
use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
use hyper::{Body, Request, Response, service::Service, Uri};
use percent_encoding::{utf8_percent_encode, AsciiSet};
use std::borrow::Cow;
use std::convert::TryInto;
use std::io::{ErrorKind, Read};
use std::error::Error;
use std::future::Future;
use std::fmt;
use std::marker::PhantomData;
use std::path::Path;
use std::sync::{Arc, Mutex};
use std::str;
use std::str::FromStr;
use std::string::ToString;
use std::task::{Context, Poll};
use swagger::{ApiError, AuthData, BodyExt, Connector, DropContextService, Has, XSpanIdString};
use url::form_urlencoded;
use mime::Mime;
use std::io::Cursor;
use multipart::client::lazy::Multipart;
use crate::models;
use crate::header;
#[allow(dead_code)]
const FRAGMENT_ENCODE_SET: &AsciiSet = &percent_encoding::CONTROLS
.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
#[allow(dead_code)]
const ID_ENCODE_SET: &AsciiSet = &FRAGMENT_ENCODE_SET.add(b'|');
use crate::{Api,
AddPetResponse,
DeletePetResponse,
FindPetsByStatusResponse,
FindPetsByTagsResponse,
GetPetByIdResponse,
UpdatePetResponse,
UpdatePetWithFormResponse,
UploadFileResponse,
DeleteOrderResponse,
GetInventoryResponse,
GetOrderByIdResponse,
PlaceOrderResponse,
CreateUserResponse,
CreateUsersWithArrayInputResponse,
CreateUsersWithListInputResponse,
DeleteUserResponse,
GetUserByNameResponse,
LoginUserResponse,
LogoutUserResponse,
UpdateUserResponse
};
fn into_base_path(input: impl TryInto<Uri, Error=hyper::http::uri::InvalidUri>, correct_scheme: Option<&'static str>) -> Result<String, ClientInitError> {
let uri = input.try_into()?;
let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?;
if let Some(correct_scheme) = correct_scheme {
if scheme != correct_scheme {
return Err(ClientInitError::InvalidScheme);
}
}
let host = uri.host().ok_or_else(|| ClientInitError::MissingHost)?;
let port = uri.port_u16().map(|x| format!(":{}", x)).unwrap_or_default();
Ok(format!("{}://{}{}{}", scheme, host, port, uri.path().trim_end_matches('/')))
}
pub struct Client<S, C> where
S: Service<
(Request<Body>, C),
Response=Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<crate::ServiceError> + fmt::Display,
C: Clone + Send + Sync + 'static
{
client_service: S,
base_path: String,
marker: PhantomData<fn(C)>,
}
impl<S, C> fmt::Debug for Client<S, C> where
S: Service<
(Request<Body>, C),
Response=Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<crate::ServiceError> + fmt::Display,
C: Clone + Send + Sync + 'static
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Client {{ base_path: {} }}", self.base_path)
}
}
impl<S, C> Clone for Client<S, C> where
S: Service<
(Request<Body>, C),
Response=Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<crate::ServiceError> + fmt::Display,
C: Clone + Send + Sync + 'static
{
fn clone(&self) -> Self {
Self {
client_service: self.client_service.clone(),
base_path: self.base_path.clone(),
marker: PhantomData,
}
}
}
impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Body>, C>, C> where
Connector: hyper::client::connect::Connect + Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static,
{
pub fn try_new_with_connector(
base_path: &str,
protocol: Option<&'static str>,
connector: Connector,
) -> Result<Self, ClientInitError>
{
let client_service = hyper::client::Client::builder().build(connector);
let client_service = DropContextService::new(client_service);
Ok(Self {
client_service,
base_path: into_base_path(base_path, protocol)?,
marker: PhantomData,
})
}
}
#[derive(Debug, Clone)]
pub enum HyperClient {
Http(hyper::client::Client<hyper::client::HttpConnector, Body>),
Https(hyper::client::Client<HttpsConnector, Body>),
}
impl Service<Request<Body>> for HyperClient {
type Response = Response<Body>;
type Error = hyper::Error;
type Future = hyper::client::ResponseFuture;
fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
match self {
HyperClient::Http(client) => client.poll_ready(cx),
HyperClient::Https(client) => client.poll_ready(cx),
}
}
fn call(&mut self, req: Request<Body>) -> Self::Future {
match self {
HyperClient::Http(client) => client.call(req),
HyperClient::Https(client) => client.call(req)
}
}
}
impl<C> Client<DropContextService<HyperClient, C>, C> where
C: Clone + Send + Sync + 'static,
{
pub fn try_new(
base_path: &str,
) -> Result<Self, ClientInitError> {
let uri = Uri::from_str(base_path)?;
let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?;
let scheme = scheme.to_ascii_lowercase();
let connector = Connector::builder();
let client_service = match scheme.as_str() {
"http" => {
HyperClient::Http(hyper::client::Client::builder().build(connector.build()))
},
"https" => {
let connector = connector.https()
.build()
.map_err(|e| ClientInitError::SslError(e))?;
HyperClient::Https(hyper::client::Client::builder().build(connector))
},
_ => {
return Err(ClientInitError::InvalidScheme);
}
};
let client_service = DropContextService::new(client_service);
Ok(Self {
client_service,
base_path: into_base_path(base_path, None)?,
marker: PhantomData,
})
}
}
impl<C> Client<DropContextService<hyper::client::Client<hyper::client::HttpConnector, Body>, C>, C> where
C: Clone + Send + Sync + 'static
{
pub fn try_new_http(
base_path: &str,
) -> Result<Self, ClientInitError> {
let http_connector = Connector::builder().build();
Self::try_new_with_connector(base_path, Some("http"), http_connector)
}
}
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
type HttpsConnector = hyper_tls::HttpsConnector<hyper::client::HttpConnector>;
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
type HttpsConnector = hyper_openssl::HttpsConnector<hyper::client::HttpConnector>;
impl<C> Client<DropContextService<hyper::client::Client<HttpsConnector, Body>, C>, C> where
C: Clone + Send + Sync + 'static
{
pub fn try_new_https(base_path: &str) -> Result<Self, ClientInitError>
{
let https_connector = Connector::builder()
.https()
.build()
.map_err(|e| ClientInitError::SslError(e))?;
Self::try_new_with_connector(base_path, Some("https"), https_connector)
}
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
pub fn try_new_https_pinned<CA>(
base_path: &str,
ca_certificate: CA,
) -> Result<Self, ClientInitError>
where
CA: AsRef<Path>,
{
let https_connector = Connector::builder()
.https()
.pin_server_certificate(ca_certificate)
.build()
.map_err(|e| ClientInitError::SslError(e))?;
Self::try_new_with_connector(base_path, Some("https"), https_connector)
}
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
pub fn try_new_https_mutual<CA, K, D>(
base_path: &str,
ca_certificate: CA,
client_key: K,
client_certificate: D,
) -> Result<Self, ClientInitError>
where
CA: AsRef<Path>,
K: AsRef<Path>,
D: AsRef<Path>,
{
let https_connector = Connector::builder()
.https()
.pin_server_certificate(ca_certificate)
.client_authentication(client_key, client_certificate)
.build()
.map_err(|e| ClientInitError::SslError(e))?;
Self::try_new_with_connector(base_path, Some("https"), https_connector)
}
}
impl<S, C> Client<S, C> where
S: Service<
(Request<Body>, C),
Response=Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<crate::ServiceError> + fmt::Display,
C: Clone + Send + Sync + 'static
{
pub fn try_new_with_client_service(
client_service: S,
base_path: &str,
) -> Result<Self, ClientInitError>
{
Ok(Self {
client_service,
base_path: into_base_path(base_path, None)?,
marker: PhantomData,
})
}
}
#[derive(Debug)]
pub enum ClientInitError {
InvalidScheme,
InvalidUri(hyper::http::uri::InvalidUri),
MissingHost,
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
SslError(native_tls::Error),
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
SslError(openssl::error::ErrorStack),
}
impl From<hyper::http::uri::InvalidUri> for ClientInitError {
fn from(err: hyper::http::uri::InvalidUri) -> ClientInitError {
ClientInitError::InvalidUri(err)
}
}
impl fmt::Display for ClientInitError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s: &dyn fmt::Debug = self;
s.fmt(f)
}
}
impl Error for ClientInitError {
fn description(&self) -> &str {
"Failed to produce a hyper client."
}
}
#[async_trait]
impl<S, C> Api<C> for Client<S, C> where
S: Service<
(Request<Body>, C),
Response=Response<Body>> + Clone + Sync + Send + 'static,
S::Future: Send + 'static,
S::Error: Into<crate::ServiceError> + fmt::Display,
C: Has<XSpanIdString> + Has<Option<AuthData>> + Clone + Send + Sync + 'static,
{
fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), crate::ServiceError>> {
match self.client_service.clone().poll_ready(cx) {
Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
Poll::Ready(Ok(o)) => Poll::Ready(Ok(o)),
Poll::Pending => Poll::Pending,
}
}
async fn add_pet(
&self,
param_pet: models::Pet,
context: &C) -> Result<AddPetResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_pet).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Pet>(body)?;
Ok(AddPetResponse::SuccessfulOperation
(body)
)
}
405 => {
let body = response.into_body();
Ok(
AddPetResponse::InvalidInput
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn delete_pet(
&self,
param_pet_id: i64,
param_api_key: Option<String>,
context: &C) -> Result<DeletePetResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/{pet_id}",
self.base_path
,pet_id=utf8_percent_encode(¶m_pet_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
match param_api_key {
Some(param_api_key) => {
request.headers_mut().append(
HeaderName::from_static("api_key"),
match header::IntoHeaderValue(param_api_key.clone()).try_into() {
Ok(header) => header,
Err(e) => {
return Err(ApiError(format!(
"Invalid header api_key - {}", e)));
},
});
},
None => {}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
400 => {
let body = response.into_body();
Ok(
DeletePetResponse::InvalidPetValue
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn find_pets_by_status(
&self,
param_status: &Vec<String>,
context: &C) -> Result<FindPetsByStatusResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/findByStatus",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.append_pair("status",
¶m_status.iter().map(ToString::to_string).collect::<Vec<String>>().join(","));
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<Vec<models::Pet>>(body)?;
Ok(FindPetsByStatusResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
FindPetsByStatusResponse::InvalidStatusValue
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn find_pets_by_tags(
&self,
param_tags: &Vec<String>,
context: &C) -> Result<FindPetsByTagsResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/findByTags",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.append_pair("tags",
¶m_tags.iter().map(ToString::to_string).collect::<Vec<String>>().join(","));
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<Vec<models::Pet>>(body)?;
Ok(FindPetsByTagsResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
FindPetsByTagsResponse::InvalidTagValue
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn get_pet_by_id(
&self,
param_pet_id: i64,
context: &C) -> Result<GetPetByIdResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/{pet_id}",
self.base_path
,pet_id=utf8_percent_encode(¶m_pet_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Pet>(body)?;
Ok(GetPetByIdResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
GetPetByIdResponse::InvalidIDSupplied
)
}
404 => {
let body = response.into_body();
Ok(
GetPetByIdResponse::PetNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn update_pet(
&self,
param_pet: models::Pet,
context: &C) -> Result<UpdatePetResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_pet).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Pet>(body)?;
Ok(UpdatePetResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
UpdatePetResponse::InvalidIDSupplied
)
}
404 => {
let body = response.into_body();
Ok(
UpdatePetResponse::PetNotFound
)
}
405 => {
let body = response.into_body();
Ok(
UpdatePetResponse::ValidationException
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn update_pet_with_form(
&self,
param_pet_id: i64,
param_name: Option<String>,
param_status: Option<String>,
context: &C) -> Result<UpdatePetWithFormResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/{pet_id}",
self.base_path
,pet_id=utf8_percent_encode(¶m_pet_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let params = &[
("name", param_name),
("status", param_status),
];
let body = serde_urlencoded::to_string(params).expect("impossible to fail to serialize");
let header = "application/x-www-form-urlencoded";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
*request.body_mut() = Body::from(body.into_bytes());
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
405 => {
let body = response.into_body();
Ok(
UpdatePetWithFormResponse::InvalidInput
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn upload_file(
&self,
param_pet_id: i64,
param_additional_metadata: Option<String>,
param_file: Option<swagger::ByteArray>,
context: &C) -> Result<UploadFileResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/pet/{pet_id}/uploadImage",
self.base_path
,pet_id=utf8_percent_encode(¶m_pet_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let (body_string, multipart_header) = {
let mut multipart = Multipart::new();
let additional_metadata_str = match serde_json::to_string(¶m_additional_metadata) {
Ok(str) => str,
Err(e) => return Err(ApiError(format!("Unable to serialize additional_metadata to string: {}", e))),
};
let additional_metadata_vec = additional_metadata_str.as_bytes().to_vec();
let additional_metadata_mime = mime_0_2::Mime::from_str("application/json").expect("impossible to fail to parse");
let additional_metadata_cursor = Cursor::new(additional_metadata_vec);
multipart.add_stream("additional_metadata", additional_metadata_cursor, None as Option<&str>, Some(additional_metadata_mime));
let file_str = match serde_json::to_string(¶m_file) {
Ok(str) => str,
Err(e) => return Err(ApiError(format!("Unable to serialize file to string: {}", e))),
};
let file_vec = file_str.as_bytes().to_vec();
let file_mime = mime_0_2::Mime::from_str("application/json").expect("impossible to fail to parse");
let file_cursor = Cursor::new(file_vec);
multipart.add_stream("file", file_cursor, None as Option<&str>, Some(file_mime));
let mut fields = match multipart.prepare() {
Ok(fields) => fields,
Err(err) => return Err(ApiError(format!("Unable to build request: {}", err))),
};
let mut body_string = String::new();
match fields.read_to_string(&mut body_string) {
Ok(_) => (),
Err(err) => return Err(ApiError(format!("Unable to build body: {}", err))),
}
let boundary = fields.boundary();
let multipart_header = format!("multipart/form-data;boundary={}", boundary);
(body_string, multipart_header)
};
*request.body_mut() = Body::from(body_string);
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(&multipart_header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", multipart_header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
&AuthData::Bearer(ref bearer_header) => {
let auth = swagger::auth::Header(bearer_header.clone());
let header = match HeaderValue::from_str(&format!("{}", auth)) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create Authorization header: {}", e)))
};
request.headers_mut().insert(
hyper::header::AUTHORIZATION,
header);
},
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::ApiResponse>(body)?;
Ok(UploadFileResponse::SuccessfulOperation
(body)
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn delete_order(
&self,
param_order_id: String,
context: &C) -> Result<DeleteOrderResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/store/order/{order_id}",
self.base_path
,order_id=utf8_percent_encode(¶m_order_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
400 => {
let body = response.into_body();
Ok(
DeleteOrderResponse::InvalidIDSupplied
)
}
404 => {
let body = response.into_body();
Ok(
DeleteOrderResponse::OrderNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn get_inventory(
&self,
context: &C) -> Result<GetInventoryResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/store/inventory",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<std::collections::HashMap<String, i32>>(body)?;
Ok(GetInventoryResponse::SuccessfulOperation
(body)
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn get_order_by_id(
&self,
param_order_id: i64,
context: &C) -> Result<GetOrderByIdResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/store/order/{order_id}",
self.base_path
,order_id=utf8_percent_encode(¶m_order_id.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Order>(body)?;
Ok(GetOrderByIdResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
GetOrderByIdResponse::InvalidIDSupplied
)
}
404 => {
let body = response.into_body();
Ok(
GetOrderByIdResponse::OrderNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn place_order(
&self,
param_order: models::Order,
context: &C) -> Result<PlaceOrderResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/store/order",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_order).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Order>(body)?;
Ok(PlaceOrderResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
PlaceOrderResponse::InvalidOrder
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn create_user(
&self,
param_user: models::User,
context: &C) -> Result<CreateUserResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_user).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
0 => {
let body = response.into_body();
Ok(
CreateUserResponse::SuccessfulOperation
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn create_users_with_array_input(
&self,
param_user: &Vec<models::User>,
context: &C) -> Result<CreateUsersWithArrayInputResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/createWithArray",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_user).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
0 => {
let body = response.into_body();
Ok(
CreateUsersWithArrayInputResponse::SuccessfulOperation
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn create_users_with_list_input(
&self,
param_user: &Vec<models::User>,
context: &C) -> Result<CreateUsersWithListInputResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/createWithList",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_user).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
0 => {
let body = response.into_body();
Ok(
CreateUsersWithListInputResponse::SuccessfulOperation
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn delete_user(
&self,
param_username: String,
context: &C) -> Result<DeleteUserResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/{username}",
self.base_path
,username=utf8_percent_encode(¶m_username.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
400 => {
let body = response.into_body();
Ok(
DeleteUserResponse::InvalidUsernameSupplied
)
}
404 => {
let body = response.into_body();
Ok(
DeleteUserResponse::UserNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn get_user_by_name(
&self,
param_username: String,
context: &C) -> Result<GetUserByNameResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/{username}",
self.base_path
,username=utf8_percent_encode(¶m_username.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::User>(body)?;
Ok(GetUserByNameResponse::SuccessfulOperation
(body)
)
}
400 => {
let body = response.into_body();
Ok(
GetUserByNameResponse::InvalidUsernameSupplied
)
}
404 => {
let body = response.into_body();
Ok(
GetUserByNameResponse::UserNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn login_user(
&self,
param_username: String,
param_password: String,
context: &C) -> Result<LoginUserResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/login",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.append_pair("username",
¶m_username.to_string());
query_string.append_pair("password",
¶m_password.to_string());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
200 => {
let response_set_cookie = match response.headers().get(HeaderName::from_static("set-cookie")) {
Some(response_set_cookie) => {
let response_set_cookie = response_set_cookie.clone();
let response_set_cookie = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_set_cookie) {
Ok(value) => value,
Err(e) => {
return Err(ApiError(format!("Invalid response header Set-Cookie for response 200 - {}", e)));
},
};
let response_set_cookie = response_set_cookie.0;
Some(response_set_cookie)
},
None => None,
};
let response_x_rate_limit = match response.headers().get(HeaderName::from_static("x-rate-limit")) {
Some(response_x_rate_limit) => {
let response_x_rate_limit = response_x_rate_limit.clone();
let response_x_rate_limit = match TryInto::<header::IntoHeaderValue<i32>>::try_into(response_x_rate_limit) {
Ok(value) => value,
Err(e) => {
return Err(ApiError(format!("Invalid response header X-Rate-Limit for response 200 - {}", e)));
},
};
let response_x_rate_limit = response_x_rate_limit.0;
Some(response_x_rate_limit)
},
None => None,
};
let response_x_expires_after = match response.headers().get(HeaderName::from_static("x-expires-after")) {
Some(response_x_expires_after) => {
let response_x_expires_after = response_x_expires_after.clone();
let response_x_expires_after = match TryInto::<header::IntoHeaderValue<chrono::DateTime::<chrono::Utc>>>::try_into(response_x_expires_after) {
Ok(value) => value,
Err(e) => {
return Err(ApiError(format!("Invalid response header X-Expires-After for response 200 - {}", e)));
},
};
let response_x_expires_after = response_x_expires_after.0;
Some(response_x_expires_after)
},
None => None,
};
let body = response.into_body();
let body = body
.to_raw()
.map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
let body = str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<String>(body)?;
Ok(LoginUserResponse::SuccessfulOperation
{
body: body,
set_cookie: response_set_cookie,
x_rate_limit: response_x_rate_limit,
x_expires_after: response_x_expires_after,
}
)
}
400 => {
let body = response.into_body();
Ok(
LoginUserResponse::InvalidUsername
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn logout_user(
&self,
context: &C) -> Result<LogoutUserResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/logout",
self.base_path
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
0 => {
let body = response.into_body();
Ok(
LogoutUserResponse::SuccessfulOperation
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
async fn update_user(
&self,
param_username: String,
param_user: models::User,
context: &C) -> Result<UpdateUserResponse, ApiError>
{
let mut client_service = self.client_service.clone();
let mut uri = format!(
"{}/v2/user/{username}",
self.base_path
,username=utf8_percent_encode(¶m_username.to_string(), ID_ENCODE_SET)
);
let query_string = {
let mut query_string = form_urlencoded::Serializer::new("".to_owned());
query_string.finish()
};
if !query_string.is_empty() {
uri += "?";
uri += &query_string;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))),
};
let mut request = match Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty()) {
Ok(req) => req,
Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
};
let body = serde_json::to_string(¶m_user).expect("impossible to fail to serialize");
*request.body_mut() = Body::from(body);
let header = "application/json";
request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(header) {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create header: {} - {}", header, e)))
});
let header = HeaderValue::from_str(Has::<XSpanIdString>::get(context).0.clone().to_string().as_str());
request.headers_mut().insert(HeaderName::from_static("x-span-id"), match header {
Ok(h) => h,
Err(e) => return Err(ApiError(format!("Unable to create X-Span ID header value: {}", e)))
});
if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() {
match auth_data {
_ => {}
}
}
let mut response = client_service.call((request, context.clone()))
.map_err(|e| ApiError(format!("No response received: {}", e))).await?;
match response.status().as_u16() {
400 => {
let body = response.into_body();
Ok(
UpdateUserResponse::InvalidUserSupplied
)
}
404 => {
let body = response.into_body();
Ok(
UpdateUserResponse::UserNotFound
)
}
code => {
let headers = response.headers().clone();
let body = response.into_body()
.take(100)
.to_raw().await;
Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(body) => match String::from_utf8(body) {
Ok(body) => body,
Err(e) => format!("<Body was not UTF8: {:?}>", e),
},
Err(e) => format!("<Failed to read body: {}>", e),
}
)))
}
}
}
}