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
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
143
144
145
146
147

//! Energy amount (Energiemenge) business object.
//!
//! Represents a quantity of energy with associated measurements.

use serde::{Deserialize, Serialize};

use crate::com::{MeasuredValue, TimePeriod};
use crate::enums::{Division, EnergyDirection, MeasurementType};
use crate::traits::{Bo4eMeta, Bo4eObject};

/// An amount of energy with time series data.
///
/// German: Energiemenge
///
/// Energy amounts represent measured or calculated energy quantities
/// over time, typically associated with a market or metering location.
///
/// # Example
///
/// ```rust
/// use bo4e_core::bo::EnergyAmount;
/// use bo4e_core::enums::{Division, EnergyDirection};
///
/// let energy = EnergyAmount {
///     energy_amount_id: Some("EA001".to_string()),
///     division: Some(Division::Electricity),
///     energy_direction: Some(EnergyDirection::FeedOut),
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnergyAmount {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

    /// Energy amount ID (Energiemenge-ID)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub energy_amount_id: Option<String>,

    /// Energy division (Sparte)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub division: Option<Division>,

    /// Energy direction (Energierichtung)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub energy_direction: Option<EnergyDirection>,

    /// Measurement type (Messart)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub measurement_type: Option<MeasurementType>,

    /// Validity period (Gueltigkeitszeitraum)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validity_period: Option<TimePeriod>,

    /// Time series data (Messwerte)
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub measured_values: Vec<MeasuredValue>,

    /// Associated market location ID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub market_location_id: Option<String>,

    /// Associated metering location ID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metering_location_id: Option<String>,

    /// OBIS code for the measurement
    #[serde(skip_serializing_if = "Option::is_none")]
    pub obis_code: Option<String>,

    /// Total energy value (Gesamtenergie)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_energy: Option<f64>,
}

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

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

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

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

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

    #[test]
    fn test_energy_amount_creation() {
        let energy = EnergyAmount {
            energy_amount_id: Some("EA001".to_string()),
            division: Some(Division::Electricity),
            energy_direction: Some(EnergyDirection::FeedOut),
            ..Default::default()
        };

        assert_eq!(energy.energy_amount_id, Some("EA001".to_string()));
    }

    #[test]
    fn test_serialize() {
        let energy = EnergyAmount {
            meta: Bo4eMeta::with_type("Energiemenge"),
            energy_amount_id: Some("EA001".to_string()),
            ..Default::default()
        };

        let json = serde_json::to_string(&energy).unwrap();
        assert!(json.contains(r#""_typ":"Energiemenge""#));
    }

    #[test]
    fn test_roundtrip() {
        let energy = EnergyAmount {
            meta: Bo4eMeta::with_type("Energiemenge"),
            energy_amount_id: Some("EA001".to_string()),
            division: Some(Division::Electricity),
            energy_direction: Some(EnergyDirection::FeedOut),
            total_energy: Some(1234.56),
            obis_code: Some("1-0:1.8.0".to_string()),
            ..Default::default()
        };

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

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