diff options
Diffstat (limited to 'rust/fatcat-api/src/server.rs')
| -rw-r--r-- | rust/fatcat-api/src/server.rs | 2597 |
1 files changed, 1800 insertions, 797 deletions
diff --git a/rust/fatcat-api/src/server.rs b/rust/fatcat-api/src/server.rs index cb307ad4..66539c55 100644 --- a/rust/fatcat-api/src/server.rs +++ b/rust/fatcat-api/src/server.rs @@ -1,34 +1,31 @@ #![allow(unused_extern_crates)] -extern crate serde_ignored; +extern crate bodyparser; +extern crate chrono; extern crate iron; extern crate router; -extern crate bodyparser; +extern crate serde_ignored; extern crate urlencoded; extern crate uuid; -extern crate chrono; - -use futures::Future; -use futures::future; -use futures::{stream, Stream}; -use hyper; -use hyper::header::{Headers, ContentType}; use self::iron::prelude::*; -use self::iron::{status, modifiers, BeforeMiddleware}; use self::iron::url::percent_encoding::percent_decode; +use self::iron::{modifiers, status, BeforeMiddleware}; use self::router::Router; use self::urlencoded::UrlEncodedQuery; +use futures::Future; +use futures::future; +use futures::{stream, Stream}; +use hyper; +use hyper::header::{ContentType, Headers}; use mimetypes; - use serde_json; - #[allow(unused_imports)] -use std::collections::{HashMap, BTreeMap}; +use std::collections::{BTreeMap, HashMap}; +use std::io::Error; #[allow(unused_imports)] use swagger; -use std::io::Error; #[allow(unused_imports)] use std::collections::BTreeSet; @@ -37,34 +34,22 @@ pub use swagger::auth::Authorization; use swagger::auth::{AuthData, Scopes}; use swagger::{ApiError, Context, XSpanId}; -use {Api, - ContainerIdGetResponse, - ContainerLookupGetResponse, - ContainerPostResponse, - CreatorIdGetResponse, - CreatorLookupGetResponse, - CreatorPostResponse, - EditgroupIdAcceptPostResponse, - EditgroupIdGetResponse, - EditgroupPostResponse, - EditorUsernameChangelogGetResponse, - EditorUsernameGetResponse, - FileIdGetResponse, - FileLookupGetResponse, - FilePostResponse, - ReleaseIdGetResponse, - ReleaseLookupGetResponse, - ReleasePostResponse, - WorkIdGetResponse, - WorkPostResponse - }; #[allow(unused_imports)] use models; +use {Api, ContainerIdGetResponse, ContainerLookupGetResponse, ContainerPostResponse, + CreatorIdGetResponse, CreatorLookupGetResponse, CreatorPostResponse, + EditgroupIdAcceptPostResponse, EditgroupIdGetResponse, EditgroupPostResponse, + EditorUsernameChangelogGetResponse, EditorUsernameGetResponse, FileIdGetResponse, + FileLookupGetResponse, FilePostResponse, ReleaseIdGetResponse, ReleaseLookupGetResponse, + ReleasePostResponse, WorkIdGetResponse, WorkPostResponse}; header! { (Warning, "Warning") => [String] } /// Create a new router for `Api` -pub fn router<T>(api: T) -> Router where T: Api + Send + Sync + Clone + 'static { +pub fn router<T>(api: T) -> Router +where + T: Api + Send + Sync + Clone + 'static, +{ let mut router = Router::new(); add_routes(&mut router, api); router @@ -90,14 +75,19 @@ pub fn router<T>(api: T) -> Router where T: Api + Send + Sync + Clone + 'static /// /// This function exists to allow legacy code, which doesn't separate its APIs properly, to make /// use of this crate. -#[deprecated(note="APIs should not overlap - only for use in legacy code.")] -pub fn route<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone + 'static { +#[deprecated(note = "APIs should not overlap - only for use in legacy code.")] +pub fn route<T>(router: &mut Router, api: T) +where + T: Api + Send + Sync + Clone + 'static, +{ add_routes(router, api) } /// Add routes for `Api` to a provided router -fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone + 'static { - +fn add_routes<T>(router: &mut Router, api: T) +where + T: Api + Send + Sync + Clone + 'static, +{ let api_clone = api.clone(); router.get( "/v0/container/:id", @@ -105,75 +95,134 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.container_id_get(param_id, context).wait() { Ok(rsp) => match rsp { ContainerIdGetResponse::FetchASingleContainerById(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_FETCH_A_SINGLE_CONTAINER_BY_ID.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } ContainerIdGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_ID_GET_BAD_REQUEST.clone(), + )); - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } ContainerIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_ID_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_ID_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ContainerIdGet"); + "ContainerIdGet", + ); let api_clone = api.clone(); router.get( @@ -182,84 +231,144 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default(); - let param_issn = query_params.get("issn") - .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter issn".to_string())))? - .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter issn was empty".to_string())))? - .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter issn - doesn't match schema: {}", e))))?; - + let param_issn = query_params + .get("issn") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing required query parameter issn".to_string(), + )) + })? + .first() + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Required query parameter issn was empty".to_string(), + )) + })? + .parse::<String>() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!( + "Couldn't parse query parameter issn - doesn't match schema: {}", + e + ), + )) + })?; match api.container_lookup_get(param_issn, context).wait() { - Ok(rsp) => match rsp { - ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_FIND_A_SINGLE_CONTAINER_BY_EXTERNAL_IDENTIFER.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - ContainerLookupGetResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - ContainerLookupGetResponse::NoSuchContainer(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_NO_SUCH_CONTAINER.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - ContainerLookupGetResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + Ok(rsp) => { + match rsp { + ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer( + body, + ) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_FIND_A_SINGLE_CONTAINER_BY_EXTERNAL_IDENTIFER.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + ContainerLookupGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_LOOKUP_GET_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + ContainerLookupGetResponse::NoSuchContainer(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_LOOKUP_GET_NO_SUCH_CONTAINER + .clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + ContainerLookupGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - Ok(response) - }, - }, + Ok(response) + } + } + } Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ContainerLookupGet"); + "ContainerLookupGet", + ); let api_clone = api.clone(); router.post( @@ -268,15 +377,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Body parameters (note that non-required body parameters will ignore garbage // values, rather than causing a 400 response). Produce warning header and logs for // any unused fields. @@ -285,10 +402,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut unused_elements = Vec::new(); - let param_body = if let Some(param_body_raw) = param_body { + let param_body = if let Some(param_body_raw) = param_body { let deserializer = &mut serde_json::Deserializer::from_str(¶m_body_raw); - let param_body: Option<models::ContainerEntity> = serde_ignored::deserialize(deserializer, |path| { + let param_body: Option<models::ContainerEntity> = + serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }).unwrap_or(None); @@ -296,65 +414,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone param_body } else { None - };; - + }; match api.container_post(param_body, context).wait() { Ok(rsp) => match rsp { ContainerPostResponse::Created(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_POST_CREATED.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } ContainerPostResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_POST_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } ContainerPostResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CONTAINER_POST_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CONTAINER_POST_GENERIC_ERROR_RESPONSE.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ContainerPost"); + "ContainerPost", + ); let api_clone = api.clone(); router.get( @@ -363,75 +514,136 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.creator_id_get(param_id, context).wait() { - Ok(rsp) => match rsp { - CreatorIdGetResponse::FetchASingleCreatorById(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_FETCH_A_SINGLE_CREATOR_BY_ID.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - CreatorIdGetResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - CreatorIdGetResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - }, + Ok(rsp) => { + match rsp { + CreatorIdGetResponse::FetchASingleCreatorById(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType(mimetypes::responses::CREATOR_ID_GET_FETCH_A_SINGLE_CREATOR_BY_ID.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + CreatorIdGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_ID_GET_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + CreatorIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_ID_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + } + } Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "CreatorIdGet"); + "CreatorIdGet", + ); let api_clone = api.clone(); router.get( @@ -440,84 +652,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default(); - let param_orcid = query_params.get("orcid") - .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter orcid".to_string())))? - .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter orcid was empty".to_string())))? - .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter orcid - doesn't match schema: {}", e))))?; - + let param_orcid = query_params + .get("orcid") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing required query parameter orcid".to_string(), + )) + })? + .first() + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Required query parameter orcid was empty".to_string(), + )) + })? + .parse::<String>() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!( + "Couldn't parse query parameter orcid - doesn't match schema: {}", + e + ), + )) + })?; match api.creator_lookup_get(param_orcid, context).wait() { Ok(rsp) => match rsp { CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_FIND_A_SINGLE_CREATOR_BY_EXTERNAL_IDENTIFER.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } CreatorLookupGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_BAD_REQUEST.clone())); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_LOOKUP_GET_BAD_REQUEST.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } CreatorLookupGetResponse::NoSuchCreator(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_LOOKUP_GET_NO_SUCH_CREATOR.clone(), + )); - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_NO_SUCH_CREATOR.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } CreatorLookupGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_LOOKUP_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "CreatorLookupGet"); + "CreatorLookupGet", + ); let api_clone = api.clone(); router.post( @@ -526,15 +796,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Body parameters (note that non-required body parameters will ignore garbage // values, rather than causing a 400 response). Produce warning header and logs for // any unused fields. @@ -543,10 +821,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut unused_elements = Vec::new(); - let param_body = if let Some(param_body_raw) = param_body { + let param_body = if let Some(param_body_raw) = param_body { let deserializer = &mut serde_json::Deserializer::from_str(¶m_body_raw); - let param_body: Option<models::CreatorEntity> = serde_ignored::deserialize(deserializer, |path| { + let param_body: Option<models::CreatorEntity> = + serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }).unwrap_or(None); @@ -554,65 +833,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone param_body } else { None - };; - + }; match api.creator_post(param_body, context).wait() { Ok(rsp) => match rsp { CreatorPostResponse::Created(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_POST_CREATED.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } CreatorPostResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_POST_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } CreatorPostResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::CREATOR_POST_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::CREATOR_POST_GENERIC_ERROR_RESPONSE.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "CreatorPost"); + "CreatorPost", + ); let api_clone = api.clone(); router.post( @@ -621,86 +933,146 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.editgroup_id_accept_post(param_id, context).wait() { - Ok(rsp) => match rsp { - EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_MERGED_EDITGROUP_SUCCESSFULLY_.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_EDITGROUP_IS_IN_AN_UNMERGABLE_STATE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + Ok(rsp) => { + match rsp { + EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_MERGED_EDITGROUP_SUCCESSFULLY_.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - Ok(response) - }, - EditgroupIdAcceptPostResponse::NoSuchEditgroup(body) => { + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_EDITGROUP_IS_IN_AN_UNMERGABLE_STATE.clone())); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_NO_SUCH_EDITGROUP.clone())); + Ok(response) + } + EditgroupIdAcceptPostResponse::NoSuchEditgroup(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_NO_SUCH_EDITGROUP.clone())); - Ok(response) - }, - EditgroupIdAcceptPostResponse::GenericErrorResponse(body) => { + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + Ok(response) + } + EditgroupIdAcceptPostResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_GENERIC_ERROR_RESPONSE.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - Ok(response) - }, - }, + Ok(response) + } + } + } Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "EditgroupIdAcceptPost"); + "EditgroupIdAcceptPost", + ); let api_clone = api.clone(); router.get( @@ -709,75 +1081,134 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.editgroup_id_get(param_id, context).wait() { Ok(rsp) => match rsp { EditgroupIdGetResponse::FetchEditgroupByIdentifier(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_FETCH_EDITGROUP_BY_IDENTIFIER.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditgroupIdGetResponse::NoSuchEditgroup(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITGROUP_ID_GET_NO_SUCH_EDITGROUP.clone(), + )); - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_NO_SUCH_EDITGROUP.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditgroupIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITGROUP_ID_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "EditgroupIdGet"); + "EditgroupIdGet", + ); let api_clone = api.clone(); router.post( @@ -786,66 +1217,99 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - - match api.editgroup_post(context).wait() { Ok(rsp) => match rsp { EditgroupPostResponse::SuccessfullyCreated(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITGROUP_POST_SUCCESSFULLY_CREATED.clone(), + )); - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_SUCCESSFULLY_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditgroupPostResponse::InvalidRequestParameters(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_INVALID_REQUEST_PARAMETERS.clone())); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITGROUP_POST_INVALID_REQUEST_PARAMETERS + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditgroupPostResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITGROUP_POST_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITGROUP_POST_GENERIC_ERROR_RESPONSE.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "EditgroupPost"); + "EditgroupPost", + ); let api_clone = api.clone(); router.get( @@ -854,75 +1318,133 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_username = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("username").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter username".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter username: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("username") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter username".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter username: {}", e), + )) + })? }; + match api.editor_username_changelog_get(param_username, context) + .wait() + { + Ok(rsp) => { + match rsp { + EditorUsernameChangelogGetResponse::FindChanges_(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_FIND_CHANGES_.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + EditorUsernameChangelogGetResponse::UsernameNotFound(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_USERNAME_NOT_FOUND.clone())); - match api.editor_username_changelog_get(param_username, context).wait() { - Ok(rsp) => match rsp { - EditorUsernameChangelogGetResponse::FindChanges_(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_FIND_CHANGES_.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - EditorUsernameChangelogGetResponse::UsernameNotFound(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_USERNAME_NOT_FOUND.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - EditorUsernameChangelogGetResponse::GenericErrorResponse(body) => { + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + Ok(response) + } + EditorUsernameChangelogGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_GENERIC_ERROR_RESPONSE.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); - Ok(response) - }, - }, + Ok(response) + } + } + } Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "EditorUsernameChangelogGet"); + "EditorUsernameChangelogGet", + ); let api_clone = api.clone(); router.get( @@ -931,75 +1453,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_username = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("username").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter username".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter username: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("username") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter username".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter username: {}", e), + )) + })? }; - - match api.editor_username_get(param_username, context).wait() { Ok(rsp) => match rsp { EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_FETCH_GENERIC_INFORMATION_ABOUT_AN_EDITOR.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditorUsernameGetResponse::UsernameNotFound(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_USERNAME_NOT_FOUND.clone())); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITOR_USERNAME_GET_USERNAME_NOT_FOUND + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } EditorUsernameGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::EDITOR_USERNAME_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "EditorUsernameGet"); + "EditorUsernameGet", + ); let api_clone = api.clone(); router.get( @@ -1008,75 +1590,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.file_id_get(param_id, context).wait() { Ok(rsp) => match rsp { FileIdGetResponse::FetchASingleFileById(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_FETCH_A_SINGLE_FILE_BY_ID.clone())); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_ID_GET_FETCH_A_SINGLE_FILE_BY_ID.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } FileIdGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_ID_GET_BAD_REQUEST.clone(), + )); - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } FileIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_ID_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_ID_GET_GENERIC_ERROR_RESPONSE.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "FileIdGet"); + "FileIdGet", + ); let api_clone = api.clone(); router.get( @@ -1085,84 +1727,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default(); - let param_sha1 = query_params.get("sha1") - .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter sha1".to_string())))? - .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter sha1 was empty".to_string())))? - .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter sha1 - doesn't match schema: {}", e))))?; - + let param_sha1 = query_params + .get("sha1") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing required query parameter sha1".to_string(), + )) + })? + .first() + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Required query parameter sha1 was empty".to_string(), + )) + })? + .parse::<String>() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!( + "Couldn't parse query parameter sha1 - doesn't match schema: {}", + e + ), + )) + })?; match api.file_lookup_get(param_sha1, context).wait() { Ok(rsp) => match rsp { FileLookupGetResponse::FindASingleFileByExternalIdentifer(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_FIND_A_SINGLE_FILE_BY_EXTERNAL_IDENTIFER.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } FileLookupGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_BAD_REQUEST.clone())); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_LOOKUP_GET_BAD_REQUEST.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } FileLookupGetResponse::NoSuchFile(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_LOOKUP_GET_NO_SUCH_FILE.clone(), + )); - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_NO_SUCH_FILE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } FileLookupGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_LOOKUP_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "FileLookupGet"); + "FileLookupGet", + ); let api_clone = api.clone(); router.post( @@ -1171,15 +1871,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Body parameters (note that non-required body parameters will ignore garbage // values, rather than causing a 400 response). Produce warning header and logs for // any unused fields. @@ -1188,10 +1896,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut unused_elements = Vec::new(); - let param_body = if let Some(param_body_raw) = param_body { + let param_body = if let Some(param_body_raw) = param_body { let deserializer = &mut serde_json::Deserializer::from_str(¶m_body_raw); - let param_body: Option<models::FileEntity> = serde_ignored::deserialize(deserializer, |path| { + let param_body: Option<models::FileEntity> = + serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }).unwrap_or(None); @@ -1199,65 +1908,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone param_body } else { None - };; - + }; match api.file_post(param_body, context).wait() { Ok(rsp) => match rsp { FilePostResponse::Created(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_POST_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response + .headers + .set(ContentType(mimetypes::responses::FILE_POST_CREATED.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } FilePostResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_POST_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_POST_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } FilePostResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::FILE_POST_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::FILE_POST_GENERIC_ERROR_RESPONSE.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "FilePost"); + "FilePost", + ); let api_clone = api.clone(); router.get( @@ -1266,75 +2008,136 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.release_id_get(param_id, context).wait() { - Ok(rsp) => match rsp { - ReleaseIdGetResponse::FetchASingleReleaseById(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_FETCH_A_SINGLE_RELEASE_BY_ID.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - ReleaseIdGetResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - ReleaseIdGetResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); - - Ok(response) - }, - }, + Ok(rsp) => { + match rsp { + ReleaseIdGetResponse::FetchASingleReleaseById(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType(mimetypes::responses::RELEASE_ID_GET_FETCH_A_SINGLE_RELEASE_BY_ID.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + ReleaseIdGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_ID_GET_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + ReleaseIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_ID_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); + + Ok(response) + } + } + } Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ReleaseIdGet"); + "ReleaseIdGet", + ); let api_clone = api.clone(); router.get( @@ -1343,84 +2146,142 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = req.get::<UrlEncodedQuery>().unwrap_or_default(); - let param_doi = query_params.get("doi") - .ok_or_else(|| Response::with((status::BadRequest, "Missing required query parameter doi".to_string())))? - .first().ok_or_else(|| Response::with((status::BadRequest, "Required query parameter doi was empty".to_string())))? - .parse::<String>().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse query parameter doi - doesn't match schema: {}", e))))?; - + let param_doi = query_params + .get("doi") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing required query parameter doi".to_string(), + )) + })? + .first() + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Required query parameter doi was empty".to_string(), + )) + })? + .parse::<String>() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!( + "Couldn't parse query parameter doi - doesn't match schema: {}", + e + ), + )) + })?; match api.release_lookup_get(param_doi, context).wait() { Ok(rsp) => match rsp { ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(200), body_string)); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_FIND_A_SINGLE_RELEASE_BY_EXTERNAL_IDENTIFER.clone())); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } ReleaseLookupGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_LOOKUP_GET_BAD_REQUEST.clone(), + )); - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } ReleaseLookupGetResponse::NoSuchRelease(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(404), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_NO_SUCH_RELEASE.clone())); + let mut response = + Response::with((status::Status::from_u16(404), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_LOOKUP_GET_NO_SUCH_RELEASE.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } ReleaseLookupGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_LOOKUP_GET_GENERIC_ERROR_RESPONSE + .clone(), + )); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ReleaseLookupGet"); + "ReleaseLookupGet", + ); let api_clone = api.clone(); router.post( @@ -1429,15 +2290,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Body parameters (note that non-required body parameters will ignore garbage // values, rather than causing a 400 response). Produce warning header and logs for // any unused fields. @@ -1446,10 +2315,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut unused_elements = Vec::new(); - let param_body = if let Some(param_body_raw) = param_body { + let param_body = if let Some(param_body_raw) = param_body { let deserializer = &mut serde_json::Deserializer::from_str(¶m_body_raw); - let param_body: Option<models::ReleaseEntity> = serde_ignored::deserialize(deserializer, |path| { + let param_body: Option<models::ReleaseEntity> = + serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }).unwrap_or(None); @@ -1457,65 +2327,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone param_body } else { None - };; - + }; match api.release_post(param_body, context).wait() { Ok(rsp) => match rsp { ReleasePostResponse::Created(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_POST_CREATED.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } ReleasePostResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_POST_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } ReleasePostResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::RELEASE_POST_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::RELEASE_POST_GENERIC_ERROR_RESPONSE.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "ReleasePost"); + "ReleasePost", + ); let api_clone = api.clone(); router.get( @@ -1524,75 +2427,135 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - // Path parameters let param_id = { - let param = req.extensions.get::<Router>().ok_or_else(|| Response::with((status::InternalServerError, "An internal error occurred".to_string())))? - .find("id").ok_or_else(|| Response::with((status::BadRequest, "Missing path parameter id".to_string())))?; - percent_decode(param.as_bytes()).decode_utf8() - .map_err(|_| Response::with((status::BadRequest, format!("Couldn't percent-decode path parameter as UTF-8: {}", param))))? - .parse().map_err(|e| Response::with((status::BadRequest, format!("Couldn't parse path parameter id: {}", e))))? + let param = req.extensions + .get::<Router>() + .ok_or_else(|| { + Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + )) + })? + .find("id") + .ok_or_else(|| { + Response::with(( + status::BadRequest, + "Missing path parameter id".to_string(), + )) + })?; + percent_decode(param.as_bytes()) + .decode_utf8() + .map_err(|_| { + Response::with(( + status::BadRequest, + format!( + "Couldn't percent-decode path parameter as UTF-8: {}", + param + ), + )) + })? + .parse() + .map_err(|e| { + Response::with(( + status::BadRequest, + format!("Couldn't parse path parameter id: {}", e), + )) + })? }; - - match api.work_id_get(param_id, context).wait() { Ok(rsp) => match rsp { WorkIdGetResponse::FetchASingleWorkById(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(200), body_string)); + response.headers.set(ContentType( + mimetypes::responses::WORK_ID_GET_FETCH_A_SINGLE_WORK_BY_ID.clone(), + )); - let mut response = Response::with((status::Status::from_u16(200), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_FETCH_A_SINGLE_WORK_BY_ID.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } WorkIdGetResponse::BadRequest(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_BAD_REQUEST.clone())); + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::WORK_ID_GET_BAD_REQUEST.clone(), + )); - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } WorkIdGetResponse::GenericErrorResponse(body) => { + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::WORK_ID_GET_GENERIC_ERROR_RESPONSE.clone(), + )); - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_ID_GET_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "WorkIdGet"); + "WorkIdGet", + ); let api_clone = api.clone(); router.post( @@ -1601,15 +2564,23 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut context = Context::default(); // Helper function to provide a code block to use `?` in (to be replaced by the `catch` block when it exists). - fn handle_request<T>(req: &mut Request, api: &T, context: &mut Context) -> Result<Response, Response> where T: Api { - - context.x_span_id = Some(req.headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string())); + fn handle_request<T>( + req: &mut Request, + api: &T, + context: &mut Context, + ) -> Result<Response, Response> + where + T: Api, + { + context.x_span_id = Some( + req.headers + .get::<XSpanId>() + .map(XSpanId::to_string) + .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), + ); context.auth_data = req.extensions.remove::<AuthData>(); context.authorization = req.extensions.remove::<Authorization>(); - - - // Body parameters (note that non-required body parameters will ignore garbage // values, rather than causing a 400 response). Produce warning header and logs for // any unused fields. @@ -1618,10 +2589,11 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone let mut unused_elements = Vec::new(); - let param_body = if let Some(param_body_raw) = param_body { + let param_body = if let Some(param_body_raw) = param_body { let deserializer = &mut serde_json::Deserializer::from_str(¶m_body_raw); - let param_body: Option<models::WorkEntity> = serde_ignored::deserialize(deserializer, |path| { + let param_body: Option<models::WorkEntity> = + serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }).unwrap_or(None); @@ -1629,66 +2601,98 @@ fn add_routes<T>(router: &mut Router, api: T) where T: Api + Send + Sync + Clone param_body } else { None - };; - + }; match api.work_post(param_body, context).wait() { Ok(rsp) => match rsp { WorkPostResponse::Created(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(201), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_POST_CREATED.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(201), body_string)); + response + .headers + .set(ContentType(mimetypes::responses::WORK_POST_CREATED.clone())); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } WorkPostResponse::BadRequest(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(400), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_POST_BAD_REQUEST.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(400), body_string)); + response.headers.set(ContentType( + mimetypes::responses::WORK_POST_BAD_REQUEST.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } WorkPostResponse::GenericErrorResponse(body) => { - - let body_string = serde_json::to_string(&body).expect("impossible to fail to serialize"); - - let mut response = Response::with((status::Status::from_u16(0), body_string)); - response.headers.set(ContentType(mimetypes::responses::WORK_POST_GENERIC_ERROR_RESPONSE.clone())); - - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + let body_string = serde_json::to_string(&body) + .expect("impossible to fail to serialize"); + + let mut response = + Response::with((status::Status::from_u16(0), body_string)); + response.headers.set(ContentType( + mimetypes::responses::WORK_POST_GENERIC_ERROR_RESPONSE.clone(), + )); + + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); if !unused_elements.is_empty() { - response.headers.set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements))); + response.headers.set(Warning(format!( + "Ignoring unknown fields in body: {:?}", + unused_elements + ))); } Ok(response) - }, + } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. - Err(Response::with((status::InternalServerError, "An internal error occurred".to_string()))) + Err(Response::with(( + status::InternalServerError, + "An internal error occurred".to_string(), + ))) } } } handle_request(req, &api_clone, &mut context).or_else(|mut response| { - context.x_span_id.as_ref().map(|header| response.headers.set(XSpanId(header.clone()))); + context + .x_span_id + .as_ref() + .map(|header| response.headers.set(XSpanId(header.clone()))); Ok(response) }) }, - "WorkPost"); - + "WorkPost", + ); } /// Middleware to extract authentication data from request @@ -1696,7 +2700,6 @@ pub struct ExtractAuthData; impl BeforeMiddleware for ExtractAuthData { fn before(&self, req: &mut Request) -> IronResult<()> { - Ok(()) } } |