diff options
Diffstat (limited to 'rust/fatcat-api/src/client.rs')
| -rw-r--r-- | rust/fatcat-api/src/client.rs | 948 |
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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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)) } } |