diff options
Diffstat (limited to 'fatcat-openapi/src')
| -rw-r--r-- | fatcat-openapi/src/client/mod.rs | 16107 | ||||
| -rw-r--r-- | fatcat-openapi/src/context.rs | 120 | ||||
| -rw-r--r-- | fatcat-openapi/src/header.rs | 197 | ||||
| -rw-r--r-- | fatcat-openapi/src/lib.rs | 3844 | ||||
| -rw-r--r-- | fatcat-openapi/src/models.rs | 7621 | ||||
| -rw-r--r-- | fatcat-openapi/src/server/mod.rs | 15856 |
6 files changed, 43745 insertions, 0 deletions
diff --git a/fatcat-openapi/src/client/mod.rs b/fatcat-openapi/src/client/mod.rs new file mode 100644 index 0000000..bb1cee8 --- /dev/null +++ b/fatcat-openapi/src/client/mod.rs @@ -0,0 +1,16107 @@ +use async_trait::async_trait; +use futures::{ + future, future::BoxFuture, future::FutureExt, future::TryFutureExt, stream, stream::StreamExt, + Stream, +}; +use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE}; +use hyper::{service::Service, Body, Request, Response, Uri}; +use percent_encoding::{utf8_percent_encode, AsciiSet}; +use std::borrow::Cow; +use std::convert::TryInto; +use std::error::Error; +use std::fmt; +use std::future::Future; +use std::io::{ErrorKind, Read}; +use std::marker::PhantomData; +use std::path::Path; +use std::str; +use std::str::FromStr; +use std::string::ToString; +use std::sync::{Arc, Mutex}; +use std::task::{Context, Poll}; +use swagger::{ApiError, AuthData, BodyExt, Connector, DropContextService, Has, XSpanIdString}; +use url::form_urlencoded; + +use crate::header; +use crate::models; + +/// https://url.spec.whatwg.org/#fragment-percent-encode-set +#[allow(dead_code)] +const FRAGMENT_ENCODE_SET: &AsciiSet = &percent_encoding::CONTROLS + .add(b' ') + .add(b'"') + .add(b'<') + .add(b'>') + .add(b'`'); + +/// This encode set is used for object IDs +/// +/// Aside from the special characters defined in the `PATH_SEGMENT_ENCODE_SET`, +/// the vertical bar (|) is encoded. +#[allow(dead_code)] +const ID_ENCODE_SET: &AsciiSet = &FRAGMENT_ENCODE_SET.add(b'|'); + +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, +}; + +/// Convert input into a base path, e.g. "http://example:123". Also checks the scheme as it goes. +fn into_base_path( + input: impl TryInto<Uri, Error = hyper::http::uri::InvalidUri>, + correct_scheme: Option<&'static str>, +) -> Result<String, ClientInitError> { + // First convert to Uri, since a base path is a subset of Uri. + let uri = input.try_into()?; + + let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?; + + // Check the scheme if necessary + if let Some(correct_scheme) = correct_scheme { + if scheme != correct_scheme { + return Err(ClientInitError::InvalidScheme); + } + } + + let host = uri.host().ok_or_else(|| ClientInitError::MissingHost)?; + let port = uri + .port_u16() + .map(|x| format!(":{}", x)) + .unwrap_or_default(); + Ok(format!( + "{}://{}{}{}", + scheme, + host, + port, + uri.path().trim_end_matches('/') + )) +} + +/// A client that implements the API by making HTTP calls out to a server. +pub struct Client<S, C> +where + S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, + S::Future: Send + 'static, + S::Error: Into<crate::ServiceError> + fmt::Display, + C: Clone + Send + Sync + 'static, +{ + /// Inner service + client_service: S, + + /// Base path of the API + base_path: String, + + /// Marker + marker: PhantomData<fn(C)>, +} + +impl<S, C> fmt::Debug for Client<S, C> +where + S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, + S::Future: Send + 'static, + S::Error: Into<crate::ServiceError> + fmt::Display, + C: Clone + Send + Sync + 'static, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Client {{ base_path: {} }}", self.base_path) + } +} + +impl<S, C> Clone for Client<S, C> +where + S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, + S::Future: Send + 'static, + S::Error: Into<crate::ServiceError> + fmt::Display, + C: Clone + Send + Sync + 'static, +{ + fn clone(&self) -> Self { + Self { + client_service: self.client_service.clone(), + base_path: self.base_path.clone(), + marker: PhantomData, + } + } +} + +impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Body>, C>, C> +where + Connector: hyper::client::connect::Connect + Clone + Send + Sync + 'static, + C: Clone + Send + Sync + 'static, +{ + /// Create a client with a custom implementation of hyper::client::Connect. + /// + /// Intended for use with custom implementations of connect for e.g. protocol logging + /// or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection, + /// this function should be used in conjunction with `swagger::Connector::builder()`. + /// + /// For ordinary tcp connections, prefer the use of `try_new_http`, `try_new_https` + /// and `try_new_https_mutual`, to avoid introducing a dependency on the underlying transport layer. + /// + /// # Arguments + /// + /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com" + /// * `protocol` - Which protocol to use when constructing the request url, e.g. `Some("http")` + /// * `connector` - Implementation of `hyper::client::Connect` to use for the client + pub fn try_new_with_connector( + base_path: &str, + protocol: Option<&'static str>, + connector: Connector, + ) -> Result<Self, ClientInitError> { + let client_service = hyper::client::Client::builder().build(connector); + let client_service = DropContextService::new(client_service); + + Ok(Self { + client_service, + base_path: into_base_path(base_path, protocol)?, + marker: PhantomData, + }) + } +} + +#[derive(Debug, Clone)] +pub enum HyperClient { + Http(hyper::client::Client<hyper::client::HttpConnector, Body>), + Https(hyper::client::Client<HttpsConnector, Body>), +} + +impl Service<Request<Body>> for HyperClient { + type Response = Response<Body>; + type Error = hyper::Error; + type Future = hyper::client::ResponseFuture; + + fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> { + match self { + HyperClient::Http(client) => client.poll_ready(cx), + HyperClient::Https(client) => client.poll_ready(cx), + } + } + + fn call(&mut self, req: Request<Body>) -> Self::Future { + match self { + HyperClient::Http(client) => client.call(req), + HyperClient::Https(client) => client.call(req), + } + } +} + +impl<C> Client<DropContextService<HyperClient, C>, C> +where + C: Clone + Send + Sync + 'static, +{ + /// Create an HTTP client. + /// + /// # Arguments + /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com" + pub fn try_new(base_path: &str) -> Result<Self, ClientInitError> { + let uri = Uri::from_str(base_path)?; + + let scheme = uri.scheme_str().ok_or(ClientInitError::InvalidScheme)?; + let scheme = scheme.to_ascii_lowercase(); + + let connector = Connector::builder(); + + let client_service = match scheme.as_str() { + "http" => HyperClient::Http(hyper::client::Client::builder().build(connector.build())), + "https" => { + let connector = connector + .https() + .build() + .map_err(|e| ClientInitError::SslError(e))?; + HyperClient::Https(hyper::client::Client::builder().build(connector)) + } + _ => { + return Err(ClientInitError::InvalidScheme); + } + }; + + let client_service = DropContextService::new(client_service); + + Ok(Self { + client_service, + base_path: into_base_path(base_path, None)?, + marker: PhantomData, + }) + } +} + +impl<C> Client<DropContextService<hyper::client::Client<hyper::client::HttpConnector, Body>, C>, C> +where + C: Clone + Send + Sync + 'static, +{ + /// Create an HTTP client. + /// + /// # Arguments + /// * `base_path` - base path of the client API, i.e. "http://www.my-api-implementation.com" + pub fn try_new_http(base_path: &str) -> Result<Self, ClientInitError> { + let http_connector = Connector::builder().build(); + + Self::try_new_with_connector(base_path, Some("http"), http_connector) + } +} + +#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))] +type HttpsConnector = hyper_tls::HttpsConnector<hyper::client::HttpConnector>; + +#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))] +type HttpsConnector = hyper_openssl::HttpsConnector<hyper::client::HttpConnector>; + +impl<C> Client<DropContextService<hyper::client::Client<HttpsConnector, Body>, C>, C> +where + C: Clone + Send + Sync + 'static, +{ + /// Create a client with a TLS connection to the server + /// + /// # Arguments + /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com" + pub fn try_new_https(base_path: &str) -> Result<Self, ClientInitError> { + let https_connector = Connector::builder() + .https() + .build() + .map_err(|e| ClientInitError::SslError(e))?; + Self::try_new_with_connector(base_path, Some("https"), https_connector) + } + + /// Create a client with a TLS connection to the server using a pinned certificate + /// + /// # Arguments + /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com" + /// * `ca_certificate` - Path to CA certificate used to authenticate the server + #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))] + pub fn try_new_https_pinned<CA>( + base_path: &str, + ca_certificate: CA, + ) -> Result<Self, ClientInitError> + where + CA: AsRef<Path>, + { + let https_connector = Connector::builder() + .https() + .pin_server_certificate(ca_certificate) + .build() + .map_err(|e| ClientInitError::SslError(e))?; + Self::try_new_with_connector(base_path, Some("https"), https_connector) + } + + /// Create a client with a mutually authenticated TLS connection to the server. + /// + /// # Arguments + /// * `base_path` - base path of the client API, i.e. "https://www.my-api-implementation.com" + /// * `ca_certificate` - Path to CA certificate used to authenticate the server + /// * `client_key` - Path to the client private key + /// * `client_certificate` - Path to the client's public certificate associated with the private key + #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))] + pub fn try_new_https_mutual<CA, K, D>( + base_path: &str, + ca_certificate: CA, + client_key: K, + client_certificate: D, + ) -> Result<Self, ClientInitError> + where + CA: AsRef<Path>, + K: AsRef<Path>, + D: AsRef<Path>, + { + let https_connector = Connector::builder() + .https() + .pin_server_certificate(ca_certificate) + .client_authentication(client_key, client_certificate) + .build() + .map_err(|e| ClientInitError::SslError(e))?; + Self::try_new_with_connector(base_path, Some("https"), https_connector) + } +} + +impl<S, C> Client<S, C> +where + S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, + S::Future: Send + 'static, + S::Error: Into<crate::ServiceError> + fmt::Display, + C: Clone + Send + Sync + 'static, +{ + /// Constructor for creating a `Client` by passing in a pre-made `hyper::service::Service` / + /// `tower::Service` + /// + /// This allows adding custom wrappers around the underlying transport, for example for logging. + pub fn try_new_with_client_service( + client_service: S, + base_path: &str, + ) -> Result<Self, ClientInitError> { + Ok(Self { + client_service, + base_path: into_base_path(base_path, None)?, + marker: PhantomData, + }) + } +} + +/// Error type failing to create a Client +#[derive(Debug)] +pub enum ClientInitError { + /// Invalid URL Scheme + InvalidScheme, + + /// Invalid URI + InvalidUri(hyper::http::uri::InvalidUri), + + /// Missing Hostname + MissingHost, + + /// SSL Connection Error + #[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))] + SslError(native_tls::Error), + + /// SSL Connection Error + #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))] + SslError(openssl::error::ErrorStack), +} + +impl From<hyper::http::uri::InvalidUri> for ClientInitError { + fn from(err: hyper::http::uri::InvalidUri) -> ClientInitError { + ClientInitError::InvalidUri(err) + } +} + +impl fmt::Display for ClientInitError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let s: &dyn fmt::Debug = self; + s.fmt(f) + } +} + +impl Error for ClientInitError { + fn description(&self) -> &str { + "Failed to produce a hyper client." + } +} + +#[async_trait] +impl<S, C> Api<C> for Client<S, C> +where + S: Service<(Request<Body>, C), Response = Response<Body>> + Clone + Sync + Send + 'static, + S::Future: Send + 'static, + S::Error: Into<crate::ServiceError> + fmt::Display, + C: Has<XSpanIdString> + Has<Option<AuthData>> + Clone + Send + Sync + 'static, +{ + fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), crate::ServiceError>> { + match self.client_service.clone().poll_ready(cx) { + Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())), + Poll::Ready(Ok(o)) => Poll::Ready(Ok(o)), + Poll::Pending => Poll::Pending, + } + } + + async fn accept_editgroup( + &self, + param_editgroup_id: String, + context: &C, + ) -> Result<AcceptEditgroupResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/accept", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(AcceptEditgroupResponse::MergedSuccessfully(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::NotFound(body)) + } + 409 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::EditConflict(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AcceptEditgroupResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn auth_check( + &self, + param_role: Option<String>, + context: &C, + ) -> Result<AuthCheckResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/auth/check", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_role) = param_role { + query_string.append_pair("role", ¶m_role.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(AuthCheckResponse::Success(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthCheckResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthCheckResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthCheckResponse::Forbidden(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthCheckResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn auth_oidc( + &self, + param_auth_oidc: models::AuthOidc, + context: &C, + ) -> Result<AuthOidcResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/auth/oidc", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_auth_oidc).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::AuthOidcResult>(body)?; + Ok(AuthOidcResponse::Found(body)) + } + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::AuthOidcResult>(body)?; + Ok(AuthOidcResponse::Created(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthOidcResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthOidcResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthOidcResponse::Forbidden(body)) + } + 409 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthOidcResponse::Conflict(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(AuthOidcResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_auth_token( + &self, + param_editor_id: String, + param_duration_seconds: Option<i32>, + context: &C, + ) -> Result<CreateAuthTokenResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/auth/token/{editor_id}", + self.base_path, + editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_duration_seconds) = param_duration_seconds { + query_string.append_pair("duration_seconds", ¶m_duration_seconds.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::AuthTokenResult>(body)?; + Ok(CreateAuthTokenResponse::Success(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateAuthTokenResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateAuthTokenResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateAuthTokenResponse::Forbidden(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateAuthTokenResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_container( + &self, + param_editgroup_id: String, + param_container_entity: models::ContainerEntity, + context: &C, + ) -> Result<CreateContainerResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/container", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_container_entity) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateContainerResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_container_auto_batch( + &self, + param_container_auto_batch: models::ContainerAutoBatch, + context: &C, + ) -> Result<CreateContainerAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/container/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_container_auto_batch) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateContainerAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateContainerAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_creator( + &self, + param_editgroup_id: String, + param_creator_entity: models::CreatorEntity, + context: &C, + ) -> Result<CreateCreatorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/creator", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_creator_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateCreatorResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_creator_auto_batch( + &self, + param_creator_auto_batch: models::CreatorAutoBatch, + context: &C, + ) -> Result<CreateCreatorAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/creator/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_creator_auto_batch) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateCreatorAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateCreatorAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_editgroup( + &self, + param_editgroup: models::Editgroup, + context: &C, + ) -> Result<CreateEditgroupResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_editgroup).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateEditgroupResponse::SuccessfullyCreated(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_editgroup_annotation( + &self, + param_editgroup_id: String, + param_editgroup_annotation: models::EditgroupAnnotation, + context: &C, + ) -> Result<CreateEditgroupAnnotationResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/annotation", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_editgroup_annotation) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EditgroupAnnotation>(body)?; + Ok(CreateEditgroupAnnotationResponse::Created(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupAnnotationResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupAnnotationResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupAnnotationResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupAnnotationResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateEditgroupAnnotationResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_file( + &self, + param_editgroup_id: String, + param_file_entity: models::FileEntity, + context: &C, + ) -> Result<CreateFileResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/file", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_file_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateFileResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_file_auto_batch( + &self, + param_file_auto_batch: models::FileAutoBatch, + context: &C, + ) -> Result<CreateFileAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/file/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_file_auto_batch).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateFileAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFileAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_fileset( + &self, + param_editgroup_id: String, + param_fileset_entity: models::FilesetEntity, + context: &C, + ) -> Result<CreateFilesetResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/fileset", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_fileset_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateFilesetResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_fileset_auto_batch( + &self, + param_fileset_auto_batch: models::FilesetAutoBatch, + context: &C, + ) -> Result<CreateFilesetAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/fileset/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_fileset_auto_batch) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateFilesetAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateFilesetAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_release( + &self, + param_editgroup_id: String, + param_release_entity: models::ReleaseEntity, + context: &C, + ) -> Result<CreateReleaseResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/release", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_release_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateReleaseResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_release_auto_batch( + &self, + param_release_auto_batch: models::ReleaseAutoBatch, + context: &C, + ) -> Result<CreateReleaseAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/release/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_release_auto_batch) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateReleaseAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateReleaseAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_webcapture( + &self, + param_editgroup_id: String, + param_webcapture_entity: models::WebcaptureEntity, + context: &C, + ) -> Result<CreateWebcaptureResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/webcapture", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_webcapture_entity) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateWebcaptureResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_webcapture_auto_batch( + &self, + param_webcapture_auto_batch: models::WebcaptureAutoBatch, + context: &C, + ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/webcapture/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_webcapture_auto_batch) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWebcaptureAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_work( + &self, + param_editgroup_id: String, + param_work_entity: models::WorkEntity, + context: &C, + ) -> Result<CreateWorkResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/work", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_work_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(CreateWorkResponse::CreatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn create_work_auto_batch( + &self, + param_work_auto_batch: models::WorkAutoBatch, + context: &C, + ) -> Result<CreateWorkAutoBatchResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/auto/work/batch", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("POST") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_work_auto_batch).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 201 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(CreateWorkAutoBatchResponse::CreatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkAutoBatchResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkAutoBatchResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkAutoBatchResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkAutoBatchResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(CreateWorkAutoBatchResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_container( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteContainerResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/container/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteContainerResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_container_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteContainerEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/container/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteContainerEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteContainerEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_creator( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteCreatorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/creator/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteCreatorResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_creator_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteCreatorEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/creator/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteCreatorEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteCreatorEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_file( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteFileResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/file/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteFileResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_file_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteFileEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/file/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteFileEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFileEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_fileset( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteFilesetResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/fileset/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteFilesetResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_fileset_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteFilesetEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/fileset/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteFilesetEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteFilesetEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_release( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteReleaseResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/release/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteReleaseResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_release_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteReleaseEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/release/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteReleaseEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteReleaseEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_webcapture( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteWebcaptureResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/webcapture/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteWebcaptureResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_webcapture_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteWebcaptureEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/webcapture/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteWebcaptureEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWebcaptureEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_work( + &self, + param_editgroup_id: String, + param_ident: String, + context: &C, + ) -> Result<DeleteWorkResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/work/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(DeleteWorkResponse::DeletedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn delete_work_edit( + &self, + param_editgroup_id: String, + param_edit_id: String, + context: &C, + ) -> Result<DeleteWorkEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/work/edit/{edit_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("DELETE") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Success>(body)?; + Ok(DeleteWorkEditResponse::DeletedEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkEditResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkEditResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkEditResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(DeleteWorkEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_changelog( + &self, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetChangelogResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/changelog", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::ChangelogEntry>>(body)?; + Ok(GetChangelogResponse::Success(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetChangelogResponse::BadRequest(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetChangelogResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_changelog_entry( + &self, + param_index: i64, + context: &C, + ) -> Result<GetChangelogEntryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/changelog/{index}", + self.base_path, + index = utf8_percent_encode(¶m_index.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ChangelogEntry>(body)?; + Ok(GetChangelogEntryResponse::FoundChangelogEntry(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetChangelogEntryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetChangelogEntryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetChangelogEntryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_container( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetContainerResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/container/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ContainerEntity>(body)?; + Ok(GetContainerResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_container_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetContainerEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/container/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetContainerEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_container_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetContainerHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/container/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetContainerHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_container_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetContainerRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/container/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetContainerRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_container_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetContainerRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/container/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ContainerEntity>(body)?; + Ok(GetContainerRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetContainerRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetCreatorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::CreatorEntity>(body)?; + Ok(GetCreatorResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetCreatorEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetCreatorEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetCreatorHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetCreatorHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetCreatorRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetCreatorRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator_releases( + &self, + param_ident: String, + param_hide: Option<String>, + context: &C, + ) -> Result<GetCreatorReleasesResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/{ident}/releases", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::ReleaseEntity>>(body)?; + Ok(GetCreatorReleasesResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorReleasesResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorReleasesResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorReleasesResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_creator_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetCreatorRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/creator/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::CreatorEntity>(body)?; + Ok(GetCreatorRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetCreatorRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editgroup( + &self, + param_editgroup_id: String, + context: &C, + ) -> Result<GetEditgroupResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(GetEditgroupResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editgroup_annotations( + &self, + param_editgroup_id: String, + param_expand: Option<String>, + context: &C, + ) -> Result<GetEditgroupAnnotationsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/annotations", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)?; + Ok(GetEditgroupAnnotationsResponse::Success(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupAnnotationsResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupAnnotationsResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupAnnotationsResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupAnnotationsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupAnnotationsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editgroups_reviewable( + &self, + param_expand: Option<String>, + param_limit: Option<i64>, + param_before: Option<chrono::DateTime<chrono::Utc>>, + param_since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditgroupsReviewableResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/editgroup/reviewable", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + if let Some(param_before) = param_before { + query_string.append_pair("before", ¶m_before.to_string()); + } + if let Some(param_since) = param_since { + query_string.append_pair("since", ¶m_since.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::Editgroup>>(body)?; + Ok(GetEditgroupsReviewableResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupsReviewableResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupsReviewableResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditgroupsReviewableResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editor( + &self, + param_editor_id: String, + context: &C, + ) -> Result<GetEditorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editor/{editor_id}", + self.base_path, + editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editor>(body)?; + Ok(GetEditorResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editor_annotations( + &self, + param_editor_id: String, + param_limit: Option<i64>, + param_before: Option<chrono::DateTime<chrono::Utc>>, + param_since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditorAnnotationsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editor/{editor_id}/annotations", + self.base_path, + editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + if let Some(param_before) = param_before { + query_string.append_pair("before", ¶m_before.to_string()); + } + if let Some(param_since) = param_since { + query_string.append_pair("since", ¶m_since.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EditgroupAnnotation>>(body)?; + Ok(GetEditorAnnotationsResponse::Success(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorAnnotationsResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorAnnotationsResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorAnnotationsResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorAnnotationsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorAnnotationsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_editor_editgroups( + &self, + param_editor_id: String, + param_limit: Option<i64>, + param_before: Option<chrono::DateTime<chrono::Utc>>, + param_since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditorEditgroupsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editor/{editor_id}/editgroups", + self.base_path, + editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + if let Some(param_before) = param_before { + query_string.append_pair("before", ¶m_before.to_string()); + } + if let Some(param_since) = param_since { + query_string.append_pair("since", ¶m_since.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::Editgroup>>(body)?; + Ok(GetEditorEditgroupsResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorEditgroupsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorEditgroupsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetEditorEditgroupsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_file( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetFileResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/file/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::FileEntity>(body)?; + Ok(GetFileResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_file_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetFileEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/file/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetFileEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_file_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetFileHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/file/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetFileHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_file_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetFileRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/file/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetFileRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_file_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetFileRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/file/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::FileEntity>(body)?; + Ok(GetFileRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFileRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_fileset( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetFilesetResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/fileset/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::FilesetEntity>(body)?; + Ok(GetFilesetResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_fileset_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetFilesetEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/fileset/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetFilesetEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_fileset_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetFilesetHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/fileset/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetFilesetHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_fileset_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetFilesetRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/fileset/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetFilesetRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_fileset_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetFilesetRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/fileset/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::FilesetEntity>(body)?; + Ok(GetFilesetRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetFilesetRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetReleaseResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ReleaseEntity>(body)?; + Ok(GetReleaseResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetReleaseEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetReleaseEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_files( + &self, + param_ident: String, + param_hide: Option<String>, + context: &C, + ) -> Result<GetReleaseFilesResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}/files", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::FileEntity>>(body)?; + Ok(GetReleaseFilesResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_filesets( + &self, + param_ident: String, + param_hide: Option<String>, + context: &C, + ) -> Result<GetReleaseFilesetsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}/filesets", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::FilesetEntity>>(body)?; + Ok(GetReleaseFilesetsResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesetsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesetsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseFilesetsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetReleaseHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetReleaseHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetReleaseRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetReleaseRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetReleaseRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ReleaseEntity>(body)?; + Ok(GetReleaseRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_release_webcaptures( + &self, + param_ident: String, + param_hide: Option<String>, + context: &C, + ) -> Result<GetReleaseWebcapturesResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/release/{ident}/webcaptures", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::WebcaptureEntity>>(body)?; + Ok(GetReleaseWebcapturesResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseWebcapturesResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseWebcapturesResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetReleaseWebcapturesResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_webcapture( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetWebcaptureResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/webcapture/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::WebcaptureEntity>(body)?; + Ok(GetWebcaptureResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_webcapture_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetWebcaptureEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/webcapture/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetWebcaptureEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_webcapture_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetWebcaptureHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/webcapture/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetWebcaptureHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_webcapture_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetWebcaptureRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/webcapture/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetWebcaptureRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_webcapture_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetWebcaptureRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/webcapture/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::WebcaptureEntity>(body)?; + Ok(GetWebcaptureRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWebcaptureRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work( + &self, + param_ident: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetWorkResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/{ident}", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::WorkEntity>(body)?; + Ok(GetWorkResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work_edit( + &self, + param_edit_id: String, + context: &C, + ) -> Result<GetWorkEditResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/edit/{edit_id}", + self.base_path, + edit_id = utf8_percent_encode(¶m_edit_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(GetWorkEditResponse::FoundEdit(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkEditResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkEditResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkEditResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work_history( + &self, + param_ident: String, + param_limit: Option<i64>, + context: &C, + ) -> Result<GetWorkHistoryResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/{ident}/history", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_limit) = param_limit { + query_string.append_pair("limit", ¶m_limit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::EntityHistoryEntry>>(body)?; + Ok(GetWorkHistoryResponse::FoundEntityHistory(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkHistoryResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkHistoryResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkHistoryResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work_redirects( + &self, + param_ident: String, + context: &C, + ) -> Result<GetWorkRedirectsResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/{ident}/redirects", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<String>>(body)?; + Ok(GetWorkRedirectsResponse::FoundEntityRedirects(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRedirectsResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRedirectsResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRedirectsResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work_releases( + &self, + param_ident: String, + param_hide: Option<String>, + context: &C, + ) -> Result<GetWorkReleasesResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/{ident}/releases", + self.base_path, + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<Vec<models::ReleaseEntity>>(body)?; + Ok(GetWorkReleasesResponse::Found(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkReleasesResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkReleasesResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkReleasesResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn get_work_revision( + &self, + param_rev_id: String, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<GetWorkRevisionResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/work/rev/{rev_id}", + self.base_path, + rev_id = utf8_percent_encode(¶m_rev_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::WorkEntity>(body)?; + Ok(GetWorkRevisionResponse::FoundEntityRevision(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRevisionResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRevisionResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(GetWorkRevisionResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn lookup_container( + &self, + param_issnl: Option<String>, + param_wikidata_qid: Option<String>, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<LookupContainerResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/container/lookup", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_issnl) = param_issnl { + query_string.append_pair("issnl", ¶m_issnl.to_string()); + } + if let Some(param_wikidata_qid) = param_wikidata_qid { + query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string()); + } + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ContainerEntity>(body)?; + Ok(LookupContainerResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupContainerResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupContainerResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupContainerResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn lookup_creator( + &self, + param_orcid: Option<String>, + param_wikidata_qid: Option<String>, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<LookupCreatorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/creator/lookup", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_orcid) = param_orcid { + query_string.append_pair("orcid", ¶m_orcid.to_string()); + } + if let Some(param_wikidata_qid) = param_wikidata_qid { + query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string()); + } + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::CreatorEntity>(body)?; + Ok(LookupCreatorResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupCreatorResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupCreatorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupCreatorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn lookup_file( + &self, + param_md5: Option<String>, + param_sha1: Option<String>, + param_sha256: Option<String>, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<LookupFileResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/file/lookup", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_md5) = param_md5 { + query_string.append_pair("md5", ¶m_md5.to_string()); + } + if let Some(param_sha1) = param_sha1 { + query_string.append_pair("sha1", ¶m_sha1.to_string()); + } + if let Some(param_sha256) = param_sha256 { + query_string.append_pair("sha256", ¶m_sha256.to_string()); + } + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::FileEntity>(body)?; + Ok(LookupFileResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupFileResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupFileResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupFileResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn lookup_release( + &self, + param_doi: Option<String>, + param_wikidata_qid: Option<String>, + param_isbn13: Option<String>, + param_pmid: Option<String>, + param_pmcid: Option<String>, + param_core: Option<String>, + param_arxiv: Option<String>, + param_jstor: Option<String>, + param_ark: Option<String>, + param_mag: Option<String>, + param_doaj: Option<String>, + param_dblp: Option<String>, + param_oai: Option<String>, + param_expand: Option<String>, + param_hide: Option<String>, + context: &C, + ) -> Result<LookupReleaseResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!("{}/v0/release/lookup", self.base_path); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_doi) = param_doi { + query_string.append_pair("doi", ¶m_doi.to_string()); + } + if let Some(param_wikidata_qid) = param_wikidata_qid { + query_string.append_pair("wikidata_qid", ¶m_wikidata_qid.to_string()); + } + if let Some(param_isbn13) = param_isbn13 { + query_string.append_pair("isbn13", ¶m_isbn13.to_string()); + } + if let Some(param_pmid) = param_pmid { + query_string.append_pair("pmid", ¶m_pmid.to_string()); + } + if let Some(param_pmcid) = param_pmcid { + query_string.append_pair("pmcid", ¶m_pmcid.to_string()); + } + if let Some(param_core) = param_core { + query_string.append_pair("core", ¶m_core.to_string()); + } + if let Some(param_arxiv) = param_arxiv { + query_string.append_pair("arxiv", ¶m_arxiv.to_string()); + } + if let Some(param_jstor) = param_jstor { + query_string.append_pair("jstor", ¶m_jstor.to_string()); + } + if let Some(param_ark) = param_ark { + query_string.append_pair("ark", ¶m_ark.to_string()); + } + if let Some(param_mag) = param_mag { + query_string.append_pair("mag", ¶m_mag.to_string()); + } + if let Some(param_doaj) = param_doaj { + query_string.append_pair("doaj", ¶m_doaj.to_string()); + } + if let Some(param_dblp) = param_dblp { + query_string.append_pair("dblp", ¶m_dblp.to_string()); + } + if let Some(param_oai) = param_oai { + query_string.append_pair("oai", ¶m_oai.to_string()); + } + if let Some(param_expand) = param_expand { + query_string.append_pair("expand", ¶m_expand.to_string()); + } + if let Some(param_hide) = param_hide { + query_string.append_pair("hide", ¶m_hide.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("GET") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ReleaseEntity>(body)?; + Ok(LookupReleaseResponse::FoundEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupReleaseResponse::BadRequest(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupReleaseResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(LookupReleaseResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_container( + &self, + param_editgroup_id: String, + param_ident: String, + param_container_entity: models::ContainerEntity, + context: &C, + ) -> Result<UpdateContainerResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/container/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_container_entity) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateContainerResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateContainerResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateContainerResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateContainerResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateContainerResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateContainerResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_creator( + &self, + param_editgroup_id: String, + param_ident: String, + param_creator_entity: models::CreatorEntity, + context: &C, + ) -> Result<UpdateCreatorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/creator/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_creator_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateCreatorResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateCreatorResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateCreatorResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateCreatorResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateCreatorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateCreatorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_editgroup( + &self, + param_editgroup_id: String, + param_editgroup: models::Editgroup, + param_submit: Option<bool>, + context: &C, + ) -> Result<UpdateEditgroupResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + if let Some(param_submit) = param_submit { + query_string.append_pair("submit", ¶m_submit.to_string()); + } + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_editgroup).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editgroup>(body)?; + Ok(UpdateEditgroupResponse::UpdatedEditgroup(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditgroupResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditgroupResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditgroupResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditgroupResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditgroupResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_editor( + &self, + param_editor_id: String, + param_editor: models::Editor, + context: &C, + ) -> Result<UpdateEditorResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editor/{editor_id}", + self.base_path, + editor_id = utf8_percent_encode(¶m_editor_id.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_editor).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::Editor>(body)?; + Ok(UpdateEditorResponse::UpdatedEditor(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditorResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditorResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditorResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditorResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateEditorResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_file( + &self, + param_editgroup_id: String, + param_ident: String, + param_file_entity: models::FileEntity, + context: &C, + ) -> Result<UpdateFileResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/file/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_file_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateFileResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFileResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFileResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFileResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFileResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFileResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_fileset( + &self, + param_editgroup_id: String, + param_ident: String, + param_fileset_entity: models::FilesetEntity, + context: &C, + ) -> Result<UpdateFilesetResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/fileset/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_fileset_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateFilesetResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFilesetResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFilesetResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFilesetResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFilesetResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateFilesetResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_release( + &self, + param_editgroup_id: String, + param_ident: String, + param_release_entity: models::ReleaseEntity, + context: &C, + ) -> Result<UpdateReleaseResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/release/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_release_entity).expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateReleaseResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateReleaseResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateReleaseResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateReleaseResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateReleaseResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateReleaseResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_webcapture( + &self, + param_editgroup_id: String, + param_ident: String, + param_webcapture_entity: models::WebcaptureEntity, + context: &C, + ) -> Result<UpdateWebcaptureResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/webcapture/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = serde_json::to_string(¶m_webcapture_entity) + .expect("impossible to fail to serialize"); + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateWebcaptureResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWebcaptureResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWebcaptureResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWebcaptureResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWebcaptureResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWebcaptureResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } + + async fn update_work( + &self, + param_editgroup_id: String, + param_ident: String, + param_work_entity: models::WorkEntity, + context: &C, + ) -> Result<UpdateWorkResponse, ApiError> { + let mut client_service = self.client_service.clone(); + let mut uri = format!( + "{}/v0/editgroup/{editgroup_id}/work/{ident}", + self.base_path, + editgroup_id = utf8_percent_encode(¶m_editgroup_id.to_string(), ID_ENCODE_SET), + ident = utf8_percent_encode(¶m_ident.to_string(), ID_ENCODE_SET) + ); + + // Query parameters + let query_string = { + let mut query_string = form_urlencoded::Serializer::new("".to_owned()); + query_string.finish() + }; + if !query_string.is_empty() { + uri += "?"; + uri += &query_string; + } + + let uri = match Uri::from_str(&uri) { + Ok(uri) => uri, + Err(err) => return Err(ApiError(format!("Unable to build URI: {}", err))), + }; + + let mut request = match Request::builder() + .method("PUT") + .uri(uri) + .body(Body::empty()) + { + Ok(req) => req, + Err(e) => return Err(ApiError(format!("Unable to create request: {}", e))), + }; + + let body = + serde_json::to_string(¶m_work_entity).expect("impossible to fail to serialize"); + + *request.body_mut() = Body::from(body); + + let header = "application/json"; + request.headers_mut().insert( + CONTENT_TYPE, + match HeaderValue::from_str(header) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create header: {} - {}", + header, e + ))) + } + }, + ); + + let header = HeaderValue::from_str( + Has::<XSpanIdString>::get(context) + .0 + .clone() + .to_string() + .as_str(), + ); + request.headers_mut().insert( + HeaderName::from_static("x-span-id"), + match header { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create X-Span ID header value: {}", + e + ))) + } + }, + ); + + if let Some(auth_data) = Has::<Option<AuthData>>::get(context).as_ref() { + // Currently only authentication with Basic and Bearer are supported + match auth_data { + &AuthData::Bearer(ref bearer_header) => { + let auth = swagger::auth::Header(bearer_header.clone()); + let header = match HeaderValue::from_str(&format!("{}", auth)) { + Ok(h) => h, + Err(e) => { + return Err(ApiError(format!( + "Unable to create Authorization header: {}", + e + ))) + } + }; + request + .headers_mut() + .insert(hyper::header::AUTHORIZATION, header); + } + _ => {} + } + } + + let mut response = client_service + .call((request, context.clone())) + .map_err(|e| ApiError(format!("No response received: {}", e))) + .await?; + + match response.status().as_u16() { + 200 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::EntityEdit>(body)?; + Ok(UpdateWorkResponse::UpdatedEntity(body)) + } + 400 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWorkResponse::BadRequest(body)) + } + 401 => { + let response_www_authenticate = match response + .headers() + .get(HeaderName::from_static("www_authenticate")) + { + Some(response_www_authenticate) => { + let response_www_authenticate = response_www_authenticate.clone(); + let response_www_authenticate = match TryInto::< + header::IntoHeaderValue<String>, + >::try_into( + response_www_authenticate + ) { + Ok(value) => value, + Err(e) => { + return Err(ApiError(format!("Invalid response header WWW_Authenticate for response 401 - {}", e))); + } + }; + let response_www_authenticate = response_www_authenticate.0; + Some(response_www_authenticate) + } + None => None, + }; + + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWorkResponse::NotAuthorized { + body: body, + www_authenticate: response_www_authenticate, + }) + } + 403 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWorkResponse::Forbidden(body)) + } + 404 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWorkResponse::NotFound(body)) + } + 500 => { + let body = response.into_body(); + let body = body + .to_raw() + .map_err(|e| ApiError(format!("Failed to read response: {}", e))) + .await?; + let body = str::from_utf8(&body) + .map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))?; + let body = serde_json::from_str::<models::ErrorResponse>(body)?; + Ok(UpdateWorkResponse::GenericError(body)) + } + code => { + let headers = response.headers().clone(); + let body = response.into_body().take(100).to_raw().await; + Err(ApiError(format!( + "Unexpected response code {}:\n{:?}\n\n{}", + code, + headers, + match body { + Ok(body) => match String::from_utf8(body) { + Ok(body) => body, + Err(e) => format!("<Body was not UTF8: {:?}>", e), + }, + Err(e) => format!("<Failed to read body: {}>", e), + } + ))) + } + } + } +} diff --git a/fatcat-openapi/src/context.rs b/fatcat-openapi/src/context.rs new file mode 100644 index 0000000..d782855 --- /dev/null +++ b/fatcat-openapi/src/context.rs @@ -0,0 +1,120 @@ +use crate::Api; +use futures::future::BoxFuture; +use hyper::header::HeaderName; +use hyper::{service::Service, Error, Request, Response, StatusCode}; +use std::default::Default; +use std::io; +use std::marker::PhantomData; +use std::task::{Context, Poll}; +use swagger::auth::{AuthData, Authorization, Bearer, Scopes}; +use swagger::{EmptyContext, Has, Pop, Push, XSpanIdString}; +use url::form_urlencoded; + +pub struct MakeAddContext<T, A> { + inner: T, + marker: PhantomData<A>, +} + +impl<T, A, B, C, D> MakeAddContext<T, A> +where + A: Default + Push<XSpanIdString, Result = B>, + B: Push<Option<AuthData>, Result = C>, + C: Push<Option<Authorization>, Result = D>, +{ + pub fn new(inner: T) -> MakeAddContext<T, A> { + MakeAddContext { + inner, + marker: PhantomData, + } + } +} + +// Make a service that adds context. +impl<Target, T, A, B, C, D> Service<Target> for MakeAddContext<T, A> +where + Target: Send, + A: Default + Push<XSpanIdString, Result = B> + Send, + B: Push<Option<AuthData>, Result = C>, + C: Push<Option<Authorization>, Result = D>, + D: Send + 'static, + T: Service<Target> + Send, + T::Future: Send + 'static, +{ + type Error = T::Error; + type Response = AddContext<T::Response, A, B, C, D>; + type Future = BoxFuture<'static, Result<Self::Response, Self::Error>>; + + fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { + self.inner.poll_ready(cx) + } + + fn call(&mut self, target: Target) -> Self::Future { + let service = self.inner.call(target); + + Box::pin(async move { Ok(AddContext::new(service.await?)) }) + } +} + +/// Middleware to add context data from the request +pub struct AddContext<T, A, B, C, D> +where + A: Default + Push<XSpanIdString, Result = B>, + B: Push<Option<AuthData>, Result = C>, + C: Push<Option<Authorization>, Result = D>, +{ + inner: T, + marker: PhantomData<A>, +} + +impl<T, A, B, C, D> AddContext<T, A, B, C, D> +where + A: Default + Push<XSpanIdString, Result = B>, + B: Push<Option<AuthData>, Result = C>, + C: Push<Option<Authorization>, Result = D>, +{ + pub fn new(inner: T) -> Self { + AddContext { + inner, + marker: PhantomData, + } + } +} + +impl<T, A, B, C, D, ReqBody> Service<Request<ReqBody>> for AddContext<T, A, B, C, D> +where + A: Default + Push<XSpanIdString, Result = B>, + B: Push<Option<AuthData>, Result = C>, + C: Push<Option<Authorization>, Result = D>, + D: Send + 'static, + T: Service<(Request<ReqBody>, D)>, +{ + type Error = T::Error; + type Future = T::Future; + type Response = T::Response; + + fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { + self.inner.poll_ready(cx) + } + + fn call(&mut self, request: Request<ReqBody>) -> Self::Future { + let context = A::default().push(XSpanIdString::get_or_generate(&request)); + let headers = request.headers(); + + { + use std::ops::Deref; + use swagger::auth::Basic; + if let Some(basic) = swagger::auth::from_headers::<Basic>(&headers) { + let auth_data = AuthData::Basic(basic); + let context = context.push(Some(auth_data)); + let context = context.push(None::<Authorization>); + + return self.inner.call((request, context)); + } + } + + let context = context.push(None::<AuthData>); + let context = context.push(None::<Authorization>); + + self.inner.call((request, context)) + } +} diff --git a/fatcat-openapi/src/header.rs b/fatcat-openapi/src/header.rs new file mode 100644 index 0000000..7589ab0 --- /dev/null +++ b/fatcat-openapi/src/header.rs @@ -0,0 +1,197 @@ +use chrono::{DateTime, Utc}; +use hyper::header::HeaderValue; +use std::convert::TryFrom; +use std::fmt; +use std::ops::Deref; + +/// A struct to allow homogeneous conversion into a HeaderValue. We can't +/// implement the From/Into trait on HeaderValue because we don't own +/// either of the types. +#[derive(Debug, Clone)] +pub(crate) struct IntoHeaderValue<T>(pub T); + +// Generic implementations + +impl<T> Deref for IntoHeaderValue<T> { + type Target = T; + + fn deref(&self) -> &T { + &self.0 + } +} + +// Derive for each TryFrom<T> in hyper::header::HeaderValue + +macro_rules! ihv_generate { + ($t:ident) => { + impl TryFrom<HeaderValue> for IntoHeaderValue<$t> { + type Error = String; + + fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> { + match hdr_value.to_str() { + Ok(hdr_value) => match hdr_value.parse::<$t>() { + Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)), + Err(e) => Err(format!( + "Unable to parse {} as a string: {}", + stringify!($t), + e + )), + }, + Err(e) => Err(format!( + "Unable to parse header {:?} as a string - {}", + hdr_value, e + )), + } + } + } + + impl TryFrom<IntoHeaderValue<$t>> for HeaderValue { + type Error = String; + + fn try_from(hdr_value: IntoHeaderValue<$t>) -> Result<Self, Self::Error> { + Ok(hdr_value.0.into()) + } + } + }; +} + +ihv_generate!(u64); +ihv_generate!(i64); +ihv_generate!(i16); +ihv_generate!(u16); +ihv_generate!(u32); +ihv_generate!(usize); +ihv_generate!(isize); +ihv_generate!(i32); + +// Custom derivations + +// Vec<String> + +impl TryFrom<HeaderValue> for IntoHeaderValue<Vec<String>> { + type Error = String; + + fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> { + match hdr_value.to_str() { + Ok(hdr_value) => Ok(IntoHeaderValue( + hdr_value + .split(',') + .filter_map(|x| match x.trim() { + "" => None, + y => Some(y.to_string()), + }) + .collect(), + )), + Err(e) => Err(format!( + "Unable to parse header: {:?} as a string - {}", + hdr_value, e + )), + } + } +} + +impl TryFrom<IntoHeaderValue<Vec<String>>> for HeaderValue { + type Error = String; + + fn try_from(hdr_value: IntoHeaderValue<Vec<String>>) -> Result<Self, Self::Error> { + match HeaderValue::from_str(&hdr_value.0.join(", ")) { + Ok(hdr_value) => Ok(hdr_value), + Err(e) => Err(format!( + "Unable to convert {:?} into a header - {}", + hdr_value, e + )), + } + } +} + +// String + +impl TryFrom<HeaderValue> for IntoHeaderValue<String> { + type Error = String; + + fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> { + match hdr_value.to_str() { + Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value.to_string())), + Err(e) => Err(format!("Unable to convert header {:?} to {}", hdr_value, e)), + } + } +} + +impl TryFrom<IntoHeaderValue<String>> for HeaderValue { + type Error = String; + + fn try_from(hdr_value: IntoHeaderValue<String>) -> Result<Self, Self::Error> { + match HeaderValue::from_str(&hdr_value.0) { + Ok(hdr_value) => Ok(hdr_value), + Err(e) => Err(format!( + "Unable to convert {:?} from a header {}", + hdr_value, e + )), + } + } +} + +// bool +impl TryFrom<HeaderValue> for IntoHeaderValue<bool> { + type Error = String; + + fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> { + match hdr_value.to_str() { + Ok(hdr_value) => match hdr_value.parse() { + Ok(hdr_value) => Ok(IntoHeaderValue(hdr_value)), + Err(e) => Err(format!("Unable to parse bool from {} - {}", hdr_value, e)), + }, + Err(e) => Err(format!( + "Unable to convert {:?} from a header {}", + hdr_value, e + )), + } + } +} + +impl TryFrom<IntoHeaderValue<bool>> for HeaderValue { + type Error = String; + + fn try_from(hdr_value: IntoHeaderValue<bool>) -> Result<Self, Self::Error> { + match HeaderValue::from_str(&hdr_value.0.to_string()) { + Ok(hdr_value) => Ok(hdr_value), + Err(e) => Err(format!( + "Unable to convert: {:?} into a header: {}", + hdr_value, e + )), + } + } +} + +// DateTime + +impl TryFrom<HeaderValue> for IntoHeaderValue<DateTime<Utc>> { + type Error = String; + + fn try_from(hdr_value: HeaderValue) -> Result<Self, Self::Error> { + match hdr_value.to_str() { + Ok(hdr_value) => match DateTime::parse_from_rfc3339(hdr_value) { + Ok(date) => Ok(IntoHeaderValue(date.with_timezone(&Utc))), + Err(e) => Err(format!("Unable to parse: {} as date - {}", hdr_value, e)), + }, + Err(e) => Err(format!( + "Unable to convert header {:?} to string {}", + hdr_value, e + )), + } + } +} + +impl TryFrom<IntoHeaderValue<DateTime<Utc>>> for HeaderValue { + type Error = String; + + fn try_from(hdr_value: IntoHeaderValue<DateTime<Utc>>) -> Result<Self, Self::Error> { + match HeaderValue::from_str(hdr_value.0.to_rfc3339().as_str()) { + Ok(hdr_value) => Ok(hdr_value), + Err(e) => Err(format!( + "Unable to convert {:?} to a header: {}", + hdr_value, e + )), + } + } +} diff --git a/fatcat-openapi/src/lib.rs b/fatcat-openapi/src/lib.rs new file mode 100644 index 0000000..ba49f27 --- /dev/null +++ b/fatcat-openapi/src/lib.rs @@ -0,0 +1,3844 @@ +#![allow( + missing_docs, + trivial_casts, + unused_variables, + unused_mut, + unused_imports, + unused_extern_crates, + non_camel_case_types +)] + +use async_trait::async_trait; +use futures::Stream; +use std::error::Error; +use std::task::{Context, Poll}; +use swagger::{ApiError, ContextWrapper}; + +type ServiceError = Box<dyn Error + Send + Sync + 'static>; + +pub const BASE_PATH: &'static str = "/v0"; +pub const API_VERSION: &'static str = "0.3.3"; + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum AcceptEditgroupResponse { + /// Merged Successfully + MergedSuccessfully(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Edit Conflict + EditConflict(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum AuthCheckResponse { + /// Success + Success(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum AuthOidcResponse { + /// Found + Found(models::AuthOidcResult), + /// Created + Created(models::AuthOidcResult), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Conflict + Conflict(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateAuthTokenResponse { + /// Success + Success(models::AuthTokenResult), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateContainerResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateContainerAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateCreatorResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateCreatorAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateEditgroupResponse { + /// Successfully Created + SuccessfullyCreated(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateEditgroupAnnotationResponse { + /// Created + Created(models::EditgroupAnnotation), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateFileResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateFileAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateFilesetResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateFilesetAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateReleaseResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateReleaseAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateWebcaptureResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateWebcaptureAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateWorkResponse { + /// Created Entity + CreatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum CreateWorkAutoBatchResponse { + /// Created Editgroup + CreatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteContainerResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteContainerEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteCreatorResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteCreatorEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteFileResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteFileEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteFilesetResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteFilesetEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteReleaseResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteReleaseEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteWebcaptureResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteWebcaptureEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteWorkResponse { + /// Deleted Entity + DeletedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum DeleteWorkEditResponse { + /// Deleted Edit + DeletedEdit(models::Success), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetChangelogResponse { + /// Success + Success(Vec<models::ChangelogEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetChangelogEntryResponse { + /// Found Changelog Entry + FoundChangelogEntry(models::ChangelogEntry), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetContainerResponse { + /// Found Entity + FoundEntity(models::ContainerEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetContainerEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetContainerHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetContainerRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetContainerRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::ContainerEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorResponse { + /// Found Entity + FoundEntity(models::CreatorEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorReleasesResponse { + /// Found + Found(Vec<models::ReleaseEntity>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetCreatorRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::CreatorEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditgroupResponse { + /// Found + Found(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditgroupAnnotationsResponse { + /// Success + Success(Vec<models::EditgroupAnnotation>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditgroupsReviewableResponse { + /// Found + Found(Vec<models::Editgroup>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditorResponse { + /// Found + Found(models::Editor), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditorAnnotationsResponse { + /// Success + Success(Vec<models::EditgroupAnnotation>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetEditorEditgroupsResponse { + /// Found + Found(Vec<models::Editgroup>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFileResponse { + /// Found Entity + FoundEntity(models::FileEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFileEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFileHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFileRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFileRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::FileEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFilesetResponse { + /// Found Entity + FoundEntity(models::FilesetEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFilesetEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFilesetHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFilesetRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetFilesetRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::FilesetEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseResponse { + /// Found Entity + FoundEntity(models::ReleaseEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseFilesResponse { + /// Found + Found(Vec<models::FileEntity>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseFilesetsResponse { + /// Found + Found(Vec<models::FilesetEntity>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::ReleaseEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetReleaseWebcapturesResponse { + /// Found + Found(Vec<models::WebcaptureEntity>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWebcaptureResponse { + /// Found Entity + FoundEntity(models::WebcaptureEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWebcaptureEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWebcaptureHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWebcaptureRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWebcaptureRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::WebcaptureEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkResponse { + /// Found Entity + FoundEntity(models::WorkEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkEditResponse { + /// Found Edit + FoundEdit(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkHistoryResponse { + /// Found Entity History + FoundEntityHistory(Vec<models::EntityHistoryEntry>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkRedirectsResponse { + /// Found Entity Redirects + FoundEntityRedirects(Vec<String>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkReleasesResponse { + /// Found + Found(Vec<models::ReleaseEntity>), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum GetWorkRevisionResponse { + /// Found Entity Revision + FoundEntityRevision(models::WorkEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum LookupContainerResponse { + /// Found Entity + FoundEntity(models::ContainerEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum LookupCreatorResponse { + /// Found Entity + FoundEntity(models::CreatorEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum LookupFileResponse { + /// Found Entity + FoundEntity(models::FileEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum LookupReleaseResponse { + /// Found Entity + FoundEntity(models::ReleaseEntity), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateContainerResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateCreatorResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateEditgroupResponse { + /// Updated Editgroup + UpdatedEditgroup(models::Editgroup), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateEditorResponse { + /// Updated Editor + UpdatedEditor(models::Editor), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateFileResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateFilesetResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateReleaseResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateWebcaptureResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +#[derive(Debug, PartialEq)] +#[must_use] +pub enum UpdateWorkResponse { + /// Updated Entity + UpdatedEntity(models::EntityEdit), + /// Bad Request + BadRequest(models::ErrorResponse), + /// Not Authorized + NotAuthorized { + body: models::ErrorResponse, + www_authenticate: Option<String>, + }, + /// Forbidden + Forbidden(models::ErrorResponse), + /// Not Found + NotFound(models::ErrorResponse), + /// Generic Error + GenericError(models::ErrorResponse), +} + +/// API +#[async_trait] +pub trait Api<C: Send + Sync> { + fn poll_ready( + &self, + _cx: &mut Context, + ) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>> { + Poll::Ready(Ok(())) + } + + async fn accept_editgroup( + &self, + editgroup_id: String, + context: &C, + ) -> Result<AcceptEditgroupResponse, ApiError>; + + async fn auth_check( + &self, + role: Option<String>, + context: &C, + ) -> Result<AuthCheckResponse, ApiError>; + + async fn auth_oidc( + &self, + auth_oidc: models::AuthOidc, + context: &C, + ) -> Result<AuthOidcResponse, ApiError>; + + async fn create_auth_token( + &self, + editor_id: String, + duration_seconds: Option<i32>, + context: &C, + ) -> Result<CreateAuthTokenResponse, ApiError>; + + async fn create_container( + &self, + editgroup_id: String, + container_entity: models::ContainerEntity, + context: &C, + ) -> Result<CreateContainerResponse, ApiError>; + + async fn create_container_auto_batch( + &self, + container_auto_batch: models::ContainerAutoBatch, + context: &C, + ) -> Result<CreateContainerAutoBatchResponse, ApiError>; + + async fn create_creator( + &self, + editgroup_id: String, + creator_entity: models::CreatorEntity, + context: &C, + ) -> Result<CreateCreatorResponse, ApiError>; + + async fn create_creator_auto_batch( + &self, + creator_auto_batch: models::CreatorAutoBatch, + context: &C, + ) -> Result<CreateCreatorAutoBatchResponse, ApiError>; + + async fn create_editgroup( + &self, + editgroup: models::Editgroup, + context: &C, + ) -> Result<CreateEditgroupResponse, ApiError>; + + async fn create_editgroup_annotation( + &self, + editgroup_id: String, + editgroup_annotation: models::EditgroupAnnotation, + context: &C, + ) -> Result<CreateEditgroupAnnotationResponse, ApiError>; + + async fn create_file( + &self, + editgroup_id: String, + file_entity: models::FileEntity, + context: &C, + ) -> Result<CreateFileResponse, ApiError>; + + async fn create_file_auto_batch( + &self, + file_auto_batch: models::FileAutoBatch, + context: &C, + ) -> Result<CreateFileAutoBatchResponse, ApiError>; + + async fn create_fileset( + &self, + editgroup_id: String, + fileset_entity: models::FilesetEntity, + context: &C, + ) -> Result<CreateFilesetResponse, ApiError>; + + async fn create_fileset_auto_batch( + &self, + fileset_auto_batch: models::FilesetAutoBatch, + context: &C, + ) -> Result<CreateFilesetAutoBatchResponse, ApiError>; + + async fn create_release( + &self, + editgroup_id: String, + release_entity: models::ReleaseEntity, + context: &C, + ) -> Result<CreateReleaseResponse, ApiError>; + + async fn create_release_auto_batch( + &self, + release_auto_batch: models::ReleaseAutoBatch, + context: &C, + ) -> Result<CreateReleaseAutoBatchResponse, ApiError>; + + async fn create_webcapture( + &self, + editgroup_id: String, + webcapture_entity: models::WebcaptureEntity, + context: &C, + ) -> Result<CreateWebcaptureResponse, ApiError>; + + async fn create_webcapture_auto_batch( + &self, + webcapture_auto_batch: models::WebcaptureAutoBatch, + context: &C, + ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError>; + + async fn create_work( + &self, + editgroup_id: String, + work_entity: models::WorkEntity, + context: &C, + ) -> Result<CreateWorkResponse, ApiError>; + + async fn create_work_auto_batch( + &self, + work_auto_batch: models::WorkAutoBatch, + context: &C, + ) -> Result<CreateWorkAutoBatchResponse, ApiError>; + + async fn delete_container( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteContainerResponse, ApiError>; + + async fn delete_container_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteContainerEditResponse, ApiError>; + + async fn delete_creator( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteCreatorResponse, ApiError>; + + async fn delete_creator_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteCreatorEditResponse, ApiError>; + + async fn delete_file( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteFileResponse, ApiError>; + + async fn delete_file_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteFileEditResponse, ApiError>; + + async fn delete_fileset( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteFilesetResponse, ApiError>; + + async fn delete_fileset_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteFilesetEditResponse, ApiError>; + + async fn delete_release( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteReleaseResponse, ApiError>; + + async fn delete_release_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteReleaseEditResponse, ApiError>; + + async fn delete_webcapture( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteWebcaptureResponse, ApiError>; + + async fn delete_webcapture_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteWebcaptureEditResponse, ApiError>; + + async fn delete_work( + &self, + editgroup_id: String, + ident: String, + context: &C, + ) -> Result<DeleteWorkResponse, ApiError>; + + async fn delete_work_edit( + &self, + editgroup_id: String, + edit_id: String, + context: &C, + ) -> Result<DeleteWorkEditResponse, ApiError>; + + async fn get_changelog( + &self, + limit: Option<i64>, + context: &C, + ) -> Result<GetChangelogResponse, ApiError>; + + async fn get_changelog_entry( + &self, + index: i64, + context: &C, + ) -> Result<GetChangelogEntryResponse, ApiError>; + + async fn get_container( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetContainerResponse, ApiError>; + + async fn get_container_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetContainerEditResponse, ApiError>; + + async fn get_container_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetContainerHistoryResponse, ApiError>; + + async fn get_container_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetContainerRedirectsResponse, ApiError>; + + async fn get_container_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetContainerRevisionResponse, ApiError>; + + async fn get_creator( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetCreatorResponse, ApiError>; + + async fn get_creator_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetCreatorEditResponse, ApiError>; + + async fn get_creator_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetCreatorHistoryResponse, ApiError>; + + async fn get_creator_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetCreatorRedirectsResponse, ApiError>; + + async fn get_creator_releases( + &self, + ident: String, + hide: Option<String>, + context: &C, + ) -> Result<GetCreatorReleasesResponse, ApiError>; + + async fn get_creator_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetCreatorRevisionResponse, ApiError>; + + async fn get_editgroup( + &self, + editgroup_id: String, + context: &C, + ) -> Result<GetEditgroupResponse, ApiError>; + + async fn get_editgroup_annotations( + &self, + editgroup_id: String, + expand: Option<String>, + context: &C, + ) -> Result<GetEditgroupAnnotationsResponse, ApiError>; + + async fn get_editgroups_reviewable( + &self, + expand: Option<String>, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditgroupsReviewableResponse, ApiError>; + + async fn get_editor( + &self, + editor_id: String, + context: &C, + ) -> Result<GetEditorResponse, ApiError>; + + async fn get_editor_annotations( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditorAnnotationsResponse, ApiError>; + + async fn get_editor_editgroups( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + context: &C, + ) -> Result<GetEditorEditgroupsResponse, ApiError>; + + async fn get_file( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetFileResponse, ApiError>; + + async fn get_file_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetFileEditResponse, ApiError>; + + async fn get_file_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetFileHistoryResponse, ApiError>; + + async fn get_file_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetFileRedirectsResponse, ApiError>; + + async fn get_file_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetFileRevisionResponse, ApiError>; + + async fn get_fileset( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetFilesetResponse, ApiError>; + + async fn get_fileset_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetFilesetEditResponse, ApiError>; + + async fn get_fileset_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetFilesetHistoryResponse, ApiError>; + + async fn get_fileset_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetFilesetRedirectsResponse, ApiError>; + + async fn get_fileset_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetFilesetRevisionResponse, ApiError>; + + async fn get_release( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetReleaseResponse, ApiError>; + + async fn get_release_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetReleaseEditResponse, ApiError>; + + async fn get_release_files( + &self, + ident: String, + hide: Option<String>, + context: &C, + ) -> Result<GetReleaseFilesResponse, ApiError>; + + async fn get_release_filesets( + &self, + ident: String, + hide: Option<String>, + context: &C, + ) -> Result<GetReleaseFilesetsResponse, ApiError>; + + async fn get_release_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetReleaseHistoryResponse, ApiError>; + + async fn get_release_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetReleaseRedirectsResponse, ApiError>; + + async fn get_release_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetReleaseRevisionResponse, ApiError>; + + async fn get_release_webcaptures( + &self, + ident: String, + hide: Option<String>, + context: &C, + ) -> Result<GetReleaseWebcapturesResponse, ApiError>; + + async fn get_webcapture( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetWebcaptureResponse, ApiError>; + + async fn get_webcapture_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetWebcaptureEditResponse, ApiError>; + + async fn get_webcapture_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetWebcaptureHistoryResponse, ApiError>; + + async fn get_webcapture_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetWebcaptureRedirectsResponse, ApiError>; + + async fn get_webcapture_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetWebcaptureRevisionResponse, ApiError>; + + async fn get_work( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetWorkResponse, ApiError>; + + async fn get_work_edit( + &self, + edit_id: String, + context: &C, + ) -> Result<GetWorkEditResponse, ApiError>; + + async fn get_work_history( + &self, + ident: String, + limit: Option<i64>, + context: &C, + ) -> Result<GetWorkHistoryResponse, ApiError>; + + async fn get_work_redirects( + &self, + ident: String, + context: &C, + ) -> Result<GetWorkRedirectsResponse, ApiError>; + + async fn get_work_releases( + &self, + ident: String, + hide: Option<String>, + context: &C, + ) -> Result<GetWorkReleasesResponse, ApiError>; + + async fn get_work_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<GetWorkRevisionResponse, ApiError>; + + async fn lookup_container( + &self, + issnl: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<LookupContainerResponse, ApiError>; + + async fn lookup_creator( + &self, + orcid: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<LookupCreatorResponse, ApiError>; + + async fn lookup_file( + &self, + md5: Option<String>, + sha1: Option<String>, + sha256: Option<String>, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<LookupFileResponse, ApiError>; + + async fn lookup_release( + &self, + doi: Option<String>, + wikidata_qid: Option<String>, + isbn13: Option<String>, + pmid: Option<String>, + pmcid: Option<String>, + core: Option<String>, + arxiv: Option<String>, + jstor: Option<String>, + ark: Option<String>, + mag: Option<String>, + doaj: Option<String>, + dblp: Option<String>, + oai: Option<String>, + expand: Option<String>, + hide: Option<String>, + context: &C, + ) -> Result<LookupReleaseResponse, ApiError>; + + async fn update_container( + &self, + editgroup_id: String, + ident: String, + container_entity: models::ContainerEntity, + context: &C, + ) -> Result<UpdateContainerResponse, ApiError>; + + async fn update_creator( + &self, + editgroup_id: String, + ident: String, + creator_entity: models::CreatorEntity, + context: &C, + ) -> Result<UpdateCreatorResponse, ApiError>; + + async fn update_editgroup( + &self, + editgroup_id: String, + editgroup: models::Editgroup, + submit: Option<bool>, + context: &C, + ) -> Result<UpdateEditgroupResponse, ApiError>; + + async fn update_editor( + &self, + editor_id: String, + editor: models::Editor, + context: &C, + ) -> Result<UpdateEditorResponse, ApiError>; + + async fn update_file( + &self, + editgroup_id: String, + ident: String, + file_entity: models::FileEntity, + context: &C, + ) -> Result<UpdateFileResponse, ApiError>; + + async fn update_fileset( + &self, + editgroup_id: String, + ident: String, + fileset_entity: models::FilesetEntity, + context: &C, + ) -> Result<UpdateFilesetResponse, ApiError>; + + async fn update_release( + &self, + editgroup_id: String, + ident: String, + release_entity: models::ReleaseEntity, + context: &C, + ) -> Result<UpdateReleaseResponse, ApiError>; + + async fn update_webcapture( + &self, + editgroup_id: String, + ident: String, + webcapture_entity: models::WebcaptureEntity, + context: &C, + ) -> Result<UpdateWebcaptureResponse, ApiError>; + + async fn update_work( + &self, + editgroup_id: String, + ident: String, + work_entity: models::WorkEntity, + context: &C, + ) -> Result<UpdateWorkResponse, ApiError>; +} + +/// API where `Context` isn't passed on every API call +#[async_trait] +pub trait ApiNoContext<C: Send + Sync> { + fn poll_ready( + &self, + _cx: &mut Context, + ) -> Poll<Result<(), Box<dyn Error + Send + Sync + 'static>>>; + + fn context(&self) -> &C; + + async fn accept_editgroup( + &self, + editgroup_id: String, + ) -> Result<AcceptEditgroupResponse, ApiError>; + + async fn auth_check(&self, role: Option<String>) -> Result<AuthCheckResponse, ApiError>; + + async fn auth_oidc(&self, auth_oidc: models::AuthOidc) -> Result<AuthOidcResponse, ApiError>; + + async fn create_auth_token( + &self, + editor_id: String, + duration_seconds: Option<i32>, + ) -> Result<CreateAuthTokenResponse, ApiError>; + + async fn create_container( + &self, + editgroup_id: String, + container_entity: models::ContainerEntity, + ) -> Result<CreateContainerResponse, ApiError>; + + async fn create_container_auto_batch( + &self, + container_auto_batch: models::ContainerAutoBatch, + ) -> Result<CreateContainerAutoBatchResponse, ApiError>; + + async fn create_creator( + &self, + editgroup_id: String, + creator_entity: models::CreatorEntity, + ) -> Result<CreateCreatorResponse, ApiError>; + + async fn create_creator_auto_batch( + &self, + creator_auto_batch: models::CreatorAutoBatch, + ) -> Result<CreateCreatorAutoBatchResponse, ApiError>; + + async fn create_editgroup( + &self, + editgroup: models::Editgroup, + ) -> Result<CreateEditgroupResponse, ApiError>; + + async fn create_editgroup_annotation( + &self, + editgroup_id: String, + editgroup_annotation: models::EditgroupAnnotation, + ) -> Result<CreateEditgroupAnnotationResponse, ApiError>; + + async fn create_file( + &self, + editgroup_id: String, + file_entity: models::FileEntity, + ) -> Result<CreateFileResponse, ApiError>; + + async fn create_file_auto_batch( + &self, + file_auto_batch: models::FileAutoBatch, + ) -> Result<CreateFileAutoBatchResponse, ApiError>; + + async fn create_fileset( + &self, + editgroup_id: String, + fileset_entity: models::FilesetEntity, + ) -> Result<CreateFilesetResponse, ApiError>; + + async fn create_fileset_auto_batch( + &self, + fileset_auto_batch: models::FilesetAutoBatch, + ) -> Result<CreateFilesetAutoBatchResponse, ApiError>; + + async fn create_release( + &self, + editgroup_id: String, + release_entity: models::ReleaseEntity, + ) -> Result<CreateReleaseResponse, ApiError>; + + async fn create_release_auto_batch( + &self, + release_auto_batch: models::ReleaseAutoBatch, + ) -> Result<CreateReleaseAutoBatchResponse, ApiError>; + + async fn create_webcapture( + &self, + editgroup_id: String, + webcapture_entity: models::WebcaptureEntity, + ) -> Result<CreateWebcaptureResponse, ApiError>; + + async fn create_webcapture_auto_batch( + &self, + webcapture_auto_batch: models::WebcaptureAutoBatch, + ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError>; + + async fn create_work( + &self, + editgroup_id: String, + work_entity: models::WorkEntity, + ) -> Result<CreateWorkResponse, ApiError>; + + async fn create_work_auto_batch( + &self, + work_auto_batch: models::WorkAutoBatch, + ) -> Result<CreateWorkAutoBatchResponse, ApiError>; + + async fn delete_container( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteContainerResponse, ApiError>; + + async fn delete_container_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteContainerEditResponse, ApiError>; + + async fn delete_creator( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteCreatorResponse, ApiError>; + + async fn delete_creator_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteCreatorEditResponse, ApiError>; + + async fn delete_file( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteFileResponse, ApiError>; + + async fn delete_file_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteFileEditResponse, ApiError>; + + async fn delete_fileset( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteFilesetResponse, ApiError>; + + async fn delete_fileset_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteFilesetEditResponse, ApiError>; + + async fn delete_release( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteReleaseResponse, ApiError>; + + async fn delete_release_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteReleaseEditResponse, ApiError>; + + async fn delete_webcapture( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteWebcaptureResponse, ApiError>; + + async fn delete_webcapture_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteWebcaptureEditResponse, ApiError>; + + async fn delete_work( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteWorkResponse, ApiError>; + + async fn delete_work_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteWorkEditResponse, ApiError>; + + async fn get_changelog(&self, limit: Option<i64>) -> Result<GetChangelogResponse, ApiError>; + + async fn get_changelog_entry(&self, index: i64) -> Result<GetChangelogEntryResponse, ApiError>; + + async fn get_container( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetContainerResponse, ApiError>; + + async fn get_container_edit( + &self, + edit_id: String, + ) -> Result<GetContainerEditResponse, ApiError>; + + async fn get_container_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetContainerHistoryResponse, ApiError>; + + async fn get_container_redirects( + &self, + ident: String, + ) -> Result<GetContainerRedirectsResponse, ApiError>; + + async fn get_container_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetContainerRevisionResponse, ApiError>; + + async fn get_creator( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetCreatorResponse, ApiError>; + + async fn get_creator_edit(&self, edit_id: String) -> Result<GetCreatorEditResponse, ApiError>; + + async fn get_creator_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetCreatorHistoryResponse, ApiError>; + + async fn get_creator_redirects( + &self, + ident: String, + ) -> Result<GetCreatorRedirectsResponse, ApiError>; + + async fn get_creator_releases( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetCreatorReleasesResponse, ApiError>; + + async fn get_creator_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetCreatorRevisionResponse, ApiError>; + + async fn get_editgroup(&self, editgroup_id: String) -> Result<GetEditgroupResponse, ApiError>; + + async fn get_editgroup_annotations( + &self, + editgroup_id: String, + expand: Option<String>, + ) -> Result<GetEditgroupAnnotationsResponse, ApiError>; + + async fn get_editgroups_reviewable( + &self, + expand: Option<String>, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditgroupsReviewableResponse, ApiError>; + + async fn get_editor(&self, editor_id: String) -> Result<GetEditorResponse, ApiError>; + + async fn get_editor_annotations( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditorAnnotationsResponse, ApiError>; + + async fn get_editor_editgroups( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditorEditgroupsResponse, ApiError>; + + async fn get_file( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFileResponse, ApiError>; + + async fn get_file_edit(&self, edit_id: String) -> Result<GetFileEditResponse, ApiError>; + + async fn get_file_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetFileHistoryResponse, ApiError>; + + async fn get_file_redirects(&self, ident: String) + -> Result<GetFileRedirectsResponse, ApiError>; + + async fn get_file_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFileRevisionResponse, ApiError>; + + async fn get_fileset( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFilesetResponse, ApiError>; + + async fn get_fileset_edit(&self, edit_id: String) -> Result<GetFilesetEditResponse, ApiError>; + + async fn get_fileset_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetFilesetHistoryResponse, ApiError>; + + async fn get_fileset_redirects( + &self, + ident: String, + ) -> Result<GetFilesetRedirectsResponse, ApiError>; + + async fn get_fileset_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFilesetRevisionResponse, ApiError>; + + async fn get_release( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetReleaseResponse, ApiError>; + + async fn get_release_edit(&self, edit_id: String) -> Result<GetReleaseEditResponse, ApiError>; + + async fn get_release_files( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseFilesResponse, ApiError>; + + async fn get_release_filesets( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseFilesetsResponse, ApiError>; + + async fn get_release_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetReleaseHistoryResponse, ApiError>; + + async fn get_release_redirects( + &self, + ident: String, + ) -> Result<GetReleaseRedirectsResponse, ApiError>; + + async fn get_release_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetReleaseRevisionResponse, ApiError>; + + async fn get_release_webcaptures( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseWebcapturesResponse, ApiError>; + + async fn get_webcapture( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWebcaptureResponse, ApiError>; + + async fn get_webcapture_edit( + &self, + edit_id: String, + ) -> Result<GetWebcaptureEditResponse, ApiError>; + + async fn get_webcapture_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetWebcaptureHistoryResponse, ApiError>; + + async fn get_webcapture_redirects( + &self, + ident: String, + ) -> Result<GetWebcaptureRedirectsResponse, ApiError>; + + async fn get_webcapture_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWebcaptureRevisionResponse, ApiError>; + + async fn get_work( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWorkResponse, ApiError>; + + async fn get_work_edit(&self, edit_id: String) -> Result<GetWorkEditResponse, ApiError>; + + async fn get_work_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetWorkHistoryResponse, ApiError>; + + async fn get_work_redirects(&self, ident: String) + -> Result<GetWorkRedirectsResponse, ApiError>; + + async fn get_work_releases( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetWorkReleasesResponse, ApiError>; + + async fn get_work_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWorkRevisionResponse, ApiError>; + + async fn lookup_container( + &self, + issnl: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupContainerResponse, ApiError>; + + async fn lookup_creator( + &self, + orcid: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupCreatorResponse, ApiError>; + + async fn lookup_file( + &self, + md5: Option<String>, + sha1: Option<String>, + sha256: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupFileResponse, ApiError>; + + async fn lookup_release( + &self, + doi: Option<String>, + wikidata_qid: Option<String>, + isbn13: Option<String>, + pmid: Option<String>, + pmcid: Option<String>, + core: Option<String>, + arxiv: Option<String>, + jstor: Option<String>, + ark: Option<String>, + mag: Option<String>, + doaj: Option<String>, + dblp: Option<String>, + oai: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupReleaseResponse, ApiError>; + + async fn update_container( + &self, + editgroup_id: String, + ident: String, + container_entity: models::ContainerEntity, + ) -> Result<UpdateContainerResponse, ApiError>; + + async fn update_creator( + &self, + editgroup_id: String, + ident: String, + creator_entity: models::CreatorEntity, + ) -> Result<UpdateCreatorResponse, ApiError>; + + async fn update_editgroup( + &self, + editgroup_id: String, + editgroup: models::Editgroup, + submit: Option<bool>, + ) -> Result<UpdateEditgroupResponse, ApiError>; + + async fn update_editor( + &self, + editor_id: String, + editor: models::Editor, + ) -> Result<UpdateEditorResponse, ApiError>; + + async fn update_file( + &self, + editgroup_id: String, + ident: String, + file_entity: models::FileEntity, + ) -> Result<UpdateFileResponse, ApiError>; + + async fn update_fileset( + &self, + editgroup_id: String, + ident: String, + fileset_entity: models::FilesetEntity, + ) -> Result<UpdateFilesetResponse, ApiError>; + + async fn update_release( + &self, + editgroup_id: String, + ident: String, + release_entity: models::ReleaseEntity, + ) -> Result<UpdateReleaseResponse, ApiError>; + + async fn update_webcapture( + &self, + editgroup_id: String, + ident: String, + webcapture_entity: models::WebcaptureEntity, + ) -> Result<UpdateWebcaptureResponse, ApiError>; + + async fn update_work( + &self, + editgroup_id: String, + ident: String, + work_entity: models::WorkEntity, + ) -> Result<UpdateWorkResponse, ApiError>; +} + +/// Trait to extend an API to make it easy to bind it to a context. +pub trait ContextWrapperExt<C: Send + Sync> +where + Self: Sized, +{ + /// Binds this API to a context. + fn with_context(self: Self, context: C) -> ContextWrapper<Self, C>; +} + +impl<T: Api<C> + Send + Sync, C: Clone + Send + Sync> ContextWrapperExt<C> for T { + fn with_context(self: T, context: C) -> ContextWrapper<T, C> { + ContextWrapper::<T, C>::new(self, context) + } +} + +#[async_trait] +impl<T: Api<C> + Send + Sync, C: Clone + Send + Sync> ApiNoContext<C> for ContextWrapper<T, C> { + fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), ServiceError>> { + self.api().poll_ready(cx) + } + + fn context(&self) -> &C { + ContextWrapper::context(self) + } + + async fn accept_editgroup( + &self, + editgroup_id: String, + ) -> Result<AcceptEditgroupResponse, ApiError> { + let context = self.context().clone(); + self.api().accept_editgroup(editgroup_id, &context).await + } + + async fn auth_check(&self, role: Option<String>) -> Result<AuthCheckResponse, ApiError> { + let context = self.context().clone(); + self.api().auth_check(role, &context).await + } + + async fn auth_oidc(&self, auth_oidc: models::AuthOidc) -> Result<AuthOidcResponse, ApiError> { + let context = self.context().clone(); + self.api().auth_oidc(auth_oidc, &context).await + } + + async fn create_auth_token( + &self, + editor_id: String, + duration_seconds: Option<i32>, + ) -> Result<CreateAuthTokenResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_auth_token(editor_id, duration_seconds, &context) + .await + } + + async fn create_container( + &self, + editgroup_id: String, + container_entity: models::ContainerEntity, + ) -> Result<CreateContainerResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_container(editgroup_id, container_entity, &context) + .await + } + + async fn create_container_auto_batch( + &self, + container_auto_batch: models::ContainerAutoBatch, + ) -> Result<CreateContainerAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_container_auto_batch(container_auto_batch, &context) + .await + } + + async fn create_creator( + &self, + editgroup_id: String, + creator_entity: models::CreatorEntity, + ) -> Result<CreateCreatorResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_creator(editgroup_id, creator_entity, &context) + .await + } + + async fn create_creator_auto_batch( + &self, + creator_auto_batch: models::CreatorAutoBatch, + ) -> Result<CreateCreatorAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_creator_auto_batch(creator_auto_batch, &context) + .await + } + + async fn create_editgroup( + &self, + editgroup: models::Editgroup, + ) -> Result<CreateEditgroupResponse, ApiError> { + let context = self.context().clone(); + self.api().create_editgroup(editgroup, &context).await + } + + async fn create_editgroup_annotation( + &self, + editgroup_id: String, + editgroup_annotation: models::EditgroupAnnotation, + ) -> Result<CreateEditgroupAnnotationResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_editgroup_annotation(editgroup_id, editgroup_annotation, &context) + .await + } + + async fn create_file( + &self, + editgroup_id: String, + file_entity: models::FileEntity, + ) -> Result<CreateFileResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_file(editgroup_id, file_entity, &context) + .await + } + + async fn create_file_auto_batch( + &self, + file_auto_batch: models::FileAutoBatch, + ) -> Result<CreateFileAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_file_auto_batch(file_auto_batch, &context) + .await + } + + async fn create_fileset( + &self, + editgroup_id: String, + fileset_entity: models::FilesetEntity, + ) -> Result<CreateFilesetResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_fileset(editgroup_id, fileset_entity, &context) + .await + } + + async fn create_fileset_auto_batch( + &self, + fileset_auto_batch: models::FilesetAutoBatch, + ) -> Result<CreateFilesetAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_fileset_auto_batch(fileset_auto_batch, &context) + .await + } + + async fn create_release( + &self, + editgroup_id: String, + release_entity: models::ReleaseEntity, + ) -> Result<CreateReleaseResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_release(editgroup_id, release_entity, &context) + .await + } + + async fn create_release_auto_batch( + &self, + release_auto_batch: models::ReleaseAutoBatch, + ) -> Result<CreateReleaseAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_release_auto_batch(release_auto_batch, &context) + .await + } + + async fn create_webcapture( + &self, + editgroup_id: String, + webcapture_entity: models::WebcaptureEntity, + ) -> Result<CreateWebcaptureResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_webcapture(editgroup_id, webcapture_entity, &context) + .await + } + + async fn create_webcapture_auto_batch( + &self, + webcapture_auto_batch: models::WebcaptureAutoBatch, + ) -> Result<CreateWebcaptureAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_webcapture_auto_batch(webcapture_auto_batch, &context) + .await + } + + async fn create_work( + &self, + editgroup_id: String, + work_entity: models::WorkEntity, + ) -> Result<CreateWorkResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_work(editgroup_id, work_entity, &context) + .await + } + + async fn create_work_auto_batch( + &self, + work_auto_batch: models::WorkAutoBatch, + ) -> Result<CreateWorkAutoBatchResponse, ApiError> { + let context = self.context().clone(); + self.api() + .create_work_auto_batch(work_auto_batch, &context) + .await + } + + async fn delete_container( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteContainerResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_container(editgroup_id, ident, &context) + .await + } + + async fn delete_container_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteContainerEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_container_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_creator( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteCreatorResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_creator(editgroup_id, ident, &context) + .await + } + + async fn delete_creator_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteCreatorEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_creator_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_file( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteFileResponse, ApiError> { + let context = self.context().clone(); + self.api().delete_file(editgroup_id, ident, &context).await + } + + async fn delete_file_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteFileEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_file_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_fileset( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteFilesetResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_fileset(editgroup_id, ident, &context) + .await + } + + async fn delete_fileset_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteFilesetEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_fileset_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_release( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteReleaseResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_release(editgroup_id, ident, &context) + .await + } + + async fn delete_release_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteReleaseEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_release_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_webcapture( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteWebcaptureResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_webcapture(editgroup_id, ident, &context) + .await + } + + async fn delete_webcapture_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteWebcaptureEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_webcapture_edit(editgroup_id, edit_id, &context) + .await + } + + async fn delete_work( + &self, + editgroup_id: String, + ident: String, + ) -> Result<DeleteWorkResponse, ApiError> { + let context = self.context().clone(); + self.api().delete_work(editgroup_id, ident, &context).await + } + + async fn delete_work_edit( + &self, + editgroup_id: String, + edit_id: String, + ) -> Result<DeleteWorkEditResponse, ApiError> { + let context = self.context().clone(); + self.api() + .delete_work_edit(editgroup_id, edit_id, &context) + .await + } + + async fn get_changelog(&self, limit: Option<i64>) -> Result<GetChangelogResponse, ApiError> { + let context = self.context().clone(); + self.api().get_changelog(limit, &context).await + } + + async fn get_changelog_entry(&self, index: i64) -> Result<GetChangelogEntryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_changelog_entry(index, &context).await + } + + async fn get_container( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetContainerResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_container(ident, expand, hide, &context) + .await + } + + async fn get_container_edit( + &self, + edit_id: String, + ) -> Result<GetContainerEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_container_edit(edit_id, &context).await + } + + async fn get_container_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetContainerHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_container_history(ident, limit, &context) + .await + } + + async fn get_container_redirects( + &self, + ident: String, + ) -> Result<GetContainerRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_container_redirects(ident, &context).await + } + + async fn get_container_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetContainerRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_container_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_creator( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetCreatorResponse, ApiError> { + let context = self.context().clone(); + self.api().get_creator(ident, expand, hide, &context).await + } + + async fn get_creator_edit(&self, edit_id: String) -> Result<GetCreatorEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_creator_edit(edit_id, &context).await + } + + async fn get_creator_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetCreatorHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_creator_history(ident, limit, &context).await + } + + async fn get_creator_redirects( + &self, + ident: String, + ) -> Result<GetCreatorRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_creator_redirects(ident, &context).await + } + + async fn get_creator_releases( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetCreatorReleasesResponse, ApiError> { + let context = self.context().clone(); + self.api().get_creator_releases(ident, hide, &context).await + } + + async fn get_creator_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetCreatorRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_creator_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_editgroup(&self, editgroup_id: String) -> Result<GetEditgroupResponse, ApiError> { + let context = self.context().clone(); + self.api().get_editgroup(editgroup_id, &context).await + } + + async fn get_editgroup_annotations( + &self, + editgroup_id: String, + expand: Option<String>, + ) -> Result<GetEditgroupAnnotationsResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_editgroup_annotations(editgroup_id, expand, &context) + .await + } + + async fn get_editgroups_reviewable( + &self, + expand: Option<String>, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditgroupsReviewableResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_editgroups_reviewable(expand, limit, before, since, &context) + .await + } + + async fn get_editor(&self, editor_id: String) -> Result<GetEditorResponse, ApiError> { + let context = self.context().clone(); + self.api().get_editor(editor_id, &context).await + } + + async fn get_editor_annotations( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditorAnnotationsResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_editor_annotations(editor_id, limit, before, since, &context) + .await + } + + async fn get_editor_editgroups( + &self, + editor_id: String, + limit: Option<i64>, + before: Option<chrono::DateTime<chrono::Utc>>, + since: Option<chrono::DateTime<chrono::Utc>>, + ) -> Result<GetEditorEditgroupsResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_editor_editgroups(editor_id, limit, before, since, &context) + .await + } + + async fn get_file( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFileResponse, ApiError> { + let context = self.context().clone(); + self.api().get_file(ident, expand, hide, &context).await + } + + async fn get_file_edit(&self, edit_id: String) -> Result<GetFileEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_file_edit(edit_id, &context).await + } + + async fn get_file_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetFileHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_file_history(ident, limit, &context).await + } + + async fn get_file_redirects( + &self, + ident: String, + ) -> Result<GetFileRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_file_redirects(ident, &context).await + } + + async fn get_file_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFileRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_file_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_fileset( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFilesetResponse, ApiError> { + let context = self.context().clone(); + self.api().get_fileset(ident, expand, hide, &context).await + } + + async fn get_fileset_edit(&self, edit_id: String) -> Result<GetFilesetEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_fileset_edit(edit_id, &context).await + } + + async fn get_fileset_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetFilesetHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_fileset_history(ident, limit, &context).await + } + + async fn get_fileset_redirects( + &self, + ident: String, + ) -> Result<GetFilesetRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_fileset_redirects(ident, &context).await + } + + async fn get_fileset_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetFilesetRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_fileset_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_release( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetReleaseResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release(ident, expand, hide, &context).await + } + + async fn get_release_edit(&self, edit_id: String) -> Result<GetReleaseEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release_edit(edit_id, &context).await + } + + async fn get_release_files( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseFilesResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release_files(ident, hide, &context).await + } + + async fn get_release_filesets( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseFilesetsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release_filesets(ident, hide, &context).await + } + + async fn get_release_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetReleaseHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release_history(ident, limit, &context).await + } + + async fn get_release_redirects( + &self, + ident: String, + ) -> Result<GetReleaseRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_release_redirects(ident, &context).await + } + + async fn get_release_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetReleaseRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_release_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_release_webcaptures( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetReleaseWebcapturesResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_release_webcaptures(ident, hide, &context) + .await + } + + async fn get_webcapture( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWebcaptureResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_webcapture(ident, expand, hide, &context) + .await + } + + async fn get_webcapture_edit( + &self, + edit_id: String, + ) -> Result<GetWebcaptureEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_webcapture_edit(edit_id, &context).await + } + + async fn get_webcapture_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetWebcaptureHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_webcapture_history(ident, limit, &context) + .await + } + + async fn get_webcapture_redirects( + &self, + ident: String, + ) -> Result<GetWebcaptureRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_webcapture_redirects(ident, &context).await + } + + async fn get_webcapture_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWebcaptureRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_webcapture_revision(rev_id, expand, hide, &context) + .await + } + + async fn get_work( + &self, + ident: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWorkResponse, ApiError> { + let context = self.context().clone(); + self.api().get_work(ident, expand, hide, &context).await + } + + async fn get_work_edit(&self, edit_id: String) -> Result<GetWorkEditResponse, ApiError> { + let context = self.context().clone(); + self.api().get_work_edit(edit_id, &context).await + } + + async fn get_work_history( + &self, + ident: String, + limit: Option<i64>, + ) -> Result<GetWorkHistoryResponse, ApiError> { + let context = self.context().clone(); + self.api().get_work_history(ident, limit, &context).await + } + + async fn get_work_redirects( + &self, + ident: String, + ) -> Result<GetWorkRedirectsResponse, ApiError> { + let context = self.context().clone(); + self.api().get_work_redirects(ident, &context).await + } + + async fn get_work_releases( + &self, + ident: String, + hide: Option<String>, + ) -> Result<GetWorkReleasesResponse, ApiError> { + let context = self.context().clone(); + self.api().get_work_releases(ident, hide, &context).await + } + + async fn get_work_revision( + &self, + rev_id: String, + expand: Option<String>, + hide: Option<String>, + ) -> Result<GetWorkRevisionResponse, ApiError> { + let context = self.context().clone(); + self.api() + .get_work_revision(rev_id, expand, hide, &context) + .await + } + + async fn lookup_container( + &self, + issnl: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupContainerResponse, ApiError> { + let context = self.context().clone(); + self.api() + .lookup_container(issnl, wikidata_qid, expand, hide, &context) + .await + } + + async fn lookup_creator( + &self, + orcid: Option<String>, + wikidata_qid: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupCreatorResponse, ApiError> { + let context = self.context().clone(); + self.api() + .lookup_creator(orcid, wikidata_qid, expand, hide, &context) + .await + } + + async fn lookup_file( + &self, + md5: Option<String>, + sha1: Option<String>, + sha256: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupFileResponse, ApiError> { + let context = self.context().clone(); + self.api() + .lookup_file(md5, sha1, sha256, expand, hide, &context) + .await + } + + async fn lookup_release( + &self, + doi: Option<String>, + wikidata_qid: Option<String>, + isbn13: Option<String>, + pmid: Option<String>, + pmcid: Option<String>, + core: Option<String>, + arxiv: Option<String>, + jstor: Option<String>, + ark: Option<String>, + mag: Option<String>, + doaj: Option<String>, + dblp: Option<String>, + oai: Option<String>, + expand: Option<String>, + hide: Option<String>, + ) -> Result<LookupReleaseResponse, ApiError> { + let context = self.context().clone(); + self.api() + .lookup_release( + doi, + wikidata_qid, + isbn13, + pmid, + pmcid, + core, + arxiv, + jstor, + ark, + mag, + doaj, + dblp, + oai, + expand, + hide, + &context, + ) + .await + } + + async fn update_container( + &self, + editgroup_id: String, + ident: String, + container_entity: models::ContainerEntity, + ) -> Result<UpdateContainerResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_container(editgroup_id, ident, container_entity, &context) + .await + } + + async fn update_creator( + &self, + editgroup_id: String, + ident: String, + creator_entity: models::CreatorEntity, + ) -> Result<UpdateCreatorResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_creator(editgroup_id, ident, creator_entity, &context) + .await + } + + async fn update_editgroup( + &self, + editgroup_id: String, + editgroup: models::Editgroup, + submit: Option<bool>, + ) -> Result<UpdateEditgroupResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_editgroup(editgroup_id, editgroup, submit, &context) + .await + } + + async fn update_editor( + &self, + editor_id: String, + editor: models::Editor, + ) -> Result<UpdateEditorResponse, ApiError> { + let context = self.context().clone(); + self.api().update_editor(editor_id, editor, &context).await + } + + async fn update_file( + &self, + editgroup_id: String, + ident: String, + file_entity: models::FileEntity, + ) -> Result<UpdateFileResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_file(editgroup_id, ident, file_entity, &context) + .await + } + + async fn update_fileset( + &self, + editgroup_id: String, + ident: String, + fileset_entity: models::FilesetEntity, + ) -> Result<UpdateFilesetResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_fileset(editgroup_id, ident, fileset_entity, &context) + .await + } + + async fn update_release( + &self, + editgroup_id: String, + ident: String, + release_entity: models::ReleaseEntity, + ) -> Result<UpdateReleaseResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_release(editgroup_id, ident, release_entity, &context) + .await + } + + async fn update_webcapture( + &self, + editgroup_id: String, + ident: String, + webcapture_entity: models::WebcaptureEntity, + ) -> Result<UpdateWebcaptureResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_webcapture(editgroup_id, ident, webcapture_entity, &context) + .await + } + + async fn update_work( + &self, + editgroup_id: String, + ident: String, + work_entity: models::WorkEntity, + ) -> Result<UpdateWorkResponse, ApiError> { + let context = self.context().clone(); + self.api() + .update_work(editgroup_id, ident, work_entity, &context) + .await + } +} + +#[cfg(feature = "client")] +pub mod client; + +// Re-export Client as a top-level name +#[cfg(feature = "client")] +pub use client::Client; + +#[cfg(feature = "server")] +pub mod server; + +// Re-export router() as a top-level name +#[cfg(feature = "server")] +pub use self::server::Service; + +#[cfg(feature = "server")] +pub mod context; + +pub mod models; + +#[cfg(any(feature = "client", feature = "server"))] +pub(crate) mod header; diff --git a/fatcat-openapi/src/models.rs b/fatcat-openapi/src/models.rs new file mode 100644 index 0000000..d642c62 --- /dev/null +++ b/fatcat-openapi/src/models.rs @@ -0,0 +1,7621 @@ +#![allow(unused_qualifications)] + +#[cfg(any(feature = "client", feature = "server"))] +use crate::header; +use crate::models; + +// Methods for converting between header::IntoHeaderValue<AuthOidc> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidc>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<AuthOidc>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for AuthOidc - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidc> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <AuthOidc as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into AuthOidc - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct AuthOidc { + /// Fatcat-specific short name (slug) for remote service being used for authentication. + #[serde(rename = "provider")] + pub provider: String, + + /// `SUB` from OIDC protocol. Usually a URL. + #[serde(rename = "sub")] + pub sub: String, + + /// `ISS` from OIDC protocol. Usually a stable account username, number, or identifier. + #[serde(rename = "iss")] + pub iss: String, + + /// What it sounds like; returned by OIDC, and used as a hint when creating new editor accounts. Fatcat usernames are usually this string with the `provider` slug as a suffix, though some munging may occur. + #[serde(rename = "preferred_username")] + pub preferred_username: String, +} + +impl AuthOidc { + pub fn new(provider: String, sub: String, iss: String, preferred_username: String) -> AuthOidc { + AuthOidc { + provider: provider, + sub: sub, + iss: iss, + preferred_username: preferred_username, + } + } +} + +/// Converts the AuthOidc value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for AuthOidc { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("provider".to_string()); + params.push(self.provider.to_string()); + + params.push("sub".to_string()); + params.push(self.sub.to_string()); + + params.push("iss".to_string()); + params.push(self.iss.to_string()); + + params.push("preferred_username".to_string()); + params.push(self.preferred_username.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidc value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for AuthOidc { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub provider: Vec<String>, + pub sub: Vec<String>, + pub iss: Vec<String>, + pub preferred_username: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing AuthOidc".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "provider" => intermediate_rep + .provider + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sub" => intermediate_rep + .sub + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "iss" => intermediate_rep + .iss + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "preferred_username" => intermediate_rep + .preferred_username + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing AuthOidc".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(AuthOidc { + provider: intermediate_rep + .provider + .into_iter() + .next() + .ok_or("provider missing in AuthOidc".to_string())?, + sub: intermediate_rep + .sub + .into_iter() + .next() + .ok_or("sub missing in AuthOidc".to_string())?, + iss: intermediate_rep + .iss + .into_iter() + .next() + .ok_or("iss missing in AuthOidc".to_string())?, + preferred_username: intermediate_rep + .preferred_username + .into_iter() + .next() + .ok_or("preferred_username missing in AuthOidc".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<AuthOidcResult> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidcResult>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<AuthOidcResult>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for AuthOidcResult - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidcResult> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <AuthOidcResult as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into AuthOidcResult - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct AuthOidcResult { + #[serde(rename = "editor")] + pub editor: models::Editor, + + #[serde(rename = "token")] + pub token: String, +} + +impl AuthOidcResult { + pub fn new(editor: models::Editor, token: String) -> AuthOidcResult { + AuthOidcResult { + editor: editor, + token: token, + } + } +} + +/// Converts the AuthOidcResult value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for AuthOidcResult { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editor in query parameter serialization + + params.push("token".to_string()); + params.push(self.token.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidcResult value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for AuthOidcResult { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editor: Vec<models::Editor>, + pub token: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing AuthOidcResult".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editor" => intermediate_rep + .editor + .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?), + "token" => intermediate_rep + .token + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing AuthOidcResult".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(AuthOidcResult { + editor: intermediate_rep + .editor + .into_iter() + .next() + .ok_or("editor missing in AuthOidcResult".to_string())?, + token: intermediate_rep + .token + .into_iter() + .next() + .ok_or("token missing in AuthOidcResult".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<AuthTokenResult> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<AuthTokenResult>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<AuthTokenResult>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for AuthTokenResult - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<AuthTokenResult> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <AuthTokenResult as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into AuthTokenResult - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct AuthTokenResult { + #[serde(rename = "token")] + pub token: String, +} + +impl AuthTokenResult { + pub fn new(token: String) -> AuthTokenResult { + AuthTokenResult { token: token } + } +} + +/// Converts the AuthTokenResult value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for AuthTokenResult { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("token".to_string()); + params.push(self.token.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a AuthTokenResult value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for AuthTokenResult { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub token: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing AuthTokenResult".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "token" => intermediate_rep + .token + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing AuthTokenResult".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(AuthTokenResult { + token: intermediate_rep + .token + .into_iter() + .next() + .ok_or("token missing in AuthTokenResult".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ChangelogEntry> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ChangelogEntry>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ChangelogEntry>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ChangelogEntry - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ChangelogEntry> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ChangelogEntry as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ChangelogEntry - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ChangelogEntry { + /// Monotonically increasing sequence number of this changelog entry. + #[serde(rename = "index")] + pub index: i64, + + /// Identifier of editgroup accepted/merged in this changelog entry. + #[serde(rename = "editgroup_id")] + pub editgroup_id: String, + + /// Date and time when the editgroup was accpeted. + #[serde(rename = "timestamp")] + pub timestamp: chrono::DateTime<chrono::Utc>, + + #[serde(rename = "editgroup")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editgroup: Option<models::Editgroup>, +} + +impl ChangelogEntry { + pub fn new( + index: i64, + editgroup_id: String, + timestamp: chrono::DateTime<chrono::Utc>, + ) -> ChangelogEntry { + ChangelogEntry { + index: index, + editgroup_id: editgroup_id, + timestamp: timestamp, + editgroup: None, + } + } +} + +/// Converts the ChangelogEntry value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ChangelogEntry { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("index".to_string()); + params.push(self.index.to_string()); + + params.push("editgroup_id".to_string()); + params.push(self.editgroup_id.to_string()); + + // Skipping timestamp in query parameter serialization + + // Skipping editgroup in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ChangelogEntry value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ChangelogEntry { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub index: Vec<i64>, + pub editgroup_id: Vec<String>, + pub timestamp: Vec<chrono::DateTime<chrono::Utc>>, + pub editgroup: Vec<models::Editgroup>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ChangelogEntry".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "index" => intermediate_rep + .index + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "editgroup_id" => intermediate_rep + .editgroup_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "timestamp" => intermediate_rep.timestamp.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ChangelogEntry".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ChangelogEntry { + index: intermediate_rep + .index + .into_iter() + .next() + .ok_or("index missing in ChangelogEntry".to_string())?, + editgroup_id: intermediate_rep + .editgroup_id + .into_iter() + .next() + .ok_or("editgroup_id missing in ChangelogEntry".to_string())?, + timestamp: intermediate_rep + .timestamp + .into_iter() + .next() + .ok_or("timestamp missing in ChangelogEntry".to_string())?, + editgroup: intermediate_rep.editgroup.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ContainerAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ContainerAutoBatch>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ContainerAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ContainerAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<ContainerAutoBatch> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ContainerAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ContainerAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ContainerAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::ContainerEntity>, +} + +impl ContainerAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::ContainerEntity>, + ) -> ContainerAutoBatch { + ContainerAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the ContainerAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ContainerAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ContainerAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ContainerAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::ContainerEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ContainerAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => return std::result::Result::Err( + "Parsing a container in this style is not supported in ContainerAutoBatch" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ContainerAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ContainerAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in ContainerAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in ContainerAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ContainerEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ContainerEntity>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ContainerEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ContainerEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<ContainerEntity> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ContainerEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ContainerEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ContainerEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Name of the container (eg, Journal title). Required for entity creation. + #[serde(rename = "name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub name: Option<String>, + + /// Type of container, eg 'journal' or 'proceedings'. See Guide for list of valid types. + #[serde(rename = "container_type")] + #[serde(skip_serializing_if = "Option::is_none")] + pub container_type: Option<String>, + + /// Name of the organization or entity responsible for publication. Not the complete imprint/brand. + #[serde(rename = "publisher")] + #[serde(skip_serializing_if = "Option::is_none")] + pub publisher: Option<String>, + + /// Linking ISSN number (ISSN-L). Should be valid and registered with issn.org + #[serde(rename = "issnl")] + #[serde(skip_serializing_if = "Option::is_none")] + pub issnl: Option<String>, + + #[serde(rename = "wikidata_qid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub wikidata_qid: Option<String>, +} + +impl ContainerEntity { + pub fn new() -> ContainerEntity { + ContainerEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + name: None, + container_type: None, + publisher: None, + issnl: None, + wikidata_qid: None, + } + } +} + +/// Converts the ContainerEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ContainerEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + if let Some(ref name) = self.name { + params.push("name".to_string()); + params.push(name.to_string()); + } + + if let Some(ref container_type) = self.container_type { + params.push("container_type".to_string()); + params.push(container_type.to_string()); + } + + if let Some(ref publisher) = self.publisher { + params.push("publisher".to_string()); + params.push(publisher.to_string()); + } + + if let Some(ref issnl) = self.issnl { + params.push("issnl".to_string()); + params.push(issnl.to_string()); + } + + if let Some(ref wikidata_qid) = self.wikidata_qid { + params.push("wikidata_qid".to_string()); + params.push(wikidata_qid.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ContainerEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ContainerEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub name: Vec<String>, + pub container_type: Vec<String>, + pub publisher: Vec<String>, + pub issnl: Vec<String>, + pub wikidata_qid: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ContainerEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ContainerEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ContainerEntity" + .to_string(), + ) + } + "name" => intermediate_rep + .name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "container_type" => intermediate_rep + .container_type + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "publisher" => intermediate_rep + .publisher + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "issnl" => intermediate_rep + .issnl + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "wikidata_qid" => intermediate_rep + .wikidata_qid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ContainerEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ContainerEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + name: intermediate_rep.name.into_iter().next(), + container_type: intermediate_rep.container_type.into_iter().next(), + publisher: intermediate_rep.publisher.into_iter().next(), + issnl: intermediate_rep.issnl.into_iter().next(), + wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<CreatorAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<CreatorAutoBatch>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<CreatorAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for CreatorAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<CreatorAutoBatch> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <CreatorAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into CreatorAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct CreatorAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::CreatorEntity>, +} + +impl CreatorAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::CreatorEntity>, + ) -> CreatorAutoBatch { + CreatorAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the CreatorAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for CreatorAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a CreatorAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for CreatorAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::CreatorEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing CreatorAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => return std::result::Result::Err( + "Parsing a container in this style is not supported in CreatorAutoBatch" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing CreatorAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(CreatorAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in CreatorAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in CreatorAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<CreatorEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<CreatorEntity>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<CreatorEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for CreatorEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<CreatorEntity> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <CreatorEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into CreatorEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct CreatorEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Name as should be displayed in web interface or in author lists (not index/sorted). Required for valid entities. + #[serde(rename = "display_name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub display_name: Option<String>, + + /// In English commonly the first name, but ordering is context and culture specific. + #[serde(rename = "given_name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub given_name: Option<String>, + + /// In English commonly the last, or family name, but ordering is context and culture specific. + #[serde(rename = "surname")] + #[serde(skip_serializing_if = "Option::is_none")] + pub surname: Option<String>, + + /// ORCiD (https://orcid.org) identifier + #[serde(rename = "orcid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub orcid: Option<String>, + + /// Wikidata entity QID + #[serde(rename = "wikidata_qid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub wikidata_qid: Option<String>, +} + +impl CreatorEntity { + pub fn new() -> CreatorEntity { + CreatorEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + display_name: None, + given_name: None, + surname: None, + orcid: None, + wikidata_qid: None, + } + } +} + +/// Converts the CreatorEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for CreatorEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + if let Some(ref display_name) = self.display_name { + params.push("display_name".to_string()); + params.push(display_name.to_string()); + } + + if let Some(ref given_name) = self.given_name { + params.push("given_name".to_string()); + params.push(given_name.to_string()); + } + + if let Some(ref surname) = self.surname { + params.push("surname".to_string()); + params.push(surname.to_string()); + } + + if let Some(ref orcid) = self.orcid { + params.push("orcid".to_string()); + params.push(orcid.to_string()); + } + + if let Some(ref wikidata_qid) = self.wikidata_qid { + params.push("wikidata_qid".to_string()); + params.push(wikidata_qid.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a CreatorEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for CreatorEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub display_name: Vec<String>, + pub given_name: Vec<String>, + pub surname: Vec<String>, + pub orcid: Vec<String>, + pub wikidata_qid: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing CreatorEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in CreatorEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in CreatorEntity" + .to_string(), + ) + } + "display_name" => intermediate_rep + .display_name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "given_name" => intermediate_rep + .given_name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "surname" => intermediate_rep + .surname + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "orcid" => intermediate_rep + .orcid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "wikidata_qid" => intermediate_rep + .wikidata_qid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing CreatorEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(CreatorEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + display_name: intermediate_rep.display_name.into_iter().next(), + given_name: intermediate_rep.given_name.into_iter().next(), + surname: intermediate_rep.surname.into_iter().next(), + orcid: intermediate_rep.orcid.into_iter().next(), + wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<Editgroup> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<Editgroup>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<Editgroup>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for Editgroup - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editgroup> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <Editgroup as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into Editgroup - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct Editgroup { + /// Fatcat identifier for this editgroup. Assigned on creation. + #[serde(rename = "editgroup_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editgroup_id: Option<String>, + + /// Fatcat identifer of editor that created this editgroup. + #[serde(rename = "editor_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editor_id: Option<String>, + + #[serde(rename = "editor")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editor: Option<models::Editor>, + + /// For accepted/merged editgroups, the changelog index that the accept occured at. WARNING: not populated in all contexts that an editgroup could be included in a response. + #[serde(rename = "changelog_index")] + #[serde(skip_serializing_if = "Option::is_none")] + pub changelog_index: Option<i64>, + + /// Timestamp when this editgroup was first created. + #[serde(rename = "created")] + #[serde(skip_serializing_if = "Option::is_none")] + pub created: Option<chrono::DateTime<chrono::Utc>>, + + /// Timestamp when this editgroup was most recently submitted for review. If withdrawn, or never submitted, will be `null`. + #[serde(rename = "submitted")] + #[serde(skip_serializing_if = "Option::is_none")] + pub submitted: Option<chrono::DateTime<chrono::Utc>>, + + /// Comment describing the changes in this editgroup. Can be updated with PUT request. + #[serde(rename = "description")] + #[serde(skip_serializing_if = "Option::is_none")] + pub description: Option<String>, + + /// Free-form JSON metadata attached to this editgroup. Eg, metadata provenance, or script user-agent details. See guide for (unenforced) schema norms. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests. + #[serde(rename = "annotations")] + #[serde(skip_serializing_if = "Option::is_none")] + pub annotations: Option<Vec<models::EditgroupAnnotation>>, + + #[serde(rename = "edits")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edits: Option<models::EditgroupEdits>, +} + +impl Editgroup { + pub fn new() -> Editgroup { + Editgroup { + editgroup_id: None, + editor_id: None, + editor: None, + changelog_index: None, + created: None, + submitted: None, + description: None, + extra: None, + annotations: None, + edits: None, + } + } +} + +/// Converts the Editgroup value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for Editgroup { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref editgroup_id) = self.editgroup_id { + params.push("editgroup_id".to_string()); + params.push(editgroup_id.to_string()); + } + + if let Some(ref editor_id) = self.editor_id { + params.push("editor_id".to_string()); + params.push(editor_id.to_string()); + } + + // Skipping editor in query parameter serialization + + if let Some(ref changelog_index) = self.changelog_index { + params.push("changelog_index".to_string()); + params.push(changelog_index.to_string()); + } + + // Skipping created in query parameter serialization + + // Skipping submitted in query parameter serialization + + if let Some(ref description) = self.description { + params.push("description".to_string()); + params.push(description.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping annotations in query parameter serialization + + // Skipping edits in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a Editgroup value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for Editgroup { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup_id: Vec<String>, + pub editor_id: Vec<String>, + pub editor: Vec<models::Editor>, + pub changelog_index: Vec<i64>, + pub created: Vec<chrono::DateTime<chrono::Utc>>, + pub submitted: Vec<chrono::DateTime<chrono::Utc>>, + pub description: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub annotations: Vec<Vec<models::EditgroupAnnotation>>, + pub edits: Vec<models::EditgroupEdits>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing Editgroup".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup_id" => intermediate_rep + .editgroup_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editor_id" => intermediate_rep + .editor_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editor" => intermediate_rep + .editor + .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?), + "changelog_index" => intermediate_rep + .changelog_index + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "created" => intermediate_rep.created.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "submitted" => intermediate_rep.submitted.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "description" => intermediate_rep + .description + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in Editgroup" + .to_string(), + ) + } + "annotations" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in Editgroup" + .to_string(), + ) + } + "edits" => intermediate_rep + .edits + .push(models::EditgroupEdits::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing Editgroup".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(Editgroup { + editgroup_id: intermediate_rep.editgroup_id.into_iter().next(), + editor_id: intermediate_rep.editor_id.into_iter().next(), + editor: intermediate_rep.editor.into_iter().next(), + changelog_index: intermediate_rep.changelog_index.into_iter().next(), + created: intermediate_rep.created.into_iter().next(), + submitted: intermediate_rep.submitted.into_iter().next(), + description: intermediate_rep.description.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + annotations: intermediate_rep.annotations.into_iter().next(), + edits: intermediate_rep.edits.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<EditgroupAnnotation> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupAnnotation>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<EditgroupAnnotation>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for EditgroupAnnotation - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<EditgroupAnnotation> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <EditgroupAnnotation as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into EditgroupAnnotation - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct EditgroupAnnotation { + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "annotation_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub annotation_id: Option<String>, + + /// Editgroup that this annotation applies to. Set automatically in creations based on URL parameter. + #[serde(rename = "editgroup_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editgroup_id: Option<String>, + + /// Defaults to editor created the annotation via POST request. + #[serde(rename = "editor_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editor_id: Option<String>, + + #[serde(rename = "editor")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editor: Option<models::Editor>, + + /// Timestamp when annotation was first created. + #[serde(rename = "created")] + #[serde(skip_serializing_if = "Option::is_none")] + pub created: Option<chrono::DateTime<chrono::Utc>>, + + #[serde(rename = "comment_markdown")] + #[serde(skip_serializing_if = "Option::is_none")] + pub comment_markdown: Option<String>, + + /// Additional free-form JSON metadata that can be included as part of the annotation (or even as the primary annotation itself). See guide for details. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, +} + +impl EditgroupAnnotation { + pub fn new() -> EditgroupAnnotation { + EditgroupAnnotation { + annotation_id: None, + editgroup_id: None, + editor_id: None, + editor: None, + created: None, + comment_markdown: None, + extra: None, + } + } +} + +/// Converts the EditgroupAnnotation value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for EditgroupAnnotation { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref annotation_id) = self.annotation_id { + params.push("annotation_id".to_string()); + params.push(annotation_id.to_string()); + } + + if let Some(ref editgroup_id) = self.editgroup_id { + params.push("editgroup_id".to_string()); + params.push(editgroup_id.to_string()); + } + + if let Some(ref editor_id) = self.editor_id { + params.push("editor_id".to_string()); + params.push(editor_id.to_string()); + } + + // Skipping editor in query parameter serialization + + // Skipping created in query parameter serialization + + if let Some(ref comment_markdown) = self.comment_markdown { + params.push("comment_markdown".to_string()); + params.push(comment_markdown.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupAnnotation value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for EditgroupAnnotation { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub annotation_id: Vec<String>, + pub editgroup_id: Vec<String>, + pub editor_id: Vec<String>, + pub editor: Vec<models::Editor>, + pub created: Vec<chrono::DateTime<chrono::Utc>>, + pub comment_markdown: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing EditgroupAnnotation".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "annotation_id" => intermediate_rep + .annotation_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editgroup_id" => intermediate_rep + .editgroup_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editor_id" => intermediate_rep + .editor_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editor" => intermediate_rep + .editor + .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?), + "created" => intermediate_rep.created.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "comment_markdown" => intermediate_rep + .comment_markdown + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupAnnotation" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing EditgroupAnnotation".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(EditgroupAnnotation { + annotation_id: intermediate_rep.annotation_id.into_iter().next(), + editgroup_id: intermediate_rep.editgroup_id.into_iter().next(), + editor_id: intermediate_rep.editor_id.into_iter().next(), + editor: intermediate_rep.editor.into_iter().next(), + created: intermediate_rep.created.into_iter().next(), + comment_markdown: intermediate_rep.comment_markdown.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + }) + } +} + +/// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests. +// Methods for converting between header::IntoHeaderValue<EditgroupEdits> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupEdits>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<EditgroupEdits>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for EditgroupEdits - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EditgroupEdits> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <EditgroupEdits as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into EditgroupEdits - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct EditgroupEdits { + #[serde(rename = "containers")] + #[serde(skip_serializing_if = "Option::is_none")] + pub containers: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "creators")] + #[serde(skip_serializing_if = "Option::is_none")] + pub creators: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "files")] + #[serde(skip_serializing_if = "Option::is_none")] + pub files: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "filesets")] + #[serde(skip_serializing_if = "Option::is_none")] + pub filesets: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "webcaptures")] + #[serde(skip_serializing_if = "Option::is_none")] + pub webcaptures: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "releases")] + #[serde(skip_serializing_if = "Option::is_none")] + pub releases: Option<Vec<models::EntityEdit>>, + + #[serde(rename = "works")] + #[serde(skip_serializing_if = "Option::is_none")] + pub works: Option<Vec<models::EntityEdit>>, +} + +impl EditgroupEdits { + pub fn new() -> EditgroupEdits { + EditgroupEdits { + containers: None, + creators: None, + files: None, + filesets: None, + webcaptures: None, + releases: None, + works: None, + } + } +} + +/// Converts the EditgroupEdits value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for EditgroupEdits { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping containers in query parameter serialization + + // Skipping creators in query parameter serialization + + // Skipping files in query parameter serialization + + // Skipping filesets in query parameter serialization + + // Skipping webcaptures in query parameter serialization + + // Skipping releases in query parameter serialization + + // Skipping works in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupEdits value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for EditgroupEdits { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub containers: Vec<Vec<models::EntityEdit>>, + pub creators: Vec<Vec<models::EntityEdit>>, + pub files: Vec<Vec<models::EntityEdit>>, + pub filesets: Vec<Vec<models::EntityEdit>>, + pub webcaptures: Vec<Vec<models::EntityEdit>>, + pub releases: Vec<Vec<models::EntityEdit>>, + pub works: Vec<Vec<models::EntityEdit>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing EditgroupEdits".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "containers" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "creators" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "files" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "filesets" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "webcaptures" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "releases" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + "works" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EditgroupEdits" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing EditgroupEdits".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(EditgroupEdits { + containers: intermediate_rep.containers.into_iter().next(), + creators: intermediate_rep.creators.into_iter().next(), + files: intermediate_rep.files.into_iter().next(), + filesets: intermediate_rep.filesets.into_iter().next(), + webcaptures: intermediate_rep.webcaptures.into_iter().next(), + releases: intermediate_rep.releases.into_iter().next(), + works: intermediate_rep.works.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<Editor> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<Editor>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<Editor>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for Editor - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editor> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <Editor as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into Editor - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct Editor { + /// Fatcat identifier for the editor. Can not be changed. + #[serde(rename = "editor_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub editor_id: Option<String>, + + /// Username/handle (short slug-like string) to identify this editor. May be changed at any time by the editor; use the `editor_id` as a persistend identifer. + #[serde(rename = "username")] + pub username: String, + + /// Whether this editor has the `admin` role. + #[serde(rename = "is_admin")] + #[serde(skip_serializing_if = "Option::is_none")] + pub is_admin: Option<bool>, + + /// Whether this editor is a bot (as opposed to a human making manual edits) + #[serde(rename = "is_bot")] + #[serde(skip_serializing_if = "Option::is_none")] + pub is_bot: Option<bool>, + + /// Whether this editor's account is enabled (if not API tokens and web logins will not work). + #[serde(rename = "is_active")] + #[serde(skip_serializing_if = "Option::is_none")] + pub is_active: Option<bool>, +} + +impl Editor { + pub fn new(username: String) -> Editor { + Editor { + editor_id: None, + username: username, + is_admin: None, + is_bot: None, + is_active: None, + } + } +} + +/// Converts the Editor value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for Editor { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref editor_id) = self.editor_id { + params.push("editor_id".to_string()); + params.push(editor_id.to_string()); + } + + params.push("username".to_string()); + params.push(self.username.to_string()); + + if let Some(ref is_admin) = self.is_admin { + params.push("is_admin".to_string()); + params.push(is_admin.to_string()); + } + + if let Some(ref is_bot) = self.is_bot { + params.push("is_bot".to_string()); + params.push(is_bot.to_string()); + } + + if let Some(ref is_active) = self.is_active { + params.push("is_active".to_string()); + params.push(is_active.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a Editor value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for Editor { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editor_id: Vec<String>, + pub username: Vec<String>, + pub is_admin: Vec<bool>, + pub is_bot: Vec<bool>, + pub is_active: Vec<bool>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing Editor".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editor_id" => intermediate_rep + .editor_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "username" => intermediate_rep + .username + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "is_admin" => intermediate_rep + .is_admin + .push(bool::from_str(val).map_err(|x| format!("{}", x))?), + "is_bot" => intermediate_rep + .is_bot + .push(bool::from_str(val).map_err(|x| format!("{}", x))?), + "is_active" => intermediate_rep + .is_active + .push(bool::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing Editor".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(Editor { + editor_id: intermediate_rep.editor_id.into_iter().next(), + username: intermediate_rep + .username + .into_iter() + .next() + .ok_or("username missing in Editor".to_string())?, + is_admin: intermediate_rep.is_admin.into_iter().next(), + is_bot: intermediate_rep.is_bot.into_iter().next(), + is_active: intermediate_rep.is_active.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<EntityEdit> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<EntityEdit>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<EntityEdit>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for EntityEdit - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EntityEdit> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <EntityEdit as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into EntityEdit - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct EntityEdit { + /// Unique UUID for this specific edit object. + #[serde(rename = "edit_id")] + pub edit_id: String, + + /// Fatcat identifier of the entity this edit is mutating. + #[serde(rename = "ident")] + pub ident: String, + + /// Entity revision that this edit will set the entity to. May be `null` in the case of deletions. + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// Revision of entity just before this edit. May be used in the future to prevent edit race conditions. + #[serde(rename = "prev_revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub prev_revision: Option<String>, + + /// When an edit is to merge entities (redirect one to another), this is the entity fatcat identifier for the target entity. + #[serde(rename = "redirect_ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect_ident: Option<String>, + + /// Editgroup identifier that this edit is part of. + #[serde(rename = "editgroup_id")] + pub editgroup_id: String, + + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, +} + +impl EntityEdit { + pub fn new(edit_id: String, ident: String, editgroup_id: String) -> EntityEdit { + EntityEdit { + edit_id: edit_id, + ident: ident, + revision: None, + prev_revision: None, + redirect_ident: None, + editgroup_id: editgroup_id, + extra: None, + } + } +} + +/// Converts the EntityEdit value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for EntityEdit { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("edit_id".to_string()); + params.push(self.edit_id.to_string()); + + params.push("ident".to_string()); + params.push(self.ident.to_string()); + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref prev_revision) = self.prev_revision { + params.push("prev_revision".to_string()); + params.push(prev_revision.to_string()); + } + + if let Some(ref redirect_ident) = self.redirect_ident { + params.push("redirect_ident".to_string()); + params.push(redirect_ident.to_string()); + } + + params.push("editgroup_id".to_string()); + params.push(self.editgroup_id.to_string()); + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a EntityEdit value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for EntityEdit { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub edit_id: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub prev_revision: Vec<String>, + pub redirect_ident: Vec<String>, + pub editgroup_id: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing EntityEdit".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "edit_id" => intermediate_rep + .edit_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "prev_revision" => intermediate_rep + .prev_revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect_ident" => intermediate_rep + .redirect_ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "editgroup_id" => intermediate_rep + .editgroup_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in EntityEdit" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing EntityEdit".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(EntityEdit { + edit_id: intermediate_rep + .edit_id + .into_iter() + .next() + .ok_or("edit_id missing in EntityEdit".to_string())?, + ident: intermediate_rep + .ident + .into_iter() + .next() + .ok_or("ident missing in EntityEdit".to_string())?, + revision: intermediate_rep.revision.into_iter().next(), + prev_revision: intermediate_rep.prev_revision.into_iter().next(), + redirect_ident: intermediate_rep.redirect_ident.into_iter().next(), + editgroup_id: intermediate_rep + .editgroup_id + .into_iter() + .next() + .ok_or("editgroup_id missing in EntityEdit".to_string())?, + extra: intermediate_rep.extra.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<EntityHistoryEntry> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<EntityHistoryEntry>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<EntityHistoryEntry>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for EntityHistoryEntry - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<EntityHistoryEntry> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <EntityHistoryEntry as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into EntityHistoryEntry - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct EntityHistoryEntry { + #[serde(rename = "edit")] + pub edit: models::EntityEdit, + + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "changelog_entry")] + pub changelog_entry: models::ChangelogEntry, +} + +impl EntityHistoryEntry { + pub fn new( + edit: models::EntityEdit, + editgroup: models::Editgroup, + changelog_entry: models::ChangelogEntry, + ) -> EntityHistoryEntry { + EntityHistoryEntry { + edit: edit, + editgroup: editgroup, + changelog_entry: changelog_entry, + } + } +} + +/// Converts the EntityHistoryEntry value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for EntityHistoryEntry { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping edit in query parameter serialization + + // Skipping editgroup in query parameter serialization + + // Skipping changelog_entry in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a EntityHistoryEntry value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for EntityHistoryEntry { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub edit: Vec<models::EntityEdit>, + pub editgroup: Vec<models::Editgroup>, + pub changelog_entry: Vec<models::ChangelogEntry>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing EntityHistoryEntry".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "edit" => intermediate_rep + .edit + .push(models::EntityEdit::from_str(val).map_err(|x| format!("{}", x))?), + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "changelog_entry" => intermediate_rep + .changelog_entry + .push(models::ChangelogEntry::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing EntityHistoryEntry".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(EntityHistoryEntry { + edit: intermediate_rep + .edit + .into_iter() + .next() + .ok_or("edit missing in EntityHistoryEntry".to_string())?, + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in EntityHistoryEntry".to_string())?, + changelog_entry: intermediate_rep + .changelog_entry + .into_iter() + .next() + .ok_or("changelog_entry missing in EntityHistoryEntry".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ErrorResponse> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ErrorResponse>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ErrorResponse>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ErrorResponse - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ErrorResponse> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ErrorResponse as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ErrorResponse - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ErrorResponse { + #[serde(rename = "success")] + pub success: bool, + + #[serde(rename = "error")] + pub error: String, + + #[serde(rename = "message")] + pub message: String, +} + +impl ErrorResponse { + pub fn new(success: bool, error: String, message: String) -> ErrorResponse { + ErrorResponse { + success: success, + error: error, + message: message, + } + } +} + +/// Converts the ErrorResponse value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ErrorResponse { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("success".to_string()); + params.push(self.success.to_string()); + + params.push("error".to_string()); + params.push(self.error.to_string()); + + params.push("message".to_string()); + params.push(self.message.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ErrorResponse value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ErrorResponse { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub success: Vec<bool>, + pub error: Vec<String>, + pub message: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ErrorResponse".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "success" => intermediate_rep + .success + .push(bool::from_str(val).map_err(|x| format!("{}", x))?), + "error" => intermediate_rep + .error + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "message" => intermediate_rep + .message + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ErrorResponse".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ErrorResponse { + success: intermediate_rep + .success + .into_iter() + .next() + .ok_or("success missing in ErrorResponse".to_string())?, + error: intermediate_rep + .error + .into_iter() + .next() + .ok_or("error missing in ErrorResponse".to_string())?, + message: intermediate_rep + .message + .into_iter() + .next() + .ok_or("message missing in ErrorResponse".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FileAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FileAutoBatch>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FileAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FileAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileAutoBatch> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FileAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FileAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FileAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::FileEntity>, +} + +impl FileAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::FileEntity>, + ) -> FileAutoBatch { + FileAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the FileAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FileAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FileAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FileAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::FileEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FileAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileAutoBatch" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FileAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FileAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in FileAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in FileAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FileEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FileEntity>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FileEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FileEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileEntity> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FileEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FileEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FileEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Size of file in bytes. Non-zero. + #[serde(rename = "size")] + #[serde(skip_serializing_if = "Option::is_none")] + pub size: Option<i64>, + + /// MD5 hash of data, in hex encoding + #[serde(rename = "md5")] + #[serde(skip_serializing_if = "Option::is_none")] + pub md5: Option<String>, + + /// SHA-1 hash of data, in hex encoding + #[serde(rename = "sha1")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha1: Option<String>, + + /// SHA-256 hash of data, in hex encoding + #[serde(rename = "sha256")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha256: Option<String>, + + #[serde(rename = "urls")] + #[serde(skip_serializing_if = "Option::is_none")] + pub urls: Option<Vec<models::FileUrl>>, + + #[serde(rename = "mimetype")] + #[serde(skip_serializing_if = "Option::is_none")] + pub mimetype: Option<String>, + + /// Set of identifier of release entities this file represents a full manifestation of. Usually a single release, but some files contain content of multiple full releases (eg, an issue of a journal). + #[serde(rename = "release_ids")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_ids: Option<Vec<String>>, + + /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests. + #[serde(rename = "releases")] + #[serde(skip_serializing_if = "Option::is_none")] + pub releases: Option<Vec<models::ReleaseEntity>>, +} + +impl FileEntity { + pub fn new() -> FileEntity { + FileEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + size: None, + md5: None, + sha1: None, + sha256: None, + urls: None, + mimetype: None, + release_ids: None, + releases: None, + } + } +} + +/// Converts the FileEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FileEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + if let Some(ref size) = self.size { + params.push("size".to_string()); + params.push(size.to_string()); + } + + if let Some(ref md5) = self.md5 { + params.push("md5".to_string()); + params.push(md5.to_string()); + } + + if let Some(ref sha1) = self.sha1 { + params.push("sha1".to_string()); + params.push(sha1.to_string()); + } + + if let Some(ref sha256) = self.sha256 { + params.push("sha256".to_string()); + params.push(sha256.to_string()); + } + + // Skipping urls in query parameter serialization + + if let Some(ref mimetype) = self.mimetype { + params.push("mimetype".to_string()); + params.push(mimetype.to_string()); + } + + if let Some(ref release_ids) = self.release_ids { + params.push("release_ids".to_string()); + params.push( + release_ids + .iter() + .map(|x| x.to_string()) + .collect::<Vec<_>>() + .join(",") + .to_string(), + ); + } + + // Skipping releases in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FileEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FileEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub size: Vec<i64>, + pub md5: Vec<String>, + pub sha1: Vec<String>, + pub sha256: Vec<String>, + pub urls: Vec<Vec<models::FileUrl>>, + pub mimetype: Vec<String>, + pub release_ids: Vec<Vec<String>>, + pub releases: Vec<Vec<models::ReleaseEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FileEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileEntity" + .to_string(), + ) + } + "size" => intermediate_rep + .size + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "md5" => intermediate_rep + .md5 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sha1" => intermediate_rep + .sha1 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sha256" => intermediate_rep + .sha256 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "urls" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileEntity" + .to_string(), + ) + } + "mimetype" => intermediate_rep + .mimetype + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "release_ids" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileEntity" + .to_string(), + ) + } + "releases" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FileEntity" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FileEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FileEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + size: intermediate_rep.size.into_iter().next(), + md5: intermediate_rep.md5.into_iter().next(), + sha1: intermediate_rep.sha1.into_iter().next(), + sha256: intermediate_rep.sha256.into_iter().next(), + urls: intermediate_rep.urls.into_iter().next(), + mimetype: intermediate_rep.mimetype.into_iter().next(), + release_ids: intermediate_rep.release_ids.into_iter().next(), + releases: intermediate_rep.releases.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FileUrl> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FileUrl>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FileUrl>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FileUrl - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileUrl> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FileUrl as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FileUrl - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FileUrl { + /// URL/URI pointing directly to a machine retrievable copy of this exact file. + #[serde(rename = "url")] + pub url: String, + + /// Indicates type of host this URL points to. Eg, \"publisher\", \"repository\", \"webarchive\". See guide for list of acceptable values. + #[serde(rename = "rel")] + pub rel: String, +} + +impl FileUrl { + pub fn new(url: String, rel: String) -> FileUrl { + FileUrl { url: url, rel: rel } + } +} + +/// Converts the FileUrl value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FileUrl { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("url".to_string()); + params.push(self.url.to_string()); + + params.push("rel".to_string()); + params.push(self.rel.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FileUrl value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FileUrl { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub url: Vec<String>, + pub rel: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FileUrl".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "url" => intermediate_rep + .url + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "rel" => intermediate_rep + .rel + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FileUrl".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FileUrl { + url: intermediate_rep + .url + .into_iter() + .next() + .ok_or("url missing in FileUrl".to_string())?, + rel: intermediate_rep + .rel + .into_iter() + .next() + .ok_or("rel missing in FileUrl".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FilesetAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FilesetAutoBatch>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FilesetAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FilesetAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<FilesetAutoBatch> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FilesetAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FilesetAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FilesetAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::FilesetEntity>, +} + +impl FilesetAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::FilesetEntity>, + ) -> FilesetAutoBatch { + FilesetAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the FilesetAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FilesetAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FilesetAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FilesetAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::FilesetEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FilesetAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetAutoBatch" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FilesetAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FilesetAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in FilesetAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in FilesetAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FilesetEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FilesetEntity>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FilesetEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FilesetEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetEntity> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FilesetEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FilesetEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FilesetEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + #[serde(rename = "manifest")] + #[serde(skip_serializing_if = "Option::is_none")] + pub manifest: Option<Vec<models::FilesetFile>>, + + #[serde(rename = "urls")] + #[serde(skip_serializing_if = "Option::is_none")] + pub urls: Option<Vec<models::FilesetUrl>>, + + /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release. + #[serde(rename = "release_ids")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_ids: Option<Vec<String>>, + + /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests. + #[serde(rename = "releases")] + #[serde(skip_serializing_if = "Option::is_none")] + pub releases: Option<Vec<models::ReleaseEntity>>, +} + +impl FilesetEntity { + pub fn new() -> FilesetEntity { + FilesetEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + manifest: None, + urls: None, + release_ids: None, + releases: None, + } + } +} + +/// Converts the FilesetEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FilesetEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + // Skipping manifest in query parameter serialization + + // Skipping urls in query parameter serialization + + if let Some(ref release_ids) = self.release_ids { + params.push("release_ids".to_string()); + params.push( + release_ids + .iter() + .map(|x| x.to_string()) + .collect::<Vec<_>>() + .join(",") + .to_string(), + ); + } + + // Skipping releases in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FilesetEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FilesetEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub manifest: Vec<Vec<models::FilesetFile>>, + pub urls: Vec<Vec<models::FilesetUrl>>, + pub release_ids: Vec<Vec<String>>, + pub releases: Vec<Vec<models::ReleaseEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FilesetEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + "manifest" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + "urls" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + "release_ids" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + "releases" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetEntity" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FilesetEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FilesetEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + manifest: intermediate_rep.manifest.into_iter().next(), + urls: intermediate_rep.urls.into_iter().next(), + release_ids: intermediate_rep.release_ids.into_iter().next(), + releases: intermediate_rep.releases.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FilesetFile> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FilesetFile>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FilesetFile>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FilesetFile - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetFile> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FilesetFile as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FilesetFile - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FilesetFile { + /// Path name of file within this fileset (eg, directory) + #[serde(rename = "path")] + pub path: String, + + /// File size in bytes + #[serde(rename = "size")] + pub size: i64, + + /// MD5 hash of data, in hex encoding + #[serde(rename = "md5")] + #[serde(skip_serializing_if = "Option::is_none")] + pub md5: Option<String>, + + /// SHA-1 hash of data, in hex encoding + #[serde(rename = "sha1")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha1: Option<String>, + + /// SHA-256 hash of data, in hex encoding + #[serde(rename = "sha256")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha256: Option<String>, + + /// Free-form additional metadata about this specific file in the set. Eg, `mimetype`. See guide for nomative (but unenforced) schema fields. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, +} + +impl FilesetFile { + pub fn new(path: String, size: i64) -> FilesetFile { + FilesetFile { + path: path, + size: size, + md5: None, + sha1: None, + sha256: None, + extra: None, + } + } +} + +/// Converts the FilesetFile value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FilesetFile { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("path".to_string()); + params.push(self.path.to_string()); + + params.push("size".to_string()); + params.push(self.size.to_string()); + + if let Some(ref md5) = self.md5 { + params.push("md5".to_string()); + params.push(md5.to_string()); + } + + if let Some(ref sha1) = self.sha1 { + params.push("sha1".to_string()); + params.push(sha1.to_string()); + } + + if let Some(ref sha256) = self.sha256 { + params.push("sha256".to_string()); + params.push(sha256.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FilesetFile value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FilesetFile { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub path: Vec<String>, + pub size: Vec<i64>, + pub md5: Vec<String>, + pub sha1: Vec<String>, + pub sha256: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FilesetFile".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "path" => intermediate_rep + .path + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "size" => intermediate_rep + .size + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "md5" => intermediate_rep + .md5 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sha1" => intermediate_rep + .sha1 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sha256" => intermediate_rep + .sha256 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in FilesetFile" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FilesetFile".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FilesetFile { + path: intermediate_rep + .path + .into_iter() + .next() + .ok_or("path missing in FilesetFile".to_string())?, + size: intermediate_rep + .size + .into_iter() + .next() + .ok_or("size missing in FilesetFile".to_string())?, + md5: intermediate_rep.md5.into_iter().next(), + sha1: intermediate_rep.sha1.into_iter().next(), + sha256: intermediate_rep.sha256.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<FilesetUrl> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<FilesetUrl>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<FilesetUrl>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for FilesetUrl - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetUrl> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <FilesetUrl as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into FilesetUrl - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct FilesetUrl { + #[serde(rename = "url")] + pub url: String, + + /// Indicates type of host this URL points to. See guide for list of acceptable values. + #[serde(rename = "rel")] + pub rel: String, +} + +impl FilesetUrl { + pub fn new(url: String, rel: String) -> FilesetUrl { + FilesetUrl { url: url, rel: rel } + } +} + +/// Converts the FilesetUrl value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for FilesetUrl { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("url".to_string()); + params.push(self.url.to_string()); + + params.push("rel".to_string()); + params.push(self.rel.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a FilesetUrl value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for FilesetUrl { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub url: Vec<String>, + pub rel: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing FilesetUrl".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "url" => intermediate_rep + .url + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "rel" => intermediate_rep + .rel + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing FilesetUrl".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(FilesetUrl { + url: intermediate_rep + .url + .into_iter() + .next() + .ok_or("url missing in FilesetUrl".to_string())?, + rel: intermediate_rep + .rel + .into_iter() + .next() + .ok_or("rel missing in FilesetUrl".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseAbstract> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAbstract>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseAbstract>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseAbstract - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<ReleaseAbstract> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseAbstract as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseAbstract - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseAbstract { + /// SHA-1 hash of data, in hex encoding + #[serde(rename = "sha1")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha1: Option<String>, + + /// Abstract content. May be encoded, as per `mimetype` field, but only string/text content may be included. + #[serde(rename = "content")] + #[serde(skip_serializing_if = "Option::is_none")] + pub content: Option<String>, + + /// Mimetype of abstract contents. `text/plain` is the default if content isn't encoded. + #[serde(rename = "mimetype")] + #[serde(skip_serializing_if = "Option::is_none")] + pub mimetype: Option<String>, + + /// ISO language code of the abstract. Same semantics as release `language` field. + #[serde(rename = "lang")] + #[serde(skip_serializing_if = "Option::is_none")] + pub lang: Option<String>, +} + +impl ReleaseAbstract { + pub fn new() -> ReleaseAbstract { + ReleaseAbstract { + sha1: None, + content: None, + mimetype: None, + lang: None, + } + } +} + +/// Converts the ReleaseAbstract value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseAbstract { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref sha1) = self.sha1 { + params.push("sha1".to_string()); + params.push(sha1.to_string()); + } + + if let Some(ref content) = self.content { + params.push("content".to_string()); + params.push(content.to_string()); + } + + if let Some(ref mimetype) = self.mimetype { + params.push("mimetype".to_string()); + params.push(mimetype.to_string()); + } + + if let Some(ref lang) = self.lang { + params.push("lang".to_string()); + params.push(lang.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAbstract value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseAbstract { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub sha1: Vec<String>, + pub content: Vec<String>, + pub mimetype: Vec<String>, + pub lang: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseAbstract".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "sha1" => intermediate_rep + .sha1 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "content" => intermediate_rep + .content + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "mimetype" => intermediate_rep + .mimetype + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "lang" => intermediate_rep + .lang + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseAbstract".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseAbstract { + sha1: intermediate_rep.sha1.into_iter().next(), + content: intermediate_rep.content.into_iter().next(), + mimetype: intermediate_rep.mimetype.into_iter().next(), + lang: intermediate_rep.lang.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAutoBatch>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<ReleaseAutoBatch> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::ReleaseEntity>, +} + +impl ReleaseAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::ReleaseEntity>, + ) -> ReleaseAutoBatch { + ReleaseAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the ReleaseAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::ReleaseEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseAutoBatch" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in ReleaseAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in ReleaseAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseContrib> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseContrib>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseContrib>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseContrib - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseContrib> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseContrib as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseContrib - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseContrib { + /// Internally assigned zero-indexed sequence number of contribution. Authors should come first; this encodes the order of attriubtion. + #[serde(rename = "index")] + #[serde(skip_serializing_if = "Option::is_none")] + pub index: Option<i64>, + + /// If known, indicates the creator entity this contribution was made by. + #[serde(rename = "creator_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub creator_id: Option<String>, + + #[serde(rename = "creator")] + #[serde(skip_serializing_if = "Option::is_none")] + pub creator: Option<models::CreatorEntity>, + + /// Full name of the contributor as typeset in the release. + #[serde(rename = "raw_name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub raw_name: Option<String>, + + /// In English commonly the first name, but ordering is context and culture specific. + #[serde(rename = "given_name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub given_name: Option<String>, + + /// In English commonly the last, or family name, but ordering is context and culture specific. + #[serde(rename = "surname")] + #[serde(skip_serializing_if = "Option::is_none")] + pub surname: Option<String>, + + /// Short string (slug) indicating type of contribution (eg, \"author\", \"translator\"). See guide for list of accpeted values. + #[serde(rename = "role")] + #[serde(skip_serializing_if = "Option::is_none")] + pub role: Option<String>, + + /// Raw affiliation string as displayed in text + #[serde(rename = "raw_affiliation")] + #[serde(skip_serializing_if = "Option::is_none")] + pub raw_affiliation: Option<String>, + + /// Additional free-form JSON metadata about this contributor/contribution. See guide for normative schema. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, +} + +impl ReleaseContrib { + pub fn new() -> ReleaseContrib { + ReleaseContrib { + index: None, + creator_id: None, + creator: None, + raw_name: None, + given_name: None, + surname: None, + role: None, + raw_affiliation: None, + extra: None, + } + } +} + +/// Converts the ReleaseContrib value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseContrib { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref index) = self.index { + params.push("index".to_string()); + params.push(index.to_string()); + } + + if let Some(ref creator_id) = self.creator_id { + params.push("creator_id".to_string()); + params.push(creator_id.to_string()); + } + + // Skipping creator in query parameter serialization + + if let Some(ref raw_name) = self.raw_name { + params.push("raw_name".to_string()); + params.push(raw_name.to_string()); + } + + if let Some(ref given_name) = self.given_name { + params.push("given_name".to_string()); + params.push(given_name.to_string()); + } + + if let Some(ref surname) = self.surname { + params.push("surname".to_string()); + params.push(surname.to_string()); + } + + if let Some(ref role) = self.role { + params.push("role".to_string()); + params.push(role.to_string()); + } + + if let Some(ref raw_affiliation) = self.raw_affiliation { + params.push("raw_affiliation".to_string()); + params.push(raw_affiliation.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseContrib value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseContrib { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub index: Vec<i64>, + pub creator_id: Vec<String>, + pub creator: Vec<models::CreatorEntity>, + pub raw_name: Vec<String>, + pub given_name: Vec<String>, + pub surname: Vec<String>, + pub role: Vec<String>, + pub raw_affiliation: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseContrib".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "index" => intermediate_rep + .index + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "creator_id" => intermediate_rep + .creator_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "creator" => intermediate_rep + .creator + .push(models::CreatorEntity::from_str(val).map_err(|x| format!("{}", x))?), + "raw_name" => intermediate_rep + .raw_name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "given_name" => intermediate_rep + .given_name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "surname" => intermediate_rep + .surname + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "role" => intermediate_rep + .role + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "raw_affiliation" => intermediate_rep + .raw_affiliation + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseContrib" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseContrib".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseContrib { + index: intermediate_rep.index.into_iter().next(), + creator_id: intermediate_rep.creator_id.into_iter().next(), + creator: intermediate_rep.creator.into_iter().next(), + raw_name: intermediate_rep.raw_name.into_iter().next(), + given_name: intermediate_rep.given_name.into_iter().next(), + surname: intermediate_rep.surname.into_iter().next(), + role: intermediate_rep.role.into_iter().next(), + raw_affiliation: intermediate_rep.raw_affiliation.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseEntity>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseEntity> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Required for valid entities. The title used in citations and for display. Sometimes the English translation of title e even if release content is not English. + #[serde(rename = "title")] + #[serde(skip_serializing_if = "Option::is_none")] + pub title: Option<String>, + + /// Subtitle of release. In many cases, better to merge with title than include as separate field (unless combined title would be very long). See guide for details. + #[serde(rename = "subtitle")] + #[serde(skip_serializing_if = "Option::is_none")] + pub subtitle: Option<String>, + + /// Title in original language if `title` field has been translated. See guide for details. + #[serde(rename = "original_title")] + #[serde(skip_serializing_if = "Option::is_none")] + pub original_title: Option<String>, + + /// Identifier of work this release is part of. In creation (POST) requests, a work entity will be created automatically if this field is not set. + #[serde(rename = "work_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub work_id: Option<String>, + + #[serde(rename = "container")] + #[serde(skip_serializing_if = "Option::is_none")] + pub container: Option<models::ContainerEntity>, + + /// Complete file entities identified by `file_ids` field. Only included in GET responses when `files` included in `expand` parameter; ignored in PUT or POST requests. + #[serde(rename = "files")] + #[serde(skip_serializing_if = "Option::is_none")] + pub files: Option<Vec<models::FileEntity>>, + + /// Complete file entities identified by `filesets_ids` field. Only included in GET responses when `filesets` included in `expand` parameter; ignored in PUT or POST requests. + #[serde(rename = "filesets")] + #[serde(skip_serializing_if = "Option::is_none")] + pub filesets: Option<Vec<models::FilesetEntity>>, + + /// Complete webcapture entities identified by `webcapture_ids` field. Only included in GET responses when `webcaptures` included in `expand` parameter; ignored in PUT or POST requests. + #[serde(rename = "webcaptures")] + #[serde(skip_serializing_if = "Option::is_none")] + pub webcaptures: Option<Vec<models::WebcaptureEntity>>, + + /// Used to link this release to a container entity that the release was published as part of. + #[serde(rename = "container_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub container_id: Option<String>, + + /// \"Type\" or \"medium\" that this release is published as. See guide for valid values. + #[serde(rename = "release_type")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_type: Option<String>, + + /// The stage of publication of this specific release. See guide for valid values and semantics. + #[serde(rename = "release_stage")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_stage: Option<String>, + + /// Full date when this release was formally published. ISO format, like `2019-03-05`. See guide for semantics. + #[serde(rename = "release_date")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_date: Option<chrono::NaiveDate>, + + /// Year when this release was formally published. Must match `release_date` if that field is set; this field exists because sometimes only the year is known. + #[serde(rename = "release_year")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_year: Option<i64>, + + /// Type of withdrawl or retraction of this release, if applicable. If release has not been withdrawn, should be `null` (aka, not set, not the string \"null\" or an empty string). + #[serde(rename = "withdrawn_status")] + #[serde(skip_serializing_if = "Option::is_none")] + pub withdrawn_status: Option<String>, + + /// Full date when this release was formally withdrawn (if applicable). ISO format, like `release_date`. + #[serde(rename = "withdrawn_date")] + #[serde(skip_serializing_if = "Option::is_none")] + pub withdrawn_date: Option<chrono::NaiveDate>, + + /// Year corresponding with `withdrawn_date` like `release_year`/`release_date`. + #[serde(rename = "withdrawn_year")] + #[serde(skip_serializing_if = "Option::is_none")] + pub withdrawn_year: Option<i64>, + + #[serde(rename = "ext_ids")] + pub ext_ids: models::ReleaseExtIds, + + /// Volume number of container that this release was published in. Often corresponds to the \"Nth\" year of publication, but can be any string. See guide. + #[serde(rename = "volume")] + #[serde(skip_serializing_if = "Option::is_none")] + pub volume: Option<String>, + + /// Issue number of volume/container that this release was published in. Sometimes coresponds to a month number in the year, but can be any string. See guide. + #[serde(rename = "issue")] + #[serde(skip_serializing_if = "Option::is_none")] + pub issue: Option<String>, + + /// Either a single page number (\"first page\") or a range of pages separated by a dash (\"-\"). See guide for details. + #[serde(rename = "pages")] + #[serde(skip_serializing_if = "Option::is_none")] + pub pages: Option<String>, + + /// For, eg, technical reports, which are published in series or assigned some other institutional or container-specific identifier. + #[serde(rename = "number")] + #[serde(skip_serializing_if = "Option::is_none")] + pub number: Option<String>, + + /// For, eg, updated technical reports or software packages, where the version string may be the only field disambiguating between releases. + #[serde(rename = "version")] + #[serde(skip_serializing_if = "Option::is_none")] + pub version: Option<String>, + + /// Name, usually English, of the entity or institution responsible for publication of this release. Not necessarily the imprint/brand. See guide. + #[serde(rename = "publisher")] + #[serde(skip_serializing_if = "Option::is_none")] + pub publisher: Option<String>, + + /// Primary language of the content of the full release. Two-letter RFC1766/ISO639-1 language code, with some custom extensions/additions. See guide. + #[serde(rename = "language")] + #[serde(skip_serializing_if = "Option::is_none")] + pub language: Option<String>, + + /// Short string (slug) name of license under which release is openly published (if applicable). + #[serde(rename = "license_slug")] + #[serde(skip_serializing_if = "Option::is_none")] + pub license_slug: Option<String>, + + #[serde(rename = "contribs")] + #[serde(skip_serializing_if = "Option::is_none")] + pub contribs: Option<Vec<models::ReleaseContrib>>, + + #[serde(rename = "refs")] + #[serde(skip_serializing_if = "Option::is_none")] + pub refs: Option<Vec<models::ReleaseRef>>, + + #[serde(rename = "abstracts")] + #[serde(skip_serializing_if = "Option::is_none")] + pub abstracts: Option<Vec<models::ReleaseAbstract>>, +} + +impl ReleaseEntity { + pub fn new(ext_ids: models::ReleaseExtIds) -> ReleaseEntity { + ReleaseEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + title: None, + subtitle: None, + original_title: None, + work_id: None, + container: None, + files: None, + filesets: None, + webcaptures: None, + container_id: None, + release_type: None, + release_stage: None, + release_date: None, + release_year: None, + withdrawn_status: None, + withdrawn_date: None, + withdrawn_year: None, + ext_ids: ext_ids, + volume: None, + issue: None, + pages: None, + number: None, + version: None, + publisher: None, + language: None, + license_slug: None, + contribs: None, + refs: None, + abstracts: None, + } + } +} + +/// Converts the ReleaseEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + if let Some(ref title) = self.title { + params.push("title".to_string()); + params.push(title.to_string()); + } + + if let Some(ref subtitle) = self.subtitle { + params.push("subtitle".to_string()); + params.push(subtitle.to_string()); + } + + if let Some(ref original_title) = self.original_title { + params.push("original_title".to_string()); + params.push(original_title.to_string()); + } + + if let Some(ref work_id) = self.work_id { + params.push("work_id".to_string()); + params.push(work_id.to_string()); + } + + // Skipping container in query parameter serialization + + // Skipping files in query parameter serialization + + // Skipping filesets in query parameter serialization + + // Skipping webcaptures in query parameter serialization + + if let Some(ref container_id) = self.container_id { + params.push("container_id".to_string()); + params.push(container_id.to_string()); + } + + if let Some(ref release_type) = self.release_type { + params.push("release_type".to_string()); + params.push(release_type.to_string()); + } + + if let Some(ref release_stage) = self.release_stage { + params.push("release_stage".to_string()); + params.push(release_stage.to_string()); + } + + // Skipping release_date in query parameter serialization + + if let Some(ref release_year) = self.release_year { + params.push("release_year".to_string()); + params.push(release_year.to_string()); + } + + if let Some(ref withdrawn_status) = self.withdrawn_status { + params.push("withdrawn_status".to_string()); + params.push(withdrawn_status.to_string()); + } + + // Skipping withdrawn_date in query parameter serialization + + if let Some(ref withdrawn_year) = self.withdrawn_year { + params.push("withdrawn_year".to_string()); + params.push(withdrawn_year.to_string()); + } + + // Skipping ext_ids in query parameter serialization + + if let Some(ref volume) = self.volume { + params.push("volume".to_string()); + params.push(volume.to_string()); + } + + if let Some(ref issue) = self.issue { + params.push("issue".to_string()); + params.push(issue.to_string()); + } + + if let Some(ref pages) = self.pages { + params.push("pages".to_string()); + params.push(pages.to_string()); + } + + if let Some(ref number) = self.number { + params.push("number".to_string()); + params.push(number.to_string()); + } + + if let Some(ref version) = self.version { + params.push("version".to_string()); + params.push(version.to_string()); + } + + if let Some(ref publisher) = self.publisher { + params.push("publisher".to_string()); + params.push(publisher.to_string()); + } + + if let Some(ref language) = self.language { + params.push("language".to_string()); + params.push(language.to_string()); + } + + if let Some(ref license_slug) = self.license_slug { + params.push("license_slug".to_string()); + params.push(license_slug.to_string()); + } + + // Skipping contribs in query parameter serialization + + // Skipping refs in query parameter serialization + + // Skipping abstracts in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub title: Vec<String>, + pub subtitle: Vec<String>, + pub original_title: Vec<String>, + pub work_id: Vec<String>, + pub container: Vec<models::ContainerEntity>, + pub files: Vec<Vec<models::FileEntity>>, + pub filesets: Vec<Vec<models::FilesetEntity>>, + pub webcaptures: Vec<Vec<models::WebcaptureEntity>>, + pub container_id: Vec<String>, + pub release_type: Vec<String>, + pub release_stage: Vec<String>, + pub release_date: Vec<chrono::NaiveDate>, + pub release_year: Vec<i64>, + pub withdrawn_status: Vec<String>, + pub withdrawn_date: Vec<chrono::NaiveDate>, + pub withdrawn_year: Vec<i64>, + pub ext_ids: Vec<models::ReleaseExtIds>, + pub volume: Vec<String>, + pub issue: Vec<String>, + pub pages: Vec<String>, + pub number: Vec<String>, + pub version: Vec<String>, + pub publisher: Vec<String>, + pub language: Vec<String>, + pub license_slug: Vec<String>, + pub contribs: Vec<Vec<models::ReleaseContrib>>, + pub refs: Vec<Vec<models::ReleaseRef>>, + pub abstracts: Vec<Vec<models::ReleaseAbstract>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "title" => intermediate_rep + .title + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "subtitle" => intermediate_rep + .subtitle + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "original_title" => intermediate_rep + .original_title + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "work_id" => intermediate_rep + .work_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "container" => intermediate_rep.container.push( + models::ContainerEntity::from_str(val).map_err(|x| format!("{}", x))?, + ), + "files" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "filesets" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "webcaptures" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "container_id" => intermediate_rep + .container_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "release_type" => intermediate_rep + .release_type + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "release_stage" => intermediate_rep + .release_stage + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "release_date" => intermediate_rep + .release_date + .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?), + "release_year" => intermediate_rep + .release_year + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "withdrawn_status" => intermediate_rep + .withdrawn_status + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "withdrawn_date" => intermediate_rep + .withdrawn_date + .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?), + "withdrawn_year" => intermediate_rep + .withdrawn_year + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "ext_ids" => intermediate_rep + .ext_ids + .push(models::ReleaseExtIds::from_str(val).map_err(|x| format!("{}", x))?), + "volume" => intermediate_rep + .volume + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "issue" => intermediate_rep + .issue + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "pages" => intermediate_rep + .pages + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "number" => intermediate_rep + .number + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "version" => intermediate_rep + .version + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "publisher" => intermediate_rep + .publisher + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "language" => intermediate_rep + .language + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "license_slug" => intermediate_rep + .license_slug + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "contribs" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "refs" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + "abstracts" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseEntity" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + title: intermediate_rep.title.into_iter().next(), + subtitle: intermediate_rep.subtitle.into_iter().next(), + original_title: intermediate_rep.original_title.into_iter().next(), + work_id: intermediate_rep.work_id.into_iter().next(), + container: intermediate_rep.container.into_iter().next(), + files: intermediate_rep.files.into_iter().next(), + filesets: intermediate_rep.filesets.into_iter().next(), + webcaptures: intermediate_rep.webcaptures.into_iter().next(), + container_id: intermediate_rep.container_id.into_iter().next(), + release_type: intermediate_rep.release_type.into_iter().next(), + release_stage: intermediate_rep.release_stage.into_iter().next(), + release_date: intermediate_rep.release_date.into_iter().next(), + release_year: intermediate_rep.release_year.into_iter().next(), + withdrawn_status: intermediate_rep.withdrawn_status.into_iter().next(), + withdrawn_date: intermediate_rep.withdrawn_date.into_iter().next(), + withdrawn_year: intermediate_rep.withdrawn_year.into_iter().next(), + ext_ids: intermediate_rep + .ext_ids + .into_iter() + .next() + .ok_or("ext_ids missing in ReleaseEntity".to_string())?, + volume: intermediate_rep.volume.into_iter().next(), + issue: intermediate_rep.issue.into_iter().next(), + pages: intermediate_rep.pages.into_iter().next(), + number: intermediate_rep.number.into_iter().next(), + version: intermediate_rep.version.into_iter().next(), + publisher: intermediate_rep.publisher.into_iter().next(), + language: intermediate_rep.language.into_iter().next(), + license_slug: intermediate_rep.license_slug.into_iter().next(), + contribs: intermediate_rep.contribs.into_iter().next(), + refs: intermediate_rep.refs.into_iter().next(), + abstracts: intermediate_rep.abstracts.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseExtIds> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseExtIds>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseExtIds>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseExtIds - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseExtIds> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseExtIds as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseExtIds - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseExtIds { + /// Digital Object Identifier (DOI), mostly for published papers and datasets. Should be registered and resolvable via https://doi.org/ + #[serde(rename = "doi")] + #[serde(skip_serializing_if = "Option::is_none")] + pub doi: Option<String>, + + /// Wikidata entity QID + #[serde(rename = "wikidata_qid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub wikidata_qid: Option<String>, + + /// ISBN-13, for books. Usually not set for chapters. ISBN-10 should be converted to ISBN-13. + #[serde(rename = "isbn13")] + #[serde(skip_serializing_if = "Option::is_none")] + pub isbn13: Option<String>, + + /// PubMed Identifier + #[serde(rename = "pmid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub pmid: Option<String>, + + /// PubMed Central Identifier + #[serde(rename = "pmcid")] + #[serde(skip_serializing_if = "Option::is_none")] + pub pmcid: Option<String>, + + /// CORE (https://core.ac.uk) identifier + #[serde(rename = "core")] + #[serde(skip_serializing_if = "Option::is_none")] + pub core: Option<String>, + + /// arXiv (https://arxiv.org) identifier; must include version + #[serde(rename = "arxiv")] + #[serde(skip_serializing_if = "Option::is_none")] + pub arxiv: Option<String>, + + /// JSTOR work identifier + #[serde(rename = "jstor")] + #[serde(skip_serializing_if = "Option::is_none")] + pub jstor: Option<String>, + + /// ARK identifier + #[serde(rename = "ark")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ark: Option<String>, + + /// Microsoft Academic Graph identifier + #[serde(rename = "mag")] + #[serde(skip_serializing_if = "Option::is_none")] + pub mag: Option<String>, + + /// DOAJ article-level identifier + #[serde(rename = "doaj")] + #[serde(skip_serializing_if = "Option::is_none")] + pub doaj: Option<String>, + + /// dblp (https://dblp.uni-trier.de/) paper identifier; eg for conference proceedings + #[serde(rename = "dblp")] + #[serde(skip_serializing_if = "Option::is_none")] + pub dblp: Option<String>, + + /// OAI-PMH identifier; only used when an OAI-PMH record is the only authoritative metadata (eg, journal OAI-PMH feeds w/o DOIs) + #[serde(rename = "oai")] + #[serde(skip_serializing_if = "Option::is_none")] + pub oai: Option<String>, +} + +impl ReleaseExtIds { + pub fn new() -> ReleaseExtIds { + ReleaseExtIds { + doi: None, + wikidata_qid: None, + isbn13: None, + pmid: None, + pmcid: None, + core: None, + arxiv: None, + jstor: None, + ark: None, + mag: None, + doaj: None, + dblp: None, + oai: None, + } + } +} + +/// Converts the ReleaseExtIds value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseExtIds { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref doi) = self.doi { + params.push("doi".to_string()); + params.push(doi.to_string()); + } + + if let Some(ref wikidata_qid) = self.wikidata_qid { + params.push("wikidata_qid".to_string()); + params.push(wikidata_qid.to_string()); + } + + if let Some(ref isbn13) = self.isbn13 { + params.push("isbn13".to_string()); + params.push(isbn13.to_string()); + } + + if let Some(ref pmid) = self.pmid { + params.push("pmid".to_string()); + params.push(pmid.to_string()); + } + + if let Some(ref pmcid) = self.pmcid { + params.push("pmcid".to_string()); + params.push(pmcid.to_string()); + } + + if let Some(ref core) = self.core { + params.push("core".to_string()); + params.push(core.to_string()); + } + + if let Some(ref arxiv) = self.arxiv { + params.push("arxiv".to_string()); + params.push(arxiv.to_string()); + } + + if let Some(ref jstor) = self.jstor { + params.push("jstor".to_string()); + params.push(jstor.to_string()); + } + + if let Some(ref ark) = self.ark { + params.push("ark".to_string()); + params.push(ark.to_string()); + } + + if let Some(ref mag) = self.mag { + params.push("mag".to_string()); + params.push(mag.to_string()); + } + + if let Some(ref doaj) = self.doaj { + params.push("doaj".to_string()); + params.push(doaj.to_string()); + } + + if let Some(ref dblp) = self.dblp { + params.push("dblp".to_string()); + params.push(dblp.to_string()); + } + + if let Some(ref oai) = self.oai { + params.push("oai".to_string()); + params.push(oai.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseExtIds value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseExtIds { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub doi: Vec<String>, + pub wikidata_qid: Vec<String>, + pub isbn13: Vec<String>, + pub pmid: Vec<String>, + pub pmcid: Vec<String>, + pub core: Vec<String>, + pub arxiv: Vec<String>, + pub jstor: Vec<String>, + pub ark: Vec<String>, + pub mag: Vec<String>, + pub doaj: Vec<String>, + pub dblp: Vec<String>, + pub oai: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseExtIds".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "doi" => intermediate_rep + .doi + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "wikidata_qid" => intermediate_rep + .wikidata_qid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "isbn13" => intermediate_rep + .isbn13 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "pmid" => intermediate_rep + .pmid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "pmcid" => intermediate_rep + .pmcid + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "core" => intermediate_rep + .core + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "arxiv" => intermediate_rep + .arxiv + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "jstor" => intermediate_rep + .jstor + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ark" => intermediate_rep + .ark + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "mag" => intermediate_rep + .mag + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "doaj" => intermediate_rep + .doaj + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "dblp" => intermediate_rep + .dblp + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "oai" => intermediate_rep + .oai + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseExtIds".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseExtIds { + doi: intermediate_rep.doi.into_iter().next(), + wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(), + isbn13: intermediate_rep.isbn13.into_iter().next(), + pmid: intermediate_rep.pmid.into_iter().next(), + pmcid: intermediate_rep.pmcid.into_iter().next(), + core: intermediate_rep.core.into_iter().next(), + arxiv: intermediate_rep.arxiv.into_iter().next(), + jstor: intermediate_rep.jstor.into_iter().next(), + ark: intermediate_rep.ark.into_iter().next(), + mag: intermediate_rep.mag.into_iter().next(), + doaj: intermediate_rep.doaj.into_iter().next(), + dblp: intermediate_rep.dblp.into_iter().next(), + oai: intermediate_rep.oai.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<ReleaseRef>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for ReleaseRef - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <ReleaseRef as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into ReleaseRef - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct ReleaseRef { + /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`. + #[serde(rename = "index")] + #[serde(skip_serializing_if = "Option::is_none")] + pub index: Option<i64>, + + /// Optional, fatcat identifier of release entity that this reference is citing. + #[serde(rename = "target_release_id")] + #[serde(skip_serializing_if = "Option::is_none")] + pub target_release_id: Option<String>, + + /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field. + #[serde(rename = "key")] + #[serde(skip_serializing_if = "Option::is_none")] + pub key: Option<String>, + + /// Year that the cited work was published in. + #[serde(rename = "year")] + #[serde(skip_serializing_if = "Option::is_none")] + pub year: Option<i64>, + + /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name. + #[serde(rename = "container_name")] + #[serde(skip_serializing_if = "Option::is_none")] + pub container_name: Option<String>, + + /// Name of the work being cited. + #[serde(rename = "title")] + #[serde(skip_serializing_if = "Option::is_none")] + pub title: Option<String>, + + /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited. + #[serde(rename = "locator")] + #[serde(skip_serializing_if = "Option::is_none")] + pub locator: Option<String>, +} + +impl ReleaseRef { + pub fn new() -> ReleaseRef { + ReleaseRef { + index: None, + target_release_id: None, + extra: None, + key: None, + year: None, + container_name: None, + title: None, + locator: None, + } + } +} + +/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for ReleaseRef { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref index) = self.index { + params.push("index".to_string()); + params.push(index.to_string()); + } + + if let Some(ref target_release_id) = self.target_release_id { + params.push("target_release_id".to_string()); + params.push(target_release_id.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + if let Some(ref key) = self.key { + params.push("key".to_string()); + params.push(key.to_string()); + } + + if let Some(ref year) = self.year { + params.push("year".to_string()); + params.push(year.to_string()); + } + + if let Some(ref container_name) = self.container_name { + params.push("container_name".to_string()); + params.push(container_name.to_string()); + } + + if let Some(ref title) = self.title { + params.push("title".to_string()); + params.push(title.to_string()); + } + + if let Some(ref locator) = self.locator { + params.push("locator".to_string()); + params.push(locator.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for ReleaseRef { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub index: Vec<i64>, + pub target_release_id: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub key: Vec<String>, + pub year: Vec<i64>, + pub container_name: Vec<String>, + pub title: Vec<String>, + pub locator: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing ReleaseRef".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "index" => intermediate_rep + .index + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "target_release_id" => intermediate_rep + .target_release_id + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in ReleaseRef" + .to_string(), + ) + } + "key" => intermediate_rep + .key + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "year" => intermediate_rep + .year + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "container_name" => intermediate_rep + .container_name + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "title" => intermediate_rep + .title + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "locator" => intermediate_rep + .locator + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing ReleaseRef".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(ReleaseRef { + index: intermediate_rep.index.into_iter().next(), + target_release_id: intermediate_rep.target_release_id.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + key: intermediate_rep.key.into_iter().next(), + year: intermediate_rep.year.into_iter().next(), + container_name: intermediate_rep.container_name.into_iter().next(), + title: intermediate_rep.title.into_iter().next(), + locator: intermediate_rep.locator.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<Success>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for Success - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <Success as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into Success - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct Success { + #[serde(rename = "success")] + pub success: bool, + + #[serde(rename = "message")] + pub message: String, +} + +impl Success { + pub fn new(success: bool, message: String) -> Success { + Success { + success: success, + message: message, + } + } +} + +/// Converts the Success value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for Success { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("success".to_string()); + params.push(self.success.to_string()); + + params.push("message".to_string()); + params.push(self.message.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a Success value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for Success { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub success: Vec<bool>, + pub message: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing Success".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "success" => intermediate_rep + .success + .push(bool::from_str(val).map_err(|x| format!("{}", x))?), + "message" => intermediate_rep + .message + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing Success".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(Success { + success: intermediate_rep + .success + .into_iter() + .next() + .ok_or("success missing in Success".to_string())?, + message: intermediate_rep + .message + .into_iter() + .next() + .ok_or("message missing in Success".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<WebcaptureAutoBatch> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WebcaptureAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WebcaptureAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::WebcaptureEntity>, +} + +impl WebcaptureAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::WebcaptureEntity>, + ) -> WebcaptureAutoBatch { + WebcaptureAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WebcaptureAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WebcaptureAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::WebcaptureEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WebcaptureAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureAutoBatch" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WebcaptureAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WebcaptureAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<WebcaptureCdxLine> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WebcaptureCdxLine - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WebcaptureCdxLine { + /// \"Sortable URL\" format. See guide for details. + #[serde(rename = "surt")] + pub surt: String, + + /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision. + #[serde(rename = "timestamp")] + pub timestamp: chrono::DateTime<chrono::Utc>, + + /// Full URL/URI of resource captured. + #[serde(rename = "url")] + pub url: String, + + /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type. + #[serde(rename = "mimetype")] + #[serde(skip_serializing_if = "Option::is_none")] + pub mimetype: Option<String>, + + /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully. + #[serde(rename = "status_code")] + #[serde(skip_serializing_if = "Option::is_none")] + pub status_code: Option<i64>, + + /// Resource (file) size in bytes + #[serde(rename = "size")] + #[serde(skip_serializing_if = "Option::is_none")] + pub size: Option<i64>, + + /// SHA-1 hash of data, in hex encoding + #[serde(rename = "sha1")] + pub sha1: String, + + /// SHA-256 hash of data, in hex encoding + #[serde(rename = "sha256")] + #[serde(skip_serializing_if = "Option::is_none")] + pub sha256: Option<String>, +} + +impl WebcaptureCdxLine { + pub fn new( + surt: String, + timestamp: chrono::DateTime<chrono::Utc>, + url: String, + sha1: String, + ) -> WebcaptureCdxLine { + WebcaptureCdxLine { + surt: surt, + timestamp: timestamp, + url: url, + mimetype: None, + status_code: None, + size: None, + sha1: sha1, + sha256: None, + } + } +} + +/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WebcaptureCdxLine { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("surt".to_string()); + params.push(self.surt.to_string()); + + // Skipping timestamp in query parameter serialization + + params.push("url".to_string()); + params.push(self.url.to_string()); + + if let Some(ref mimetype) = self.mimetype { + params.push("mimetype".to_string()); + params.push(mimetype.to_string()); + } + + if let Some(ref status_code) = self.status_code { + params.push("status_code".to_string()); + params.push(status_code.to_string()); + } + + if let Some(ref size) = self.size { + params.push("size".to_string()); + params.push(size.to_string()); + } + + params.push("sha1".to_string()); + params.push(self.sha1.to_string()); + + if let Some(ref sha256) = self.sha256 { + params.push("sha256".to_string()); + params.push(sha256.to_string()); + } + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WebcaptureCdxLine { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub surt: Vec<String>, + pub timestamp: Vec<chrono::DateTime<chrono::Utc>>, + pub url: Vec<String>, + pub mimetype: Vec<String>, + pub status_code: Vec<i64>, + pub size: Vec<i64>, + pub sha1: Vec<String>, + pub sha256: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WebcaptureCdxLine".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "surt" => intermediate_rep + .surt + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "timestamp" => intermediate_rep.timestamp.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "url" => intermediate_rep + .url + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "mimetype" => intermediate_rep + .mimetype + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "status_code" => intermediate_rep + .status_code + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "size" => intermediate_rep + .size + .push(i64::from_str(val).map_err(|x| format!("{}", x))?), + "sha1" => intermediate_rep + .sha1 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "sha256" => intermediate_rep + .sha256 + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WebcaptureCdxLine".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WebcaptureCdxLine { + surt: intermediate_rep + .surt + .into_iter() + .next() + .ok_or("surt missing in WebcaptureCdxLine".to_string())?, + timestamp: intermediate_rep + .timestamp + .into_iter() + .next() + .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?, + url: intermediate_rep + .url + .into_iter() + .next() + .ok_or("url missing in WebcaptureCdxLine".to_string())?, + mimetype: intermediate_rep.mimetype.into_iter().next(), + status_code: intermediate_rep.status_code.into_iter().next(), + size: intermediate_rep.size.into_iter().next(), + sha1: intermediate_rep + .sha1 + .into_iter() + .next() + .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?, + sha256: intermediate_rep.sha256.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>> + for hyper::header::HeaderValue +{ + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WebcaptureEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WebcaptureEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> + for header::IntoHeaderValue<WebcaptureEntity> +{ + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WebcaptureEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WebcaptureEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WebcaptureEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + #[serde(rename = "cdx")] + #[serde(skip_serializing_if = "Option::is_none")] + pub cdx: Option<Vec<models::WebcaptureCdxLine>>, + + #[serde(rename = "archive_urls")] + #[serde(skip_serializing_if = "Option::is_none")] + pub archive_urls: Option<Vec<models::WebcaptureUrl>>, + + /// Base URL of the primary resource this is a capture of + #[serde(rename = "original_url")] + #[serde(skip_serializing_if = "Option::is_none")] + pub original_url: Option<String>, + + /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL. + #[serde(rename = "timestamp")] + #[serde(skip_serializing_if = "Option::is_none")] + pub timestamp: Option<chrono::DateTime<chrono::Utc>>, + + /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release. + #[serde(rename = "release_ids")] + #[serde(skip_serializing_if = "Option::is_none")] + pub release_ids: Option<Vec<String>>, + + /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests. + #[serde(rename = "releases")] + #[serde(skip_serializing_if = "Option::is_none")] + pub releases: Option<Vec<models::ReleaseEntity>>, +} + +impl WebcaptureEntity { + pub fn new() -> WebcaptureEntity { + WebcaptureEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + cdx: None, + archive_urls: None, + original_url: None, + timestamp: None, + release_ids: None, + releases: None, + } + } +} + +/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WebcaptureEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + // Skipping cdx in query parameter serialization + + // Skipping archive_urls in query parameter serialization + + if let Some(ref original_url) = self.original_url { + params.push("original_url".to_string()); + params.push(original_url.to_string()); + } + + // Skipping timestamp in query parameter serialization + + if let Some(ref release_ids) = self.release_ids { + params.push("release_ids".to_string()); + params.push( + release_ids + .iter() + .map(|x| x.to_string()) + .collect::<Vec<_>>() + .join(",") + .to_string(), + ); + } + + // Skipping releases in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WebcaptureEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub cdx: Vec<Vec<models::WebcaptureCdxLine>>, + pub archive_urls: Vec<Vec<models::WebcaptureUrl>>, + pub original_url: Vec<String>, + pub timestamp: Vec<chrono::DateTime<chrono::Utc>>, + pub release_ids: Vec<Vec<String>>, + pub releases: Vec<Vec<models::ReleaseEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WebcaptureEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + "edit_extra" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + "cdx" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + "archive_urls" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + "original_url" => intermediate_rep + .original_url + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "timestamp" => intermediate_rep.timestamp.push( + chrono::DateTime::<chrono::Utc>::from_str(val) + .map_err(|x| format!("{}", x))?, + ), + "release_ids" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + "releases" => return std::result::Result::Err( + "Parsing a container in this style is not supported in WebcaptureEntity" + .to_string(), + ), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WebcaptureEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WebcaptureEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + cdx: intermediate_rep.cdx.into_iter().next(), + archive_urls: intermediate_rep.archive_urls.into_iter().next(), + original_url: intermediate_rep.original_url.into_iter().next(), + timestamp: intermediate_rep.timestamp.into_iter().next(), + release_ids: intermediate_rep.release_ids.into_iter().next(), + releases: intermediate_rep.releases.into_iter().next(), + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WebcaptureUrl>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WebcaptureUrl - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WebcaptureUrl as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WebcaptureUrl - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WebcaptureUrl { + /// URL/URI pointing to archive of this web resource. + #[serde(rename = "url")] + pub url: String, + + /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list. + #[serde(rename = "rel")] + pub rel: String, +} + +impl WebcaptureUrl { + pub fn new(url: String, rel: String) -> WebcaptureUrl { + WebcaptureUrl { url: url, rel: rel } + } +} + +/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WebcaptureUrl { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + params.push("url".to_string()); + params.push(self.url.to_string()); + + params.push("rel".to_string()); + params.push(self.rel.to_string()); + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WebcaptureUrl { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub url: Vec<String>, + pub rel: Vec<String>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WebcaptureUrl".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "url" => intermediate_rep + .url + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "rel" => intermediate_rep + .rel + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WebcaptureUrl".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WebcaptureUrl { + url: intermediate_rep + .url + .into_iter() + .next() + .ok_or("url missing in WebcaptureUrl".to_string())?, + rel: intermediate_rep + .rel + .into_iter() + .next() + .ok_or("rel missing in WebcaptureUrl".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WorkAutoBatch>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WorkAutoBatch - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WorkAutoBatch as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WorkAutoBatch - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WorkAutoBatch { + #[serde(rename = "editgroup")] + pub editgroup: models::Editgroup, + + #[serde(rename = "entity_list")] + pub entity_list: Vec<models::WorkEntity>, +} + +impl WorkAutoBatch { + pub fn new( + editgroup: models::Editgroup, + entity_list: Vec<models::WorkEntity>, + ) -> WorkAutoBatch { + WorkAutoBatch { + editgroup: editgroup, + entity_list: entity_list, + } + } +} + +/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WorkAutoBatch { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + // Skipping editgroup in query parameter serialization + + // Skipping entity_list in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WorkAutoBatch { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub editgroup: Vec<models::Editgroup>, + pub entity_list: Vec<Vec<models::WorkEntity>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WorkAutoBatch".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "editgroup" => intermediate_rep + .editgroup + .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?), + "entity_list" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in WorkAutoBatch" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WorkAutoBatch".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WorkAutoBatch { + editgroup: intermediate_rep + .editgroup + .into_iter() + .next() + .ok_or("editgroup missing in WorkAutoBatch".to_string())?, + entity_list: intermediate_rep + .entity_list + .into_iter() + .next() + .ok_or("entity_list missing in WorkAutoBatch".to_string())?, + }) + } +} + +// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue { + type Error = String; + + fn try_from( + hdr_value: header::IntoHeaderValue<WorkEntity>, + ) -> std::result::Result<Self, Self::Error> { + let hdr_value = hdr_value.to_string(); + match hyper::header::HeaderValue::from_str(&hdr_value) { + std::result::Result::Ok(value) => std::result::Result::Ok(value), + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Invalid header value for WorkEntity - value: {} is invalid {}", + hdr_value, e + )), + } + } +} + +#[cfg(any(feature = "client", feature = "server"))] +impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> { + type Error = String; + + fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> { + match hdr_value.to_str() { + std::result::Result::Ok(value) => { + match <WorkEntity as std::str::FromStr>::from_str(value) { + std::result::Result::Ok(value) => { + std::result::Result::Ok(header::IntoHeaderValue(value)) + } + std::result::Result::Err(err) => std::result::Result::Err(format!( + "Unable to convert header value '{}' into WorkEntity - {}", + value, err + )), + } + } + std::result::Result::Err(e) => std::result::Result::Err(format!( + "Unable to convert header: {:?} to string: {}", + hdr_value, e + )), + } + } +} + +#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)] +#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))] +pub struct WorkEntity { + // Note: inline enums are not fully supported by openapi-generator + #[serde(rename = "state")] + #[serde(skip_serializing_if = "Option::is_none")] + pub state: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "ident")] + #[serde(skip_serializing_if = "Option::is_none")] + pub ident: Option<String>, + + /// UUID (lower-case, dash-separated, hex-encoded 128-bit) + #[serde(rename = "revision")] + #[serde(skip_serializing_if = "Option::is_none")] + pub revision: Option<String>, + + /// base32-encoded unique identifier + #[serde(rename = "redirect")] + #[serde(skip_serializing_if = "Option::is_none")] + pub redirect: Option<String>, + + /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions. + #[serde(rename = "extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub extra: Option<std::collections::HashMap<String, serde_json::Value>>, + + /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete). + #[serde(rename = "edit_extra")] + #[serde(skip_serializing_if = "Option::is_none")] + pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>, +} + +impl WorkEntity { + pub fn new() -> WorkEntity { + WorkEntity { + state: None, + ident: None, + revision: None, + redirect: None, + extra: None, + edit_extra: None, + } + } +} + +/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false) +/// specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde serializer +impl std::string::ToString for WorkEntity { + fn to_string(&self) -> String { + let mut params: Vec<String> = vec![]; + + if let Some(ref state) = self.state { + params.push("state".to_string()); + params.push(state.to_string()); + } + + if let Some(ref ident) = self.ident { + params.push("ident".to_string()); + params.push(ident.to_string()); + } + + if let Some(ref revision) = self.revision { + params.push("revision".to_string()); + params.push(revision.to_string()); + } + + if let Some(ref redirect) = self.redirect { + params.push("redirect".to_string()); + params.push(redirect.to_string()); + } + + // Skipping extra in query parameter serialization + // Skipping extra in query parameter serialization + + // Skipping edit_extra in query parameter serialization + // Skipping edit_extra in query parameter serialization + + params.join(",").to_string() + } +} + +/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value +/// as specified in https://swagger.io/docs/specification/serialization/ +/// Should be implemented in a serde deserializer +impl std::str::FromStr for WorkEntity { + type Err = String; + + fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { + #[derive(Default)] + // An intermediate representation of the struct to use for parsing. + struct IntermediateRep { + pub state: Vec<String>, + pub ident: Vec<String>, + pub revision: Vec<String>, + pub redirect: Vec<String>, + pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>, + } + + let mut intermediate_rep = IntermediateRep::default(); + + // Parse into intermediate representation + let mut string_iter = s.split(',').into_iter(); + let mut key_result = string_iter.next(); + + while key_result.is_some() { + let val = match string_iter.next() { + Some(x) => x, + None => { + return std::result::Result::Err( + "Missing value while parsing WorkEntity".to_string(), + ) + } + }; + + if let Some(key) = key_result { + match key { + "state" => intermediate_rep + .state + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "ident" => intermediate_rep + .ident + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "revision" => intermediate_rep + .revision + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "redirect" => intermediate_rep + .redirect + .push(String::from_str(val).map_err(|x| format!("{}", x))?), + "extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in WorkEntity" + .to_string(), + ) + } + "edit_extra" => { + return std::result::Result::Err( + "Parsing a container in this style is not supported in WorkEntity" + .to_string(), + ) + } + _ => { + return std::result::Result::Err( + "Unexpected key while parsing WorkEntity".to_string(), + ) + } + } + } + + // Get the next key + key_result = string_iter.next(); + } + + // Use the intermediate representation to return the struct + std::result::Result::Ok(WorkEntity { + state: intermediate_rep.state.into_iter().next(), + ident: intermediate_rep.ident.into_iter().next(), + revision: intermediate_rep.revision.into_iter().next(), + redirect: intermediate_rep.redirect.into_iter().next(), + extra: intermediate_rep.extra.into_iter().next(), + edit_extra: intermediate_rep.edit_extra.into_iter().next(), + }) + } +} 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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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( + ¶m_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( + ¶m_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(¶m_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( + ¶m_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( + ¶m_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(¶m_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( + ¶m_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( + ¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(¶m_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(()), + } + } +} |