Skip to main content

bo4e_core/com/
quality_indicator.rs

1//! Quality indicator (Qualitaetsindikator) component.
2
3use serde::{Deserialize, Serialize};
4
5use crate::enums::MeasuredValueStatus;
6use crate::traits::{Bo4eMeta, Bo4eObject};
7
8/// Quality indicator for measured data.
9///
10/// German: Qualitaetsindikator
11///
12/// # Example
13///
14/// ```rust
15/// use bo4e_core::com::QualityIndicator;
16/// use bo4e_core::enums::MeasuredValueStatus;
17///
18/// let indicator = QualityIndicator {
19///     quality_code: Some("G1".to_string()),
20///     status: Some(MeasuredValueStatus::Read),
21///     ..Default::default()
22/// };
23/// ```
24#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
25#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))]
26#[cfg_attr(feature = "json-schema", schemars(rename = "Qualitaetsindikator"))]
27#[serde(rename_all = "camelCase")]
28pub struct QualityIndicator {
29    /// BO4E metadata
30    #[serde(flatten)]
31    pub meta: Bo4eMeta,
32
33    /// Quality code (Qualitätscode)
34    #[serde(skip_serializing_if = "Option::is_none")]
35    #[cfg_attr(feature = "json-schema", schemars(rename = "qualitaetscode"))]
36    pub quality_code: Option<String>,
37
38    /// Status of the measured value (Status)
39    #[serde(skip_serializing_if = "Option::is_none")]
40    #[cfg_attr(feature = "json-schema", schemars(rename = "status"))]
41    pub status: Option<MeasuredValueStatus>,
42
43    /// Quality description (Qualitätsbeschreibung)
44    #[serde(skip_serializing_if = "Option::is_none")]
45    #[cfg_attr(feature = "json-schema", schemars(rename = "qualitaetsbeschreibung"))]
46    pub quality_description: Option<String>,
47
48    /// Confidence percentage (Konfidenz)
49    #[serde(skip_serializing_if = "Option::is_none")]
50    #[cfg_attr(feature = "json-schema", schemars(rename = "konfidenz"))]
51    pub confidence_percent: Option<f64>,
52
53    /// Data source (Datenquelle)
54    #[serde(skip_serializing_if = "Option::is_none")]
55    #[cfg_attr(feature = "json-schema", schemars(rename = "datenquelle"))]
56    pub data_source: Option<String>,
57
58    /// Whether the value was substituted (Ersetzt)
59    #[serde(skip_serializing_if = "Option::is_none")]
60    #[cfg_attr(feature = "json-schema", schemars(rename = "ersetzt"))]
61    pub is_substituted: Option<bool>,
62}
63
64impl Bo4eObject for QualityIndicator {
65    fn type_name_german() -> &'static str {
66        "Qualitaetsindikator"
67    }
68
69    fn type_name_english() -> &'static str {
70        "QualityIndicator"
71    }
72
73    fn meta(&self) -> &Bo4eMeta {
74        &self.meta
75    }
76
77    fn meta_mut(&mut self) -> &mut Bo4eMeta {
78        &mut self.meta
79    }
80}
81
82#[cfg(test)]
83mod tests {
84    use super::*;
85
86    #[test]
87    fn test_quality_indicator() {
88        let indicator = QualityIndicator {
89            quality_code: Some("G1".to_string()),
90            status: Some(MeasuredValueStatus::Read),
91            confidence_percent: Some(99.5),
92            is_substituted: Some(false),
93            ..Default::default()
94        };
95
96        let json = serde_json::to_string(&indicator).unwrap();
97        assert!(json.contains("G1"));
98        assert!(json.contains("99.5"));
99    }
100
101    #[test]
102    fn test_substituted_value() {
103        let indicator = QualityIndicator {
104            status: Some(MeasuredValueStatus::Substitute),
105            is_substituted: Some(true),
106            data_source: Some("INTERPOLATION".to_string()),
107            ..Default::default()
108        };
109
110        let json = serde_json::to_string(&indicator).unwrap();
111        assert!(json.contains("INTERPOLATION"));
112    }
113
114    #[test]
115    fn test_roundtrip() {
116        let indicator = QualityIndicator {
117            quality_code: Some("G2".to_string()),
118            status: Some(MeasuredValueStatus::Forecast),
119            ..Default::default()
120        };
121
122        let json = serde_json::to_string(&indicator).unwrap();
123        let parsed: QualityIndicator = serde_json::from_str(&json).unwrap();
124        assert_eq!(indicator, parsed);
125    }
126
127    #[test]
128    fn test_bo4e_object_impl() {
129        assert_eq!(QualityIndicator::type_name_german(), "Qualitaetsindikator");
130        assert_eq!(QualityIndicator::type_name_english(), "QualityIndicator");
131    }
132}