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

//! Market role (Marktrolle) enumeration.

use serde::{Deserialize, Serialize};

/// Role of a market participant in the energy market.
///
/// German: Marktrolle
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum MarketRole {
    /// Technical resource operator (Betreiber einer technischen Ressource)
    #[serde(rename = "BTR")]
    TechnicalResourceOperator,

    /// Balance coordinator / market area manager (Bilanzkoordinator / Marktgebietsverantwortlicher)
    #[serde(rename = "BIKO")]
    BalanceCoordinator,

    /// Balance responsible party (Bilanzkreisverantwortlicher)
    #[serde(rename = "BKV")]
    BalanceResponsibleParty,

    /// Data provider
    #[serde(rename = "DP")]
    DataProvider,

    /// Deployment responsible (Einsatzverantwortlicher)
    #[serde(rename = "EIV")]
    DeploymentResponsible,

    /// Energy service provider of connection user (Energieserviceanbieter des Anschlussnutzers)
    #[serde(rename = "ESA")]
    EnergyServiceProvider,

    /// Capacity user (Kapazitaetsnutzer)
    #[serde(rename = "KN")]
    CapacityUser,

    /// Supplier (Lieferant)
    #[serde(rename = "LF")]
    Supplier,

    /// Market area manager (Marktgebietsverantwortlicher)
    #[serde(rename = "MGV")]
    MarketAreaManager,

    /// Metering point operator (Messstellenbetreiber)
    #[serde(rename = "MSB")]
    MeteringPointOperator,

    /// Network operator (Netzbetreiber)
    #[serde(rename = "NB")]
    NetworkOperator,

    /// Register operator (Registerbetreiber)
    #[serde(rename = "RB")]
    RegisterOperator,

    /// Transmission system operator (Uebertragungsnetzbetreiber)
    #[serde(rename = "UENB")]
    TransmissionSystemOperator,
}

impl MarketRole {
    /// Returns the German name.
    pub fn german_name(&self) -> &'static str {
        match self {
            Self::TechnicalResourceOperator => "Betreiber einer technischen Ressource",
            Self::BalanceCoordinator => "Bilanzkoordinator",
            Self::BalanceResponsibleParty => "Bilanzkreisverantwortlicher",
            Self::DataProvider => "Data Provider",
            Self::DeploymentResponsible => "Einsatzverantwortlicher",
            Self::EnergyServiceProvider => "Energieserviceanbieter des Anschlussnutzers",
            Self::CapacityUser => "Kapazitaetsnutzer",
            Self::Supplier => "Lieferant",
            Self::MarketAreaManager => "Marktgebietsverantwortlicher",
            Self::MeteringPointOperator => "Messstellenbetreiber",
            Self::NetworkOperator => "Netzbetreiber",
            Self::RegisterOperator => "Registerbetreiber",
            Self::TransmissionSystemOperator => "Uebertragungsnetzbetreiber",
        }
    }
}

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

    #[test]
    fn test_serialize() {
        assert_eq!(
            serde_json::to_string(&MarketRole::NetworkOperator).unwrap(),
            r#""NB""#
        );
        assert_eq!(
            serde_json::to_string(&MarketRole::Supplier).unwrap(),
            r#""LF""#
        );
    }

    #[test]
    fn test_deserialize() {
        assert_eq!(
            serde_json::from_str::<MarketRole>(r#""MSB""#).unwrap(),
            MarketRole::MeteringPointOperator
        );
        assert_eq!(
            serde_json::from_str::<MarketRole>(r#""BKV""#).unwrap(),
            MarketRole::BalanceResponsibleParty
        );
    }

    #[test]
    fn test_roundtrip() {
        for role in [
            MarketRole::TechnicalResourceOperator,
            MarketRole::BalanceCoordinator,
            MarketRole::BalanceResponsibleParty,
            MarketRole::DataProvider,
            MarketRole::DeploymentResponsible,
            MarketRole::EnergyServiceProvider,
            MarketRole::CapacityUser,
            MarketRole::Supplier,
            MarketRole::MarketAreaManager,
            MarketRole::MeteringPointOperator,
            MarketRole::NetworkOperator,
            MarketRole::RegisterOperator,
            MarketRole::TransmissionSystemOperator,
        ] {
            let json = serde_json::to_string(&role).unwrap();
            let parsed: MarketRole = serde_json::from_str(&json).unwrap();
            assert_eq!(role, parsed);
        }
    }
}