diff options
Diffstat (limited to 'fatcat-openapi/src/models.rs')
| -rw-r--r-- | fatcat-openapi/src/models.rs | 7621 |
1 files changed, 7621 insertions, 0 deletions
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(), + }) + } +} |