crossref_xml/journal/

issue.rs

use crate::{
    enums::{ContributorRole, InstitutionIdType, Iso639_1, MediaTypeDate, NameStyle, Sequence},
    journal::metadata::{ArchiveLocations, DoiData},
    regex::{INSTITUTION_PID_REGEX, NAME_REGEX, ORCID_REGEX},
    serializers::*,
};
use serde::Serialize;
use validator::Validate;

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct JournalIssue {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub contributors: Vec<Contributor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub titles: Option<Titles>,
    #[validate(nested)]
    pub publication_date: PublicationDate,
    // TODO: journal_volume
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(length(min = 1, max = 32))]
    pub issue: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(length(min = 1, max = 15))]
    pub special_numbering: Option<String>,
    #[validate(nested)]
    pub archive_locations: ArchiveLocations,
    #[validate(nested)]
    pub doi_data: DoiData,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct PublicationDate {
    #[serde(rename = "@media_type")]
    pub media_type: MediaTypeDate,
    #[serde(serialize_with = "serialize_two_digits")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(range(min = 1, max = 34))]
    pub month: Option<u32>,
    #[serde(serialize_with = "serialize_two_digits")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(range(min = 1, max = 31))]
    pub day: Option<u32>,
    #[validate(range(min = 1400, max = 2200))]
    pub year: i32,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Titles {
    pub title: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub original_language_title: Option<OriginalLanguageTitle>,
    #[serde(rename = "subtitle")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orginal_language_subtitle: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct OriginalLanguageTitle {
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    #[serde(rename = "$text")]
    pub value: String,
}

// TODO: Validate at least one is present
// #[derive(Debug, Clone, Default, Serialize, Validate)]
// pub struct Contributors {
//     #[serde(skip_serializing_if = "Option::is_none")]
//     #[validate(nested)]
//     pub organization: Option<Organization>,
//     #[serde(skip_serializing_if = "Option::is_none")]
//     #[validate(nested)]
//     pub person_name: Option<PersonName>,
//     #[serde(skip_serializing_if = "Option::is_none")]
//     #[validate(nested)]
//     pub anonymous: Option<Anonymous>,
// }

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Contributors {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    #[serde(rename = "$text")]
    pub value: Vec<Contributor>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Contributor {
    #[serde(skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub organization: Vec<Organization>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub person_name: Vec<PersonName>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub anonymous: Vec<Anonymous>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Organization {
    #[serde(rename = "$text")]
    pub value: String,
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    #[serde(rename = "@sequence")]
    pub sequence: Sequence,
    #[serde(rename = "@contributor_role")]
    pub contributor_role: ContributorRole,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Anonymous {
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    #[serde(rename = "@sequence")]
    pub sequence: Sequence,
    #[serde(rename = "@contributor_role")]
    pub contributor_role: ContributorRole,
    #[serde(rename = "@name-style")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_style: Option<NameStyle>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct PersonName {
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    #[serde(rename = "@sequence")]
    pub sequence: Sequence,
    #[serde(rename = "@contributor_role")]
    pub contributor_role: ContributorRole,
    #[serde(rename = "@name-style")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name_style: Option<NameStyle>,
    #[validate(length(min = 1, max = 60))]
    #[validate(regex(path = *NAME_REGEX))]
    pub given_name: String,
    #[validate(length(min = 1, max = 60))]
    #[validate(regex(path = *NAME_REGEX))]
    pub surname: String,
    #[validate(length(min = 1, max = 10))]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suffix: Option<String>,
    #[serde(skip_serializing_if = "Affiliations::is_empty")]
    #[validate(nested)]
    pub affiliations: Affiliations,
    #[serde(rename = "ORCID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub orcid: Option<Orcid>,
    // pub TODO: alt-name
}

impl Affiliations {
    pub fn is_empty(&self) -> bool {
        self.institution.is_empty()
    }
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Orcid {
    #[serde(rename = "@authenticated")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authenticated: Option<bool>,
    #[serde(rename = "$text")]
    #[validate(regex(path = *ORCID_REGEX))]
    pub value: String,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Affiliations {
    #[validate(nested)]
    pub institution: Vec<Institution>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Institution {
    #[validate(nested)]
    pub institution_id: InstitutionId,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct InstitutionId {
    #[serde(rename = "@type")]
    pub institution_type: InstitutionIdType,
    #[serde(rename = "$text")]
    #[validate(regex(path = *INSTITUTION_PID_REGEX))]
    pub value: String,
}

#[cfg(test)]
mod unit {
    use super::*;

    mod institution_id {
        use super::*;

        fn valid_institution_id() -> InstitutionId {
            InstitutionId {
                institution_type: InstitutionIdType::Ror,
                value: "https://ror.org/12345".to_string(),
            }
        }

        #[test]
        fn valid_institution_id_passes() {
            let inst_id = valid_institution_id();
            assert!(inst_id.validate().is_ok());
        }

        #[test]
        fn invalid_url_fails() {
            let mut inst_id = valid_institution_id();
            inst_id.value = "http://example.com".to_string(); // http not https
            assert!(inst_id.validate().is_err());
        }

        #[test]
        fn various_institution_types_pass() {
            let types = [
                InstitutionIdType::Ror,
                InstitutionIdType::Isni,
                InstitutionIdType::Wikidata,
            ];
            for inst_type in types {
                let mut inst_id = valid_institution_id();
                inst_id.institution_type = inst_type;
                assert!(inst_id.validate().is_ok());
            }
        }
    }

    mod institution {
        use super::*;

        fn valid_institution() -> Institution {
            Institution {
                institution_id: InstitutionId {
                    institution_type: InstitutionIdType::Ror,
                    value: "https://ror.org/12345".to_string(),
                },
            }
        }

        #[test]
        fn valid_institution_passes() {
            let inst = valid_institution();
            assert!(inst.validate().is_ok());
        }
    }

    mod affiliations {
        use super::*;

        fn valid_affiliation() -> Affiliations {
            Affiliations {
                institution: vec![Institution {
                    institution_id: InstitutionId {
                        institution_type: InstitutionIdType::Ror,
                        value: "https://ror.org/12345".to_string(),
                    },
                }],
            }
        }

        #[test]
        fn valid_affiliations_passes() {
            let aff = valid_affiliation();
            assert!(aff.validate().is_ok());
            assert!(!aff.is_empty());
        }

        #[test]
        fn empty_affiliations_passes() {
            let aff = Affiliations::default();
            assert!(aff.validate().is_ok());
            assert!(aff.is_empty());
        }

        #[test]
        fn multiple_institutions_pass() {
            let aff = Affiliations {
                institution: vec![
                    Institution {
                        institution_id: InstitutionId {
                            institution_type: InstitutionIdType::Ror,
                            value: "https://ror.org/12345".to_string(),
                        },
                    },
                    Institution {
                        institution_id: InstitutionId {
                            institution_type: InstitutionIdType::Isni,
                            value: "https://isni.org/abc".to_string(),
                        },
                    },
                ],
            };
            assert!(aff.validate().is_ok());
        }
    }

    mod orcid {
        use super::*;

        fn valid_orcid() -> Orcid {
            Orcid {
                authenticated: Some(true),
                value: "https://orcid.org/0000-0002-1825-0097".to_string(),
            }
        }

        #[test]
        fn valid_orcid_passes() {
            let orcid = valid_orcid();
            assert!(orcid.validate().is_ok());
        }

        #[test]
        fn invalid_orcid_format_fails() {
            let mut orcid = valid_orcid();
            orcid.value = "invalid-orcid".to_string();
            assert!(orcid.validate().is_err());
        }

        #[test]
        fn orcid_without_protocol_fails() {
            let mut orcid = valid_orcid();
            orcid.value = "orcid.org/0000-0002-1825-0097".to_string();
            assert!(orcid.validate().is_err());
        }

        #[test]
        fn authenticated_false_passes() {
            let orcid = Orcid {
                authenticated: Some(false),
                value: "https://orcid.org/0000-0002-1825-0097".to_string(),
            };
            assert!(orcid.validate().is_ok());
        }

        #[test]
        fn authenticated_none_passes() {
            let orcid = Orcid {
                authenticated: None,
                value: "https://orcid.org/0000-0002-1825-0097".to_string(),
            };
            assert!(orcid.validate().is_ok());
        }

        #[test]
        fn various_valid_orcids_pass() {
            let orcids = [
                "https://orcid.org/0000-0002-1825-0097",
                "http://orcid.org/0000-0001-5109-3700",
                "https://orcid.org/0000-0002-1694-233X",
            ];
            for orcid_str in orcids {
                let orcid = Orcid {
                    authenticated: None,
                    value: orcid_str.to_string(),
                };
                assert!(
                    orcid.validate().is_ok(),
                    "ORCID should be valid: {}",
                    orcid_str
                );
            }
        }
    }

    mod person_name {
        use super::*;

        fn valid_person_name() -> PersonName {
            PersonName {
                language: Iso639_1::En,
                sequence: Sequence::First,
                contributor_role: ContributorRole::Author,
                name_style: None,
                given_name: "Jane".to_string(),
                surname: "Smith".to_string(),
                suffix: None,
                affiliations: Affiliations::default(),
                orcid: None,
            }
        }

        #[test]
        fn valid_person_name_passes() {
            let person = valid_person_name();
            assert!(person.validate().is_ok());
        }

        #[test]
        fn given_name_invalid_regex_fails() {
            let mut person = valid_person_name();
            person.given_name = "123".to_string();
            assert!(person.validate().is_err());
        }

        #[test]
        fn surname_invalid_regex_fails() {
            let mut person = valid_person_name();
            person.surname = "456".to_string();
            assert!(person.validate().is_err());
        }

        #[test]
        fn suffix_none_passes() {
            let mut person = valid_person_name();
            person.suffix = None;
            assert!(person.validate().is_ok());
        }

        #[test]
        fn with_valid_orcid_passes() {
            let mut person = valid_person_name();
            person.orcid = Some(Orcid {
                authenticated: Some(true),
                value: "https://orcid.org/0000-0002-1825-0097".to_string(),
            });
            assert!(person.validate().is_ok());
        }

        #[test]
        fn with_invalid_orcid_fails() {
            let mut person = valid_person_name();
            person.orcid = Some(Orcid {
                authenticated: None,
                value: "invalid".to_string(),
            });
            assert!(person.validate().is_err());
        }

        #[test]
        fn with_affiliations_passes() {
            let mut person = valid_person_name();
            person.affiliations = Affiliations {
                institution: vec![Institution {
                    institution_id: InstitutionId {
                        institution_type: InstitutionIdType::Ror,
                        value: "https://ror.org/12345".to_string(),
                    },
                }],
            };
            assert!(person.validate().is_ok());
        }
    }

    mod anonymous {
        use super::*;

        fn valid_anonymous() -> Anonymous {
            Anonymous {
                language: Iso639_1::En,
                sequence: Sequence::First,
                contributor_role: ContributorRole::Author,
                name_style: None,
            }
        }

        #[test]
        fn valid_anonymous_passes() {
            let anon = valid_anonymous();
            assert!(anon.validate().is_ok());
        }

        #[test]
        fn with_name_style_passes() {
            let mut anon = valid_anonymous();
            anon.name_style = Some(NameStyle::Western);
            assert!(anon.validate().is_ok());
        }
    }

    mod organization {
        use super::*;

        fn valid_organization() -> Organization {
            Organization {
                value: "Example University".to_string(),
                language: Iso639_1::En,
                sequence: Sequence::First,
                contributor_role: ContributorRole::Author,
            }
        }

        #[test]
        fn valid_organization_passes() {
            let org = valid_organization();
            assert!(org.validate().is_ok());
        }
    }

    mod contributors {
        use super::*;

        fn valid_contributors_person() -> Contributor {
            Contributor {
                organization: vec![],
                person_name: vec![PersonName {
                    language: Iso639_1::En,
                    sequence: Sequence::First,
                    contributor_role: ContributorRole::Author,
                    name_style: None,
                    given_name: "Jane".to_string(),
                    surname: "Smith".to_string(),
                    suffix: None,
                    affiliations: Affiliations::default(),
                    orcid: None,
                }],
                anonymous: vec![],
            }
        }

        #[test]
        fn contributors_with_person_passes() {
            let contrib = valid_contributors_person();
            assert!(contrib.validate().is_ok());
        }

        #[test]
        fn contributors_with_organization_passes() {
            let contrib = Contributor {
                organization: vec![Organization {
                    value: "Example University".to_string(),
                    language: Iso639_1::En,
                    sequence: Sequence::First,
                    contributor_role: ContributorRole::Author,
                }],
                person_name: vec![],
                anonymous: vec![],
            };
            assert!(contrib.validate().is_ok());
        }

        #[test]
        fn contributors_with_anonymous_passes() {
            let contrib = Contributor {
                organization: vec![],
                person_name: vec![],
                anonymous: vec![Anonymous {
                    language: Iso639_1::En,
                    sequence: Sequence::First,
                    contributor_role: ContributorRole::Author,
                    name_style: None,
                }],
            };
            assert!(contrib.validate().is_ok());
        }

        #[test]
        fn contributors_all_none_fails() {
            // Note: There's a TODO comment saying at least one should be present
            // but there's no validation for it yet
            // let contrib = Contributors::default();
            // assert!(contrib.validate().is_err());
        }

        #[test]
        fn vector_of_contributors() {
            // TODO (both test and implementation)
        }
    }

    mod original_language_title {
        use super::*;

        fn valid_original_language_title() -> OriginalLanguageTitle {
            OriginalLanguageTitle {
                language: Iso639_1::Es,
                value: "Título Original".to_string(),
            }
        }

        #[test]
        fn valid_original_language_title_passes() {
            let title = valid_original_language_title();
            assert!(title.validate().is_ok());
        }
    }

    mod titles {
        use super::*;

        fn valid_titles() -> Titles {
            Titles {
                title: "Example Article Title".to_string(),
                subtitle: Some("A Comprehensive Study".to_string()),
                original_language_title: None,
                orginal_language_subtitle: None,
            }
        }

        #[test]
        fn valid_titles_passes() {
            let titles = valid_titles();
            assert!(titles.validate().is_ok());
        }

        #[test]
        fn with_original_language_title_passes() {
            let mut titles = valid_titles();
            titles.original_language_title = Some(OriginalLanguageTitle {
                language: Iso639_1::Es,
                value: "Título Original".to_string(),
            });
            assert!(titles.validate().is_ok());
        }

        #[test]
        fn subtitle_none_passes() {
            let mut titles = valid_titles();
            titles.subtitle = None;
            assert!(titles.validate().is_ok());
        }
    }

    mod publication_date {
        use super::*;

        fn valid_publication_date() -> PublicationDate {
            PublicationDate {
                media_type: MediaTypeDate::Online,
                month: Some(6),
                day: Some(15),
                year: 2024,
            }
        }

        #[test]
        fn valid_publication_date_passes() {
            let date = valid_publication_date();
            assert!(date.validate().is_ok());
        }

        #[test]
        fn month_none_passes() {
            let mut date = valid_publication_date();
            date.month = None;
            assert!(date.validate().is_ok());
        }

        #[test]
        fn day_none_passes() {
            let mut date = valid_publication_date();
            date.day = None;
            assert!(date.validate().is_ok());
        }

        #[test]
        fn minimal_date_passes() {
            let date = PublicationDate {
                media_type: MediaTypeDate::Online,
                month: None,
                day: None,
                year: 2024,
            };
            assert!(date.validate().is_ok());
        }
    }

    mod journal_issue {
        use super::*;
        use crate::enums::ContentVersion;
        use crate::journal::metadata::{DoiData, Resource};

        fn valid_journal_issue() -> JournalIssue {
            JournalIssue {
                contributors: vec![Contributor {
                    organization: vec![],
                    person_name: vec![PersonName {
                        language: Iso639_1::En,
                        sequence: Sequence::First,
                        contributor_role: ContributorRole::Author,
                        name_style: None,
                        given_name: "Jane".to_string(),
                        surname: "Smith".to_string(),
                        suffix: None,
                        affiliations: Affiliations::default(),
                        orcid: None,
                    }],
                    anonymous: vec![],
                }],
                titles: Some(Titles {
                    title: "Issue Title".to_string(),
                    subtitle: None,
                    original_language_title: None,
                    orginal_language_subtitle: None,
                }),
                publication_date: PublicationDate {
                    media_type: MediaTypeDate::Online,
                    month: Some(6),
                    day: Some(15),
                    year: 2024,
                },
                issue: Some("1".to_string()),
                special_numbering: None,
                archive_locations: ArchiveLocations::default(),
                doi_data: DoiData {
                    doi: "10.1234/issue.001".to_string(),
                    timestamp: (),
                    resource: Resource {
                        value: "https://example.com/issue/1".to_string(),
                        mime_type: None,
                        content_version: ContentVersion::Vor,
                    },
                },
            }
        }

        #[test]
        fn valid_journal_issue_passes() {
            let issue = valid_journal_issue();
            assert!(issue.validate().is_ok());
        }

        #[test]
        fn invalid_publication_date_fails() {
            let mut issue = valid_journal_issue();
            issue.publication_date.year = 1000; // too old
            assert!(issue.validate().is_err());
        }

        #[test]
        fn invalid_doi_data_fails() {
            let mut issue = valid_journal_issue();
            issue.doi_data.doi = "invalid".to_string();
            assert!(issue.validate().is_err());
        }

        #[test]
        fn minimal_valid_issue_passes() {
            let issue = JournalIssue {
                contributors: vec![],
                titles: None,
                publication_date: PublicationDate {
                    media_type: MediaTypeDate::Online,
                    month: None,
                    day: None,
                    year: 2024,
                },
                issue: None,
                special_numbering: None,
                archive_locations: ArchiveLocations::default(),
                doi_data: DoiData {
                    doi: "10.1234/a".to_string(),
                    timestamp: (),
                    resource: Resource {
                        value: "https://example.com".to_string(),
                        mime_type: None,
                        content_version: ContentVersion::Vor,
                    },
                },
            };
            assert!(issue.validate().is_ok());
        }
    }
}