mef2tmf 0.1.0

Library to translate from MEF into TMF
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use tmflib::{tmf674::geographic_site_v4::GeographicSite as TMFSite, HasName};
use tmflib::common::related_party::RelatedParty;
use meflib::w122::geographic_site::GeographicSite as MEFSite;

use std::convert::From;

#[warn(missing_docs)]

/// Container class to hold either TMF or MEF site objects
#[derive(Clone)]
pub enum SiteVal {
    /// TMF Varient
    TMF(TMFSite),
    /// MEF Varient
    MEF(MEFSite),
}

impl From<MEFSite> for SiteVal {
    fn from(value: MEFSite) -> Self {
        SiteVal::MEF(value)
    }
}

impl From<TMFSite> for SiteVal {
    fn from(value: TMFSite) -> Self {
        SiteVal::TMF(value)
    }
}

pub struct MEFTMF {
    val : SiteVal,
}

impl From<SiteVal> for TMFSite {
    fn from(value: SiteVal) -> Self {
        match value {
            SiteVal::TMF(t) => t.clone(),
            SiteVal::MEF(m) => {
                // This is where we do the conversion from MEF into TMF
                let mut tmf = TMFSite::new(m.name);
                tmf.description = Some(m.description);
                tmf.related_party = Some(vec![]);
                m.related_contact_information.into_iter().for_each(|c| {
                    // Convert RelatedContactInformation into RelatedParty from TMF
                    
                    let related_party = RelatedParty {
                        name : Some(c.name.clone()),
                        base_type: Some("individual".to_string()),
                        ..Default::default()
                    };
                    tmf.related_party.as_mut().unwrap().push(related_party);
                });
                tmf
            }
        }
    }
}

impl From<SiteVal> for MEFSite {
    fn from(value: SiteVal) -> Self {
        match value {
            SiteVal::TMF(t) => {
                // This is where we do the conversion from TMF into MEF
                MEFSite {
                    name : t.get_name(),
                    description: t.description.unwrap_or("No TMF description".to_string()),
                    company_name: match t.related_party {
                        Some(v) => {
                            v.first().unwrap().clone().name.unwrap()
                        }
                        None => String::from("No name"),
                    },
                    ..MEFSite::default()
                }
            },
            SiteVal::MEF(m) => m.clone(),
        }    
    }
}

impl MEFTMF {
    pub fn mef(&self) -> MEFSite {
        MEFSite::from(self.val.clone())
    }
    pub fn tmf(&self) -> TMFSite {
        TMFSite::from(self.val.clone())
    }
}

impl From<MEFSite> for MEFTMF {
    fn from(value: MEFSite) -> Self {
        MEFTMF { 
            val : SiteVal::MEF(value),
        }
    }
}

/// Convert from MEF into TMF using intermedary Enum
/// ```
/// use meflib::w122::geographic_site::GeographicSite as MEFSite;
/// use mef2tmf::mef_to_tmf_site;
/// let mef = MEFSite::default();
/// let tmf = mef_to_tmf_site(mef);
/// ```
pub fn mef_to_tmf_site(mef : MEFSite) -> TMFSite {
    let siteval = SiteVal::from(mef);
    TMFSite::from(siteval)
}

/// Convert from TMF into MEF using intermedary Enum
/// ```
/// use mef2tmf::tmf_to_mef_site;
/// let tmf = tmflib::tmf674::geographic_site_v4::GeographicSite::new("A Site");
/// let mef = tmf_to_mef_site(tmf);
/// ```
pub fn tmf_to_mef_site(tmf : TMFSite) -> MEFSite {
    let siteval = SiteVal::from(tmf);
    MEFSite::from(siteval)
}

#[cfg(test)]
mod test {
    use tmflib::tmf674::geographic_site_v4::GeographicSite as TMFSite;
    use super::*;
    const TMF_SITE : &str = "TMF Site";
    #[test]
    fn test_tmf_to_mef() {
        let tmf = TMFSite::new(TMF_SITE);
        let mef = tmf_to_mef_site(tmf.clone());

        assert_eq!(tmf.get_name(),mef.name);
    }
}