#![allow(unused_extern_crates)] extern crate chrono; extern crate hyper_tls; extern crate mime; extern crate native_tls; extern crate openssl; extern crate serde_ignored; extern crate tokio_core; extern crate uuid; extern crate percent_encoding; extern crate url; use self::url::form_urlencoded; use futures::{future, stream, Future, Stream}; use hyper; use hyper::header::{ContentType, Headers}; use hyper::{Error, Request, Response, StatusCode}; use mimetypes; use std::sync::Arc; use serde_json; #[allow(unused_imports)] use std::collections::{BTreeMap, HashMap}; use std::io; #[allow(unused_imports)] use swagger; #[allow(unused_imports)] use std::collections::BTreeSet; pub use swagger::auth::Authorization; use swagger::auth::Scopes; use swagger::{ApiError, Context, XSpanId}; #[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}; pub mod auth; header! { (Warning, "Warning") => [String] } mod paths { extern crate regex; lazy_static! { pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(&[ r"^/v0/container$", r"^/v0/container/lookup$", r"^/v0/container/(?P[^/?#]*)$", r"^/v0/creator$", r"^/v0/creator/lookup$", r"^/v0/creator/(?P[^/?#]*)$", r"^/v0/editgroup$", r"^/v0/editgroup/(?P[^/?#]*)$", r"^/v0/editgroup/(?P[^/?#]*)/accept$", r"^/v0/editor/(?P[^/?#]*)$", r"^/v0/editor/(?P[^/?#]*)/changelog$", r"^/v0/file$", r"^/v0/file/lookup$", r"^/v0/file/(?P[^/?#]*)$", r"^/v0/release$", r"^/v0/release/lookup$", r"^/v0/release/(?P[^/?#]*)$", r"^/v0/work$", r"^/v0/work/(?P[^/?#]*)$" ]).unwrap(); } pub static ID_CONTAINER: usize = 0; pub static ID_CONTAINER_LOOKUP: usize = 1; pub static ID_CONTAINER_ID: usize = 2; lazy_static! { pub static ref REGEX_CONTAINER_ID: regex::Regex = regex::Regex::new(r"^/v0/container/(?P[^/?#]*)$").unwrap(); } pub static ID_CREATOR: usize = 3; pub static ID_CREATOR_LOOKUP: usize = 4; pub static ID_CREATOR_ID: usize = 5; lazy_static! { pub static ref REGEX_CREATOR_ID: regex::Regex = regex::Regex::new(r"^/v0/creator/(?P[^/?#]*)$").unwrap(); } pub static ID_EDITGROUP: usize = 6; pub static ID_EDITGROUP_ID: usize = 7; lazy_static! { pub static ref REGEX_EDITGROUP_ID: regex::Regex = regex::Regex::new(r"^/v0/editgroup/(?P[^/?#]*)$").unwrap(); } pub static ID_EDITGROUP_ID_ACCEPT: usize = 8; lazy_static! { pub static ref REGEX_EDITGROUP_ID_ACCEPT: regex::Regex = regex::Regex::new(r"^/v0/editgroup/(?P[^/?#]*)/accept$").unwrap(); } pub static ID_EDITOR_USERNAME: usize = 9; lazy_static! { pub static ref REGEX_EDITOR_USERNAME: regex::Regex = regex::Regex::new(r"^/v0/editor/(?P[^/?#]*)$").unwrap(); } pub static ID_EDITOR_USERNAME_CHANGELOG: usize = 10; lazy_static! { pub static ref REGEX_EDITOR_USERNAME_CHANGELOG: regex::Regex = regex::Regex::new(r"^/v0/editor/(?P[^/?#]*)/changelog$").unwrap(); } pub static ID_FILE: usize = 11; pub static ID_FILE_LOOKUP: usize = 12; pub static ID_FILE_ID: usize = 13; lazy_static! { pub static ref REGEX_FILE_ID: regex::Regex = regex::Regex::new(r"^/v0/file/(?P[^/?#]*)$").unwrap(); } pub static ID_RELEASE: usize = 14; pub static ID_RELEASE_LOOKUP: usize = 15; pub static ID_RELEASE_ID: usize = 16; lazy_static! { pub static ref REGEX_RELEASE_ID: regex::Regex = regex::Regex::new(r"^/v0/release/(?P[^/?#]*)$").unwrap(); } pub static ID_WORK: usize = 17; pub static ID_WORK_ID: usize = 18; lazy_static! { pub static ref REGEX_WORK_ID: regex::Regex = regex::Regex::new(r"^/v0/work/(?P[^/?#]*)$").unwrap(); } } pub struct NewService { api_impl: Arc, } impl NewService where T: Api + Clone + 'static, { pub fn new>>(api_impl: U) -> NewService { NewService { api_impl: api_impl.into(), } } } impl hyper::server::NewService for NewService where T: Api + Clone + 'static, { type Request = (Request, Context); type Response = Response; type Error = Error; type Instance = Service; fn new_service(&self) -> Result { Ok(Service::new(self.api_impl.clone())) } } pub struct Service { api_impl: Arc, } impl Service where T: Api + Clone + 'static, { pub fn new>>(api_impl: U) -> Service { Service { api_impl: api_impl.into(), } } } impl hyper::server::Service for Service where T: Api + Clone + 'static, { type Request = (Request, Context); type Response = Response; type Error = Error; type Future = Box>; fn call(&self, (req, mut context): Self::Request) -> Self::Future { let api_impl = self.api_impl.clone(); let (method, uri, _, headers, body) = req.deconstruct(); let path = paths::GLOBAL_REGEX_SET.matches(uri.path()); match &method { // ContainerIdGet - GET /container/{id} &hyper::Method::Get if path.matched(paths::ID_CONTAINER_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_CONTAINER_ID .captures(&path) .unwrap_or_else(|| { panic!("Path {} matched RE CONTAINER_ID in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_ID.as_str()) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.container_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { ContainerIdGetResponse::FetchASingleContainerById (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_ID_GET_FETCH_A_SINGLE_CONTAINER_BY_ID.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ContainerIdGetResponse::BadRequest (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_ID_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ContainerIdGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // ContainerLookupGet - GET /container/lookup &hyper::Method::Get if path.matched(paths::ID_CONTAINER_LOOKUP) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = form_urlencoded::parse( uri.query().unwrap_or_default().as_bytes(), ).collect::>(); let param_issn = query_params .iter() .filter(|e| e.0 == "issn") .map(|e| e.1.to_owned()) .nth(0); let param_issn = match param_issn { Some(param_issn) => match param_issn.parse::() { Ok(param_issn) => param_issn, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse query parameter issn - doesn't match schema: {}", e )), )) } }, None => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body("Missing required query parameter issn"), )) } }; Box::new( ({ { { Box::new(api_impl.container_lookup_get(param_issn, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { ContainerLookupGetResponse::FindASingleContainerByExternalIdentifer (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_FIND_A_SINGLE_CONTAINER_BY_EXTERNAL_IDENTIFER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ContainerLookupGetResponse::BadRequest (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ContainerLookupGetResponse::NoSuchContainer (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_NO_SUCH_CONTAINER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ContainerLookupGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // ContainerPost - POST /container &hyper::Method::Post if path.matched(paths::ID_CONTAINER) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // 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. Box::new(body.concat2().then( move |result| -> Box> { match result { Ok(body) => { let mut unused_elements = Vec::new(); let param_body: Option< models::ContainerEntity, > = if !body.is_empty() { let deserializer = &mut serde_json::Deserializer::from_slice(&*body); match serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }) { Ok(param_body) => param_body, Err(_) => None, } } else { None }; Box::new(api_impl.container_post(param_body, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); if !unused_elements.is_empty() { response.headers_mut().set(Warning(format!( "Ignoring unknown fields in body: {:?}", unused_elements ))); } match result { Ok(rsp) => match rsp { ContainerPostResponse::Created(body) => { response.set_status( StatusCode::try_from(201).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_POST_CREATED.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ContainerPostResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_POST_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ContainerPostResponse::GenericErrorResponse( body, ) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CONTAINER_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } Err(e) => Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't read body parameter body: {}", e)), )), } }, )) as Box> } // CreatorIdGet - GET /creator/{id} &hyper::Method::Get if path.matched(paths::ID_CREATOR_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_CREATOR_ID.captures(&path).unwrap_or_else(|| { panic!( "Path {} matched RE CREATOR_ID in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_ID.as_str() ) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.creator_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { CreatorIdGetResponse::FetchASingleCreatorById( body, ) => { response.set_status( StatusCode::try_from(200).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_ID_GET_FETCH_A_SINGLE_CREATOR_BY_ID.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } CreatorIdGetResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_ID_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } CreatorIdGetResponse::GenericErrorResponse( body, ) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } } }), ) as Box> } // CreatorLookupGet - GET /creator/lookup &hyper::Method::Get if path.matched(paths::ID_CREATOR_LOOKUP) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = form_urlencoded::parse( uri.query().unwrap_or_default().as_bytes(), ).collect::>(); let param_orcid = query_params .iter() .filter(|e| e.0 == "orcid") .map(|e| e.1.to_owned()) .nth(0); let param_orcid = match param_orcid { Some(param_orcid) => match param_orcid.parse::() { Ok(param_orcid) => param_orcid, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse query parameter orcid - doesn't match schema: {}", e )), )) } }, None => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body("Missing required query parameter orcid"), )) } }; Box::new( ({ { { Box::new(api_impl.creator_lookup_get(param_orcid, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { CreatorLookupGetResponse::FindASingleCreatorByExternalIdentifer (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_FIND_A_SINGLE_CREATOR_BY_EXTERNAL_IDENTIFER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, CreatorLookupGetResponse::BadRequest (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, CreatorLookupGetResponse::NoSuchCreator (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_NO_SUCH_CREATOR.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, CreatorLookupGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // CreatorPost - POST /creator &hyper::Method::Post if path.matched(paths::ID_CREATOR) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // 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. Box::new(body.concat2().then( move |result| -> Box> { match result { Ok(body) => { let mut unused_elements = Vec::new(); let param_body: Option< models::CreatorEntity, > = if !body.is_empty() { let deserializer = &mut serde_json::Deserializer::from_slice(&*body); match serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }) { Ok(param_body) => param_body, Err(_) => None, } } else { None }; Box::new(api_impl.creator_post(param_body, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); if !unused_elements.is_empty() { response.headers_mut().set(Warning(format!( "Ignoring unknown fields in body: {:?}", unused_elements ))); } match result { Ok(rsp) => match rsp { CreatorPostResponse::Created(body) => { response.set_status( StatusCode::try_from(201).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::CREATOR_POST_CREATED .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } CreatorPostResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_POST_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } CreatorPostResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::CREATOR_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } Err(e) => Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't read body parameter body: {}", e)), )), } }, )) as Box> } // EditgroupIdAcceptPost - POST /editgroup/{id}/accept &hyper::Method::Post if path.matched(paths::ID_EDITGROUP_ID_ACCEPT) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_EDITGROUP_ID_ACCEPT .captures(&path) .unwrap_or_else(|| { panic!("Path {} matched RE EDITGROUP_ID_ACCEPT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_ID_ACCEPT.as_str()) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new( api_impl.editgroup_id_accept_post(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { EditgroupIdAcceptPostResponse::MergedEditgroupSuccessfully_ (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_MERGED_EDITGROUP_SUCCESSFULLY_.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditgroupIdAcceptPostResponse::EditgroupIsInAnUnmergableState (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_EDITGROUP_IS_IN_AN_UNMERGABLE_STATE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditgroupIdAcceptPostResponse::NoSuchEditgroup (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_NO_SUCH_EDITGROUP.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditgroupIdAcceptPostResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_ACCEPT_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, ), ) } } }), ) as Box> } // EditgroupIdGet - GET /editgroup/{id} &hyper::Method::Get if path.matched(paths::ID_EDITGROUP_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_EDITGROUP_ID .captures(&path) .unwrap_or_else(|| { panic!("Path {} matched RE EDITGROUP_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_ID.as_str()) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.editgroup_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { EditgroupIdGetResponse::FetchEditgroupByIdentifier (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_FETCH_EDITGROUP_BY_IDENTIFIER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditgroupIdGetResponse::NoSuchEditgroup (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_NO_SUCH_EDITGROUP.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditgroupIdGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // EditgroupPost - POST /editgroup &hyper::Method::Post if path.matched(paths::ID_EDITGROUP) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } Box::new( ({ { { Box::new(api_impl.editgroup_post(&context).then(move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { EditgroupPostResponse::SuccessfullyCreated(body) => { response .set_status(StatusCode::try_from(201).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_POST_SUCCESSFULLY_CREATED.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } EditgroupPostResponse::InvalidRequestParameters( body, ) => { response .set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_POST_INVALID_REQUEST_PARAMETERS.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } EditgroupPostResponse::GenericErrorResponse(body) => { response .set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITGROUP_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) })) } } }), ) as Box> } // EditorUsernameChangelogGet - GET /editor/{username}/changelog &hyper::Method::Get if path.matched(paths::ID_EDITOR_USERNAME_CHANGELOG) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_EDITOR_USERNAME_CHANGELOG .captures(&path) .unwrap_or_else(|| { panic!("Path {} matched RE EDITOR_USERNAME_CHANGELOG in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_USERNAME_CHANGELOG.as_str()) }); let param_username = match percent_encoding::percent_decode( path_params["username"].as_bytes(), ).decode_utf8() { Ok(param_username) => match param_username.parse::() { Ok(param_username) => param_username, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse path parameter username: {}", e )), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["username"] )), )) } }; Box::new( ({ { { Box::new( api_impl .editor_username_changelog_get(param_username, &context) .then(move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { EditorUsernameChangelogGetResponse::FindChanges_ (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_FIND_CHANGES_.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditorUsernameChangelogGetResponse::UsernameNotFound (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_USERNAME_NOT_FOUND.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditorUsernameChangelogGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_CHANGELOG_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }), ) } } }), ) as Box> } // EditorUsernameGet - GET /editor/{username} &hyper::Method::Get if path.matched(paths::ID_EDITOR_USERNAME) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_EDITOR_USERNAME.captures(&path).unwrap_or_else( || { panic!("Path {} matched RE EDITOR_USERNAME in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_USERNAME.as_str()) }, ); let param_username = match percent_encoding::percent_decode( path_params["username"].as_bytes(), ).decode_utf8() { Ok(param_username) => match param_username.parse::() { Ok(param_username) => param_username, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse path parameter username: {}", e )), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["username"] )), )) } }; Box::new( ({ { { Box::new( api_impl.editor_username_get(param_username, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { EditorUsernameGetResponse::FetchGenericInformationAboutAnEditor (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_FETCH_GENERIC_INFORMATION_ABOUT_AN_EDITOR.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditorUsernameGetResponse::UsernameNotFound (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_USERNAME_NOT_FOUND.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, EditorUsernameGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::EDITOR_USERNAME_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, ), ) } } }), ) as Box> } // FileIdGet - GET /file/{id} &hyper::Method::Get if path.matched(paths::ID_FILE_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_FILE_ID.captures(&path).unwrap_or_else(|| { panic!( "Path {} matched RE FILE_ID in set but failed match against \"{}\"", path, paths::REGEX_FILE_ID.as_str() ) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.file_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { FileIdGetResponse::FetchASingleFileById(body) => { response.set_status( StatusCode::try_from(200).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::FILE_ID_GET_FETCH_A_SINGLE_FILE_BY_ID.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } FileIdGetResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::FILE_ID_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } FileIdGetResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::FILE_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } } }), ) as Box> } // FileLookupGet - GET /file/lookup &hyper::Method::Get if path.matched(paths::ID_FILE_LOOKUP) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = form_urlencoded::parse( uri.query().unwrap_or_default().as_bytes(), ).collect::>(); let param_sha1 = query_params .iter() .filter(|e| e.0 == "sha1") .map(|e| e.1.to_owned()) .nth(0); let param_sha1 = match param_sha1 { Some(param_sha1) => match param_sha1.parse::() { Ok(param_sha1) => param_sha1, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse query parameter sha1 - doesn't match schema: {}", e )), )) } }, None => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body("Missing required query parameter sha1"), )) } }; Box::new( ({ { { Box::new(api_impl.file_lookup_get(param_sha1, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { FileLookupGetResponse::FindASingleFileByExternalIdentifer (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_FIND_A_SINGLE_FILE_BY_EXTERNAL_IDENTIFER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, FileLookupGetResponse::BadRequest (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, FileLookupGetResponse::NoSuchFile (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_NO_SUCH_FILE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, FileLookupGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::FILE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // FilePost - POST /file &hyper::Method::Post if path.matched(paths::ID_FILE) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // 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. Box::new(body.concat2().then( move |result| -> Box> { match result { Ok(body) => { let mut unused_elements = Vec::new(); let param_body: Option< models::FileEntity, > = if !body.is_empty() { let deserializer = &mut serde_json::Deserializer::from_slice(&*body); match serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }) { Ok(param_body) => param_body, Err(_) => None, } } else { None }; Box::new(api_impl.file_post(param_body, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); if !unused_elements.is_empty() { response.headers_mut().set(Warning(format!( "Ignoring unknown fields in body: {:?}", unused_elements ))); } match result { Ok(rsp) => match rsp { FilePostResponse::Created(body) => { response.set_status( StatusCode::try_from(201).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::FILE_POST_CREATED .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } FilePostResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::FILE_POST_BAD_REQUEST .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } FilePostResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::FILE_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } Err(e) => Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't read body parameter body: {}", e)), )), } }, )) as Box> } // ReleaseIdGet - GET /release/{id} &hyper::Method::Get if path.matched(paths::ID_RELEASE_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_RELEASE_ID.captures(&path).unwrap_or_else(|| { panic!( "Path {} matched RE RELEASE_ID in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_ID.as_str() ) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.release_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { ReleaseIdGetResponse::FetchASingleReleaseById( body, ) => { response.set_status( StatusCode::try_from(200).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_ID_GET_FETCH_A_SINGLE_RELEASE_BY_ID.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ReleaseIdGetResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_ID_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ReleaseIdGetResponse::GenericErrorResponse( body, ) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } } }), ) as Box> } // ReleaseLookupGet - GET /release/lookup &hyper::Method::Get if path.matched(paths::ID_RELEASE_LOOKUP) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response) let query_params = form_urlencoded::parse( uri.query().unwrap_or_default().as_bytes(), ).collect::>(); let param_doi = query_params .iter() .filter(|e| e.0 == "doi") .map(|e| e.1.to_owned()) .nth(0); let param_doi = match param_doi { Some(param_doi) => match param_doi.parse::() { Ok(param_doi) => param_doi, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't parse query parameter doi - doesn't match schema: {}", e )), )) } }, None => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body("Missing required query parameter doi"), )) } }; Box::new( ({ { { Box::new(api_impl.release_lookup_get(param_doi, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { ReleaseLookupGetResponse::FindASingleReleaseByExternalIdentifer (body) => { response.set_status(StatusCode::try_from(200).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_FIND_A_SINGLE_RELEASE_BY_EXTERNAL_IDENTIFER.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ReleaseLookupGetResponse::BadRequest (body) => { response.set_status(StatusCode::try_from(400).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ReleaseLookupGetResponse::NoSuchRelease (body) => { response.set_status(StatusCode::try_from(404).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_NO_SUCH_RELEASE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, ReleaseLookupGetResponse::GenericErrorResponse (body) => { response.set_status(StatusCode::try_from(0).unwrap()); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_LOOKUP_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body).expect("impossible to fail to serialize"); response.set_body(body); }, }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response.set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); }, } future::ok(response) }, )) } } }), ) as Box> } // ReleasePost - POST /release &hyper::Method::Post if path.matched(paths::ID_RELEASE) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // 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. Box::new(body.concat2().then( move |result| -> Box> { match result { Ok(body) => { let mut unused_elements = Vec::new(); let param_body: Option< models::ReleaseEntity, > = if !body.is_empty() { let deserializer = &mut serde_json::Deserializer::from_slice(&*body); match serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }) { Ok(param_body) => param_body, Err(_) => None, } } else { None }; Box::new(api_impl.release_post(param_body, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); if !unused_elements.is_empty() { response.headers_mut().set(Warning(format!( "Ignoring unknown fields in body: {:?}", unused_elements ))); } match result { Ok(rsp) => match rsp { ReleasePostResponse::Created(body) => { response.set_status( StatusCode::try_from(201).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::RELEASE_POST_CREATED .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ReleasePostResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_POST_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } ReleasePostResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::RELEASE_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } Err(e) => Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't read body parameter body: {}", e)), )), } }, )) as Box> } // WorkIdGet - GET /work/{id} &hyper::Method::Get if path.matched(paths::ID_WORK_ID) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // Path parameters let path = uri.path().to_string(); let path_params = paths::REGEX_WORK_ID.captures(&path).unwrap_or_else(|| { panic!( "Path {} matched RE WORK_ID in set but failed match against \"{}\"", path, paths::REGEX_WORK_ID.as_str() ) }); let param_id = match percent_encoding::percent_decode(path_params["id"].as_bytes()) .decode_utf8() { Ok(param_id) => match param_id.parse::() { Ok(param_id) => param_id, Err(e) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't parse path parameter id: {}", e)), )) } }, Err(_) => { return Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!( "Couldn't percent-decode path parameter as UTF-8: {}", &path_params["id"] )), )) } }; Box::new( ({ { { Box::new(api_impl.work_id_get(param_id, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); match result { Ok(rsp) => match rsp { WorkIdGetResponse::FetchASingleWorkById(body) => { response.set_status( StatusCode::try_from(200).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::WORK_ID_GET_FETCH_A_SINGLE_WORK_BY_ID.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } WorkIdGetResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::WORK_ID_GET_BAD_REQUEST.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } WorkIdGetResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::WORK_ID_GET_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } } }), ) as Box> } // WorkPost - POST /work &hyper::Method::Post if path.matched(paths::ID_WORK) => { if context.x_span_id.is_none() { context.x_span_id = Some( headers .get::() .map(XSpanId::to_string) .unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()), ); } // 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. Box::new(body.concat2().then( move |result| -> Box> { match result { Ok(body) => { let mut unused_elements = Vec::new(); let param_body: Option< models::WorkEntity, > = if !body.is_empty() { let deserializer = &mut serde_json::Deserializer::from_slice(&*body); match serde_ignored::deserialize(deserializer, |path| { warn!("Ignoring unknown field in body: {}", path); unused_elements.push(path.to_string()); }) { Ok(param_body) => param_body, Err(_) => None, } } else { None }; Box::new(api_impl.work_post(param_body, &context).then( move |result| { let mut response = Response::new(); context.x_span_id.as_ref().map(|header| { response.headers_mut().set(XSpanId(header.clone())) }); if !unused_elements.is_empty() { response.headers_mut().set(Warning(format!( "Ignoring unknown fields in body: {:?}", unused_elements ))); } match result { Ok(rsp) => match rsp { WorkPostResponse::Created(body) => { response.set_status( StatusCode::try_from(201).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::WORK_POST_CREATED .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } WorkPostResponse::BadRequest(body) => { response.set_status( StatusCode::try_from(400).unwrap(), ); response.headers_mut().set(ContentType( mimetypes::responses::WORK_POST_BAD_REQUEST .clone(), )); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } WorkPostResponse::GenericErrorResponse(body) => { response.set_status( StatusCode::try_from(0).unwrap(), ); response.headers_mut().set(ContentType(mimetypes::responses::WORK_POST_GENERIC_ERROR_RESPONSE.clone())); let body = serde_json::to_string(&body) .expect("impossible to fail to serialize"); response.set_body(body); } }, Err(_) => { // Application code returned an error. This should not happen, as the implementation should // return a valid response. response .set_status(StatusCode::InternalServerError); response.set_body("An internal error occurred"); } } future::ok(response) }, )) } Err(e) => Box::new(future::ok( Response::new() .with_status(StatusCode::BadRequest) .with_body(format!("Couldn't read body parameter body: {}", e)), )), } }, )) as Box> } _ => Box::new(future::ok( Response::new().with_status(StatusCode::NotFound), )) as Box>, } } }