summaryrefslogtreecommitdiffstats
path: root/fatcat-openapi/src/server/mod.rs
diff options
context:
space:
mode:
authorBryan Newbold <bnewbold@archive.org>2021-02-09 18:57:00 -0800
committerBryan Newbold <bnewbold@archive.org>2021-02-09 18:57:00 -0800
commit19c582a3cf1c42e9c75170650ccd141eda903479 (patch)
tree0738781689e4c12308016f184cb6eb02af1716a6 /fatcat-openapi/src/server/mod.rs
parentbab3fb9fdcc921e1bb8a81e0f2b4e12558d2dde7 (diff)
downloadfatcat-cli-19c582a3cf1c42e9c75170650ccd141eda903479.tar.gz
fatcat-cli-19c582a3cf1c42e9c75170650ccd141eda903479.zip
move source code to top-level directory
Diffstat (limited to 'fatcat-openapi/src/server/mod.rs')
-rw-r--r--fatcat-openapi/src/server/mod.rs15856
1 files changed, 15856 insertions, 0 deletions
diff --git a/fatcat-openapi/src/server/mod.rs b/fatcat-openapi/src/server/mod.rs
new file mode 100644
index 0000000..ac07c6e
--- /dev/null
+++ b/fatcat-openapi/src/server/mod.rs
@@ -0,0 +1,15856 @@
+use futures::{future, future::BoxFuture, future::FutureExt, stream, stream::TryStreamExt, Stream};
+use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
+use hyper::{Body, HeaderMap, Request, Response, StatusCode};
+use log::warn;
+#[allow(unused_imports)]
+use std::convert::{TryFrom, TryInto};
+use std::error::Error;
+use std::future::Future;
+use std::marker::PhantomData;
+use std::task::{Context, Poll};
+pub use swagger::auth::Authorization;
+use swagger::auth::Scopes;
+use swagger::{ApiError, BodyExt, Has, RequestParser, XSpanIdString};
+use url::form_urlencoded;
+
+use crate::header;
+#[allow(unused_imports)]
+use crate::models;
+
+pub use crate::context;
+
+type ServiceFuture = BoxFuture<'static, Result<Response<Body>, crate::ServiceError>>;
+
+use crate::{
+ AcceptEditgroupResponse, Api, AuthCheckResponse, AuthOidcResponse, CreateAuthTokenResponse,
+ CreateContainerAutoBatchResponse, CreateContainerResponse, CreateCreatorAutoBatchResponse,
+ CreateCreatorResponse, CreateEditgroupAnnotationResponse, CreateEditgroupResponse,
+ CreateFileAutoBatchResponse, CreateFileResponse, CreateFilesetAutoBatchResponse,
+ CreateFilesetResponse, CreateReleaseAutoBatchResponse, CreateReleaseResponse,
+ CreateWebcaptureAutoBatchResponse, CreateWebcaptureResponse, CreateWorkAutoBatchResponse,
+ CreateWorkResponse, DeleteContainerEditResponse, DeleteContainerResponse,
+ DeleteCreatorEditResponse, DeleteCreatorResponse, DeleteFileEditResponse, DeleteFileResponse,
+ DeleteFilesetEditResponse, DeleteFilesetResponse, DeleteReleaseEditResponse,
+ DeleteReleaseResponse, DeleteWebcaptureEditResponse, DeleteWebcaptureResponse,
+ DeleteWorkEditResponse, DeleteWorkResponse, GetChangelogEntryResponse, GetChangelogResponse,
+ GetContainerEditResponse, GetContainerHistoryResponse, GetContainerRedirectsResponse,
+ GetContainerResponse, GetContainerRevisionResponse, GetCreatorEditResponse,
+ GetCreatorHistoryResponse, GetCreatorRedirectsResponse, GetCreatorReleasesResponse,
+ GetCreatorResponse, GetCreatorRevisionResponse, GetEditgroupAnnotationsResponse,
+ GetEditgroupResponse, GetEditgroupsReviewableResponse, GetEditorAnnotationsResponse,
+ GetEditorEditgroupsResponse, GetEditorResponse, GetFileEditResponse, GetFileHistoryResponse,
+ GetFileRedirectsResponse, GetFileResponse, GetFileRevisionResponse, GetFilesetEditResponse,
+ GetFilesetHistoryResponse, GetFilesetRedirectsResponse, GetFilesetResponse,
+ GetFilesetRevisionResponse, GetReleaseEditResponse, GetReleaseFilesResponse,
+ GetReleaseFilesetsResponse, GetReleaseHistoryResponse, GetReleaseRedirectsResponse,
+ GetReleaseResponse, GetReleaseRevisionResponse, GetReleaseWebcapturesResponse,
+ GetWebcaptureEditResponse, GetWebcaptureHistoryResponse, GetWebcaptureRedirectsResponse,
+ GetWebcaptureResponse, GetWebcaptureRevisionResponse, GetWorkEditResponse,
+ GetWorkHistoryResponse, GetWorkRedirectsResponse, GetWorkReleasesResponse, GetWorkResponse,
+ GetWorkRevisionResponse, LookupContainerResponse, LookupCreatorResponse, LookupFileResponse,
+ LookupReleaseResponse, UpdateContainerResponse, UpdateCreatorResponse, UpdateEditgroupResponse,
+ UpdateEditorResponse, UpdateFileResponse, UpdateFilesetResponse, UpdateReleaseResponse,
+ UpdateWebcaptureResponse, UpdateWorkResponse,
+};
+
+mod paths {
+ use lazy_static::lazy_static;
+
+ lazy_static! {
+ pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(vec![
+ r"^/v0/auth/check$",
+ r"^/v0/auth/oidc$",
+ r"^/v0/auth/token/(?P<editor_id>[^/?#]*)$",
+ r"^/v0/changelog$",
+ r"^/v0/changelog/(?P<index>[^/?#]*)$",
+ r"^/v0/container/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/container/lookup$",
+ r"^/v0/container/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/container/(?P<ident>[^/?#]*)$",
+ r"^/v0/container/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/container/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/creator/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/creator/lookup$",
+ r"^/v0/creator/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/creator/(?P<ident>[^/?#]*)$",
+ r"^/v0/creator/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/creator/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/creator/(?P<ident>[^/?#]*)/releases$",
+ r"^/v0/editgroup$",
+ r"^/v0/editgroup/auto/container/batch$",
+ r"^/v0/editgroup/auto/creator/batch$",
+ r"^/v0/editgroup/auto/file/batch$",
+ r"^/v0/editgroup/auto/fileset/batch$",
+ r"^/v0/editgroup/auto/release/batch$",
+ r"^/v0/editgroup/auto/webcapture/batch$",
+ r"^/v0/editgroup/auto/work/batch$",
+ r"^/v0/editgroup/reviewable$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/accept$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotation$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotations$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/(?P<ident>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/(?P<ident>[^/?#]*)$",
+ r"^/v0/editor/(?P<editor_id>[^/?#]*)$",
+ r"^/v0/editor/(?P<editor_id>[^/?#]*)/annotations$",
+ r"^/v0/editor/(?P<editor_id>[^/?#]*)/editgroups$",
+ r"^/v0/file/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/file/lookup$",
+ r"^/v0/file/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/file/(?P<ident>[^/?#]*)$",
+ r"^/v0/file/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/file/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/fileset/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/fileset/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/fileset/(?P<ident>[^/?#]*)$",
+ r"^/v0/fileset/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/fileset/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/release/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/release/lookup$",
+ r"^/v0/release/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/release/(?P<ident>[^/?#]*)$",
+ r"^/v0/release/(?P<ident>[^/?#]*)/files$",
+ r"^/v0/release/(?P<ident>[^/?#]*)/filesets$",
+ r"^/v0/release/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/release/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/release/(?P<ident>[^/?#]*)/webcaptures$",
+ r"^/v0/webcapture/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/webcapture/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/webcapture/(?P<ident>[^/?#]*)$",
+ r"^/v0/webcapture/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/webcapture/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/work/edit/(?P<edit_id>[^/?#]*)$",
+ r"^/v0/work/rev/(?P<rev_id>[^/?#]*)$",
+ r"^/v0/work/(?P<ident>[^/?#]*)$",
+ r"^/v0/work/(?P<ident>[^/?#]*)/history$",
+ r"^/v0/work/(?P<ident>[^/?#]*)/redirects$",
+ r"^/v0/work/(?P<ident>[^/?#]*)/releases$"
+ ])
+ .expect("Unable to create global regex set");
+ }
+ pub(crate) static ID_AUTH_CHECK: usize = 0;
+ pub(crate) static ID_AUTH_OIDC: usize = 1;
+ pub(crate) static ID_AUTH_TOKEN_EDITOR_ID: usize = 2;
+ lazy_static! {
+ pub static ref REGEX_AUTH_TOKEN_EDITOR_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/auth/token/(?P<editor_id>[^/?#]*)$")
+ .expect("Unable to create regex for AUTH_TOKEN_EDITOR_ID");
+ }
+ pub(crate) static ID_CHANGELOG: usize = 3;
+ pub(crate) static ID_CHANGELOG_INDEX: usize = 4;
+ lazy_static! {
+ pub static ref REGEX_CHANGELOG_INDEX: regex::Regex =
+ regex::Regex::new(r"^/v0/changelog/(?P<index>[^/?#]*)$")
+ .expect("Unable to create regex for CHANGELOG_INDEX");
+ }
+ pub(crate) static ID_CONTAINER_EDIT_EDIT_ID: usize = 5;
+ lazy_static! {
+ pub static ref REGEX_CONTAINER_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/container/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for CONTAINER_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_CONTAINER_LOOKUP: usize = 6;
+ pub(crate) static ID_CONTAINER_REV_REV_ID: usize = 7;
+ lazy_static! {
+ pub static ref REGEX_CONTAINER_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/container/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for CONTAINER_REV_REV_ID");
+ }
+ pub(crate) static ID_CONTAINER_IDENT: usize = 8;
+ lazy_static! {
+ pub static ref REGEX_CONTAINER_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for CONTAINER_IDENT");
+ }
+ pub(crate) static ID_CONTAINER_IDENT_HISTORY: usize = 9;
+ lazy_static! {
+ pub static ref REGEX_CONTAINER_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for CONTAINER_IDENT_HISTORY");
+ }
+ pub(crate) static ID_CONTAINER_IDENT_REDIRECTS: usize = 10;
+ lazy_static! {
+ pub static ref REGEX_CONTAINER_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/container/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for CONTAINER_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_CREATOR_EDIT_EDIT_ID: usize = 11;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for CREATOR_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_CREATOR_LOOKUP: usize = 12;
+ pub(crate) static ID_CREATOR_REV_REV_ID: usize = 13;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for CREATOR_REV_REV_ID");
+ }
+ pub(crate) static ID_CREATOR_IDENT: usize = 14;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for CREATOR_IDENT");
+ }
+ pub(crate) static ID_CREATOR_IDENT_HISTORY: usize = 15;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for CREATOR_IDENT_HISTORY");
+ }
+ pub(crate) static ID_CREATOR_IDENT_REDIRECTS: usize = 16;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for CREATOR_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_CREATOR_IDENT_RELEASES: usize = 17;
+ lazy_static! {
+ pub static ref REGEX_CREATOR_IDENT_RELEASES: regex::Regex =
+ regex::Regex::new(r"^/v0/creator/(?P<ident>[^/?#]*)/releases$")
+ .expect("Unable to create regex for CREATOR_IDENT_RELEASES");
+ }
+ pub(crate) static ID_EDITGROUP: usize = 18;
+ pub(crate) static ID_EDITGROUP_AUTO_CONTAINER_BATCH: usize = 19;
+ pub(crate) static ID_EDITGROUP_AUTO_CREATOR_BATCH: usize = 20;
+ pub(crate) static ID_EDITGROUP_AUTO_FILE_BATCH: usize = 21;
+ pub(crate) static ID_EDITGROUP_AUTO_FILESET_BATCH: usize = 22;
+ pub(crate) static ID_EDITGROUP_AUTO_RELEASE_BATCH: usize = 23;
+ pub(crate) static ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH: usize = 24;
+ pub(crate) static ID_EDITGROUP_AUTO_WORK_BATCH: usize = 25;
+ pub(crate) static ID_EDITGROUP_REVIEWABLE: usize = 26;
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID: usize = 27;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ACCEPT: usize = 28;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/accept$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ACCEPT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ANNOTATION: usize = 29;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotation$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ANNOTATION");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS: usize = 30;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/annotations$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_ANNOTATIONS");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER: usize = 31;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID: usize = 32;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT: usize = 33;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/container/(?P<ident>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR: usize = 34;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID: usize = 35;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT: usize = 36;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/creator/(?P<ident>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_CREATOR_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE: usize = 37;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID: usize = 38;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT: usize = 39;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/file/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILE_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET: usize = 40;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID: usize = 41;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT: usize = 42;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/fileset/(?P<ident>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_FILESET_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE: usize = 43;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID: usize = 44;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT: usize = 45;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/release/(?P<ident>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_RELEASE_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE: usize = 46;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID: usize = 47;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT: usize = 48;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/webcapture/(?P<ident>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK: usize = 49;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID: usize = 50;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(
+ r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/edit/(?P<edit_id>[^/?#]*)$"
+ )
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT: usize = 51;
+ lazy_static! {
+ pub static ref REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/editgroup/(?P<editgroup_id>[^/?#]*)/work/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for EDITGROUP_EDITGROUP_ID_WORK_IDENT");
+ }
+ pub(crate) static ID_EDITOR_EDITOR_ID: usize = 52;
+ lazy_static! {
+ pub static ref REGEX_EDITOR_EDITOR_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)$")
+ .expect("Unable to create regex for EDITOR_EDITOR_ID");
+ }
+ pub(crate) static ID_EDITOR_EDITOR_ID_ANNOTATIONS: usize = 53;
+ lazy_static! {
+ pub static ref REGEX_EDITOR_EDITOR_ID_ANNOTATIONS: regex::Regex =
+ regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)/annotations$")
+ .expect("Unable to create regex for EDITOR_EDITOR_ID_ANNOTATIONS");
+ }
+ pub(crate) static ID_EDITOR_EDITOR_ID_EDITGROUPS: usize = 54;
+ lazy_static! {
+ pub static ref REGEX_EDITOR_EDITOR_ID_EDITGROUPS: regex::Regex =
+ regex::Regex::new(r"^/v0/editor/(?P<editor_id>[^/?#]*)/editgroups$")
+ .expect("Unable to create regex for EDITOR_EDITOR_ID_EDITGROUPS");
+ }
+ pub(crate) static ID_FILE_EDIT_EDIT_ID: usize = 55;
+ lazy_static! {
+ pub static ref REGEX_FILE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/file/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for FILE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_FILE_LOOKUP: usize = 56;
+ pub(crate) static ID_FILE_REV_REV_ID: usize = 57;
+ lazy_static! {
+ pub static ref REGEX_FILE_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/file/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for FILE_REV_REV_ID");
+ }
+ pub(crate) static ID_FILE_IDENT: usize = 58;
+ lazy_static! {
+ pub static ref REGEX_FILE_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for FILE_IDENT");
+ }
+ pub(crate) static ID_FILE_IDENT_HISTORY: usize = 59;
+ lazy_static! {
+ pub static ref REGEX_FILE_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for FILE_IDENT_HISTORY");
+ }
+ pub(crate) static ID_FILE_IDENT_REDIRECTS: usize = 60;
+ lazy_static! {
+ pub static ref REGEX_FILE_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/file/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for FILE_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_FILESET_EDIT_EDIT_ID: usize = 61;
+ lazy_static! {
+ pub static ref REGEX_FILESET_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/fileset/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for FILESET_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_FILESET_REV_REV_ID: usize = 62;
+ lazy_static! {
+ pub static ref REGEX_FILESET_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/fileset/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for FILESET_REV_REV_ID");
+ }
+ pub(crate) static ID_FILESET_IDENT: usize = 63;
+ lazy_static! {
+ pub static ref REGEX_FILESET_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for FILESET_IDENT");
+ }
+ pub(crate) static ID_FILESET_IDENT_HISTORY: usize = 64;
+ lazy_static! {
+ pub static ref REGEX_FILESET_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for FILESET_IDENT_HISTORY");
+ }
+ pub(crate) static ID_FILESET_IDENT_REDIRECTS: usize = 65;
+ lazy_static! {
+ pub static ref REGEX_FILESET_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/fileset/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for FILESET_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_RELEASE_EDIT_EDIT_ID: usize = 66;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/release/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for RELEASE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_RELEASE_LOOKUP: usize = 67;
+ pub(crate) static ID_RELEASE_REV_REV_ID: usize = 68;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/release/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for RELEASE_REV_REV_ID");
+ }
+ pub(crate) static ID_RELEASE_IDENT: usize = 69;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for RELEASE_IDENT");
+ }
+ pub(crate) static ID_RELEASE_IDENT_FILES: usize = 70;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT_FILES: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/files$")
+ .expect("Unable to create regex for RELEASE_IDENT_FILES");
+ }
+ pub(crate) static ID_RELEASE_IDENT_FILESETS: usize = 71;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT_FILESETS: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/filesets$")
+ .expect("Unable to create regex for RELEASE_IDENT_FILESETS");
+ }
+ pub(crate) static ID_RELEASE_IDENT_HISTORY: usize = 72;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for RELEASE_IDENT_HISTORY");
+ }
+ pub(crate) static ID_RELEASE_IDENT_REDIRECTS: usize = 73;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for RELEASE_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_RELEASE_IDENT_WEBCAPTURES: usize = 74;
+ lazy_static! {
+ pub static ref REGEX_RELEASE_IDENT_WEBCAPTURES: regex::Regex =
+ regex::Regex::new(r"^/v0/release/(?P<ident>[^/?#]*)/webcaptures$")
+ .expect("Unable to create regex for RELEASE_IDENT_WEBCAPTURES");
+ }
+ pub(crate) static ID_WEBCAPTURE_EDIT_EDIT_ID: usize = 75;
+ lazy_static! {
+ pub static ref REGEX_WEBCAPTURE_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/webcapture/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for WEBCAPTURE_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_WEBCAPTURE_REV_REV_ID: usize = 76;
+ lazy_static! {
+ pub static ref REGEX_WEBCAPTURE_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/webcapture/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for WEBCAPTURE_REV_REV_ID");
+ }
+ pub(crate) static ID_WEBCAPTURE_IDENT: usize = 77;
+ lazy_static! {
+ pub static ref REGEX_WEBCAPTURE_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for WEBCAPTURE_IDENT");
+ }
+ pub(crate) static ID_WEBCAPTURE_IDENT_HISTORY: usize = 78;
+ lazy_static! {
+ pub static ref REGEX_WEBCAPTURE_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for WEBCAPTURE_IDENT_HISTORY");
+ }
+ pub(crate) static ID_WEBCAPTURE_IDENT_REDIRECTS: usize = 79;
+ lazy_static! {
+ pub static ref REGEX_WEBCAPTURE_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/webcapture/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for WEBCAPTURE_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_WORK_EDIT_EDIT_ID: usize = 80;
+ lazy_static! {
+ pub static ref REGEX_WORK_EDIT_EDIT_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/work/edit/(?P<edit_id>[^/?#]*)$")
+ .expect("Unable to create regex for WORK_EDIT_EDIT_ID");
+ }
+ pub(crate) static ID_WORK_REV_REV_ID: usize = 81;
+ lazy_static! {
+ pub static ref REGEX_WORK_REV_REV_ID: regex::Regex =
+ regex::Regex::new(r"^/v0/work/rev/(?P<rev_id>[^/?#]*)$")
+ .expect("Unable to create regex for WORK_REV_REV_ID");
+ }
+ pub(crate) static ID_WORK_IDENT: usize = 82;
+ lazy_static! {
+ pub static ref REGEX_WORK_IDENT: regex::Regex =
+ regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)$")
+ .expect("Unable to create regex for WORK_IDENT");
+ }
+ pub(crate) static ID_WORK_IDENT_HISTORY: usize = 83;
+ lazy_static! {
+ pub static ref REGEX_WORK_IDENT_HISTORY: regex::Regex =
+ regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/history$")
+ .expect("Unable to create regex for WORK_IDENT_HISTORY");
+ }
+ pub(crate) static ID_WORK_IDENT_REDIRECTS: usize = 84;
+ lazy_static! {
+ pub static ref REGEX_WORK_IDENT_REDIRECTS: regex::Regex =
+ regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/redirects$")
+ .expect("Unable to create regex for WORK_IDENT_REDIRECTS");
+ }
+ pub(crate) static ID_WORK_IDENT_RELEASES: usize = 85;
+ lazy_static! {
+ pub static ref REGEX_WORK_IDENT_RELEASES: regex::Regex =
+ regex::Regex::new(r"^/v0/work/(?P<ident>[^/?#]*)/releases$")
+ .expect("Unable to create regex for WORK_IDENT_RELEASES");
+ }
+}
+
+pub struct MakeService<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ api_impl: T,
+ marker: PhantomData<C>,
+}
+
+impl<T, C> MakeService<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ pub fn new(api_impl: T) -> Self {
+ MakeService {
+ api_impl,
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<T, C, Target> hyper::service::Service<Target> for MakeService<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ type Response = Service<T, C>;
+ type Error = crate::ServiceError;
+ type Future = future::Ready<Result<Self::Response, Self::Error>>;
+
+ fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+ Poll::Ready(Ok(()))
+ }
+
+ fn call(&mut self, target: Target) -> Self::Future {
+ futures::future::ok(Service::new(self.api_impl.clone()))
+ }
+}
+
+fn method_not_allowed() -> Result<Response<Body>, crate::ServiceError> {
+ Ok(Response::builder()
+ .status(StatusCode::METHOD_NOT_ALLOWED)
+ .body(Body::empty())
+ .expect("Unable to create Method Not Allowed response"))
+}
+
+pub struct Service<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ api_impl: T,
+ marker: PhantomData<C>,
+}
+
+impl<T, C> Service<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ pub fn new(api_impl: T) -> Self {
+ Service {
+ api_impl: api_impl,
+ marker: PhantomData,
+ }
+ }
+}
+
+impl<T, C> Clone for Service<T, C>
+where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ fn clone(&self) -> Self {
+ Service {
+ api_impl: self.api_impl.clone(),
+ marker: self.marker.clone(),
+ }
+ }
+}
+
+impl<T, C> hyper::service::Service<(Request<Body>, C)> for Service<T, C>
+where
+ T: Api<C> + Clone + Send + Sync + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+{
+ type Response = Response<Body>;
+ type Error = crate::ServiceError;
+ type Future = ServiceFuture;
+
+ fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+ self.api_impl.poll_ready(cx)
+ }
+
+ fn call(&mut self, req: (Request<Body>, C)) -> Self::Future {
+ async fn run<T, C>(
+ mut api_impl: T,
+ req: (Request<Body>, C),
+ ) -> Result<Response<Body>, crate::ServiceError>
+ where
+ T: Api<C> + Clone + Send + 'static,
+ C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static,
+ {
+ let (request, context) = req;
+ let (parts, body) = request.into_parts();
+ let (method, uri, headers) = (parts.method, parts.uri, parts.headers);
+ let path = paths::GLOBAL_REGEX_SET.matches(uri.path());
+
+ match &method {
+ // AcceptEditgroup - POST /editgroup/{editgroup_id}/accept
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ACCEPT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ACCEPT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .accept_editgroup(param_editgroup_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ AcceptEditgroupResponse::MergedSuccessfully(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_MERGED_SUCCESSFULLY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::EditConflict(body) => {
+ *response.status_mut() = StatusCode::from_u16(409)
+ .expect("Unable to turn 409 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_EDIT_CONFLICT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AcceptEditgroupResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for ACCEPT_EDITGROUP_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // AuthCheck - GET /auth/check
+ &hyper::Method::GET if path.matched(paths::ID_AUTH_CHECK) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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::<Vec<_>>();
+ let param_role = query_params
+ .iter()
+ .filter(|e| e.0 == "role")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_role = match param_role {
+ Some(param_role) => {
+ let param_role = <String as std::str::FromStr>::from_str(&param_role);
+ match param_role {
+ Ok(param_role) => Some(param_role),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter role - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter role")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl.auth_check(param_role, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ AuthCheckResponse::Success(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_CHECK_SUCCESS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AuthCheckResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_CHECK_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AuthCheckResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_CHECK_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AuthCheckResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_CHECK_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ AuthCheckResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_CHECK_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // AuthOidc - POST /auth/oidc
+ &hyper::Method::POST if path.matched(paths::ID_AUTH_OIDC) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_auth_oidc: Option<models::AuthOidc> = 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_auth_oidc) => param_auth_oidc,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter AuthOidc - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter AuthOidc due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_auth_oidc = match param_auth_oidc {
+ Some(param_auth_oidc) => param_auth_oidc,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter AuthOidc"))
+ .expect("Unable to create Bad Request response for missing body parameter AuthOidc")),
+ };
+
+ let result = api_impl.auth_oidc(
+ param_auth_oidc,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ AuthOidcResponse::Found
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::Created
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_CREATED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::Conflict
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(409).expect("Unable to turn 409 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_CONFLICT"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ AuthOidcResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for AUTH_OIDC_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter AuthOidc: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter AuthOidc")),
+ }
+ }
+
+ // CreateAuthToken - POST /auth/token/{editor_id}
+ &hyper::Method::POST if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_AUTH_TOKEN_EDITOR_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE AUTH_TOKEN_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_AUTH_TOKEN_EDITOR_ID.as_str())
+ );
+
+ let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
+ Ok(param_editor_id) => match param_editor_id.parse::<String>() {
+ Ok(param_editor_id) => param_editor_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_duration_seconds = query_params
+ .iter()
+ .filter(|e| e.0 == "duration_seconds")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_duration_seconds = match param_duration_seconds {
+ Some(param_duration_seconds) => {
+ let param_duration_seconds =
+ <i32 as std::str::FromStr>::from_str(&param_duration_seconds);
+ match param_duration_seconds {
+ Ok(param_duration_seconds) => Some(param_duration_seconds),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter duration_seconds - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter duration_seconds")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .create_auth_token(param_editor_id, param_duration_seconds, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateAuthTokenResponse::Success(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_SUCCESS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ CreateAuthTokenResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ CreateAuthTokenResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ CreateAuthTokenResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ CreateAuthTokenResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_AUTH_TOKEN_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // CreateContainer - POST /editgroup/{editgroup_id}/container
+ &hyper::Method::POST
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_container_entity: 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_container_entity) => param_container_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ContainerEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ContainerEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_container_entity = match param_container_entity {
+ Some(param_container_entity) => param_container_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ContainerEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter ContainerEntity")),
+ };
+
+ let result = api_impl.create_container(
+ param_editgroup_id,
+ param_container_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateContainerResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ContainerEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ContainerEntity")),
+ }
+ }
+
+ // CreateContainerAutoBatch - POST /editgroup/auto/container/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_container_auto_batch: Option<models::ContainerAutoBatch> = 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_container_auto_batch) => param_container_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ContainerAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ContainerAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_container_auto_batch = match param_container_auto_batch {
+ Some(param_container_auto_batch) => param_container_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ContainerAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter ContainerAutoBatch")),
+ };
+
+ let result = api_impl.create_container_auto_batch(
+ param_container_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateContainerAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateContainerAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CONTAINER_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ContainerAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ContainerAutoBatch")),
+ }
+ }
+
+ // CreateCreator - POST /editgroup/{editgroup_id}/creator
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_creator_entity: 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_creator_entity) => param_creator_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter CreatorEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter CreatorEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_creator_entity = match param_creator_entity {
+ Some(param_creator_entity) => param_creator_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter CreatorEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter CreatorEntity")),
+ };
+
+ let result = api_impl.create_creator(
+ param_editgroup_id,
+ param_creator_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateCreatorResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter CreatorEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter CreatorEntity")),
+ }
+ }
+
+ // CreateCreatorAutoBatch - POST /editgroup/auto/creator/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_creator_auto_batch: Option<models::CreatorAutoBatch> = 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_creator_auto_batch) => param_creator_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter CreatorAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter CreatorAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_creator_auto_batch = match param_creator_auto_batch {
+ Some(param_creator_auto_batch) => param_creator_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter CreatorAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter CreatorAutoBatch")),
+ };
+
+ let result = api_impl.create_creator_auto_batch(
+ param_creator_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateCreatorAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateCreatorAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_CREATOR_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter CreatorAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter CreatorAutoBatch")),
+ }
+ }
+
+ // CreateEditgroup - POST /editgroup
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_editgroup: Option<models::Editgroup> = 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_editgroup) => param_editgroup,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter Editgroup - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter Editgroup due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_editgroup = match param_editgroup {
+ Some(param_editgroup) => param_editgroup,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter Editgroup"))
+ .expect("Unable to create Bad Request response for missing body parameter Editgroup")),
+ };
+
+ let result = api_impl.create_editgroup(
+ param_editgroup,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateEditgroupResponse::SuccessfullyCreated
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_SUCCESSFULLY_CREATED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter Editgroup: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter Editgroup")),
+ }
+ }
+
+ // CreateEditgroupAnnotation - POST /editgroup/{editgroup_id}/annotation
+ &hyper::Method::POST
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ANNOTATION in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATION.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_editgroup_annotation: Option<models::EditgroupAnnotation> = 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_editgroup_annotation) => param_editgroup_annotation,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter EditgroupAnnotation - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter EditgroupAnnotation due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_editgroup_annotation = match param_editgroup_annotation {
+ Some(param_editgroup_annotation) => param_editgroup_annotation,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter EditgroupAnnotation"))
+ .expect("Unable to create Bad Request response for missing body parameter EditgroupAnnotation")),
+ };
+
+ let result = api_impl.create_editgroup_annotation(
+ param_editgroup_id,
+ param_editgroup_annotation,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateEditgroupAnnotationResponse::Created
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_CREATED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupAnnotationResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupAnnotationResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupAnnotationResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupAnnotationResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateEditgroupAnnotationResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_EDITGROUP_ANNOTATION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter EditgroupAnnotation: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter EditgroupAnnotation")),
+ }
+ }
+
+ // CreateFile - POST /editgroup/{editgroup_id}/file
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_file_entity: 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_file_entity) => param_file_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FileEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FileEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_file_entity = match param_file_entity {
+ Some(param_file_entity) => param_file_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FileEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter FileEntity")),
+ };
+
+ let result = api_impl.create_file(
+ param_editgroup_id,
+ param_file_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateFileResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FileEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FileEntity")),
+ }
+ }
+
+ // CreateFileAutoBatch - POST /editgroup/auto/file/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_file_auto_batch: Option<models::FileAutoBatch> = 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_file_auto_batch) => param_file_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FileAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FileAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_file_auto_batch = match param_file_auto_batch {
+ Some(param_file_auto_batch) => param_file_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FileAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter FileAutoBatch")),
+ };
+
+ let result = api_impl.create_file_auto_batch(
+ param_file_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateFileAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFileAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILE_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FileAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FileAutoBatch")),
+ }
+ }
+
+ // CreateFileset - POST /editgroup/{editgroup_id}/fileset
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_fileset_entity: Option<models::FilesetEntity> = 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_fileset_entity) => param_fileset_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FilesetEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FilesetEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_fileset_entity = match param_fileset_entity {
+ Some(param_fileset_entity) => param_fileset_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FilesetEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter FilesetEntity")),
+ };
+
+ let result = api_impl.create_fileset(
+ param_editgroup_id,
+ param_fileset_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateFilesetResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FilesetEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FilesetEntity")),
+ }
+ }
+
+ // CreateFilesetAutoBatch - POST /editgroup/auto/fileset/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_fileset_auto_batch: Option<models::FilesetAutoBatch> = 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_fileset_auto_batch) => param_fileset_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FilesetAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FilesetAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_fileset_auto_batch = match param_fileset_auto_batch {
+ Some(param_fileset_auto_batch) => param_fileset_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FilesetAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter FilesetAutoBatch")),
+ };
+
+ let result = api_impl.create_fileset_auto_batch(
+ param_fileset_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateFilesetAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateFilesetAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_FILESET_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FilesetAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FilesetAutoBatch")),
+ }
+ }
+
+ // CreateRelease - POST /editgroup/{editgroup_id}/release
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_release_entity: 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_release_entity) => param_release_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ReleaseEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ReleaseEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_release_entity = match param_release_entity {
+ Some(param_release_entity) => param_release_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ReleaseEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter ReleaseEntity")),
+ };
+
+ let result = api_impl.create_release(
+ param_editgroup_id,
+ param_release_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateReleaseResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ReleaseEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseEntity")),
+ }
+ }
+
+ // CreateReleaseAutoBatch - POST /editgroup/auto/release/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_release_auto_batch: Option<models::ReleaseAutoBatch> = 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_release_auto_batch) => param_release_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ReleaseAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ReleaseAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_release_auto_batch = match param_release_auto_batch {
+ Some(param_release_auto_batch) => param_release_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ReleaseAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter ReleaseAutoBatch")),
+ };
+
+ let result = api_impl.create_release_auto_batch(
+ param_release_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateReleaseAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateReleaseAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_RELEASE_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ReleaseAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseAutoBatch")),
+ }
+ }
+
+ // CreateWebcapture - POST /editgroup/{editgroup_id}/webcapture
+ &hyper::Method::POST
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_webcapture_entity: Option<models::WebcaptureEntity> = 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_webcapture_entity) => param_webcapture_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WebcaptureEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WebcaptureEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_webcapture_entity = match param_webcapture_entity {
+ Some(param_webcapture_entity) => param_webcapture_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WebcaptureEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter WebcaptureEntity")),
+ };
+
+ let result = api_impl.create_webcapture(
+ param_editgroup_id,
+ param_webcapture_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateWebcaptureResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WebcaptureEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureEntity")),
+ }
+ }
+
+ // CreateWebcaptureAutoBatch - POST /editgroup/auto/webcapture/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_webcapture_auto_batch: Option<models::WebcaptureAutoBatch> = 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_webcapture_auto_batch) => param_webcapture_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WebcaptureAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WebcaptureAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_webcapture_auto_batch = match param_webcapture_auto_batch {
+ Some(param_webcapture_auto_batch) => param_webcapture_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WebcaptureAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter WebcaptureAutoBatch")),
+ };
+
+ let result = api_impl.create_webcapture_auto_batch(
+ param_webcapture_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateWebcaptureAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWebcaptureAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WEBCAPTURE_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WebcaptureAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureAutoBatch")),
+ }
+ }
+
+ // CreateWork - POST /editgroup/{editgroup_id}/work
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_work_entity: 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_work_entity) => param_work_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WorkEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WorkEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_work_entity = match param_work_entity {
+ Some(param_work_entity) => param_work_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WorkEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter WorkEntity")),
+ };
+
+ let result = api_impl.create_work(
+ param_editgroup_id,
+ param_work_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateWorkResponse::CreatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_CREATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WorkEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WorkEntity")),
+ }
+ }
+
+ // CreateWorkAutoBatch - POST /editgroup/auto/work/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_work_auto_batch: Option<models::WorkAutoBatch> = 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_work_auto_batch) => param_work_auto_batch,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WorkAutoBatch - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WorkAutoBatch due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_work_auto_batch = match param_work_auto_batch {
+ Some(param_work_auto_batch) => param_work_auto_batch,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WorkAutoBatch"))
+ .expect("Unable to create Bad Request response for missing body parameter WorkAutoBatch")),
+ };
+
+ let result = api_impl.create_work_auto_batch(
+ param_work_auto_batch,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ CreateWorkAutoBatchResponse::CreatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(201).expect("Unable to turn 201 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_CREATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkAutoBatchResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkAutoBatchResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkAutoBatchResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkAutoBatchResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ CreateWorkAutoBatchResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for CREATE_WORK_AUTO_BATCH_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WorkAutoBatch: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WorkAutoBatch")),
+ }
+ }
+
+ // DeleteContainer - DELETE /editgroup/{editgroup_id}/container/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_container(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteContainerResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteContainerEdit - DELETE /editgroup/{editgroup_id}/container/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_container_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteContainerEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteContainerEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CONTAINER_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteCreator - DELETE /editgroup/{editgroup_id}/creator/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_creator(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteCreatorResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteCreatorEdit - DELETE /editgroup/{editgroup_id}/creator/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_creator_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteCreatorEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteCreatorEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_CREATOR_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteFile - DELETE /editgroup/{editgroup_id}/file/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_file(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteFileResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteFileEdit - DELETE /editgroup/{editgroup_id}/file/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_file_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteFileEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFileEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteFileset - DELETE /editgroup/{editgroup_id}/fileset/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_fileset(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteFilesetResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteFilesetEdit - DELETE /editgroup/{editgroup_id}/fileset/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_fileset_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteFilesetEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteFilesetEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_FILESET_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteRelease - DELETE /editgroup/{editgroup_id}/release/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_release(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteReleaseResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteReleaseEdit - DELETE /editgroup/{editgroup_id}/release/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_release_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteReleaseEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteReleaseEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_RELEASE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteWebcapture - DELETE /editgroup/{editgroup_id}/webcapture/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_webcapture(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteWebcaptureResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteWebcaptureEdit - DELETE /editgroup/{editgroup_id}/webcapture/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_webcapture_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteWebcaptureEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWebcaptureEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WEBCAPTURE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteWork - DELETE /editgroup/{editgroup_id}/work/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_work(param_editgroup_id, param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteWorkResponse::DeletedEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_DELETED_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // DeleteWorkEdit - DELETE /editgroup/{editgroup_id}/work/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .delete_work_edit(param_editgroup_id, param_edit_id, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ DeleteWorkEditResponse::DeletedEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_DELETED_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkEditResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkEditResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ DeleteWorkEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for DELETE_WORK_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetChangelog - GET /changelog
+ &hyper::Method::GET if path.matched(paths::ID_CHANGELOG) => {
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl.get_changelog(param_limit, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetChangelogResponse::Success(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_SUCCESS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetChangelogResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetChangelogResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetChangelogEntry - GET /changelog/{index}
+ &hyper::Method::GET if path.matched(paths::ID_CHANGELOG_INDEX) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CHANGELOG_INDEX
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CHANGELOG_INDEX in set but failed match against \"{}\"", path, paths::REGEX_CHANGELOG_INDEX.as_str())
+ );
+
+ let param_index = match percent_encoding::percent_decode(path_params["index"].as_bytes()).decode_utf8() {
+ Ok(param_index) => match param_index.parse::<i64>() {
+ Ok(param_index) => param_index,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter index: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["index"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_changelog_entry(param_index, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetChangelogEntryResponse::FoundChangelogEntry(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_FOUND_CHANGELOG_ENTRY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetChangelogEntryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetChangelogEntryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetChangelogEntryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CHANGELOG_ENTRY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetContainer - GET /container/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CONTAINER_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_container(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetContainerResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetContainerEdit - GET /container/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CONTAINER_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CONTAINER_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_container_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetContainerEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetContainerHistory - GET /container/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CONTAINER_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CONTAINER_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_container_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetContainerHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetContainerRedirects - GET /container/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CONTAINER_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CONTAINER_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .get_container_redirects(param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetContainerRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetContainerRevision - GET /container/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CONTAINER_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CONTAINER_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_CONTAINER_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_container_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetContainerRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetContainerRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CONTAINER_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreator - GET /creator/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_creator(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreatorEdit - GET /creator/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_creator_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreatorHistory - GET /creator/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_creator_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreatorRedirects - GET /creator/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_creator_redirects(param_ident, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreatorReleases - GET /creator/{ident}/releases
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_IDENT_RELEASES
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_IDENT_RELEASES in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_IDENT_RELEASES.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_creator_releases(param_ident, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorReleasesResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorReleasesResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorReleasesResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorReleasesResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_RELEASES_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetCreatorRevision - GET /creator/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_CREATOR_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE CREATOR_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_CREATOR_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_creator_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetCreatorRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetCreatorRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_CREATOR_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditgroup - GET /editgroup/{editgroup_id}
+ &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_editgroup(param_editgroup_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetEditgroupResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditgroupAnnotations - GET /editgroup/{editgroup_id}/annotations
+ &hyper::Method::GET
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) =>
+ {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_ANNOTATIONS in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_ANNOTATIONS.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_editgroup_annotations(param_editgroup_id, param_expand, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetEditgroupAnnotationsResponse::Success(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_SUCCESS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupAnnotationsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupAnnotationsResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupAnnotationsResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupAnnotationsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupAnnotationsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUP_ANNOTATIONS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditgroupsReviewable - GET /editgroup/reviewable
+ &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => {
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+ let param_before = query_params
+ .iter()
+ .filter(|e| e.0 == "before")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_before = match param_before {
+ Some(param_before) => {
+ let param_before =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_before,
+ );
+ match param_before {
+ Ok(param_before) => Some(param_before),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter before")),
+ }
+ }
+ None => None,
+ };
+ let param_since = query_params
+ .iter()
+ .filter(|e| e.0 == "since")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_since = match param_since {
+ Some(param_since) => {
+ let param_since =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_since,
+ );
+ match param_since {
+ Ok(param_since) => Some(param_since),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter since")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_editgroups_reviewable(
+ param_expand,
+ param_limit,
+ param_before,
+ param_since,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetEditgroupsReviewableResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupsReviewableResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupsReviewableResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditgroupsReviewableResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITGROUPS_REVIEWABLE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditor - GET /editor/{editor_id}
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITOR_EDITOR_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITOR_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID.as_str())
+ );
+
+ let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
+ Ok(param_editor_id) => match param_editor_id.parse::<String>() {
+ Ok(param_editor_id) => param_editor_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_editor(param_editor_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => {
+ match rsp {
+ GetEditorResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ }
+ }
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditorAnnotations - GET /editor/{editor_id}/annotations
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITOR_EDITOR_ID_ANNOTATIONS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITOR_EDITOR_ID_ANNOTATIONS in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID_ANNOTATIONS.as_str())
+ );
+
+ let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
+ Ok(param_editor_id) => match param_editor_id.parse::<String>() {
+ Ok(param_editor_id) => param_editor_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+ let param_before = query_params
+ .iter()
+ .filter(|e| e.0 == "before")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_before = match param_before {
+ Some(param_before) => {
+ let param_before =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_before,
+ );
+ match param_before {
+ Ok(param_before) => Some(param_before),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter before")),
+ }
+ }
+ None => None,
+ };
+ let param_since = query_params
+ .iter()
+ .filter(|e| e.0 == "since")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_since = match param_since {
+ Some(param_since) => {
+ let param_since =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_since,
+ );
+ match param_since {
+ Ok(param_since) => Some(param_since),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter since")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_editor_annotations(
+ param_editor_id,
+ param_limit,
+ param_before,
+ param_since,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetEditorAnnotationsResponse::Success(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_SUCCESS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorAnnotationsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorAnnotationsResponse::NotAuthorized {
+ body,
+ www_authenticate,
+ } => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate,
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401)
+ .expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorAnnotationsResponse::Forbidden(body) => {
+ *response.status_mut() = StatusCode::from_u16(403)
+ .expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_FORBIDDEN"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorAnnotationsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorAnnotationsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_ANNOTATIONS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetEditorEditgroups - GET /editor/{editor_id}/editgroups
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITOR_EDITOR_ID_EDITGROUPS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITOR_EDITOR_ID_EDITGROUPS in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID_EDITGROUPS.as_str())
+ );
+
+ let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
+ Ok(param_editor_id) => match param_editor_id.parse::<String>() {
+ Ok(param_editor_id) => param_editor_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+ let param_before = query_params
+ .iter()
+ .filter(|e| e.0 == "before")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_before = match param_before {
+ Some(param_before) => {
+ let param_before =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_before,
+ );
+ match param_before {
+ Ok(param_before) => Some(param_before),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter before - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter before")),
+ }
+ }
+ None => None,
+ };
+ let param_since = query_params
+ .iter()
+ .filter(|e| e.0 == "since")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_since = match param_since {
+ Some(param_since) => {
+ let param_since =
+ <chrono::DateTime<chrono::Utc> as std::str::FromStr>::from_str(
+ &param_since,
+ );
+ match param_since {
+ Ok(param_since) => Some(param_since),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter since - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter since")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_editor_editgroups(
+ param_editor_id,
+ param_limit,
+ param_before,
+ param_since,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetEditorEditgroupsResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorEditgroupsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorEditgroupsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetEditorEditgroupsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_EDITOR_EDITGROUPS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFile - GET /file/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_file(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFileResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFileEdit - GET /file/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_FILE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_file_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFileEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFileHistory - GET /file/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILE_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_file_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFileHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFileRedirects - GET /file/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILE_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_FILE_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_file_redirects(param_ident, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFileRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFileRevision - GET /file/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILE_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_FILE_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_file_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFileRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFileRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILE_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFileset - GET /fileset/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILESET_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_fileset(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFilesetResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFilesetEdit - GET /fileset/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILESET_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILESET_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_FILESET_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_fileset_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFilesetEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFilesetHistory - GET /fileset/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILESET_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILESET_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_fileset_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFilesetHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFilesetRedirects - GET /fileset/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILESET_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILESET_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_FILESET_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_fileset_redirects(param_ident, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFilesetRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetFilesetRevision - GET /fileset/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_FILESET_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE FILESET_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_FILESET_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_fileset_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetFilesetRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetFilesetRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_FILESET_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetRelease - GET /release/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseEdit - GET /release/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_release_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseFiles - GET /release/{ident}/files
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILES) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT_FILES
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT_FILES in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_FILES.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release_files(param_ident, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseFilesResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILES_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILES_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILES_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILES_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseFilesets - GET /release/{ident}/filesets
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT_FILESETS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT_FILESETS in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_FILESETS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release_filesets(param_ident, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseFilesetsResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesetsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesetsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseFilesetsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_FILESETS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseHistory - GET /release/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseRedirects - GET /release/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_release_redirects(param_ident, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseRevision - GET /release/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetReleaseWebcaptures - GET /release/{ident}/webcaptures
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_RELEASE_IDENT_WEBCAPTURES
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE RELEASE_IDENT_WEBCAPTURES in set but failed match against \"{}\"", path, paths::REGEX_RELEASE_IDENT_WEBCAPTURES.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_release_webcaptures(param_ident, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetReleaseWebcapturesResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseWebcapturesResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseWebcapturesResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetReleaseWebcapturesResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_RELEASE_WEBCAPTURES_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWebcapture - GET /webcapture/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WEBCAPTURE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_webcapture(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWebcaptureResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWebcaptureEdit - GET /webcapture/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WEBCAPTURE_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WEBCAPTURE_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_webcapture_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWebcaptureEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWebcaptureHistory - GET /webcapture/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WEBCAPTURE_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WEBCAPTURE_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_webcapture_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWebcaptureHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWebcaptureRedirects - GET /webcapture/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WEBCAPTURE_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WEBCAPTURE_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl
+ .get_webcapture_redirects(param_ident, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWebcaptureRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWebcaptureRevision - GET /webcapture/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WEBCAPTURE_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WEBCAPTURE_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_WEBCAPTURE_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_webcapture_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWebcaptureRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWebcaptureRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WEBCAPTURE_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWork - GET /work/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_work(param_ident, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWorkEdit - GET /work/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_EDIT_EDIT_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_EDIT_EDIT_ID in set but failed match against \"{}\"", path, paths::REGEX_WORK_EDIT_EDIT_ID.as_str())
+ );
+
+ let param_edit_id = match percent_encoding::percent_decode(path_params["edit_id"].as_bytes()).decode_utf8() {
+ Ok(param_edit_id) => match param_edit_id.parse::<String>() {
+ Ok(param_edit_id) => param_edit_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter edit_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["edit_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_work_edit(param_edit_id, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkEditResponse::FoundEdit(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_EDIT_FOUND_EDIT"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkEditResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_EDIT_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkEditResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_EDIT_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkEditResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_EDIT_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWorkHistory - GET /work/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_HISTORY) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_IDENT_HISTORY
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_IDENT_HISTORY in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_HISTORY.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_limit = query_params
+ .iter()
+ .filter(|e| e.0 == "limit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_limit = match param_limit {
+ Some(param_limit) => {
+ let param_limit = <i64 as std::str::FromStr>::from_str(&param_limit);
+ match param_limit {
+ Ok(param_limit) => Some(param_limit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter limit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter limit")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_work_history(param_ident, param_limit, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkHistoryResponse::FoundEntityHistory(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_HISTORY_FOUND_ENTITY_HISTORY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkHistoryResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_HISTORY_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkHistoryResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_HISTORY_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkHistoryResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_HISTORY_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWorkRedirects - GET /work/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_IDENT_REDIRECTS
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_IDENT_REDIRECTS in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_REDIRECTS.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let result = api_impl.get_work_redirects(param_ident, &context).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkRedirectsResponse::FoundEntityRedirects(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_FOUND_ENTITY_REDIRECTS"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRedirectsResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRedirectsResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRedirectsResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REDIRECTS_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWorkReleases - GET /work/{ident}/releases
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_RELEASES) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_IDENT_RELEASES
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_IDENT_RELEASES in set but failed match against \"{}\"", path, paths::REGEX_WORK_IDENT_RELEASES.as_str())
+ );
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_work_releases(param_ident, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkReleasesResponse::Found(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_RELEASES_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkReleasesResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_RELEASES_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkReleasesResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_RELEASES_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkReleasesResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_RELEASES_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // GetWorkRevision - GET /work/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_REV_REV_ID) => {
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_WORK_REV_REV_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE WORK_REV_REV_ID in set but failed match against \"{}\"", path, paths::REGEX_WORK_REV_REV_ID.as_str())
+ );
+
+ let param_rev_id = match percent_encoding::percent_decode(path_params["rev_id"].as_bytes()).decode_utf8() {
+ Ok(param_rev_id) => match param_rev_id.parse::<String>() {
+ Ok(param_rev_id) => param_rev_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter rev_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["rev_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .get_work_revision(param_rev_id, param_expand, param_hide, &context)
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ GetWorkRevisionResponse::FoundEntityRevision(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REVISION_FOUND_ENTITY_REVISION"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRevisionResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REVISION_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRevisionResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REVISION_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ GetWorkRevisionResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for GET_WORK_REVISION_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // LookupContainer - GET /container/lookup
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_LOOKUP) => {
+ // 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::<Vec<_>>();
+ let param_issnl = query_params
+ .iter()
+ .filter(|e| e.0 == "issnl")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_issnl = match param_issnl {
+ Some(param_issnl) => {
+ let param_issnl = <String as std::str::FromStr>::from_str(&param_issnl);
+ match param_issnl {
+ Ok(param_issnl) => Some(param_issnl),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter issnl - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter issnl")),
+ }
+ }
+ None => None,
+ };
+ let param_wikidata_qid = query_params
+ .iter()
+ .filter(|e| e.0 == "wikidata_qid")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_wikidata_qid = match param_wikidata_qid {
+ Some(param_wikidata_qid) => {
+ let param_wikidata_qid =
+ <String as std::str::FromStr>::from_str(&param_wikidata_qid);
+ match param_wikidata_qid {
+ Ok(param_wikidata_qid) => Some(param_wikidata_qid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
+ }
+ }
+ None => None,
+ };
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .lookup_container(
+ param_issnl,
+ param_wikidata_qid,
+ param_expand,
+ param_hide,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ LookupContainerResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupContainerResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupContainerResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupContainerResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CONTAINER_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // LookupCreator - GET /creator/lookup
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_LOOKUP) => {
+ // 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::<Vec<_>>();
+ 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) => {
+ let param_orcid = <String as std::str::FromStr>::from_str(&param_orcid);
+ match param_orcid {
+ Ok(param_orcid) => Some(param_orcid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter orcid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter orcid")),
+ }
+ }
+ None => None,
+ };
+ let param_wikidata_qid = query_params
+ .iter()
+ .filter(|e| e.0 == "wikidata_qid")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_wikidata_qid = match param_wikidata_qid {
+ Some(param_wikidata_qid) => {
+ let param_wikidata_qid =
+ <String as std::str::FromStr>::from_str(&param_wikidata_qid);
+ match param_wikidata_qid {
+ Ok(param_wikidata_qid) => Some(param_wikidata_qid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
+ }
+ }
+ None => None,
+ };
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .lookup_creator(
+ param_orcid,
+ param_wikidata_qid,
+ param_expand,
+ param_hide,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ LookupCreatorResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CREATOR_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupCreatorResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CREATOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupCreatorResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CREATOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupCreatorResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_CREATOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // LookupFile - GET /file/lookup
+ &hyper::Method::GET if path.matched(paths::ID_FILE_LOOKUP) => {
+ // 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::<Vec<_>>();
+ let param_md5 = query_params
+ .iter()
+ .filter(|e| e.0 == "md5")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_md5 = match param_md5 {
+ Some(param_md5) => {
+ let param_md5 = <String as std::str::FromStr>::from_str(&param_md5);
+ match param_md5 {
+ Ok(param_md5) => Some(param_md5),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter md5 - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter md5")),
+ }
+ }
+ None => None,
+ };
+ 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) => {
+ let param_sha1 = <String as std::str::FromStr>::from_str(&param_sha1);
+ match param_sha1 {
+ Ok(param_sha1) => Some(param_sha1),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter sha1 - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter sha1")),
+ }
+ }
+ None => None,
+ };
+ let param_sha256 = query_params
+ .iter()
+ .filter(|e| e.0 == "sha256")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_sha256 = match param_sha256 {
+ Some(param_sha256) => {
+ let param_sha256 =
+ <String as std::str::FromStr>::from_str(&param_sha256);
+ match param_sha256 {
+ Ok(param_sha256) => Some(param_sha256),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter sha256 - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter sha256")),
+ }
+ }
+ None => None,
+ };
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .lookup_file(
+ param_md5,
+ param_sha1,
+ param_sha256,
+ param_expand,
+ param_hide,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ LookupFileResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_FILE_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupFileResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_FILE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupFileResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_FILE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupFileResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_FILE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // LookupRelease - GET /release/lookup
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_LOOKUP) => {
+ // 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::<Vec<_>>();
+ 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) => {
+ let param_doi = <String as std::str::FromStr>::from_str(&param_doi);
+ match param_doi {
+ Ok(param_doi) => Some(param_doi),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter doi - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter doi")),
+ }
+ }
+ None => None,
+ };
+ let param_wikidata_qid = query_params
+ .iter()
+ .filter(|e| e.0 == "wikidata_qid")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_wikidata_qid = match param_wikidata_qid {
+ Some(param_wikidata_qid) => {
+ let param_wikidata_qid =
+ <String as std::str::FromStr>::from_str(&param_wikidata_qid);
+ match param_wikidata_qid {
+ Ok(param_wikidata_qid) => Some(param_wikidata_qid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter wikidata_qid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter wikidata_qid")),
+ }
+ }
+ None => None,
+ };
+ let param_isbn13 = query_params
+ .iter()
+ .filter(|e| e.0 == "isbn13")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_isbn13 = match param_isbn13 {
+ Some(param_isbn13) => {
+ let param_isbn13 =
+ <String as std::str::FromStr>::from_str(&param_isbn13);
+ match param_isbn13 {
+ Ok(param_isbn13) => Some(param_isbn13),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter isbn13 - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter isbn13")),
+ }
+ }
+ None => None,
+ };
+ let param_pmid = query_params
+ .iter()
+ .filter(|e| e.0 == "pmid")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_pmid = match param_pmid {
+ Some(param_pmid) => {
+ let param_pmid = <String as std::str::FromStr>::from_str(&param_pmid);
+ match param_pmid {
+ Ok(param_pmid) => Some(param_pmid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter pmid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter pmid")),
+ }
+ }
+ None => None,
+ };
+ let param_pmcid = query_params
+ .iter()
+ .filter(|e| e.0 == "pmcid")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_pmcid = match param_pmcid {
+ Some(param_pmcid) => {
+ let param_pmcid = <String as std::str::FromStr>::from_str(&param_pmcid);
+ match param_pmcid {
+ Ok(param_pmcid) => Some(param_pmcid),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter pmcid - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter pmcid")),
+ }
+ }
+ None => None,
+ };
+ let param_core = query_params
+ .iter()
+ .filter(|e| e.0 == "core")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_core = match param_core {
+ Some(param_core) => {
+ let param_core = <String as std::str::FromStr>::from_str(&param_core);
+ match param_core {
+ Ok(param_core) => Some(param_core),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter core - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter core")),
+ }
+ }
+ None => None,
+ };
+ let param_arxiv = query_params
+ .iter()
+ .filter(|e| e.0 == "arxiv")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_arxiv = match param_arxiv {
+ Some(param_arxiv) => {
+ let param_arxiv = <String as std::str::FromStr>::from_str(&param_arxiv);
+ match param_arxiv {
+ Ok(param_arxiv) => Some(param_arxiv),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter arxiv - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter arxiv")),
+ }
+ }
+ None => None,
+ };
+ let param_jstor = query_params
+ .iter()
+ .filter(|e| e.0 == "jstor")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_jstor = match param_jstor {
+ Some(param_jstor) => {
+ let param_jstor = <String as std::str::FromStr>::from_str(&param_jstor);
+ match param_jstor {
+ Ok(param_jstor) => Some(param_jstor),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter jstor - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter jstor")),
+ }
+ }
+ None => None,
+ };
+ let param_ark = query_params
+ .iter()
+ .filter(|e| e.0 == "ark")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_ark = match param_ark {
+ Some(param_ark) => {
+ let param_ark = <String as std::str::FromStr>::from_str(&param_ark);
+ match param_ark {
+ Ok(param_ark) => Some(param_ark),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter ark - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter ark")),
+ }
+ }
+ None => None,
+ };
+ let param_mag = query_params
+ .iter()
+ .filter(|e| e.0 == "mag")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_mag = match param_mag {
+ Some(param_mag) => {
+ let param_mag = <String as std::str::FromStr>::from_str(&param_mag);
+ match param_mag {
+ Ok(param_mag) => Some(param_mag),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter mag - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter mag")),
+ }
+ }
+ None => None,
+ };
+ let param_doaj = query_params
+ .iter()
+ .filter(|e| e.0 == "doaj")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_doaj = match param_doaj {
+ Some(param_doaj) => {
+ let param_doaj = <String as std::str::FromStr>::from_str(&param_doaj);
+ match param_doaj {
+ Ok(param_doaj) => Some(param_doaj),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter doaj - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter doaj")),
+ }
+ }
+ None => None,
+ };
+ let param_dblp = query_params
+ .iter()
+ .filter(|e| e.0 == "dblp")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_dblp = match param_dblp {
+ Some(param_dblp) => {
+ let param_dblp = <String as std::str::FromStr>::from_str(&param_dblp);
+ match param_dblp {
+ Ok(param_dblp) => Some(param_dblp),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter dblp - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter dblp")),
+ }
+ }
+ None => None,
+ };
+ let param_oai = query_params
+ .iter()
+ .filter(|e| e.0 == "oai")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_oai = match param_oai {
+ Some(param_oai) => {
+ let param_oai = <String as std::str::FromStr>::from_str(&param_oai);
+ match param_oai {
+ Ok(param_oai) => Some(param_oai),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter oai - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter oai")),
+ }
+ }
+ None => None,
+ };
+ let param_expand = query_params
+ .iter()
+ .filter(|e| e.0 == "expand")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_expand = match param_expand {
+ Some(param_expand) => {
+ let param_expand =
+ <String as std::str::FromStr>::from_str(&param_expand);
+ match param_expand {
+ Ok(param_expand) => Some(param_expand),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter expand - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter expand")),
+ }
+ }
+ None => None,
+ };
+ let param_hide = query_params
+ .iter()
+ .filter(|e| e.0 == "hide")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_hide = match param_hide {
+ Some(param_hide) => {
+ let param_hide = <String as std::str::FromStr>::from_str(&param_hide);
+ match param_hide {
+ Ok(param_hide) => Some(param_hide),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter hide - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter hide")),
+ }
+ }
+ None => None,
+ };
+
+ let result = api_impl
+ .lookup_release(
+ param_doi,
+ param_wikidata_qid,
+ param_isbn13,
+ param_pmid,
+ param_pmcid,
+ param_core,
+ param_arxiv,
+ param_jstor,
+ param_ark,
+ param_mag,
+ param_doaj,
+ param_dblp,
+ param_oai,
+ param_expand,
+ param_hide,
+ &context,
+ )
+ .await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str(
+ (&context as &dyn Has<XSpanIdString>)
+ .get()
+ .0
+ .clone()
+ .to_string()
+ .as_str(),
+ )
+ .expect("Unable to create X-Span-ID header value"),
+ );
+
+ match result {
+ Ok(rsp) => match rsp {
+ LookupReleaseResponse::FoundEntity(body) => {
+ *response.status_mut() = StatusCode::from_u16(200)
+ .expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_RELEASE_FOUND_ENTITY"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupReleaseResponse::BadRequest(body) => {
+ *response.status_mut() = StatusCode::from_u16(400)
+ .expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_RELEASE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupReleaseResponse::NotFound(body) => {
+ *response.status_mut() = StatusCode::from_u16(404)
+ .expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_RELEASE_NOT_FOUND"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ LookupReleaseResponse::GenericError(body) => {
+ *response.status_mut() = StatusCode::from_u16(500)
+ .expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for LOOKUP_RELEASE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body)
+ .expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ }
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ }
+ }
+
+ Ok(response)
+ }
+
+ // UpdateContainer - PUT /editgroup/{editgroup_id}/container/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_container_entity: 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_container_entity) => param_container_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ContainerEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ContainerEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_container_entity = match param_container_entity {
+ Some(param_container_entity) => param_container_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ContainerEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter ContainerEntity")),
+ };
+
+ let result = api_impl.update_container(
+ param_editgroup_id,
+ param_ident,
+ param_container_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateContainerResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateContainerResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateContainerResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateContainerResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateContainerResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateContainerResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CONTAINER_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ContainerEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ContainerEntity")),
+ }
+ }
+
+ // UpdateCreator - PUT /editgroup/{editgroup_id}/creator/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_CREATOR_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_creator_entity: 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_creator_entity) => param_creator_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter CreatorEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter CreatorEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_creator_entity = match param_creator_entity {
+ Some(param_creator_entity) => param_creator_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter CreatorEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter CreatorEntity")),
+ };
+
+ let result = api_impl.update_creator(
+ param_editgroup_id,
+ param_ident,
+ param_creator_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateCreatorResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateCreatorResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateCreatorResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateCreatorResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateCreatorResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateCreatorResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_CREATOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter CreatorEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter CreatorEntity")),
+ }
+ }
+
+ // UpdateEditgroup - PUT /editgroup/{editgroup_id}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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::<Vec<_>>();
+ let param_submit = query_params
+ .iter()
+ .filter(|e| e.0 == "submit")
+ .map(|e| e.1.to_owned())
+ .nth(0);
+ let param_submit = match param_submit {
+ Some(param_submit) => {
+ let param_submit = <bool as std::str::FromStr>::from_str(&param_submit);
+ match param_submit {
+ Ok(param_submit) => Some(param_submit),
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse query parameter submit - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid query parameter submit")),
+ }
+ }
+ None => None,
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_editgroup: Option<models::Editgroup> = 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_editgroup) => param_editgroup,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter Editgroup - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter Editgroup due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_editgroup = match param_editgroup {
+ Some(param_editgroup) => param_editgroup,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter Editgroup"))
+ .expect("Unable to create Bad Request response for missing body parameter Editgroup")),
+ };
+
+ let result = api_impl.update_editgroup(
+ param_editgroup_id,
+ param_editgroup,
+ param_submit,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateEditgroupResponse::UpdatedEditgroup
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_UPDATED_EDITGROUP"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditgroupResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditgroupResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditgroupResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditgroupResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditgroupResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITGROUP_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter Editgroup: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter Editgroup")),
+ }
+ }
+
+ // UpdateEditor - PUT /editor/{editor_id}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITOR_EDITOR_ID) => {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITOR_EDITOR_ID
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITOR_EDITOR_ID in set but failed match against \"{}\"", path, paths::REGEX_EDITOR_EDITOR_ID.as_str())
+ );
+
+ let param_editor_id = match percent_encoding::percent_decode(path_params["editor_id"].as_bytes()).decode_utf8() {
+ Ok(param_editor_id) => match param_editor_id.parse::<String>() {
+ Ok(param_editor_id) => param_editor_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editor_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editor_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_editor: Option<models::Editor> = 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_editor) => param_editor,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter Editor - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter Editor due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_editor = match param_editor {
+ Some(param_editor) => param_editor,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter Editor"))
+ .expect("Unable to create Bad Request response for missing body parameter Editor")),
+ };
+
+ let result = api_impl.update_editor(
+ param_editor_id,
+ param_editor,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateEditorResponse::UpdatedEditor
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_UPDATED_EDITOR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditorResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditorResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditorResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditorResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateEditorResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_EDITOR_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter Editor: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter Editor")),
+ }
+ }
+
+ // UpdateFile - PUT /editgroup/{editgroup_id}/file/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_file_entity: 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_file_entity) => param_file_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FileEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FileEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_file_entity = match param_file_entity {
+ Some(param_file_entity) => param_file_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FileEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter FileEntity")),
+ };
+
+ let result = api_impl.update_file(
+ param_editgroup_id,
+ param_ident,
+ param_file_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateFileResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFileResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFileResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFileResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFileResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFileResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FileEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FileEntity")),
+ }
+ }
+
+ // UpdateFileset - PUT /editgroup/{editgroup_id}/fileset/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_FILESET_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_FILESET_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_fileset_entity: Option<models::FilesetEntity> = 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_fileset_entity) => param_fileset_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter FilesetEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter FilesetEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_fileset_entity = match param_fileset_entity {
+ Some(param_fileset_entity) => param_fileset_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter FilesetEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter FilesetEntity")),
+ };
+
+ let result = api_impl.update_fileset(
+ param_editgroup_id,
+ param_ident,
+ param_fileset_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateFilesetResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFilesetResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFilesetResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFilesetResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFilesetResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateFilesetResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_FILESET_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter FilesetEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter FilesetEntity")),
+ }
+ }
+
+ // UpdateRelease - PUT /editgroup/{editgroup_id}/release/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_RELEASE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_release_entity: 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_release_entity) => param_release_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter ReleaseEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter ReleaseEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_release_entity = match param_release_entity {
+ Some(param_release_entity) => param_release_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter ReleaseEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter ReleaseEntity")),
+ };
+
+ let result = api_impl.update_release(
+ param_editgroup_id,
+ param_ident,
+ param_release_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateReleaseResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateReleaseResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateReleaseResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateReleaseResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateReleaseResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateReleaseResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_RELEASE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter ReleaseEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter ReleaseEntity")),
+ }
+ }
+
+ // UpdateWebcapture - PUT /editgroup/{editgroup_id}/webcapture/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_webcapture_entity: Option<models::WebcaptureEntity> = 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_webcapture_entity) => param_webcapture_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WebcaptureEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WebcaptureEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_webcapture_entity = match param_webcapture_entity {
+ Some(param_webcapture_entity) => param_webcapture_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WebcaptureEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter WebcaptureEntity")),
+ };
+
+ let result = api_impl.update_webcapture(
+ param_editgroup_id,
+ param_ident,
+ param_webcapture_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateWebcaptureResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWebcaptureResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWebcaptureResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWebcaptureResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWebcaptureResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWebcaptureResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WEBCAPTURE_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WebcaptureEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WebcaptureEntity")),
+ }
+ }
+
+ // UpdateWork - PUT /editgroup/{editgroup_id}/work/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) =>
+ {
+ {
+ let authorization = match (&context as &dyn Has<Option<Authorization>>)
+ .get()
+ {
+ &Some(ref authorization) => authorization,
+ &None => {
+ return Ok(Response::builder()
+ .status(StatusCode::FORBIDDEN)
+ .body(Body::from("Unauthenticated"))
+ .expect("Unable to create Authentication Forbidden response"))
+ }
+ };
+ }
+
+ // Path parameters
+ let path: &str = &uri.path().to_string();
+ let path_params =
+ paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT
+ .captures(&path)
+ .unwrap_or_else(||
+ panic!("Path {} matched RE EDITGROUP_EDITGROUP_ID_WORK_IDENT in set but failed match against \"{}\"", path, paths::REGEX_EDITGROUP_EDITGROUP_ID_WORK_IDENT.as_str())
+ );
+
+ let param_editgroup_id = match percent_encoding::percent_decode(path_params["editgroup_id"].as_bytes()).decode_utf8() {
+ Ok(param_editgroup_id) => match param_editgroup_id.parse::<String>() {
+ Ok(param_editgroup_id) => param_editgroup_id,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter editgroup_id: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["editgroup_id"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ let param_ident = match percent_encoding::percent_decode(path_params["ident"].as_bytes()).decode_utf8() {
+ Ok(param_ident) => match param_ident.parse::<String>() {
+ Ok(param_ident) => param_ident,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse path parameter ident: {}", e)))
+ .expect("Unable to create Bad Request response for invalid path parameter")),
+ },
+ Err(_) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["ident"])))
+ .expect("Unable to create Bad Request response for invalid percent decode"))
+ };
+
+ // 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.
+ let result = body.to_raw().await;
+ match result {
+ Ok(body) => {
+ let mut unused_elements = Vec::new();
+ let param_work_entity: 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_work_entity) => param_work_entity,
+ Err(e) => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't parse body parameter WorkEntity - doesn't match schema: {}", e)))
+ .expect("Unable to create Bad Request response for invalid body parameter WorkEntity due to schema")),
+ }
+ } else {
+ None
+ };
+ let param_work_entity = match param_work_entity {
+ Some(param_work_entity) => param_work_entity,
+ None => return Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from("Missing required body parameter WorkEntity"))
+ .expect("Unable to create Bad Request response for missing body parameter WorkEntity")),
+ };
+
+ let result = api_impl.update_work(
+ param_editgroup_id,
+ param_ident,
+ param_work_entity,
+ &context
+ ).await;
+ let mut response = Response::new(Body::empty());
+ response.headers_mut().insert(
+ HeaderName::from_static("x-span-id"),
+ HeaderValue::from_str((&context as &dyn Has<XSpanIdString>).get().0.clone().to_string().as_str())
+ .expect("Unable to create X-Span-ID header value"));
+
+ if !unused_elements.is_empty() {
+ response.headers_mut().insert(
+ HeaderName::from_static("warning"),
+ HeaderValue::from_str(format!("Ignoring unknown fields in body: {:?}", unused_elements).as_str())
+ .expect("Unable to create Warning header value"));
+ }
+
+ match result {
+ Ok(rsp) => match rsp {
+ UpdateWorkResponse::UpdatedEntity
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(200).expect("Unable to turn 200 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_UPDATED_ENTITY"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWorkResponse::BadRequest
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(400).expect("Unable to turn 400 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_BAD_REQUEST"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWorkResponse::NotAuthorized
+ {
+ body,
+ www_authenticate
+ }
+ => {
+ if let Some(www_authenticate) = www_authenticate {
+ let www_authenticate = match header::IntoHeaderValue(www_authenticate).try_into() {
+ Ok(val) => val,
+ Err(e) => {
+ return Ok(Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from(format!("An internal server error occurred handling www_authenticate header - {}", e)))
+ .expect("Unable to create Internal Server Error for invalid response header"))
+ }
+ };
+
+ response.headers_mut().insert(
+ HeaderName::from_static("www_authenticate"),
+ www_authenticate
+ );
+ }
+ *response.status_mut() = StatusCode::from_u16(401).expect("Unable to turn 401 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_NOT_AUTHORIZED"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWorkResponse::Forbidden
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(403).expect("Unable to turn 403 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_FORBIDDEN"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWorkResponse::NotFound
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(404).expect("Unable to turn 404 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_NOT_FOUND"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ UpdateWorkResponse::GenericError
+ (body)
+ => {
+ *response.status_mut() = StatusCode::from_u16(500).expect("Unable to turn 500 into a StatusCode");
+ response.headers_mut().insert(
+ CONTENT_TYPE,
+ HeaderValue::from_str("application/json")
+ .expect("Unable to create Content-Type header for UPDATE_WORK_GENERIC_ERROR"));
+ let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
+ *response.body_mut() = Body::from(body);
+ },
+ },
+ Err(_) => {
+ // Application code returned an error. This should not happen, as the implementation should
+ // return a valid response.
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
+ *response.body_mut() = Body::from("An internal error occurred");
+ },
+ }
+
+ Ok(response)
+ },
+ Err(e) => Ok(Response::builder()
+ .status(StatusCode::BAD_REQUEST)
+ .body(Body::from(format!("Couldn't read body parameter WorkEntity: {}", e)))
+ .expect("Unable to create Bad Request response due to unable to read body parameter WorkEntity")),
+ }
+ }
+
+ _ if path.matched(paths::ID_AUTH_CHECK) => method_not_allowed(),
+ _ if path.matched(paths::ID_AUTH_OIDC) => method_not_allowed(),
+ _ if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_CHANGELOG) => method_not_allowed(),
+ _ if path.matched(paths::ID_CHANGELOG_INDEX) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_LOOKUP) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_LOOKUP) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
+ method_not_allowed()
+ }
+ _ if path.matched(paths::ID_EDITOR_EDITOR_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => method_not_allowed(),
+ _ if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_LOOKUP) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILESET_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILESET_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILESET_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_LOOKUP) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT_FILES) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => method_not_allowed(),
+ _ if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_WEBCAPTURE_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_REV_REV_ID) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_IDENT) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_IDENT_HISTORY) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => method_not_allowed(),
+ _ if path.matched(paths::ID_WORK_IDENT_RELEASES) => method_not_allowed(),
+ _ => Ok(Response::builder()
+ .status(StatusCode::NOT_FOUND)
+ .body(Body::empty())
+ .expect("Unable to create Not Found response")),
+ }
+ }
+ Box::pin(run(self.api_impl.clone(), req))
+ }
+}
+
+/// Request parser for `Api`.
+pub struct ApiRequestParser;
+impl<T> RequestParser<T> for ApiRequestParser {
+ fn parse_operation_id(request: &Request<T>) -> Result<&'static str, ()> {
+ let path = paths::GLOBAL_REGEX_SET.matches(request.uri().path());
+ match request.method() {
+ // AcceptEditgroup - POST /editgroup/{editgroup_id}/accept
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ACCEPT) => {
+ Ok("AcceptEditgroup")
+ }
+ // AuthCheck - GET /auth/check
+ &hyper::Method::GET if path.matched(paths::ID_AUTH_CHECK) => Ok("AuthCheck"),
+ // AuthOidc - POST /auth/oidc
+ &hyper::Method::POST if path.matched(paths::ID_AUTH_OIDC) => Ok("AuthOidc"),
+ // CreateAuthToken - POST /auth/token/{editor_id}
+ &hyper::Method::POST if path.matched(paths::ID_AUTH_TOKEN_EDITOR_ID) => {
+ Ok("CreateAuthToken")
+ }
+ // CreateContainer - POST /editgroup/{editgroup_id}/container
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER) => {
+ Ok("CreateContainer")
+ }
+ // CreateContainerAutoBatch - POST /editgroup/auto/container/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CONTAINER_BATCH) => {
+ Ok("CreateContainerAutoBatch")
+ }
+ // CreateCreator - POST /editgroup/{editgroup_id}/creator
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR) => {
+ Ok("CreateCreator")
+ }
+ // CreateCreatorAutoBatch - POST /editgroup/auto/creator/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_CREATOR_BATCH) => {
+ Ok("CreateCreatorAutoBatch")
+ }
+ // CreateEditgroup - POST /editgroup
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP) => Ok("CreateEditgroup"),
+ // CreateEditgroupAnnotation - POST /editgroup/{editgroup_id}/annotation
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATION) => {
+ Ok("CreateEditgroupAnnotation")
+ }
+ // CreateFile - POST /editgroup/{editgroup_id}/file
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE) => {
+ Ok("CreateFile")
+ }
+ // CreateFileAutoBatch - POST /editgroup/auto/file/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILE_BATCH) => {
+ Ok("CreateFileAutoBatch")
+ }
+ // CreateFileset - POST /editgroup/{editgroup_id}/fileset
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET) => {
+ Ok("CreateFileset")
+ }
+ // CreateFilesetAutoBatch - POST /editgroup/auto/fileset/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_FILESET_BATCH) => {
+ Ok("CreateFilesetAutoBatch")
+ }
+ // CreateRelease - POST /editgroup/{editgroup_id}/release
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE) => {
+ Ok("CreateRelease")
+ }
+ // CreateReleaseAutoBatch - POST /editgroup/auto/release/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_RELEASE_BATCH) => {
+ Ok("CreateReleaseAutoBatch")
+ }
+ // CreateWebcapture - POST /editgroup/{editgroup_id}/webcapture
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE) => {
+ Ok("CreateWebcapture")
+ }
+ // CreateWebcaptureAutoBatch - POST /editgroup/auto/webcapture/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WEBCAPTURE_BATCH) => {
+ Ok("CreateWebcaptureAutoBatch")
+ }
+ // CreateWork - POST /editgroup/{editgroup_id}/work
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK) => {
+ Ok("CreateWork")
+ }
+ // CreateWorkAutoBatch - POST /editgroup/auto/work/batch
+ &hyper::Method::POST if path.matched(paths::ID_EDITGROUP_AUTO_WORK_BATCH) => {
+ Ok("CreateWorkAutoBatch")
+ }
+ // DeleteContainer - DELETE /editgroup/{editgroup_id}/container/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
+ {
+ Ok("DeleteContainer")
+ }
+ // DeleteContainerEdit - DELETE /editgroup/{editgroup_id}/container/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteContainerEdit")
+ }
+ // DeleteCreator - DELETE /editgroup/{editgroup_id}/creator/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) =>
+ {
+ Ok("DeleteCreator")
+ }
+ // DeleteCreatorEdit - DELETE /editgroup/{editgroup_id}/creator/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteCreatorEdit")
+ }
+ // DeleteFile - DELETE /editgroup/{editgroup_id}/file/{ident}
+ &hyper::Method::DELETE if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
+ Ok("DeleteFile")
+ }
+ // DeleteFileEdit - DELETE /editgroup/{editgroup_id}/file/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteFileEdit")
+ }
+ // DeleteFileset - DELETE /editgroup/{editgroup_id}/fileset/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) =>
+ {
+ Ok("DeleteFileset")
+ }
+ // DeleteFilesetEdit - DELETE /editgroup/{editgroup_id}/fileset/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteFilesetEdit")
+ }
+ // DeleteRelease - DELETE /editgroup/{editgroup_id}/release/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) =>
+ {
+ Ok("DeleteRelease")
+ }
+ // DeleteReleaseEdit - DELETE /editgroup/{editgroup_id}/release/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteReleaseEdit")
+ }
+ // DeleteWebcapture - DELETE /editgroup/{editgroup_id}/webcapture/{ident}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
+ {
+ Ok("DeleteWebcapture")
+ }
+ // DeleteWebcaptureEdit - DELETE /editgroup/{editgroup_id}/webcapture/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteWebcaptureEdit")
+ }
+ // DeleteWork - DELETE /editgroup/{editgroup_id}/work/{ident}
+ &hyper::Method::DELETE if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
+ Ok("DeleteWork")
+ }
+ // DeleteWorkEdit - DELETE /editgroup/{editgroup_id}/work/edit/{edit_id}
+ &hyper::Method::DELETE
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_EDIT_EDIT_ID) =>
+ {
+ Ok("DeleteWorkEdit")
+ }
+ // GetChangelog - GET /changelog
+ &hyper::Method::GET if path.matched(paths::ID_CHANGELOG) => Ok("GetChangelog"),
+ // GetChangelogEntry - GET /changelog/{index}
+ &hyper::Method::GET if path.matched(paths::ID_CHANGELOG_INDEX) => {
+ Ok("GetChangelogEntry")
+ }
+ // GetContainer - GET /container/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT) => Ok("GetContainer"),
+ // GetContainerEdit - GET /container/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_EDIT_EDIT_ID) => {
+ Ok("GetContainerEdit")
+ }
+ // GetContainerHistory - GET /container/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_HISTORY) => {
+ Ok("GetContainerHistory")
+ }
+ // GetContainerRedirects - GET /container/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_IDENT_REDIRECTS) => {
+ Ok("GetContainerRedirects")
+ }
+ // GetContainerRevision - GET /container/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_REV_REV_ID) => {
+ Ok("GetContainerRevision")
+ }
+ // GetCreator - GET /creator/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT) => Ok("GetCreator"),
+ // GetCreatorEdit - GET /creator/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_EDIT_EDIT_ID) => {
+ Ok("GetCreatorEdit")
+ }
+ // GetCreatorHistory - GET /creator/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_HISTORY) => {
+ Ok("GetCreatorHistory")
+ }
+ // GetCreatorRedirects - GET /creator/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_REDIRECTS) => {
+ Ok("GetCreatorRedirects")
+ }
+ // GetCreatorReleases - GET /creator/{ident}/releases
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_IDENT_RELEASES) => {
+ Ok("GetCreatorReleases")
+ }
+ // GetCreatorRevision - GET /creator/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_REV_REV_ID) => {
+ Ok("GetCreatorRevision")
+ }
+ // GetEditgroup - GET /editgroup/{editgroup_id}
+ &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
+ Ok("GetEditgroup")
+ }
+ // GetEditgroupAnnotations - GET /editgroup/{editgroup_id}/annotations
+ &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_ANNOTATIONS) => {
+ Ok("GetEditgroupAnnotations")
+ }
+ // GetEditgroupsReviewable - GET /editgroup/reviewable
+ &hyper::Method::GET if path.matched(paths::ID_EDITGROUP_REVIEWABLE) => {
+ Ok("GetEditgroupsReviewable")
+ }
+ // GetEditor - GET /editor/{editor_id}
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID) => Ok("GetEditor"),
+ // GetEditorAnnotations - GET /editor/{editor_id}/annotations
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_ANNOTATIONS) => {
+ Ok("GetEditorAnnotations")
+ }
+ // GetEditorEditgroups - GET /editor/{editor_id}/editgroups
+ &hyper::Method::GET if path.matched(paths::ID_EDITOR_EDITOR_ID_EDITGROUPS) => {
+ Ok("GetEditorEditgroups")
+ }
+ // GetFile - GET /file/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT) => Ok("GetFile"),
+ // GetFileEdit - GET /file/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_EDIT_EDIT_ID) => Ok("GetFileEdit"),
+ // GetFileHistory - GET /file/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_HISTORY) => {
+ Ok("GetFileHistory")
+ }
+ // GetFileRedirects - GET /file/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_FILE_IDENT_REDIRECTS) => {
+ Ok("GetFileRedirects")
+ }
+ // GetFileRevision - GET /file/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILE_REV_REV_ID) => Ok("GetFileRevision"),
+ // GetFileset - GET /fileset/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT) => Ok("GetFileset"),
+ // GetFilesetEdit - GET /fileset/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_EDIT_EDIT_ID) => {
+ Ok("GetFilesetEdit")
+ }
+ // GetFilesetHistory - GET /fileset/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_HISTORY) => {
+ Ok("GetFilesetHistory")
+ }
+ // GetFilesetRedirects - GET /fileset/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_IDENT_REDIRECTS) => {
+ Ok("GetFilesetRedirects")
+ }
+ // GetFilesetRevision - GET /fileset/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_FILESET_REV_REV_ID) => {
+ Ok("GetFilesetRevision")
+ }
+ // GetRelease - GET /release/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT) => Ok("GetRelease"),
+ // GetReleaseEdit - GET /release/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_EDIT_EDIT_ID) => {
+ Ok("GetReleaseEdit")
+ }
+ // GetReleaseFiles - GET /release/{ident}/files
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILES) => {
+ Ok("GetReleaseFiles")
+ }
+ // GetReleaseFilesets - GET /release/{ident}/filesets
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_FILESETS) => {
+ Ok("GetReleaseFilesets")
+ }
+ // GetReleaseHistory - GET /release/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_HISTORY) => {
+ Ok("GetReleaseHistory")
+ }
+ // GetReleaseRedirects - GET /release/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_REDIRECTS) => {
+ Ok("GetReleaseRedirects")
+ }
+ // GetReleaseRevision - GET /release/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_REV_REV_ID) => {
+ Ok("GetReleaseRevision")
+ }
+ // GetReleaseWebcaptures - GET /release/{ident}/webcaptures
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_IDENT_WEBCAPTURES) => {
+ Ok("GetReleaseWebcaptures")
+ }
+ // GetWebcapture - GET /webcapture/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT) => Ok("GetWebcapture"),
+ // GetWebcaptureEdit - GET /webcapture/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_EDIT_EDIT_ID) => {
+ Ok("GetWebcaptureEdit")
+ }
+ // GetWebcaptureHistory - GET /webcapture/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_HISTORY) => {
+ Ok("GetWebcaptureHistory")
+ }
+ // GetWebcaptureRedirects - GET /webcapture/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_IDENT_REDIRECTS) => {
+ Ok("GetWebcaptureRedirects")
+ }
+ // GetWebcaptureRevision - GET /webcapture/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_WEBCAPTURE_REV_REV_ID) => {
+ Ok("GetWebcaptureRevision")
+ }
+ // GetWork - GET /work/{ident}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT) => Ok("GetWork"),
+ // GetWorkEdit - GET /work/edit/{edit_id}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_EDIT_EDIT_ID) => Ok("GetWorkEdit"),
+ // GetWorkHistory - GET /work/{ident}/history
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_HISTORY) => {
+ Ok("GetWorkHistory")
+ }
+ // GetWorkRedirects - GET /work/{ident}/redirects
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_REDIRECTS) => {
+ Ok("GetWorkRedirects")
+ }
+ // GetWorkReleases - GET /work/{ident}/releases
+ &hyper::Method::GET if path.matched(paths::ID_WORK_IDENT_RELEASES) => {
+ Ok("GetWorkReleases")
+ }
+ // GetWorkRevision - GET /work/rev/{rev_id}
+ &hyper::Method::GET if path.matched(paths::ID_WORK_REV_REV_ID) => Ok("GetWorkRevision"),
+ // LookupContainer - GET /container/lookup
+ &hyper::Method::GET if path.matched(paths::ID_CONTAINER_LOOKUP) => {
+ Ok("LookupContainer")
+ }
+ // LookupCreator - GET /creator/lookup
+ &hyper::Method::GET if path.matched(paths::ID_CREATOR_LOOKUP) => Ok("LookupCreator"),
+ // LookupFile - GET /file/lookup
+ &hyper::Method::GET if path.matched(paths::ID_FILE_LOOKUP) => Ok("LookupFile"),
+ // LookupRelease - GET /release/lookup
+ &hyper::Method::GET if path.matched(paths::ID_RELEASE_LOOKUP) => Ok("LookupRelease"),
+ // UpdateContainer - PUT /editgroup/{editgroup_id}/container/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CONTAINER_IDENT) =>
+ {
+ Ok("UpdateContainer")
+ }
+ // UpdateCreator - PUT /editgroup/{editgroup_id}/creator/{ident}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_CREATOR_IDENT) => {
+ Ok("UpdateCreator")
+ }
+ // UpdateEditgroup - PUT /editgroup/{editgroup_id}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID) => {
+ Ok("UpdateEditgroup")
+ }
+ // UpdateEditor - PUT /editor/{editor_id}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITOR_EDITOR_ID) => Ok("UpdateEditor"),
+ // UpdateFile - PUT /editgroup/{editgroup_id}/file/{ident}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILE_IDENT) => {
+ Ok("UpdateFile")
+ }
+ // UpdateFileset - PUT /editgroup/{editgroup_id}/fileset/{ident}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_FILESET_IDENT) => {
+ Ok("UpdateFileset")
+ }
+ // UpdateRelease - PUT /editgroup/{editgroup_id}/release/{ident}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_RELEASE_IDENT) => {
+ Ok("UpdateRelease")
+ }
+ // UpdateWebcapture - PUT /editgroup/{editgroup_id}/webcapture/{ident}
+ &hyper::Method::PUT
+ if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WEBCAPTURE_IDENT) =>
+ {
+ Ok("UpdateWebcapture")
+ }
+ // UpdateWork - PUT /editgroup/{editgroup_id}/work/{ident}
+ &hyper::Method::PUT if path.matched(paths::ID_EDITGROUP_EDITGROUP_ID_WORK_IDENT) => {
+ Ok("UpdateWork")
+ }
+ _ => Err(()),
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-25 20:44:17 +0000