crossref_xml/journal/

article.rs

use crate::{
    enums::{IdType, Iso639_1, ParentRelation, PublicationType, UpdateType},
    journal::{
        issue::{Contributor, PublicationDate, Titles},
        metadata::{ArchiveLocations, DoiData},
    },
    regex::DOI_REGEX,
};
use chrono::NaiveDate;
use serde::Serialize;
use validator::Validate;

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct JournalArticle {
    #[serde(rename = "@publication_type")]
    pub publication_type: PublicationType,
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    #[validate(nested)]
    pub titles: Titles,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub contributors: Vec<Contributor>,
    #[serde(rename = "jats:abstract")]
    #[serde(skip_serializing_if = "Option::is_none")]
    // TODO: needs jats:p in there
    pub jats_abstract: Option<JatsP>,
    #[validate(nested)]
    // TODO: Can technically be a Vec<PublicationDate> 1..10
    pub publication_date: PublicationDate,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub acceptance_date: Option<PublicationDate>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub pages: Option<Pages>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub publisher_item: Option<PublisherItem>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub crossmark: Option<Crossmark>,
    // #[serde(rename = "fr:program")]
    // pub fr_program: FrProgram,
    // #[serde(rename = "ai:program")]
    // pub ai_program: AiProgram,
    // #[serde(rename = "ct:program")]
    // pub ct_program: CtProgram,
    // #[serde(rename = "rel:program")]
    // pub rel_program: RelProgram,
    #[serde(skip_serializing_if = "ArchiveLocations::is_empty")]
    #[validate(nested)]
    pub archive_locations: ArchiveLocations,
    // #[serde(skip_serializing_if = "Option::is_none")]
    // pub scn_policies: Option<ScnPolicies>,
    // #[serde(skip_serializing_if = "Option::is_none")]
    // pub version_info: Option<VersionInfo>,
    #[validate(nested)]
    pub doi_data: DoiData,
    #[serde(skip_serializing_if = "CitationList::is_empty")]
    #[validate(nested)]
    pub citation_list: CitationList,
    #[serde(skip_serializing_if = "ComponentList::is_empty")]
    #[validate(nested)]
    pub component_list: ComponentList,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct JatsP {
    #[serde(rename = "jats:p")]
    // #[serde(skip_serializing_if = "Option::is_none")]
    // TODO: needs jats:p in there
    pub value: String,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Pages {
    #[validate(length(min = 1, max = 32))]
    pub first_page: String,
    #[validate(length(min = 1, max = 32))]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_page: Option<String>,
    #[validate(length(min = 1, max = 100))]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_pages: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct PublisherItem {
    #[serde(skip_serializing_if = "Vec::is_empty")]
    #[validate(length(max = 3))]
    pub item_number: Vec<ItemNumberT>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    #[validate(length(max = 10))]
    pub identifier: Vec<IdentifierT>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct ItemNumberT {
    #[validate(length(min = 1, max = 32))]
    pub value: String,
}

#[derive(Debug, Clone, Serialize, Validate)]
pub struct IdentifierT {
    #[serde(rename = "@id_type")]
    pub id_type: IdType,
    #[validate(length(min = 1, max = 255))]
    #[serde(rename = "$text")]
    pub value: String,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Crossmark {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub crossmark_version: Option<String>,
    #[validate(length(min = 6, max = 2048), regex(path = *DOI_REGEX))]
    pub crossmark_policy: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    // pub crossmark_domains: Vec<CrossmarkDomain>
    pub crossmark_domain_exclusive: Option<bool>,
    #[serde(skip_serializing_if = "Updates::is_empty")]
    #[validate(nested)]
    pub updates: Updates,
    // pub custom_metadata: CustomMetadata
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Updates {
    #[validate(length(min = 1))]
    pub update: Vec<Update>,
}

impl Updates {
    pub fn is_empty(&self) -> bool {
        self.update.is_empty()
    }
}

#[derive(Debug, Clone, Serialize, Validate)]
pub struct Update {
    #[serde(rename = "@type")]
    pub update_type: UpdateType,
    #[serde(rename = "@date")]
    pub update_date: NaiveDate,
    #[validate(length(min = 6, max = 2048), regex(path = *DOI_REGEX))]
    #[serde(rename = "$text")]
    pub value: String,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct CitationList {
    #[serde(rename = "$text")]
    pub value: Vec<Citation>,
}

impl CitationList {
    pub fn is_empty(&self) -> bool {
        self.value.is_empty()
    }
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct Citation {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(length(min = 6, max = 2048), regex(path = *DOI_REGEX))]
    pub doi: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub elocation_id: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
pub struct ComponentList {
    #[serde(rename = "component")]
    pub value: Vec<Component>,
}

impl ComponentList {
    pub fn is_empty(&self) -> bool {
        self.value.is_empty()
    }
}

#[derive(Debug, Clone, Default, Serialize, Validate)]
#[serde(rename = "component")]
pub struct Component {
    #[serde(rename = "@parent_relation")]
    pub parent_relation: ParentRelation,
    // @reg-agency
    #[serde(rename = "@language")]
    pub language: Iso639_1,
    // @component_size
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub titles: Option<Titles>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    #[validate(nested)]
    pub contributors: Vec<Contributor>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub publication_date: Option<PublicationDate>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(nested)]
    pub description: Option<Description>,
    // format
    // ai:program
    #[validate(nested)]
    pub doi_data: DoiData,
    // #[validate(length(min = 6, max = 2048), regex(path = *DOI_REGEX))]
    // pub doi: String,
}

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

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

    mod description {
        use super::*;

        fn valid_description() -> Description {
            Description {
                language: Iso639_1::En,
                value: "Example description".to_string(),
            }
        }

        #[test]
        fn valid_description_passes() {
            let desc = valid_description();
            assert!(desc.validate().is_ok());
        }
    }

    mod component {
        use super::*;
        use crate::enums::ContentVersion;
        use crate::journal::metadata::Resource;

        fn valid_component() -> Component {
            Component {
                parent_relation: ParentRelation::IsPartOf,
                language: Iso639_1::En,
                titles: None,
                contributors: vec![],
                publication_date: None,
                description: None,
                doi_data: DoiData {
                    doi: "10.1234/component.001".to_string(),
                    timestamp: (),
                    resource: Resource {
                        value: "https://example.com/component".to_string(),
                        mime_type: None,
                        content_version: ContentVersion::Vor,
                    },
                },
            }
        }

        #[test]
        fn valid_component_passes() {
            let comp = valid_component();
            assert!(comp.validate().is_ok());
        }

        #[test]
        fn with_description_passes() {
            let mut comp = valid_component();
            comp.description = Some(Description {
                language: Iso639_1::En,
                value: "Component description".to_string(),
            });
            assert!(comp.validate().is_ok());
        }

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

    mod component_list {
        use super::*;
        use crate::enums::ContentVersion;
        use crate::journal::metadata::Resource;

        fn valid_component() -> Component {
            Component {
                parent_relation: ParentRelation::IsPartOf,
                language: Iso639_1::En,
                titles: None,
                contributors: vec![Contributor {
                    organization: vec![],
                    person_name: vec![],
                    anonymous: vec![],
                }],
                publication_date: None,
                description: None,
                doi_data: DoiData {
                    doi: "10.1234/component".to_string(),
                    timestamp: (),
                    resource: Resource {
                        value: "https://example.com/component".to_string(),
                        mime_type: None,
                        content_version: ContentVersion::Vor,
                    },
                },
            }
        }

        #[test]
        fn empty_component_list_passes() {
            let list = ComponentList::default();
            assert!(list.validate().is_ok());
            assert!(list.is_empty());
        }

        #[test]
        fn component_list_with_components_passes() {
            let list = ComponentList {
                value: vec![valid_component()],
            };
            assert!(list.validate().is_ok());
            assert!(!list.is_empty());
        }

        #[test]
        fn multiple_components_pass() {
            let list = ComponentList {
                value: vec![valid_component(), valid_component()],
            };
            assert!(list.validate().is_ok());
        }
    }

    mod citation {
        use super::*;

        #[test]
        fn citation_with_doi_passes() {
            let citation = Citation {
                doi: Some("10.1234/citation.001".to_string()),
                elocation_id: None,
            };
            assert!(citation.validate().is_ok());
        }

        #[test]
        fn citation_with_elocation_id_passes() {
            let citation = Citation {
                doi: None,
                elocation_id: Some("e123456".to_string()),
            };
            assert!(citation.validate().is_ok());
        }

        #[test]
        fn citation_with_both_passes() {
            let citation = Citation {
                doi: Some("10.1234/citation.001".to_string()),
                elocation_id: Some("e123456".to_string()),
            };
            assert!(citation.validate().is_ok());
        }

        #[test]
        fn citation_with_invalid_doi_fails() {
            let citation = Citation {
                doi: Some("invalid".to_string()),
                elocation_id: None,
            };
            assert!(citation.validate().is_err());
        }

        #[test]
        fn empty_citation_passes() {
            let citation = Citation::default();
            assert!(citation.validate().is_ok());
        }
    }

    mod citation_list {
        use super::*;

        #[test]
        fn empty_citation_list_passes() {
            let list = CitationList::default();
            assert!(list.validate().is_ok());
            assert!(list.is_empty());
        }

        #[test]
        fn citation_list_with_citations_passes() {
            let list = CitationList {
                value: vec![Citation {
                    doi: Some("10.1234/ref.001".to_string()),
                    elocation_id: None,
                }],
            };
            assert!(list.validate().is_ok());
            assert!(!list.is_empty());
        }

        #[test]
        fn multiple_citations_pass() {
            let list = CitationList {
                value: vec![
                    Citation {
                        doi: Some("10.1234/ref.001".to_string()),
                        elocation_id: None,
                    },
                    Citation {
                        doi: Some("10.1234/ref.002".to_string()),
                        elocation_id: Some("e123".to_string()),
                    },
                ],
            };
            assert!(list.validate().is_ok());
        }
    }

    mod update {
        use super::*;
        use chrono::NaiveDate;

        fn valid_update() -> Update {
            Update {
                update_type: UpdateType::Correction,
                update_date: NaiveDate::from_ymd_opt(2024, 6, 15).unwrap(),
                value: "10.1234/update.001".to_string(),
            }
        }

        #[test]
        fn valid_update_passes() {
            let update = valid_update();
            assert!(update.validate().is_ok());
        }

        #[test]
        fn value_invalid_doi_fails() {
            let mut update = valid_update();
            update.value = "invalid".to_string();
            assert!(update.validate().is_err());
        }

        #[test]
        fn various_update_types_pass() {
            let types = [
                UpdateType::Addendum,
                UpdateType::Correction,
                UpdateType::Corrigendum,
                UpdateType::Erratum,
                UpdateType::ExpressionOfConcern,
                UpdateType::NewEdition,
                UpdateType::NewVersion,
                UpdateType::PartialRetraction,
                UpdateType::Removal,
                UpdateType::Retraction,
                UpdateType::Withdrawal,
            ];
            for update_type in types {
                let mut update = valid_update();
                update.update_type = update_type;
                assert!(update.validate().is_ok());
            }
        }
    }

    mod updates {
        use super::*;
        use chrono::NaiveDate;

        fn valid_update() -> Update {
            Update {
                update_type: UpdateType::Correction,
                update_date: NaiveDate::from_ymd_opt(2024, 6, 15).unwrap(),
                value: "10.1234/update.001".to_string(),
            }
        }

        #[test]
        fn updates_with_one_update_passes() {
            let updates = Updates {
                update: vec![valid_update()],
            };
            assert!(updates.validate().is_ok());
            assert!(!updates.is_empty());
        }

        #[test]
        fn updates_with_multiple_updates_passes() {
            let updates = Updates {
                update: vec![valid_update(), valid_update()],
            };
            assert!(updates.validate().is_ok());
        }

        #[test]
        fn empty_updates_fails() {
            let updates = Updates { update: vec![] };
            assert!(updates.validate().is_err());
        }
    }

    mod crossmark {
        use super::*;

        fn valid_crossmark() -> Crossmark {
            Crossmark {
                crossmark_version: Some("1".to_string()),
                crossmark_policy: "10.1234/policy".to_string(),
                crossmark_domain_exclusive: Some(true),
                updates: Updates::default(),
            }
        }

        #[test]
        fn valid_crossmark_passes() {
            let mut crossmark = valid_crossmark();
            // Need at least one update for Updates to be valid
            crossmark.updates = Updates {
                update: vec![Update {
                    update_type: UpdateType::Correction,
                    update_date: chrono::NaiveDate::from_ymd_opt(2024, 6, 15).unwrap(),
                    value: "10.1234/update".to_string(),
                }],
            };
            assert!(crossmark.validate().is_ok());
        }

        #[test]
        fn crossmark_policy_invalid_doi_fails() {
            let mut crossmark = valid_crossmark();
            crossmark.crossmark_policy = "invalid".to_string();
            assert!(crossmark.validate().is_err());
        }
    }

    mod identifier_t {
        use super::*;

        fn valid_identifier() -> IdentifierT {
            IdentifierT {
                id_type: IdType::Pii,
                value: "ABC123".to_string(),
            }
        }

        #[test]
        fn valid_identifier_passes() {
            let id = valid_identifier();
            assert!(id.validate().is_ok());
        }

        #[test]
        fn various_id_types_pass() {
            let types = [
                IdType::Dai,
                IdType::StdDesignation,
                IdType::Doi,
                IdType::Pii,
                IdType::Pmid,
                IdType::Sici,
            ];
            for id_type in types {
                let mut id = valid_identifier();
                id.id_type = id_type;
                assert!(id.validate().is_ok());
            }
        }
    }

    mod item_number_t {
        use super::*;

        fn valid_item_number() -> ItemNumberT {
            ItemNumberT {
                value: "ITEM-001".to_string(),
            }
        }

        #[test]
        fn valid_item_number_passes() {
            let item = valid_item_number();
            assert!(item.validate().is_ok());
        }
    }

    mod publisher_item {
        use super::*;

        fn valid_publisher_item() -> PublisherItem {
            PublisherItem {
                item_number: vec![ItemNumberT {
                    value: "ITEM-001".to_string(),
                }],
                identifier: vec![IdentifierT {
                    id_type: IdType::Pii,
                    value: "ABC123".to_string(),
                }],
            }
        }

        #[test]
        fn valid_publisher_item_passes() {
            let item = valid_publisher_item();
            assert!(item.validate().is_ok());
        }

        #[test]
        fn empty_publisher_item_passes() {
            let item = PublisherItem::default();
            assert!(item.validate().is_ok());
        }
    }

    mod pages {
        use super::*;

        fn valid_pages() -> Pages {
            Pages {
                first_page: "1".to_string(),
                last_page: Some("10".to_string()),
                other_pages: None,
            }
        }

        #[test]
        fn valid_pages_passes() {
            let pages = valid_pages();
            assert!(pages.validate().is_ok());
        }

        #[test]
        fn last_page_none_passes() {
            let mut pages = valid_pages();
            pages.last_page = None;
            assert!(pages.validate().is_ok());
        }

        #[test]
        fn other_pages_none_passes() {
            let mut pages = valid_pages();
            pages.other_pages = None;
            assert!(pages.validate().is_ok());
        }

        #[test]
        fn only_first_page_passes() {
            let pages = Pages {
                first_page: "1".to_string(),
                last_page: None,
                other_pages: None,
            };
            assert!(pages.validate().is_ok());
        }
    }

    mod journal_article {
        use super::*;
        use crate::enums::{ContentVersion, MediaTypeDate};
        use crate::journal::metadata::Resource;

        fn valid_journal_article() -> JournalArticle {
            JournalArticle {
                publication_type: PublicationType::FullText,
                language: Iso639_1::En,
                titles: Titles {
                    title: "Example Article".to_string(),
                    subtitle: None,
                    original_language_title: None,
                    orginal_language_subtitle: None,
                },
                contributors: vec![],
                jats_abstract: Some(JatsP {
                    value: "Abstract text".to_string(),
                }),
                publication_date: PublicationDate {
                    media_type: MediaTypeDate::Online,
                    month: Some(6),
                    day: Some(15),
                    year: 2024,
                },
                acceptance_date: None,
                pages: None,
                publisher_item: None,
                crossmark: None,
                archive_locations: ArchiveLocations::default(),
                doi_data: DoiData {
                    doi: "10.1234/article.001".to_string(),
                    timestamp: (),
                    resource: Resource {
                        value: "https://example.com/article".to_string(),
                        mime_type: None,
                        content_version: ContentVersion::Vor,
                    },
                },
                citation_list: CitationList::default(),
                component_list: ComponentList::default(),
            }
        }

        #[test]
        fn valid_journal_article_passes() {
            let article = valid_journal_article();
            assert!(article.validate().is_ok());
        }

        #[test]
        fn with_pages_passes() {
            let mut article = valid_journal_article();
            article.pages = Some(Pages {
                first_page: "1".to_string(),
                last_page: Some("10".to_string()),
                other_pages: None,
            });
            assert!(article.validate().is_ok());
        }

        #[test]
        fn with_invalid_pages_fails() {
            let mut article = valid_journal_article();
            article.pages = Some(Pages {
                first_page: "".to_string(),
                last_page: None,
                other_pages: None,
            });
            assert!(article.validate().is_err());
        }

        #[test]
        fn with_publisher_item_passes() {
            let mut article = valid_journal_article();
            article.publisher_item = Some(PublisherItem {
                item_number: vec![ItemNumberT {
                    value: "ITEM-001".to_string(),
                }],
                identifier: vec![],
            });
            assert!(article.validate().is_ok());
        }

        #[test]
        fn with_acceptance_date_passes() {
            let mut article = valid_journal_article();
            article.acceptance_date = Some(PublicationDate {
                media_type: MediaTypeDate::Online,
                month: Some(5),
                day: Some(1),
                year: 2024,
            });
            assert!(article.validate().is_ok());
        }

        #[test]
        fn with_invalid_acceptance_date_fails() {
            let mut article = valid_journal_article();
            article.acceptance_date = Some(PublicationDate {
                media_type: MediaTypeDate::Online,
                month: None,
                day: None,
                year: 1000,
            });
            assert!(article.validate().is_err());
        }

        #[test]
        fn with_citations_passes() {
            let mut article = valid_journal_article();
            article.citation_list = CitationList {
                value: vec![Citation {
                    doi: Some("10.1234/ref.001".to_string()),
                    elocation_id: None,
                }],
            };
            assert!(article.validate().is_ok());
        }

        #[test]
        fn with_components_passes() {
            let mut article = valid_journal_article();
            article.component_list = ComponentList {
                value: vec![Component {
                    parent_relation: ParentRelation::IsPartOf,
                    language: Iso639_1::En,
                    titles: None,
                    contributors: vec![],
                    publication_date: None,
                    description: None,
                    doi_data: DoiData {
                        doi: "10.1234/comp".to_string(),
                        timestamp: (),
                        resource: Resource {
                            value: "https://example.com/comp".to_string(),
                            mime_type: None,
                            content_version: ContentVersion::Vor,
                        },
                    },
                }],
            };
            assert!(article.validate().is_ok());
        }

        #[test]
        fn minimal_article_passes() {
            let article = JournalArticle {
                publication_type: PublicationType::FullText,
                language: Iso639_1::En,
                titles: Titles {
                    title: "T".to_string(),
                    subtitle: None,
                    original_language_title: None,
                    orginal_language_subtitle: None,
                },
                contributors: vec![],
                jats_abstract: None,
                publication_date: PublicationDate {
                    media_type: MediaTypeDate::Online,
                    month: None,
                    day: None,
                    year: 2024,
                },
                acceptance_date: None,
                pages: None,
                publisher_item: None,
                crossmark: 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,
                    },
                },
                citation_list: CitationList::default(),
                component_list: ComponentList::default(),
            };
            assert!(article.validate().is_ok());
        }
    }
}