bo4e-core 0.1.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
143

//! Location assignment (Lokationszuordnung) business object.
//!
//! Represents the assignment/relationship between different location types.

use serde::{Deserialize, Serialize};

use crate::com::TimePeriod;
use crate::enums::{ArithmeticOperation, LocationType};
use crate::traits::{Bo4eMeta, Bo4eObject};

/// An assignment between locations in the energy market.
///
/// German: Lokationszuordnung
///
/// This business object represents the relationship between different
/// types of locations (market, metering, network).
///
/// # Example
///
/// ```rust
/// use bo4e_core::bo::LocationAssignment;
///
/// let assignment = LocationAssignment {
///     market_location_id: Some("12345678901".to_string()),
///     metering_location_id: Some("DE00012345678901234567890123456789".to_string()),
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LocationAssignment {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

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

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

    /// Network location ID (Netzlokations-ID)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub network_location_id: Option<String>,

    /// Technical resource ID (Technische-Ressource-ID)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub technical_resource_id: Option<String>,

    /// Controllable resource ID (Steuerbare-Ressource-ID)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub controllable_resource_id: Option<String>,

    /// Location type (Lokationstyp)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_type: Option<LocationType>,

    /// Arithmetic operation for combination (Rechenoperation)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arithmetic_operation: Option<ArithmeticOperation>,

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

    /// Sequence/order number (Reihenfolge)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sequence: Option<i32>,
}

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

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

    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_assignment_creation() {
        let assignment = LocationAssignment {
            market_location_id: Some("12345678901".to_string()),
            metering_location_id: Some("DE00012345678901234567890123456789".to_string()),
            ..Default::default()
        };

        assert!(assignment.market_location_id.is_some());
        assert!(assignment.metering_location_id.is_some());
    }

    #[test]
    fn test_serialize() {
        let assignment = LocationAssignment {
            meta: Bo4eMeta::with_type("Lokationszuordnung"),
            market_location_id: Some("12345678901".to_string()),
            ..Default::default()
        };

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

    #[test]
    fn test_roundtrip() {
        let assignment = LocationAssignment {
            meta: Bo4eMeta::with_type("Lokationszuordnung"),
            market_location_id: Some("12345678901".to_string()),
            metering_location_id: Some("DE00012345678901234567890123456789".to_string()),
            arithmetic_operation: Some(ArithmeticOperation::Addition),
            sequence: Some(1),
            ..Default::default()
        };

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

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