use futures;
use futures::{future, stream, Future, Stream};
use hyper;
use hyper::client::HttpConnector;
use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
use hyper::{Body, Response, Uri};
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
use hyper_openssl::HttpsConnector;
use serde_json;
use std::borrow::Cow;
use std::convert::TryInto;
use std::error;
use std::fmt;
use std::io::{Error, ErrorKind, Read};
use std::path::Path;
use std::str;
use std::str::FromStr;
use std::string::ToString;
use std::sync::Arc;
use swagger;
use swagger::{client::Service, ApiError, AuthData, Connector, Has, XSpanIdString};
use url::form_urlencoded;
use url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
use crate::header;
use crate::models;
url::define_encode_set! {
/// This encode set is used for object IDs
///
/// Aside from the special characters defined in the `PATH_SEGMENT_ENCODE_SET`,
/// the vertical bar (|) is encoded.
pub ID_ENCODE_SET = [PATH_SEGMENT_ENCODE_SET] | {'|'}
}
use crate::{
AcceptEditgroupResponse, Api, AuthCheckResponse, AuthOidcResponse, CreateAuthTokenResponse,
CreateContainerAutoBatchResponse, CreateContainerResponse, CreateCreatorAutoBatchResponse,
CreateCreatorResponse, CreateEditgroupAnnotationResponse, CreateEditgroupResponse,
CreateFileAutoBatchResponse, CreateFileResponse, CreateFilesetAutoBatchResponse,
CreateFilesetResponse, CreateReleaseAutoBatchResponse, CreateReleaseResponse,
CreateWebcaptureAutoBatchResponse, CreateWebcaptureResponse, CreateWorkAutoBatchResponse,
CreateWorkResponse, DeleteContainerEditResponse, DeleteContainerResponse,
DeleteCreatorEditResponse, DeleteCreatorResponse, DeleteFileEditResponse, DeleteFileResponse,
DeleteFilesetEditResponse, DeleteFilesetResponse, DeleteReleaseEditResponse,
DeleteReleaseResponse, DeleteWebcaptureEditResponse, DeleteWebcaptureResponse,
DeleteWorkEditResponse, DeleteWorkResponse, GetChangelogEntryResponse, GetChangelogResponse,
GetContainerEditResponse, GetContainerHistoryResponse, GetContainerRedirectsResponse,
GetContainerResponse, GetContainerRevisionResponse, GetCreatorEditResponse,
GetCreatorHistoryResponse, GetCreatorRedirectsResponse, GetCreatorReleasesResponse,
GetCreatorResponse, GetCreatorRevisionResponse, GetEditgroupAnnotationsResponse,
GetEditgroupResponse, GetEditgroupsReviewableResponse, GetEditorAnnotationsResponse,
GetEditorEditgroupsResponse, GetEditorResponse, GetFileEditResponse, GetFileHistoryResponse,
GetFileRedirectsResponse, GetFileResponse, GetFileRevisionResponse, GetFilesetEditResponse,
GetFilesetHistoryResponse, GetFilesetRedirectsResponse, GetFilesetResponse,
GetFilesetRevisionResponse, GetReleaseEditResponse, GetReleaseFilesResponse,
GetReleaseFilesetsResponse, GetReleaseHistoryResponse, GetReleaseRedirectsResponse,
GetReleaseResponse, GetReleaseRevisionResponse, GetReleaseWebcapturesResponse,
GetWebcaptureEditResponse, GetWebcaptureHistoryResponse, GetWebcaptureRedirectsResponse,
GetWebcaptureResponse, GetWebcaptureRevisionResponse, GetWorkEditResponse,
GetWorkHistoryResponse, GetWorkRedirectsResponse, GetWorkReleasesResponse, GetWorkResponse,
GetWorkRevisionResponse, LookupContainerResponse, LookupCreatorResponse, LookupFileResponse,
LookupReleaseResponse, UpdateContainerResponse, UpdateCreatorResponse, UpdateEditgroupResponse,
UpdateEditorResponse, UpdateFileResponse, UpdateFilesetResponse, UpdateReleaseResponse,
UpdateWebcaptureResponse, UpdateWorkResponse,
};
/// Convert input into a base path, e.g. "http://example:123". Also checks the scheme as it goes.
fn into_base_path(
input: &str,
correct_scheme: Option<&'static str>,
) -> Result<String, ClientInitError> {
// First convert to Uri, since a base path is a subset of Uri.
let uri = Uri::from_str(input)?;
let scheme = uri.scheme_part().ok_or(ClientInitError::InvalidScheme)?;
// Check the scheme if necessary
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_part()
.map(|x| format!(":{}", x))
.unwrap_or_default();
Ok(format!(
"{}://{}{}{}",
scheme,
host,
port,
uri.path().trim_end_matches('/')
))
}
/// A client that implements the API by making HTTP calls out to a server.
pub struct Client<F> {
/// Inner service
client_service: Arc<Box<dyn Service<ReqBody = Body, Future = F> + Send + Sync>>,
/// Base path of the API
base_path: String,
}
impl<F> fmt::Debug for Client<F> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Client {{ base_path: {} }}", self.base_path)
}
}
impl<F> Clone for Client<F> {
fn clone(&self) -> Self {
Client {
client_service: self.client_service.clone(),
base_path: self.base_path.clone(),
}
}
}
impl Client<hyper::client::ResponseFuture> {
/// Create a client with a custom implementation of hyper::client::Connect.
///
/// Intended for use with custom implementations of connect for e.g. protocol logging
/// or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection,
/// this function should be used in conjunction with `swagger::Connector::builder()`.
///
/// For ordinary tcp connections, prefer the use of `try_new_http`, `try_new_https`
/// and `try_new_https_mutual`, to avoid introducing a dependency on the underlying transport layer.
///
/// # Arguments
///
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
/// * `protocol` - Which protocol to use when constructing the request url, e.g. `Some("http")`
/// * `connector` - Implementation of `hyper::client::Connect` to use for the client
pub fn try_new_with_connector<C>(
base_path: &str,
protocol: Option<&'static str>,
connector: C,
) -> Result<Self, ClientInitError>
where
C: hyper::client::connect::Connect + 'static,
C::Transport: 'static,
C::Future: 'static,
{
let client_service = Box::new(hyper::client::Client::builder().build(connector));
Ok(Client {
client_service: Arc::new(client_service),
base_path: into_base_path(base_path, protocol)?,
})
}
/// Create an HTTP client.
///
/// # Arguments
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
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)
}
/// Create a client with a TLS connection to the server
///
/// # Arguments
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
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)
}
/// Create a client with a TLS connection to the server using a pinned certificate
///
/// # Arguments
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
/// * `ca_certificate` - Path to CA certificate used to authenticate the server
#[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)
}
/// Create a client with a mutually authenticated TLS connection to the server.
///
/// # Arguments
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
/// * `ca_certificate` - Path to CA certificate used to authenticate the server
/// * `client_key` - Path to the client private key
/// * `client_certificate` - Path to the client's public certificate associated with the private key
#[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<F> Client<F> {
/// Constructor for creating a `Client` by passing in a pre-made `swagger::Service`
///
/// This allows adding custom wrappers around the underlying transport, for example for logging.
pub fn try_new_with_client_service(
client_service: Arc<Box<dyn Service<ReqBody = Body, Future = F> + Send + Sync>>,
base_path: &str,
) -> Result<Self, ClientInitError> {
Ok(Client {
client_service: client_service,
base_path: into_base_path(base_path, None)?,
})
}
}
/// Error type failing to create a Client
#[derive(Debug)]
pub enum ClientInitError {
/// Invalid URL Scheme
InvalidScheme,
/// Invalid URI
InvalidUri(hyper::http::uri::InvalidUri),
/// Missing Hostname
MissingHost,
/// SSL Connection Error
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
SslError(native_tls::Error),
/// SSL Connection 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::Error for ClientInitError {
fn description(&self) -> &str {
"Failed to produce a hyper client."
}
}
impl<C, F> Api<C> for Client<F>
where
C: Has<XSpanIdString> + Has<Option<AuthData>>,
F: Future<Item = Response<Body>, Error = hyper::Error> + Send + 'static,
{
fn accept_editgroup(
&self,
param_editgroup_id: String,
context: &C,
) -> Box<dyn Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/accept",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::MergedSuccessfully
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
409 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::EditConflict
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AcceptEditgroupResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn auth_check(
&self,
param_role: Option<String>,
context: &C,
) -> Box<dyn Future<Item = AuthCheckResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/auth/check", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_role) = param_role {
query_string.append_pair("role", ¶m_role.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthCheckResponse::Success
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthCheckResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthCheckResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthCheckResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthCheckResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn auth_oidc(
&self,
param_auth_oidc: models::AuthOidc,
context: &C,
) -> Box<dyn Future<Item = AuthOidcResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/auth/oidc", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_auth_oidc).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::AuthOidcResult>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::Found
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::AuthOidcResult>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::Created
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
409 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::Conflict
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
AuthOidcResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_auth_token(
&self,
param_editor_id: String,
param_duration_seconds: Option<i32>,
context: &C,
) -> Box<dyn Future<Item = CreateAuthTokenResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/auth/token/{editor_id}",
self.base_path,
editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_duration_seconds) = param_duration_seconds {
query_string.append_pair("duration_seconds", ¶m_duration_seconds.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::AuthTokenResult>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateAuthTokenResponse::Success
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateAuthTokenResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateAuthTokenResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateAuthTokenResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateAuthTokenResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_container(
&self,
param_editgroup_id: String,
param_container_entity: models::ContainerEntity,
context: &C,
) -> Box<dyn Future<Item = CreateContainerResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/container",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_container_entity)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_container_auto_batch(
&self,
param_container_auto_batch: models::ContainerAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateContainerAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/container/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_container_auto_batch)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateContainerAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_creator(
&self,
param_editgroup_id: String,
param_creator_entity: models::CreatorEntity,
context: &C,
) -> Box<dyn Future<Item = CreateCreatorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/creator",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_creator_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_creator_auto_batch(
&self,
param_creator_auto_batch: models::CreatorAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateCreatorAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/creator/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_creator_auto_batch)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateCreatorAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_editgroup(
&self,
param_editgroup: models::Editgroup,
context: &C,
) -> Box<dyn Future<Item = CreateEditgroupResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_editgroup).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::SuccessfullyCreated
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_editgroup_annotation(
&self,
param_editgroup_id: String,
param_editgroup_annotation: models::EditgroupAnnotation,
context: &C,
) -> Box<dyn Future<Item = CreateEditgroupAnnotationResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/annotation",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_editgroup_annotation)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EditgroupAnnotation>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::Created
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateEditgroupAnnotationResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_file(
&self,
param_editgroup_id: String,
param_file_entity: models::FileEntity,
context: &C,
) -> Box<dyn Future<Item = CreateFileResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/file",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_file_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_file_auto_batch(
&self,
param_file_auto_batch: models::FileAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateFileAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/file/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_file_auto_batch).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFileAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_fileset(
&self,
param_editgroup_id: String,
param_fileset_entity: models::FilesetEntity,
context: &C,
) -> Box<dyn Future<Item = CreateFilesetResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/fileset",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_fileset_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_fileset_auto_batch(
&self,
param_fileset_auto_batch: models::FilesetAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateFilesetAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/fileset/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_fileset_auto_batch)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateFilesetAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_release(
&self,
param_editgroup_id: String,
param_release_entity: models::ReleaseEntity,
context: &C,
) -> Box<dyn Future<Item = CreateReleaseResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/release",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_release_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_release_auto_batch(
&self,
param_release_auto_batch: models::ReleaseAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateReleaseAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/release/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_release_auto_batch)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateReleaseAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_webcapture(
&self,
param_editgroup_id: String,
param_webcapture_entity: models::WebcaptureEntity,
context: &C,
) -> Box<dyn Future<Item = CreateWebcaptureResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/webcapture",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_webcapture_entity)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_webcapture_auto_batch(
&self,
param_webcapture_auto_batch: models::WebcaptureAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateWebcaptureAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/webcapture/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_webcapture_auto_batch)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWebcaptureAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_work(
&self,
param_editgroup_id: String,
param_work_entity: models::WorkEntity,
context: &C,
) -> Box<dyn Future<Item = CreateWorkResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/work",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_work_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::CreatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn create_work_auto_batch(
&self,
param_work_auto_batch: models::WorkAutoBatch,
context: &C,
) -> Box<dyn Future<Item = CreateWorkAutoBatchResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/auto/work/batch", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("POST")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_work_auto_batch).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
201 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::CreatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
CreateWorkAutoBatchResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_container(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteContainerResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/container/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_container_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteContainerEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/container/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteContainerEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_creator(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteCreatorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/creator/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_creator_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteCreatorEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/creator/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteCreatorEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_file(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteFileResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/file/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_file_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteFileEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/file/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFileEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_fileset(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteFilesetResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/fileset/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_fileset_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteFilesetEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/fileset/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteFilesetEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_release(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteReleaseResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/release/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_release_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteReleaseEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/release/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteReleaseEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_webcapture(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteWebcaptureResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/webcapture/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_webcapture_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteWebcaptureEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/webcapture/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWebcaptureEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_work(
&self,
param_editgroup_id: String,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = DeleteWorkResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/work/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::DeletedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn delete_work_edit(
&self,
param_editgroup_id: String,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = DeleteWorkEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/work/edit/{edit_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("DELETE")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Success>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::DeletedEdit
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
DeleteWorkEditResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn get_changelog(
&self,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetChangelogResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/changelog", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::ChangelogEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogResponse::Success(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_changelog_entry(
&self,
param_index: i64,
context: &C,
) -> Box<dyn Future<Item = GetChangelogEntryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/changelog/{index}",
self.base_path,
index = utf8_percent_encode(¶m_index.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ChangelogEntry>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetChangelogEntryResponse::FoundChangelogEntry(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogEntryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogEntryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetChangelogEntryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_container(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetContainerResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/container/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ContainerEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_container_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetContainerEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/container/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_container_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetContainerHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/container/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetContainerHistoryResponse::FoundEntityHistory(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_container_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetContainerRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/container/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetContainerRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_container_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetContainerRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/container/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ContainerEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetContainerRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetContainerRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetCreatorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::CreatorEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetCreatorEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetCreatorHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetCreatorHistoryResponse::FoundEntityHistory(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetCreatorRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetCreatorRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator_releases(
&self,
param_ident: String,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetCreatorReleasesResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/{ident}/releases",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::ReleaseEntity>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorReleasesResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorReleasesResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorReleasesResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorReleasesResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_creator_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetCreatorRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/creator/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::CreatorEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetCreatorRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetCreatorRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_editgroup(
&self,
param_editgroup_id: String,
context: &C,
) -> Box<dyn Future<Item = GetEditgroupResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_editgroup_annotations(
&self,
param_editgroup_id: String,
param_expand: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetEditgroupAnnotationsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/annotations",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::Success
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditgroupAnnotationsResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn get_editgroups_reviewable(
&self,
param_expand: Option<String>,
param_limit: Option<i64>,
param_before: Option<chrono::DateTime<chrono::Utc>>,
param_since: Option<chrono::DateTime<chrono::Utc>>,
context: &C,
) -> Box<dyn Future<Item = GetEditgroupsReviewableResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/editgroup/reviewable", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
if let Some(param_before) = param_before {
query_string.append_pair("before", ¶m_before.to_string());
}
if let Some(param_since) = param_since {
query_string.append_pair("since", ¶m_since.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::Editgroup>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupsReviewableResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupsReviewableResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditgroupsReviewableResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetEditgroupsReviewableResponse::GenericError(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_editor(
&self,
param_editor_id: String,
context: &C,
) -> Box<dyn Future<Item = GetEditorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editor/{editor_id}",
self.base_path,
editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::Editor>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_editor_annotations(
&self,
param_editor_id: String,
param_limit: Option<i64>,
param_before: Option<chrono::DateTime<chrono::Utc>>,
param_since: Option<chrono::DateTime<chrono::Utc>>,
context: &C,
) -> Box<dyn Future<Item = GetEditorAnnotationsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editor/{editor_id}/annotations",
self.base_path,
editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
if let Some(param_before) = param_before {
query_string.append_pair("before", ¶m_before.to_string());
}
if let Some(param_since) = param_since {
query_string.append_pair("since", ¶m_since.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::Success
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
GetEditorAnnotationsResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn get_editor_editgroups(
&self,
param_editor_id: String,
param_limit: Option<i64>,
param_before: Option<chrono::DateTime<chrono::Utc>>,
param_since: Option<chrono::DateTime<chrono::Utc>>,
context: &C,
) -> Box<dyn Future<Item = GetEditorEditgroupsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editor/{editor_id}/editgroups",
self.base_path,
editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
if let Some(param_before) = param_before {
query_string.append_pair("before", ¶m_before.to_string());
}
if let Some(param_since) = param_since {
query_string.append_pair("since", ¶m_since.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::Editgroup>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorEditgroupsResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorEditgroupsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorEditgroupsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetEditorEditgroupsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_file(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetFileResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/file/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::FileEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_file_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetFileEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/file/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_file_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetFileHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/file/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileHistoryResponse::FoundEntityHistory(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_file_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetFileRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/file/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetFileRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_file_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetFileRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/file/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::FileEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetFileRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFileRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_fileset(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetFilesetResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/fileset/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::FilesetEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_fileset_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetFilesetEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/fileset/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_fileset_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetFilesetHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/fileset/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetFilesetHistoryResponse::FoundEntityHistory(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_fileset_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetFilesetRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/fileset/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetFilesetRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_fileset_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetFilesetRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/fileset/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::FilesetEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetFilesetRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetFilesetRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ReleaseEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetReleaseEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_files(
&self,
param_ident: String,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseFilesResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}/files",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::FileEntity>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_filesets(
&self,
param_ident: String,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseFilesetsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}/filesets",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::FilesetEntity>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesetsResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesetsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesetsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseFilesetsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetReleaseHistoryResponse::FoundEntityHistory(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetReleaseRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetReleaseRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ReleaseEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetReleaseRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_release_webcaptures(
&self,
param_ident: String,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetReleaseWebcapturesResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/release/{ident}/webcaptures",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::WebcaptureEntity>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseWebcapturesResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseWebcapturesResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseWebcapturesResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetReleaseWebcapturesResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_webcapture(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetWebcaptureResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/webcapture/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::WebcaptureEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_webcapture_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetWebcaptureEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/webcapture/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_webcapture_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetWebcaptureHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/webcapture/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWebcaptureHistoryResponse::FoundEntityHistory(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_webcapture_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetWebcaptureRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/webcapture/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWebcaptureRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWebcaptureRedirectsResponse::GenericError(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_webcapture_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetWebcaptureRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/webcapture/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::WebcaptureEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWebcaptureRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWebcaptureRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work(
&self,
param_ident: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetWorkResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/{ident}",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::WorkEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work_edit(
&self,
param_edit_id: String,
context: &C,
) -> Box<dyn Future<Item = GetWorkEditResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/edit/{edit_id}",
self.base_path,
edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkEditResponse::FoundEdit(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkEditResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkEditResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkEditResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work_history(
&self,
param_ident: String,
param_limit: Option<i64>,
context: &C,
) -> Box<dyn Future<Item = GetWorkHistoryResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/{ident}/history",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_limit) = param_limit {
query_string.append_pair("limit", ¶m_limit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::EntityHistoryEntry>>(
body,
)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkHistoryResponse::FoundEntityHistory(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkHistoryResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkHistoryResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkHistoryResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work_redirects(
&self,
param_ident: String,
context: &C,
) -> Box<dyn Future<Item = GetWorkRedirectsResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/{ident}/redirects",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<String>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWorkRedirectsResponse::FoundEntityRedirects(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRedirectsResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRedirectsResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRedirectsResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work_releases(
&self,
param_ident: String,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetWorkReleasesResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/{ident}/releases",
self.base_path,
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<Vec<models::ReleaseEntity>>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkReleasesResponse::Found(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkReleasesResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkReleasesResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkReleasesResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn get_work_revision(
&self,
param_rev_id: String,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = GetWorkRevisionResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/work/rev/{rev_id}",
self.base_path,
rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::WorkEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| {
GetWorkRevisionResponse::FoundEntityRevision(body)
}),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRevisionResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRevisionResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| GetWorkRevisionResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn lookup_container(
&self,
param_issnl: Option<String>,
param_wikidata_qid: Option<String>,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = LookupContainerResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/container/lookup", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_issnl) = param_issnl {
query_string.append_pair("issnl", ¶m_issnl.to_string());
}
if let Some(param_wikidata_qid) = param_wikidata_qid {
query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string());
}
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ContainerEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupContainerResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupContainerResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupContainerResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupContainerResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn lookup_creator(
&self,
param_orcid: Option<String>,
param_wikidata_qid: Option<String>,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = LookupCreatorResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/creator/lookup", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_orcid) = param_orcid {
query_string.append_pair("orcid", ¶m_orcid.to_string());
}
if let Some(param_wikidata_qid) = param_wikidata_qid {
query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string());
}
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::CreatorEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupCreatorResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupCreatorResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupCreatorResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupCreatorResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn lookup_file(
&self,
param_md5: Option<String>,
param_sha1: Option<String>,
param_sha256: Option<String>,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = LookupFileResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/file/lookup", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_md5) = param_md5 {
query_string.append_pair("md5", ¶m_md5.to_string());
}
if let Some(param_sha1) = param_sha1 {
query_string.append_pair("sha1", ¶m_sha1.to_string());
}
if let Some(param_sha256) = param_sha256 {
query_string.append_pair("sha256", ¶m_sha256.to_string());
}
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::FileEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupFileResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupFileResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupFileResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupFileResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn lookup_release(
&self,
param_doi: Option<String>,
param_wikidata_qid: Option<String>,
param_isbn13: Option<String>,
param_pmid: Option<String>,
param_pmcid: Option<String>,
param_core: Option<String>,
param_arxiv: Option<String>,
param_jstor: Option<String>,
param_ark: Option<String>,
param_mag: Option<String>,
param_expand: Option<String>,
param_hide: Option<String>,
context: &C,
) -> Box<dyn Future<Item = LookupReleaseResponse, Error = ApiError> + Send> {
let mut uri = format!("{}/v0/release/lookup", self.base_path);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_doi) = param_doi {
query_string.append_pair("doi", ¶m_doi.to_string());
}
if let Some(param_wikidata_qid) = param_wikidata_qid {
query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string());
}
if let Some(param_isbn13) = param_isbn13 {
query_string.append_pair("isbn13", ¶m_isbn13.to_string());
}
if let Some(param_pmid) = param_pmid {
query_string.append_pair("pmid", ¶m_pmid.to_string());
}
if let Some(param_pmcid) = param_pmcid {
query_string.append_pair("pmcid", ¶m_pmcid.to_string());
}
if let Some(param_core) = param_core {
query_string.append_pair("core", ¶m_core.to_string());
}
if let Some(param_arxiv) = param_arxiv {
query_string.append_pair("arxiv", ¶m_arxiv.to_string());
}
if let Some(param_jstor) = param_jstor {
query_string.append_pair("jstor", ¶m_jstor.to_string());
}
if let Some(param_ark) = param_ark {
query_string.append_pair("ark", ¶m_ark.to_string());
}
if let Some(param_mag) = param_mag {
query_string.append_pair("mag", ¶m_mag.to_string());
}
if let Some(param_expand) = param_expand {
query_string.append_pair("expand", ¶m_expand.to_string());
}
if let Some(param_hide) = param_hide {
query_string.append_pair("hide", ¶m_hide.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("GET")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
Box::new(
self.client_service
.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ReleaseEntity>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupReleaseResponse::FoundEntity(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
400 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupReleaseResponse::BadRequest(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
404 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupReleaseResponse::NotFound(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
500 => {
let body = response.into_body();
Box::new(
body.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body| {
str::from_utf8(&body)
.map_err(|e| {
ApiError(format!("Response was not valid UTF8: {}", e))
})
.and_then(|body| {
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
})
})
.map(move |body| LookupReleaseResponse::GenericError(body)),
) as Box<dyn Future<Item = _, Error = _> + Send>
}
code => {
let headers = response.headers().clone();
Box::new(response.into_body().take(100).concat2().then(move |body| {
future::err(ApiError(format!(
"Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) =>
Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
}
)))
})) as Box<dyn Future<Item = _, Error = _> + Send>
}
}),
)
}
fn update_container(
&self,
param_editgroup_id: String,
param_ident: String,
param_container_entity: models::ContainerEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateContainerResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/container/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_container_entity)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateContainerResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_creator(
&self,
param_editgroup_id: String,
param_ident: String,
param_creator_entity: models::CreatorEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateCreatorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/creator/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_creator_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateCreatorResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_editgroup(
&self,
param_editgroup_id: String,
param_editgroup: models::Editgroup,
param_submit: Option<bool>,
context: &C,
) -> Box<dyn Future<Item = UpdateEditgroupResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
if let Some(param_submit) = param_submit {
query_string.append_pair("submit", ¶m_submit.to_string());
}
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_editgroup).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editgroup>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::UpdatedEditgroup
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditgroupResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_editor(
&self,
param_editor_id: String,
param_editor: models::Editor,
context: &C,
) -> Box<dyn Future<Item = UpdateEditorResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editor/{editor_id}",
self.base_path,
editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_editor).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::Editor>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::UpdatedEditor
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateEditorResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_file(
&self,
param_editgroup_id: String,
param_ident: String,
param_file_entity: models::FileEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateFileResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/file/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_file_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFileResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_fileset(
&self,
param_editgroup_id: String,
param_ident: String,
param_fileset_entity: models::FilesetEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateFilesetResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/fileset/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_fileset_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateFilesetResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_release(
&self,
param_editgroup_id: String,
param_ident: String,
param_release_entity: models::ReleaseEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateReleaseResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/release/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_release_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateReleaseResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_webcapture(
&self,
param_editgroup_id: String,
param_ident: String,
param_webcapture_entity: models::WebcaptureEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateWebcaptureResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/webcapture/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body = serde_json::to_string(¶m_webcapture_entity)
.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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWebcaptureResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
fn update_work(
&self,
param_editgroup_id: String,
param_ident: String,
param_work_entity: models::WorkEntity,
context: &C,
) -> Box<dyn Future<Item = UpdateWorkResponse, Error = ApiError> + Send> {
let mut uri = format!(
"{}/v0/editgroup/{editgroup_id}/work/{ident}",
self.base_path,
editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET),
ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET)
);
// Query parameters
let mut query_string = url::form_urlencoded::Serializer::new("".to_owned());
let query_string_str = query_string.finish();
if !query_string_str.is_empty() {
uri += "?";
uri += &query_string_str;
}
let uri = match Uri::from_str(&uri) {
Ok(uri) => uri,
Err(err) => {
return Box::new(future::err(ApiError(format!(
"Unable to build URI: {}",
err
))))
}
};
let mut request = match hyper::Request::builder()
.method("PUT")
.uri(uri)
.body(Body::empty())
{
Ok(req) => req,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create request: {}",
e
))))
}
};
let body =
serde_json::to_string(¶m_work_entity).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 Box::new(future::err(ApiError(format!(
"Unable to create header: {} - {}",
header, e
))))
}
},
);
let header = HeaderValue::from_str(
(context as &dyn Has<XSpanIdString>)
.get()
.0
.clone()
.to_string()
.as_str(),
);
request.headers_mut().insert(
HeaderName::from_static("x-span-id"),
match header {
Ok(h) => h,
Err(e) => {
return Box::new(future::err(ApiError(format!(
"Unable to create X-Span ID header value: {}",
e
))))
}
},
);
if let Some(auth_data) = (context as &dyn Has<Option<AuthData>>).get().as_ref() {
// Currently only authentication with Basic and Bearer are supported
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 Box::new(future::err(ApiError(format!(
"Unable to create Authorization header: {}",
e
))))
}
};
request
.headers_mut()
.insert(hyper::header::AUTHORIZATION, header);
}
_ => {}
}
}
Box::new(self.client_service.request(request)
.map_err(|e| ApiError(format!("No response received: {}", e)))
.and_then(|mut response| {
match response.status().as_u16() {
200 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::EntityEdit>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::UpdatedEntity
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
400 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::BadRequest
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
401 => {
let response_www_authenticate = match response.headers().get(HeaderName::from_static("www_authenticate")) {
Some(response_www_authenticate) => response_www_authenticate.clone(),
None => return Box::new(future::err(ApiError(String::from("Required response header WWW_Authenticate for response 401 was not found.")))) as Box<dyn Future<Item=_, Error=_> + Send>,
};
let response_www_authenticate = match TryInto::<header::IntoHeaderValue<String>>::try_into(response_www_authenticate) {
Ok(value) => value,
Err(e) => {
return Box::new(future::err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e)))) as Box<dyn Future<Item=_, Error=_> + Send>;
},
};
let response_www_authenticate = response_www_authenticate.0;
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::NotAuthorized
{
body: body,
www_authenticate: response_www_authenticate,
}
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
403 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::Forbidden
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
404 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::NotFound
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
500 => {
let body = response.into_body();
Box::new(
body
.concat2()
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
.and_then(|body|
str::from_utf8(&body)
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
.and_then(|body|
serde_json::from_str::<models::ErrorResponse>(body)
.map_err(|e| e.into())
)
)
.map(move |body| {
UpdateWorkResponse::GenericError
(body)
})
) as Box<dyn Future<Item=_, Error=_> + Send>
},
code => {
let headers = response.headers().clone();
Box::new(response.into_body()
.take(100)
.concat2()
.then(move |body|
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
code,
headers,
match body {
Ok(ref body) => match str::from_utf8(body) {
Ok(body) => Cow::from(body),
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
})))
)
) as Box<dyn Future<Item=_, Error=_> + Send>
}
}
}))
}
}