use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementError {
pub message: String,
#[serde(flatten)]
pub kind: PassportElementErrorKind,
}
impl PassportElementError {
pub fn new<S>(message: S, kind: PassportElementErrorKind) -> Self
where
S: Into<String>,
{
Self { message: message.into(), kind }
}
pub fn message<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.message = val.into();
self
}
#[must_use]
pub fn kind(mut self, val: PassportElementErrorKind) -> Self {
self.kind = val;
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "source")]
pub enum PassportElementErrorKind {
#[serde(rename = "data")]
DataField(PassportElementErrorDataField),
#[serde(rename = "snake_case")]
FrontSide(PassportElementErrorFrontSide),
#[serde(rename = "snake_case")]
ReverseSide(PassportElementErrorReverseSide),
#[serde(rename = "snake_case")]
Selfie(PassportElementErrorSelfie),
#[serde(rename = "snake_case")]
File(PassportElementErrorFile),
#[serde(rename = "snake_case")]
Files(PassportElementErrorFiles),
#[serde(rename = "snake_case")]
TranslationFile(PassportElementErrorTranslationFile),
#[serde(rename = "snake_case")]
TranslationFiles(PassportElementErrorTranslationFiles),
#[serde(rename = "snake_case")]
Unspecified(PassportElementErrorUnspecified),
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorDataField {
pub r#type: PassportElementErrorDataFieldType,
pub field_name: String,
pub data_hash: String,
}
impl PassportElementErrorDataField {
pub fn new<S1, S2>(
r#type: PassportElementErrorDataFieldType,
field_name: S1,
data_hash: S2,
) -> Self
where
S1: Into<String>,
S2: Into<String>,
{
Self { r#type, field_name: field_name.into(), data_hash: data_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorDataFieldType) -> Self {
self.r#type = val;
self
}
pub fn field_name<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.field_name = val.into();
self
}
pub fn data_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.data_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorFrontSide {
pub r#type: PassportElementErrorFrontSideType,
pub file_hash: String,
}
impl PassportElementErrorFrontSide {
pub fn new<S>(r#type: PassportElementErrorFrontSideType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, file_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorFrontSideType) -> Self {
self.r#type = val;
self
}
pub fn file_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.file_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorReverseSide {
pub r#type: PassportElementErrorReverseSideType,
pub file_hash: String,
}
impl PassportElementErrorReverseSide {
pub fn new<S>(r#type: PassportElementErrorReverseSideType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, file_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorReverseSideType) -> Self {
self.r#type = val;
self
}
pub fn file_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.file_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorSelfie {
pub r#type: PassportElementErrorSelfieType,
pub file_hash: String,
}
impl PassportElementErrorSelfie {
pub fn new<S>(r#type: PassportElementErrorSelfieType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, file_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorSelfieType) -> Self {
self.r#type = val;
self
}
pub fn file_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.file_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorFile {
pub r#type: PassportElementErrorFileType,
pub file_hash: String,
}
impl PassportElementErrorFile {
pub fn new<S>(r#type: PassportElementErrorFileType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, file_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorFileType) -> Self {
self.r#type = val;
self
}
pub fn file_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.file_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorFiles {
pub r#type: PassportElementErrorFilesType,
pub file_hashes: Vec<String>,
}
impl PassportElementErrorFiles {
pub fn new<S>(r#type: PassportElementErrorFilesType, file_hashes: S) -> Self
where
S: IntoIterator<Item = String>,
{
Self { r#type, file_hashes: file_hashes.into_iter().collect() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorFilesType) -> Self {
self.r#type = val;
self
}
pub fn file_hashes<S>(mut self, val: S) -> Self
where
S: IntoIterator<Item = String>,
{
self.file_hashes = val.into_iter().collect();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorTranslationFile {
pub r#type: PassportElementErrorTranslationFileType,
pub file_hash: String,
}
impl PassportElementErrorTranslationFile {
pub fn new<S>(r#type: PassportElementErrorTranslationFileType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, file_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorTranslationFileType) -> Self {
self.r#type = val;
self
}
pub fn file_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.file_hash = val.into();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorTranslationFiles {
pub r#type: PassportElementErrorTranslationFilesType,
pub file_hashes: Vec<String>,
}
impl PassportElementErrorTranslationFiles {
pub fn new<S>(r#type: PassportElementErrorTranslationFilesType, file_hashes: S) -> Self
where
S: IntoIterator<Item = String>,
{
Self { r#type, file_hashes: file_hashes.into_iter().collect() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorTranslationFilesType) -> Self {
self.r#type = val;
self
}
pub fn file_hashes<S>(mut self, val: S) -> Self
where
S: IntoIterator<Item = String>,
{
self.file_hashes = val.into_iter().collect();
self
}
}
#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub struct PassportElementErrorUnspecified {
pub r#type: PassportElementErrorUnspecifiedType,
pub element_hash: String,
}
impl PassportElementErrorUnspecified {
pub fn new<S>(r#type: PassportElementErrorUnspecifiedType, file_hash: S) -> Self
where
S: Into<String>,
{
Self { r#type, element_hash: file_hash.into() }
}
#[must_use]
pub fn r#type(mut self, val: PassportElementErrorUnspecifiedType) -> Self {
self.r#type = val;
self
}
pub fn element_hash<S>(mut self, val: S) -> Self
where
S: Into<String>,
{
self.element_hash = val.into();
self
}
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorDataFieldType {
PersonalDetails,
Passport,
DriverLicense,
IdentityCard,
InternalPassport,
Address,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorFrontSideType {
Passport,
DriverLicense,
IdentityCard,
InternalPassport,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorReverseSideType {
DriverLicense,
IdentityCard,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorSelfieType {
Passport,
DriverLicense,
IdentityCard,
InternalPassport,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorFileType {
UtilityBill,
BankStatement,
RentalAgreement,
PassportRegistration,
TemporaryRegistration,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorFilesType {
UtilityBill,
BankStatement,
RentalAgreement,
PassportRegistration,
TemporaryRegistration,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorTranslationFileType {
Passport,
DriverLicense,
IdentityCard,
InternalPassport,
UtilityBill,
BankStatement,
RentalAgreement,
PassportRegistration,
TemporaryRegistration,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorTranslationFilesType {
Passport,
DriverLicense,
IdentityCard,
InternalPassport,
UtilityBill,
BankStatement,
RentalAgreement,
PassportRegistration,
TemporaryRegistration,
}
#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PassportElementErrorUnspecifiedType {
DataField,
FrontSide,
ReverseSide,
Selfie,
File,
Files,
TranslationFile,
TranslationFiles,
Unspecified,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serialize_data_field() {
let data = PassportElementError {
message: "This is an error message!".to_owned(),
kind: PassportElementErrorKind::DataField(PassportElementErrorDataField {
r#type: PassportElementErrorDataFieldType::InternalPassport,
field_name: "The field name".to_owned(),
data_hash: "This is a data hash".to_owned(),
}),
};
assert_eq!(
serde_json::to_string(&data).unwrap(),
r#"{"message":"This is an error message!","source":"data","type":"internal_passport","field_name":"The field name","data_hash":"This is a data hash"}"#
);
}
}