aboutsummaryrefslogtreecommitdiffstats
path: root/rust/fatcat-api/src/client
diff options
context:
space:
mode:
authorBryan Newbold <bnewbold@robocracy.org>2018-05-15 00:33:33 -0700
committerBryan Newbold <bnewbold@robocracy.org>2018-05-15 00:33:36 -0700
commit33a4cce0b97832f5f0301b318a0a50073ce6b615 (patch)
tree1b6ba7ec5944d2be2d746510e743a7934f453cd0 /rust/fatcat-api/src/client
parent4a1d8f20ab91fda0f4794131144915d0c5214268 (diff)
downloadfatcat-33a4cce0b97832f5f0301b318a0a50073ce6b615.tar.gz
fatcat-33a4cce0b97832f5f0301b318a0a50073ce6b615.zip
revert to v2.3.1 codegen
This reverts back to something compatible with Iron and simple (blocking) parallelism, instead of the new async hyper 0.11 stuff.
Diffstat (limited to 'rust/fatcat-api/src/client')
-rw-r--r--rust/fatcat-api/src/client/mod.rs2573
1 files changed, 0 insertions, 2573 deletions
diff --git a/rust/fatcat-api/src/client/mod.rs b/rust/fatcat-api/src/client/mod.rs
deleted file mode 100644
index 361fd390..00000000
--- a/rust/fatcat-api/src/client/mod.rs
+++ /dev/null
@@ -1,2573 +0,0 @@
-#![allow(unused_extern_crates)]
-extern crate chrono;
-extern crate hyper_tls;
-extern crate mime;
-extern crate native_tls;
-extern crate openssl;
-extern crate tokio_core;
-extern crate url;
-
-use self::tokio_core::reactor::Handle;
-use self::url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
-use futures;
-use futures::{Future, Stream};
-use futures::{future, stream};
-use hyper;
-use hyper::Uri;
-use hyper::header::{ContentType, Headers};
-use std::borrow::Cow;
-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::sync::Arc;
-
-use mimetypes;
-
-use serde_json;
-
-#[allow(unused_imports)]
-use std::collections::{BTreeMap, HashMap};
-#[allow(unused_imports)]
-use swagger;
-
-use swagger::{ApiError, Context, XSpanId};
-
-use models;
-use {Api, ContainerIdGetResponse, ContainerLookupGetResponse, ContainerPostResponse,
- CreatorIdGetResponse, CreatorLookupGetResponse, CreatorPostResponse,
- EditgroupIdAcceptPostResponse, EditgroupIdGetResponse, EditgroupPostResponse,
- EditorUsernameChangelogGetResponse, EditorUsernameGetResponse, FileIdGetResponse,
- FileLookupGetResponse, FilePostResponse, ReleaseIdGetResponse, ReleaseLookupGetResponse,
- ReleasePostResponse, WorkIdGetResponse, WorkPostResponse};
-
-/// 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().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().map(|x| format!(":{}", x)).unwrap_or_default();
- Ok(format!("{}://{}{}", scheme, host, port))
-}
-
-/// A client that implements the API by making HTTP calls out to a server.
-#[derive(Clone)]
-pub struct Client {
- hyper_client: Arc<
- Fn(
- &Handle
- ) -> Box<
- hyper::client::Service<
- Request = hyper::Request<hyper::Body>,
- Response = hyper::Response,
- Error = hyper::Error,
- Future = hyper::client::FutureResponse,
- >,
- >
- + Sync
- + Send,
- >,
- handle: Arc<Handle>,
- base_path: String,
-}
-
-impl fmt::Debug for Client {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "Client {{ base_path: {} }}", self.base_path)
- }
-}
-
-impl Client {
- /// Create an HTTP client.
- ///
- /// # Arguments
- /// * `handle` - tokio reactor handle to use for execution
- /// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
- pub fn try_new_http(handle: Handle, base_path: &str) -> Result<Client, ClientInitError> {
- let http_connector = swagger::http_connector();
- Self::try_new_with_connector::<hyper::client::HttpConnector>(
- handle,
- base_path,
- Some("http"),
- http_connector,
- )
- }
-
- /// Create a client with a TLS connection to the server.
- ///
- /// # Arguments
- /// * `handle` - tokio reactor handle to use for execution
- /// * `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
- pub fn try_new_https<CA>(
- handle: Handle,
- base_path: &str,
- ca_certificate: CA,
- ) -> Result<Client, ClientInitError>
- where
- CA: AsRef<Path>,
- {
- let https_connector = swagger::https_connector(ca_certificate);
- Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
- handle,
- base_path,
- Some("https"),
- https_connector,
- )
- }
-
- /// Create a client with a mutually authenticated TLS connection to the server.
- ///
- /// # Arguments
- /// * `handle` - tokio reactor handle to use for execution
- /// * `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
- pub fn try_new_https_mutual<CA, K, C, T>(
- handle: Handle,
- base_path: &str,
- ca_certificate: CA,
- client_key: K,
- client_certificate: C,
- ) -> Result<Client, ClientInitError>
- where
- CA: AsRef<Path>,
- K: AsRef<Path>,
- C: AsRef<Path>,
- {
- let https_connector =
- swagger::https_mutual_connector(ca_certificate, client_key, client_certificate);
- Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
- handle,
- base_path,
- Some("https"),
- https_connector,
- )
- }
-
- /// 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::{http_connector, https_connector, https_mutual_connector}`.
- ///
- /// 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
- ///
- /// * `handle` - tokio reactor handle to use for execution
- /// * `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_fn` - Function which returns an implementation of `hyper::client::Connect`
- pub fn try_new_with_connector<C>(
- handle: Handle,
- base_path: &str,
- protocol: Option<&'static str>,
- connector_fn: Box<Fn(&Handle) -> C + Send + Sync>,
- ) -> Result<Client, ClientInitError>
- where
- C: hyper::client::Connect + hyper::client::Service,
- {
- let hyper_client = {
- move |handle: &Handle| -> Box<
- hyper::client::Service<
- Request = hyper::Request<hyper::Body>,
- Response = hyper::Response,
- Error = hyper::Error,
- Future = hyper::client::FutureResponse,
- >,
- > {
- let connector = connector_fn(handle);
- Box::new(
- hyper::Client::configure()
- .connector(connector)
- .build(handle),
- )
- }
- };
-
- Ok(Client {
- hyper_client: Arc::new(hyper_client),
- handle: Arc::new(handle),
- base_path: into_base_path(base_path, protocol)?,
- })
- }
-
- /// Constructor for creating a `Client` by passing in a pre-made `hyper` client.
- ///
- /// One should avoid relying on this function if possible, since it adds a dependency on the underlying transport
- /// implementation, which it would be better to abstract away. Therefore, using this function may lead to a loss of
- /// code generality, which may make it harder to move the application to a serverless environment, for example.
- ///
- /// The reason for this function's existence is to support legacy test code, which did mocking at the hyper layer.
- /// This is not a recommended way to write new tests. If other reasons are found for using this function, they
- /// should be mentioned here.
- pub fn try_new_with_hyper_client(
- hyper_client: Arc<
- Fn(
- &Handle
- ) -> Box<
- hyper::client::Service<
- Request = hyper::Request<hyper::Body>,
- Response = hyper::Response,
- Error = hyper::Error,
- Future = hyper::client::FutureResponse,
- >,
- >
- + Sync
- + Send,
- >,
- handle: Handle,
- base_path: &str,
- ) -> Result<Client, ClientInitError> {
- Ok(Client {
- hyper_client: hyper_client,
- handle: Arc::new(handle),
- base_path: into_base_path(base_path, None)?,
- })
- }
-}
-
-impl Api for Client {
- fn container_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = ContainerIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/container/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- ContainerIdGetResponse::FetchASingleContainerById(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ContainerIdGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- ContainerIdGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn container_lookup_get(
- &self,
- param_issn: String,
- context: &Context,
- ) -> Box<Future<Item = ContainerLookupGetResponse, Error = ApiError>> {
- // Query parameters
- let query_issn = format!("issn={issn}&", issn = param_issn.to_string());
-
- let uri = format!(
- "{}/v0/container/lookup?{issn}",
- self.base_path,
- issn = utf8_percent_encode(&query_issn, QUERY_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ContainerLookupGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ContainerLookupGetResponse::NoSuchContainer(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- ContainerLookupGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn container_post(
- &self,
- param_body: Option<models::ContainerEntity>,
- context: &Context,
- ) -> Box<Future<Item = ContainerPostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/container", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
- if let Some(body) = body {
- request.set_body(body.into_bytes());
- }
-
- request
- .headers_mut()
- .set(ContentType(mimetypes::requests::CONTAINER_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| ContainerPostResponse::Created(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ContainerPostResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ContainerPostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn creator_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = CreatorIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/creator/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- CreatorIdGetResponse::FetchASingleCreatorById(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorIdGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorIdGetResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn creator_lookup_get(
- &self,
- param_orcid: String,
- context: &Context,
- ) -> Box<Future<Item = CreatorLookupGetResponse, Error = ApiError>> {
- // Query parameters
- let query_orcid = format!("orcid={orcid}&", orcid = param_orcid.to_string());
-
- let uri = format!(
- "{}/v0/creator/lookup?{orcid}",
- self.base_path,
- orcid = utf8_percent_encode(&query_orcid, QUERY_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer(
- body,
- )
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorLookupGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorLookupGetResponse::NoSuchCreator(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- CreatorLookupGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn creator_post(
- &self,
- param_body: Option<models::CreatorEntity>,
- context: &Context,
- ) -> Box<Future<Item = CreatorPostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/creator", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
- if let Some(body) = body {
- request.set_body(body.into_bytes());
- }
-
- request
- .headers_mut()
- .set(ContentType(mimetypes::requests::CREATOR_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| CreatorPostResponse::Created(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorPostResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| CreatorPostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn editgroup_id_accept_post(
- &self,
- param_id: i32,
- context: &Context,
- ) -> Box<Future<Item = EditgroupIdAcceptPostResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/editgroup/{id}/accept",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(
- body,
- )
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(
- body,
- )
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditgroupIdAcceptPostResponse::NoSuchEditgroup(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditgroupIdAcceptPostResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn editgroup_id_get(
- &self,
- param_id: i32,
- context: &Context,
- ) -> Box<Future<Item = EditgroupIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/editgroup/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- EditgroupIdGetResponse::FetchEditgroupByIdentifier(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| EditgroupIdGetResponse::NoSuchEditgroup(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditgroupIdGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn editgroup_post(
- &self,
- context: &Context,
- ) -> Box<Future<Item = EditgroupPostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/editgroup", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| EditgroupPostResponse::SuccessfullyCreated(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditgroupPostResponse::InvalidRequestParameters(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| EditgroupPostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn editor_username_changelog_get(
- &self,
- param_username: String,
- context: &Context,
- ) -> Box<Future<Item = EditorUsernameChangelogGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/editor/{username}/changelog",
- self.base_path,
- username = utf8_percent_encode(&param_username.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- EditorUsernameChangelogGetResponse::FindChanges_(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditorUsernameChangelogGetResponse::UsernameNotFound(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditorUsernameChangelogGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn editor_username_get(
- &self,
- param_username: String,
- context: &Context,
- ) -> Box<Future<Item = EditorUsernameGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/editor/{username}",
- self.base_path,
- username = utf8_percent_encode(&param_username.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor(
- body,
- )
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| EditorUsernameGetResponse::UsernameNotFound(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- EditorUsernameGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn file_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = FileIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/file/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| FileIdGetResponse::FetchASingleFileById(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FileIdGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FileIdGetResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn file_lookup_get(
- &self,
- param_sha1: String,
- context: &Context,
- ) -> Box<Future<Item = FileLookupGetResponse, Error = ApiError>> {
- // Query parameters
- let query_sha1 = format!("sha1={sha1}&", sha1 = param_sha1.to_string());
-
- let uri = format!(
- "{}/v0/file/lookup?{sha1}",
- self.base_path,
- sha1 = utf8_percent_encode(&query_sha1, QUERY_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- FileLookupGetResponse::FindASingleFileByExternalIdentifer(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FileLookupGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FileLookupGetResponse::NoSuchFile(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FileLookupGetResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn file_post(
- &self,
- param_body: Option<models::FileEntity>,
- context: &Context,
- ) -> Box<Future<Item = FilePostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/file", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
- if let Some(body) = body {
- request.set_body(body.into_bytes());
- }
-
- request
- .headers_mut()
- .set(ContentType(mimetypes::requests::FILE_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| FilePostResponse::Created(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FilePostResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| FilePostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn release_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = ReleaseIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/release/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- ReleaseIdGetResponse::FetchASingleReleaseById(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleaseIdGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleaseIdGetResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn release_lookup_get(
- &self,
- param_doi: String,
- context: &Context,
- ) -> Box<Future<Item = ReleaseLookupGetResponse, Error = ApiError>> {
- // Query parameters
- let query_doi = format!("doi={doi}&", doi = param_doi.to_string());
-
- let uri = format!(
- "{}/v0/release/lookup?{doi}",
- self.base_path,
- doi = utf8_percent_encode(&query_doi, QUERY_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| {
- ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer(
- body,
- )
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleaseLookupGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 404 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleaseLookupGetResponse::NoSuchRelease(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| {
- ReleaseLookupGetResponse::GenericErrorResponse(body)
- }),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn release_post(
- &self,
- param_body: Option<models::ReleaseEntity>,
- context: &Context,
- ) -> Box<Future<Item = ReleasePostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/release", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
- if let Some(body) = body {
- request.set_body(body.into_bytes());
- }
-
- request
- .headers_mut()
- .set(ContentType(mimetypes::requests::RELEASE_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| ReleasePostResponse::Created(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleasePostResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| ReleasePostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn work_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = WorkIdGetResponse, Error = ApiError>> {
- let uri = format!(
- "{}/v0/work/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Get, uri);
-
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 200 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| WorkIdGetResponse::FetchASingleWorkById(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| WorkIdGetResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| WorkIdGetResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-
- fn work_post(
- &self,
- param_body: Option<models::WorkEntity>,
- context: &Context,
- ) -> Box<Future<Item = WorkPostResponse, Error = ApiError>> {
- let uri = format!("{}/v0/work", self.base_path);
-
- let uri = match Uri::from_str(&uri) {
- Ok(uri) => uri,
- Err(err) => {
- return Box::new(futures::done(Err(ApiError(format!(
- "Unable to build URI: {}",
- err
- )))))
- }
- };
-
- let mut request = hyper::Request::new(hyper::Method::Post, uri);
-
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
-
- if let Some(body) = body {
- request.set_body(body.into_bytes());
- }
-
- request
- .headers_mut()
- .set(ContentType(mimetypes::requests::WORK_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| request.headers_mut().set(XSpanId(header.clone())));
-
- let hyper_client = (self.hyper_client)(&*self.handle);
- Box::new(
- hyper_client
- .call(request)
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(|mut response| match response.status().as_u16() {
- 201 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|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| WorkPostResponse::Created(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 400 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| WorkPostResponse::BadRequest(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- 0 => {
- let body = response.body();
- Box::new(
- body.concat2()
- .map_err(|e| ApiError(format!("Failed to read response: {}", e)))
- .and_then(|body| {
- str::from_utf8(&body)
- .map_err(|e| {
- ApiError(format!("Response was not valid UTF8: {}", e))
- })
- .and_then(|body| {
- serde_json::from_str::<models::Error>(body)
- .map_err(|e| e.into())
- })
- })
- .map(move |body| WorkPostResponse::GenericErrorResponse(body)),
- ) as Box<Future<Item = _, Error = _>>
- }
- code => {
- let headers = response.headers().clone();
- Box::new(response.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<Future<Item = _, Error = _>>
- }
- }),
- )
- }
-}
-
-#[derive(Debug)]
-pub enum ClientInitError {
- InvalidScheme,
- InvalidUri(hyper::error::UriError),
- MissingHost,
- SslError(openssl::error::ErrorStack),
-}
-
-impl From<hyper::error::UriError> for ClientInitError {
- fn from(err: hyper::error::UriError) -> ClientInitError {
- ClientInitError::InvalidUri(err)
- }
-}
-
-impl From<openssl::error::ErrorStack> for ClientInitError {
- fn from(err: openssl::error::ErrorStack) -> ClientInitError {
- ClientInitError::SslError(err)
- }
-}
-
-impl fmt::Display for ClientInitError {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- (self as &fmt::Debug).fmt(f)
- }
-}
-
-impl error::Error for ClientInitError {
- fn description(&self) -> &str {
- "Failed to produce a hyper client."
- }
-}