bo4e-core 0.2.0

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Profile data (Profildaten) component.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

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

/// Profile data for standard load profiles or individual consumption profiles.
///
/// German: Profildaten
///
/// # Example
///
/// ```rust
/// use bo4e_core::com::ProfileData;
/// use chrono::Utc;
///
/// let profile = ProfileData {
///     profile_type: Some("H0".to_string()),
///     timestamp: Some(Utc::now()),
///     value: Some(0.000125),
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
#[cfg_attr(feature = "json-schema", schemars(rename = "Profildaten"))]
#[serde(rename_all = "camelCase")]
pub struct ProfileData {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

    /// Profile type/identifier (Profiltyp)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "profiltyp"))]
    pub profile_type: Option<String>,

    /// Timestamp of the profile value (Zeitpunkt)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "zeitpunkt"))]
    pub timestamp: Option<DateTime<Utc>>,

    /// Profile value (Profilwert)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "profilwert"))]
    pub value: Option<f64>,

    /// Unit of the profile value (Einheit)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "einheit"))]
    pub unit: Option<Unit>,

    /// Profile name (Profilname)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "profilname"))]
    pub profile_name: Option<String>,

    /// Profile version (Profilversion)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "profilversion"))]
    pub profile_version: Option<String>,

    /// Temperature zone (Temperaturzone)
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "json-schema", schemars(rename = "temperaturzone"))]
    pub temperature_zone: Option<String>,
}

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

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

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

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

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

    #[test]
    fn test_profile_data() {
        let profile = ProfileData {
            profile_type: Some("H0".to_string()),
            timestamp: Some(Utc.with_ymd_and_hms(2024, 1, 15, 12, 15, 0).unwrap()),
            value: Some(0.000125),
            profile_name: Some("Haushalt".to_string()),
            ..Default::default()
        };

        let json = serde_json::to_string(&profile).unwrap();
        assert!(json.contains("H0"));
        assert!(json.contains("0.000125"));
    }

    #[test]
    fn test_business_profile() {
        let profile = ProfileData {
            profile_type: Some("G0".to_string()),
            profile_name: Some("Gewerbe allgemein".to_string()),
            profile_version: Some("2024-01".to_string()),
            temperature_zone: Some("TZ1".to_string()),
            ..Default::default()
        };

        let json = serde_json::to_string(&profile).unwrap();
        assert!(json.contains("G0"));
        assert!(json.contains("TZ1"));
    }

    #[test]
    fn test_roundtrip() {
        let profile = ProfileData {
            profile_type: Some("L0".to_string()),
            value: Some(0.000089),
            ..Default::default()
        };

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

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