bo4e-core 0.1.1

Core types for BO4E (Business Objects for Energy)
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

//! External reference (ExterneReferenz) component.

use serde::{Deserialize, Serialize};

use crate::traits::{Bo4eMeta, Bo4eObject};

/// Reference to an external system.
///
/// Used to link BO4E objects to identifiers in other systems (e.g., SAP, CRM).
///
/// German: ExterneReferenz
///
/// # Example
///
/// ```rust
/// use bo4e_core::com::ExternalReference;
///
/// let ext_ref = ExternalReference::new("SAP", "4711");
/// assert_eq!(ext_ref.external_ref_name, Some("SAP".to_string()));
/// assert_eq!(ext_ref.external_ref_value, Some("4711".to_string()));
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalReference {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

    /// Name of the external system (ExRefName)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub external_ref_name: Option<String>,

    /// Value/ID in the external system (ExRefWert)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub external_ref_value: Option<String>,
}

impl Bo4eObject for ExternalReference {
    fn type_name_german() -> &'static str {
        "ExterneReferenz"
    }

    fn type_name_english() -> &'static str {
        "ExternalReference"
    }

    fn meta(&self) -> &Bo4eMeta {
        &self.meta
    }

    fn meta_mut(&mut self) -> &mut Bo4eMeta {
        &mut self.meta
    }
}

impl ExternalReference {
    /// Create a new external reference.
    ///
    /// # Arguments
    ///
    /// * `system` - Name of the external system
    /// * `value` - The identifier/value in that system
    pub fn new(system: impl Into<String>, value: impl Into<String>) -> Self {
        Self {
            external_ref_name: Some(system.into()),
            external_ref_value: Some(value.into()),
            ..Default::default()
        }
    }
}

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

    #[test]
    fn test_external_reference_default() {
        let ext_ref = ExternalReference::default();
        assert!(ext_ref.external_ref_name.is_none());
        assert!(ext_ref.external_ref_value.is_none());
    }

    #[test]
    fn test_sap_reference() {
        let ext_ref = ExternalReference::new("SAP", "4711");
        assert_eq!(ext_ref.external_ref_name, Some("SAP".to_string()));
        assert_eq!(ext_ref.external_ref_value, Some("4711".to_string()));
    }

    #[test]
    fn test_serialize() {
        let ext_ref = ExternalReference::new("CRM", "CUST-12345");
        let json = serde_json::to_string(&ext_ref).unwrap();
        assert!(json.contains(r#""externalRefName":"CRM""#));
        assert!(json.contains(r#""externalRefValue":"CUST-12345""#));
    }

    #[test]
    fn test_external_reference_roundtrip() {
        let ext_ref = ExternalReference {
            meta: Bo4eMeta::with_type("ExterneReferenz"),
            external_ref_name: Some("ERP".to_string()),
            external_ref_value: Some("ORDER-2024-001".to_string()),
        };

        let json = serde_json::to_string(&ext_ref).unwrap();
        let parsed: ExternalReference = serde_json::from_str(&json).unwrap();
        assert_eq!(ext_ref, parsed);
    }

    #[test]
    fn test_bo4e_object_impl() {
        assert_eq!(ExternalReference::type_name_german(), "ExterneReferenz");
        assert_eq!(ExternalReference::type_name_english(), "ExternalReference");
    }
}