aboutsummaryrefslogtreecommitdiffstats
path: root/rust/fatcat-api/src/client.rs
diff options
context:
space:
mode:
Diffstat (limited to 'rust/fatcat-api/src/client.rs')
-rw-r--r--rust/fatcat-api/src/client.rs948
1 files changed, 205 insertions, 743 deletions
diff --git a/rust/fatcat-api/src/client.rs b/rust/fatcat-api/src/client.rs
index 1219e01b..06633ad9 100644
--- a/rust/fatcat-api/src/client.rs
+++ b/rust/fatcat-api/src/client.rs
@@ -34,18 +34,12 @@ 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};
+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<T: IntoUrl>(
- input: T,
- correct_scheme: Option<&'static str>,
-) -> Result<String, ClientInitError> {
+fn into_base_path<T: IntoUrl>(input: T, correct_scheme: Option<&'static str>) -> Result<String, ClientInitError> {
// First convert to Url, since a base path is a subset of Url.
let url = input.into_url()?;
@@ -96,8 +90,7 @@ impl Client {
let https_hyper_client = move || {
// SSL implementation
- let mut ssl =
- openssl::ssl::SslConnectorBuilder::new(openssl::ssl::SslMethod::tls()).unwrap();
+ let mut ssl = openssl::ssl::SslConnectorBuilder::new(openssl::ssl::SslMethod::tls()).unwrap();
// Server authentication
ssl.set_ca_file(ca_certificate.clone()).unwrap();
@@ -113,12 +106,7 @@ impl Client {
})
}
- pub fn try_new_https_mutual<T, CA, K, C>(
- base_path: T,
- ca_certificate: CA,
- client_key: K,
- client_certificate: C,
- ) -> Result<Client, ClientInitError>
+ pub fn try_new_https_mutual<T, CA, K, C>(base_path: T, ca_certificate: CA, client_key: K, client_certificate: C) -> Result<Client, ClientInitError>
where
T: IntoUrl,
CA: AsRef<Path>,
@@ -131,17 +119,14 @@ impl Client {
let https_mutual_hyper_client = move || {
// SSL implementation
- let mut ssl =
- openssl::ssl::SslConnectorBuilder::new(openssl::ssl::SslMethod::tls()).unwrap();
+ let mut ssl = openssl::ssl::SslConnectorBuilder::new(openssl::ssl::SslMethod::tls()).unwrap();
// Server authentication
ssl.set_ca_file(ca_certificate.clone()).unwrap();
// Client authentication
- ssl.set_private_key_file(client_key.clone(), openssl::x509::X509_FILETYPE_PEM)
- .unwrap();
- ssl.set_certificate_chain_file(client_certificate.clone())
- .unwrap();
+ ssl.set_private_key_file(client_key.clone(), openssl::x509::X509_FILETYPE_PEM).unwrap();
+ ssl.set_certificate_chain_file(client_certificate.clone()).unwrap();
ssl.check_private_key().unwrap();
let ssl = hyper_openssl::OpensslClient::from(ssl.build());
@@ -164,10 +149,7 @@ impl Client {
/// 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<T>(
- base_path: T,
- hyper_client: Arc<Fn() -> hyper::client::Client + Sync + Send>,
- ) -> Result<Client, ClientInitError>
+ pub fn try_new_with_hyper_client<T>(base_path: T, hyper_client: Arc<Fn() -> hyper::client::Client + Sync + Send>) -> Result<Client, ClientInitError>
where
T: IntoUrl,
{
@@ -179,56 +161,37 @@ impl Client {
}
impl Api for Client {
- fn container_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = ContainerIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/container/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn container_id_get(&self, param_id: String, context: &Context) -> Box<Future<Item = ContainerIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/container/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ContainerIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ContainerIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::ContainerEntity>(&buf)?;
Ok(ContainerIdGetResponse::FetchASingleContainerById(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerIdGetResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerIdGetResponse::GenericErrorResponse(body))
@@ -238,90 +201,60 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn container_lookup_get(
- &self,
- param_issn: String,
- context: &Context,
- ) -> Box<Future<Item = ContainerLookupGetResponse, Error = ApiError> + Send> {
+ fn container_lookup_get(&self, param_issn: String, context: &Context) -> Box<Future<Item = ContainerLookupGetResponse, Error = ApiError> + Send> {
// Query parameters
let query_issn = format!("issn={issn}&", issn = param_issn.to_string());
- let url = format!(
- "{}/v0/container/lookup?{issn}",
- self.base_path,
- issn = utf8_percent_encode(&query_issn, QUERY_ENCODE_SET)
- );
+ let url = format!("{}/v0/container/lookup?{issn}", self.base_path, issn = utf8_percent_encode(&query_issn, QUERY_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ContainerLookupGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ContainerLookupGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::ContainerEntity>(&buf)?;
Ok(ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerLookupGetResponse::BadRequest(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerLookupGetResponse::NoSuchContainer(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerLookupGetResponse::GenericErrorResponse(body))
@@ -331,37 +264,23 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn container_post(
- &self,
- param_body: Option<models::ContainerEntity>,
- context: &Context,
- ) -> Box<Future<Item = ContainerPostResponse, Error = ApiError> + Send> {
+ fn container_post(&self, param_body: Option<models::ContainerEntity>, context: &Context) -> Box<Future<Item = ContainerPostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/container", self.base_path);
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
+ let body = param_body.map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
@@ -372,41 +291,30 @@ impl Api for Client {
};
custom_headers.set(ContentType(mimetypes::requests::CONTAINER_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ContainerPostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ContainerPostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::EntityEdit>(&buf)?;
Ok(ContainerPostResponse::Created(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerPostResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ContainerPostResponse::GenericErrorResponse(body))
@@ -416,78 +324,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn creator_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = CreatorIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/creator/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn creator_id_get(&self, param_id: String, context: &Context) -> Box<Future<Item = CreatorIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/creator/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<CreatorIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<CreatorIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::CreatorEntity>(&buf)?;
Ok(CreatorIdGetResponse::FetchASingleCreatorById(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorIdGetResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorIdGetResponse::GenericErrorResponse(body))
@@ -497,90 +377,60 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn creator_lookup_get(
- &self,
- param_orcid: String,
- context: &Context,
- ) -> Box<Future<Item = CreatorLookupGetResponse, Error = ApiError> + Send> {
+ fn creator_lookup_get(&self, param_orcid: String, context: &Context) -> Box<Future<Item = CreatorLookupGetResponse, Error = ApiError> + Send> {
// Query parameters
let query_orcid = format!("orcid={orcid}&", orcid = param_orcid.to_string());
- let url = format!(
- "{}/v0/creator/lookup?{orcid}",
- self.base_path,
- orcid = utf8_percent_encode(&query_orcid, QUERY_ENCODE_SET)
- );
+ let url = format!("{}/v0/creator/lookup?{orcid}", self.base_path, orcid = utf8_percent_encode(&query_orcid, QUERY_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<CreatorLookupGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<CreatorLookupGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::CreatorEntity>(&buf)?;
Ok(CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorLookupGetResponse::BadRequest(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorLookupGetResponse::NoSuchCreator(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorLookupGetResponse::GenericErrorResponse(body))
@@ -590,37 +440,23 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn creator_post(
- &self,
- param_body: Option<models::CreatorEntity>,
- context: &Context,
- ) -> Box<Future<Item = CreatorPostResponse, Error = ApiError> + Send> {
+ fn creator_post(&self, param_body: Option<models::CreatorEntity>, context: &Context) -> Box<Future<Item = CreatorPostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/creator", self.base_path);
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
+ let body = param_body.map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
@@ -631,41 +467,30 @@ impl Api for Client {
};
custom_headers.set(ContentType(mimetypes::requests::CREATOR_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<CreatorPostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<CreatorPostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::EntityEdit>(&buf)?;
Ok(CreatorPostResponse::Created(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorPostResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(CreatorPostResponse::GenericErrorResponse(body))
@@ -675,89 +500,57 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn editgroup_id_accept_post(
- &self,
- param_id: i32,
- context: &Context,
- ) -> Box<Future<Item = EditgroupIdAcceptPostResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/editgroup/{id}/accept",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn editgroup_id_accept_post(&self, param_id: i32, context: &Context) -> Box<Future<Item = EditgroupIdAcceptPostResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/editgroup/{id}/accept", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<EditgroupIdAcceptPostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<EditgroupIdAcceptPostResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Success>(&buf)?;
- Ok(EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(
- body,
- ))
+ Ok(EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupIdAcceptPostResponse::NoSuchEditgroup(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupIdAcceptPostResponse::GenericErrorResponse(body))
@@ -767,78 +560,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn editgroup_id_get(
- &self,
- param_id: i32,
- context: &Context,
- ) -> Box<Future<Item = EditgroupIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/editgroup/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn editgroup_id_get(&self, param_id: i32, context: &Context) -> Box<Future<Item = EditgroupIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/editgroup/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<EditgroupIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<EditgroupIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Editgroup>(&buf)?;
Ok(EditgroupIdGetResponse::FetchEditgroupByIdentifier(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupIdGetResponse::NoSuchEditgroup(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupIdGetResponse::GenericErrorResponse(body))
@@ -848,73 +613,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn editgroup_post(
- &self,
- context: &Context,
- ) -> Box<Future<Item = EditgroupPostResponse, Error = ApiError> + Send> {
+ fn editgroup_post(&self, context: &Context) -> Box<Future<Item = EditgroupPostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/editgroup", self.base_path);
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<EditgroupPostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<EditgroupPostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Editgroup>(&buf)?;
Ok(EditgroupPostResponse::SuccessfullyCreated(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupPostResponse::InvalidRequestParameters(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditgroupPostResponse::GenericErrorResponse(body))
@@ -924,33 +666,20 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn editor_username_changelog_get(
- &self,
- param_username: String,
- context: &Context,
- ) -> Box<Future<Item = EditorUsernameChangelogGetResponse, Error = ApiError> + Send> {
+ fn editor_username_changelog_get(&self, param_username: String, context: &Context) -> Box<Future<Item = EditorUsernameChangelogGetResponse, Error = ApiError> + Send> {
let url = format!(
"{}/v0/editor/{username}/changelog",
self.base_path,
@@ -961,79 +690,53 @@ impl Api for Client {
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<EditorUsernameChangelogGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<EditorUsernameChangelogGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Changelogentry>(&buf)?;
Ok(EditorUsernameChangelogGetResponse::FindChanges_(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditorUsernameChangelogGetResponse::UsernameNotFound(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
- Ok(EditorUsernameChangelogGetResponse::GenericErrorResponse(
- body,
- ))
+ Ok(EditorUsernameChangelogGetResponse::GenericErrorResponse(body))
}
code => {
let mut buf = [0; 100];
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn editor_username_get(
- &self,
- param_username: String,
- context: &Context,
- ) -> Box<Future<Item = EditorUsernameGetResponse, Error = ApiError> + Send> {
+ fn editor_username_get(&self, param_username: String, context: &Context) -> Box<Future<Item = EditorUsernameGetResponse, Error = ApiError> + Send> {
let url = format!(
"{}/v0/editor/{username}",
self.base_path,
@@ -1044,41 +747,30 @@ impl Api for Client {
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<EditorUsernameGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<EditorUsernameGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Editor>(&buf)?;
Ok(EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditorUsernameGetResponse::UsernameNotFound(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(EditorUsernameGetResponse::GenericErrorResponse(body))
@@ -1088,78 +780,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn file_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = FileIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/file/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn file_id_get(&self, param_id: String, context: &Context) -> Box<Future<Item = FileIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/file/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<FileIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<FileIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::FileEntity>(&buf)?;
Ok(FileIdGetResponse::FetchASingleFileById(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FileIdGetResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FileIdGetResponse::GenericErrorResponse(body))
@@ -1169,92 +833,60 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn file_lookup_get(
- &self,
- param_sha1: String,
- context: &Context,
- ) -> Box<Future<Item = FileLookupGetResponse, Error = ApiError> + Send> {
+ fn file_lookup_get(&self, param_sha1: String, context: &Context) -> Box<Future<Item = FileLookupGetResponse, Error = ApiError> + Send> {
// Query parameters
let query_sha1 = format!("sha1={sha1}&", sha1 = param_sha1.to_string());
- let url = format!(
- "{}/v0/file/lookup?{sha1}",
- self.base_path,
- sha1 = utf8_percent_encode(&query_sha1, QUERY_ENCODE_SET)
- );
+ let url = format!("{}/v0/file/lookup?{sha1}", self.base_path, sha1 = utf8_percent_encode(&query_sha1, QUERY_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<FileLookupGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<FileLookupGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::FileEntity>(&buf)?;
- Ok(FileLookupGetResponse::FindASingleFileByExternalIdentifer(
- body,
- ))
+ Ok(FileLookupGetResponse::FindASingleFileByExternalIdentifer(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FileLookupGetResponse::BadRequest(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FileLookupGetResponse::NoSuchFile(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FileLookupGetResponse::GenericErrorResponse(body))
@@ -1264,37 +896,23 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn file_post(
- &self,
- param_body: Option<models::FileEntity>,
- context: &Context,
- ) -> Box<Future<Item = FilePostResponse, Error = ApiError> + Send> {
+ fn file_post(&self, param_body: Option<models::FileEntity>, context: &Context) -> Box<Future<Item = FilePostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/file", self.base_path);
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
+ let body = param_body.map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
@@ -1305,41 +923,30 @@ impl Api for Client {
};
custom_headers.set(ContentType(mimetypes::requests::FILE_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<FilePostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<FilePostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::EntityEdit>(&buf)?;
Ok(FilePostResponse::Created(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FilePostResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(FilePostResponse::GenericErrorResponse(body))
@@ -1349,78 +956,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn release_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = ReleaseIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/release/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn release_id_get(&self, param_id: String, context: &Context) -> Box<Future<Item = ReleaseIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/release/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ReleaseIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ReleaseIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::ReleaseEntity>(&buf)?;
Ok(ReleaseIdGetResponse::FetchASingleReleaseById(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleaseIdGetResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleaseIdGetResponse::GenericErrorResponse(body))
@@ -1430,90 +1009,60 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn release_lookup_get(
- &self,
- param_doi: String,
- context: &Context,
- ) -> Box<Future<Item = ReleaseLookupGetResponse, Error = ApiError> + Send> {
+ fn release_lookup_get(&self, param_doi: String, context: &Context) -> Box<Future<Item = ReleaseLookupGetResponse, Error = ApiError> + Send> {
// Query parameters
let query_doi = format!("doi={doi}&", doi = param_doi.to_string());
- let url = format!(
- "{}/v0/release/lookup?{doi}",
- self.base_path,
- doi = utf8_percent_encode(&query_doi, QUERY_ENCODE_SET)
- );
+ let url = format!("{}/v0/release/lookup?{doi}", self.base_path, doi = utf8_percent_encode(&query_doi, QUERY_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ReleaseLookupGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ReleaseLookupGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::ReleaseEntity>(&buf)?;
Ok(ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleaseLookupGetResponse::BadRequest(body))
}
404 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleaseLookupGetResponse::NoSuchRelease(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleaseLookupGetResponse::GenericErrorResponse(body))
@@ -1523,37 +1072,23 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn release_post(
- &self,
- param_body: Option<models::ReleaseEntity>,
- context: &Context,
- ) -> Box<Future<Item = ReleasePostResponse, Error = ApiError> + Send> {
+ fn release_post(&self, param_body: Option<models::ReleaseEntity>, context: &Context) -> Box<Future<Item = ReleasePostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/release", self.base_path);
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
+ let body = param_body.map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
@@ -1564,41 +1099,30 @@ impl Api for Client {
};
custom_headers.set(ContentType(mimetypes::requests::RELEASE_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<ReleasePostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<ReleasePostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::EntityEdit>(&buf)?;
Ok(ReleasePostResponse::Created(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleasePostResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(ReleasePostResponse::GenericErrorResponse(body))
@@ -1608,78 +1132,50 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn work_id_get(
- &self,
- param_id: String,
- context: &Context,
- ) -> Box<Future<Item = WorkIdGetResponse, Error = ApiError> + Send> {
- let url = format!(
- "{}/v0/work/{id}",
- self.base_path,
- id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET)
- );
+ fn work_id_get(&self, param_id: String, context: &Context) -> Box<Future<Item = WorkIdGetResponse, Error = ApiError> + Send> {
+ let url = format!("{}/v0/work/{id}", self.base_path, id = utf8_percent_encode(&param_id.to_string(), PATH_SEGMENT_ENCODE_SET));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Get, &url);
let mut custom_headers = hyper::header::Headers::new();
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<WorkIdGetResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<WorkIdGetResponse, ApiError> {
match response.status.to_u16() {
200 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::WorkEntity>(&buf)?;
Ok(WorkIdGetResponse::FetchASingleWorkById(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(WorkIdGetResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(WorkIdGetResponse::GenericErrorResponse(body))
@@ -1689,37 +1185,23 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
- fn work_post(
- &self,
- param_body: Option<models::WorkEntity>,
- context: &Context,
- ) -> Box<Future<Item = WorkPostResponse, Error = ApiError> + Send> {
+ fn work_post(&self, param_body: Option<models::WorkEntity>, context: &Context) -> Box<Future<Item = WorkPostResponse, Error = ApiError> + Send> {
let url = format!("{}/v0/work", self.base_path);
- let body = param_body
- .map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
+ let body = param_body.map(|ref body| serde_json::to_string(body).expect("impossible to fail to serialize"));
let hyper_client = (self.hyper_client)();
let request = hyper_client.request(hyper::method::Method::Post, &url);
let mut custom_headers = hyper::header::Headers::new();
@@ -1730,41 +1212,30 @@ impl Api for Client {
};
custom_headers.set(ContentType(mimetypes::requests::WORK_POST.clone()));
- context
- .x_span_id
- .as_ref()
- .map(|header| custom_headers.set(XSpanId(header.clone())));
+ context.x_span_id.as_ref().map(|header| custom_headers.set(XSpanId(header.clone())));
let request = request.headers(custom_headers);
// Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists).
- fn parse_response(
- mut response: hyper::client::response::Response,
- ) -> Result<WorkPostResponse, ApiError> {
+ fn parse_response(mut response: hyper::client::response::Response) -> Result<WorkPostResponse, ApiError> {
match response.status.to_u16() {
201 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::EntityEdit>(&buf)?;
Ok(WorkPostResponse::Created(body))
}
400 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(WorkPostResponse::BadRequest(body))
}
0 => {
let mut buf = String::new();
- response
- .read_to_string(&mut buf)
- .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
+ response.read_to_string(&mut buf).map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?;
let body = serde_json::from_str::<models::Error>(&buf)?;
Ok(WorkPostResponse::GenericErrorResponse(body))
@@ -1774,25 +1245,16 @@ impl Api for Client {
let debug_body = match response.read(&mut buf) {
Ok(len) => match str::from_utf8(&buf[..len]) {
Ok(body) => Cow::from(body),
- Err(_) => Cow::from(format!(
- "<Body was not UTF8: {:?}>",
- &buf[..len].to_vec()
- )),
+ Err(_) => Cow::from(format!("<Body was not UTF8: {:?}>", &buf[..len].to_vec())),
},
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
};
- Err(ApiError(format!(
- "Unexpected response code {}:\n{:?}\n\n{}",
- code, response.headers, debug_body
- )))
+ Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}", code, response.headers, debug_body)))
}
}
}
- let result = request
- .send()
- .map_err(|e| ApiError(format!("No response received: {}", e)))
- .and_then(parse_response);
+ let result = request.send().map_err(|e| ApiError(format!("No response received: {}", e))).and_then(parse_response);
Box::new(futures::done(result))
}
}