tmflib 0.1.37

Interface library for processing TMF payloads
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

//! Related Entity Module

use serde::{Deserialize, Serialize};

use crate::HasName;
use crate::Uri;

/// Reference to another TMF schema
#[derive(Clone, Default, Debug, Deserialize, Serialize)]
pub struct EntityRef {
    /// Entity HREF
    pub href: String,
    /// Entity Id
    pub id: String,
    /// Entity Name
    pub name: String,
}

/// Reference to another TMF schema
#[derive(Clone, Default, Debug, Deserialize, Serialize)]
pub struct RelatedEntity {
    /// Referenced Name
    pub name: String,
    /// Referenced Id
    pub id: String,
    /// Referenced HREF
    pub href: Uri,
    /// Referenced Role
    pub role: Option<String>,
    /// Referred Type
    pub referred_type: String,
}

/// Generate a related entity from any TMF object that has implemented HasName trait
impl<T: HasName> From<T> for RelatedEntity {
    fn from(value: T) -> Self {
        RelatedEntity {
            name: value.get_name(),
            id: value.get_id(),
            href: value.get_href(),
            referred_type: T::get_class(),
            ..Default::default()
        }
    }
}

#[cfg(test)]
mod test {
    use crate::tmf651::agreement::Agreement;
    use crate::{HasId, HasName};

    use super::RelatedEntity;

    const AGREEMENT_NAME: &str = "AnAgreement";

    #[test]
    fn test_relatedentity_from() {
        let agreement = Agreement::new(AGREEMENT_NAME);
        let agree_ref = &agreement;

        let entity = RelatedEntity::from(agreement.clone());

        assert_eq!(entity.name, agree_ref.get_name());
        assert_eq!(entity.id, agree_ref.get_id().as_str());
        assert_eq!(entity.href, agree_ref.get_href().as_str());
        assert_eq!(entity.referred_type, Agreement::get_class());
    }
}