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
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! Tariff costs (Tarifkosten) business object.

use serde::{Deserialize, Serialize};

use crate::com::{Amount, CostBlock, Price, TimePeriod};
use crate::enums::Division;
use crate::traits::{Bo4eMeta, Bo4eObject};

/// Tariff-related costs.
///
/// Represents the costs associated with a specific tariff.
///
/// German: Tarifkosten
///
/// # Example
///
/// ```rust
/// use bo4e_core::bo::TariffCosts;
/// use bo4e_core::com::{Amount, Price};
/// use bo4e_core::enums::Division;
///
/// let tariff_costs = TariffCosts {
///     designation: Some("Haushaltstarif Kosten".to_string()),
///     division: Some(Division::Electricity),
///     base_price_cost: Some(Amount::eur(119.40)),
///     working_price_cost: Some(Amount::eur(960.00)),
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TariffCosts {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

    /// Name/designation of the tariff costs (Bezeichnung)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub designation: Option<String>,

    /// Description (Beschreibung)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

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

    /// Period the costs apply to (Abrechnungszeitraum)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period: Option<TimePeriod>,

    /// Total amount (Gesamtbetrag)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_amount: Option<Amount>,

    /// Base price applied (Grundpreis)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_price: Option<Price>,

    /// Base price cost (Grundpreiskosten)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_price_cost: Option<Amount>,

    /// Working price applied (Arbeitspreis)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub working_price: Option<Price>,

    /// Working price cost (Arbeitspreiskosten)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub working_price_cost: Option<Amount>,

    /// Consumption quantity (Verbrauchsmenge)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub consumption: Option<f64>,

    /// Cost blocks (Kostenbloecke)
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub cost_blocks: Vec<CostBlock>,

    /// Reference to the tariff
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tariff: Option<Box<super::Tariff>>,
}

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

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

    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_tariff_costs_creation() {
        let tariff_costs = TariffCosts {
            designation: Some("Haushaltstarif Kosten".to_string()),
            division: Some(Division::Electricity),
            base_price: Some(Price::eur_per_month(9.95)),
            base_price_cost: Some(Amount::eur(119.40)),
            working_price: Some(Price::eur_per_kwh(0.32)),
            working_price_cost: Some(Amount::eur(960.00)),
            consumption: Some(3000.0),
            total_amount: Some(Amount::eur(1079.40)),
            ..Default::default()
        };

        assert_eq!(tariff_costs.consumption, Some(3000.0));
    }

    #[test]
    fn test_serialize() {
        let tariff_costs = TariffCosts {
            meta: Bo4eMeta::with_type("Tarifkosten"),
            designation: Some("Test Tariff Costs".to_string()),
            total_amount: Some(Amount::eur(500.0)),
            ..Default::default()
        };

        let json = serde_json::to_string(&tariff_costs).unwrap();
        assert!(json.contains(r#""designation":"Test Tariff Costs""#));
        assert!(json.contains(r#""_typ":"Tarifkosten""#));
    }

    #[test]
    fn test_roundtrip() {
        let tariff_costs = TariffCosts {
            meta: Bo4eMeta::with_type("Tarifkosten"),
            designation: Some("Gas Tariff Costs".to_string()),
            description: Some("Annual gas tariff costs".to_string()),
            division: Some(Division::Gas),
            consumption: Some(15000.0),
            total_amount: Some(Amount::eur(1500.0)),
            ..Default::default()
        };

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

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