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

//! Offer variant (Angebotsvariante) component.

use serde::{Deserialize, Serialize};

use crate::enums::OfferStatus;
use crate::traits::{Bo4eMeta, Bo4eObject};

/// Variant of an offer with different calculation options.
///
/// German: Angebotsvariante
///
/// # Example
///
/// ```rust
/// use bo4e_core::com::OfferVariant;
/// use bo4e_core::enums::OfferStatus;
///
/// let variant = OfferVariant {
///     offer_status: Some(OfferStatus::NonBinding),
///     creation_date: Some("2024-01-15T10:00:00+01:00".to_string()),
///     ..Default::default()
/// };
/// ```
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OfferVariant {
    /// BO4E metadata
    #[serde(flatten)]
    pub meta: Bo4eMeta,

    /// Status of the offer (Angebotsstatus)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offer_status: Option<OfferStatus>,

    /// Creation date of the offer variant (Erstellungsdatum)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creation_date: Option<String>,

    /// Binding deadline - until this time the offer variant is valid (Bindefrist)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub binding_deadline: Option<String>,

    // Note: The following fields would typically reference other COM types
    // (Angebotsteil, Menge, Betrag) which will be added later.
    /// Number of offer parts in this variant
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parts_count: Option<i32>,

    /// Total quantity value across all offer parts (simplified - Gesamtmenge)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_quantity_value: Option<f64>,

    /// Total cost value across all offer parts (simplified - Gesamtkosten)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total_cost_value: Option<f64>,
}

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

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

    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_offer_variant_default() {
        let variant = OfferVariant::default();
        assert!(variant.offer_status.is_none());
        assert!(variant.creation_date.is_none());
    }

    #[test]
    fn test_offer_variant_serialize() {
        let variant = OfferVariant {
            offer_status: Some(OfferStatus::Binding),
            creation_date: Some("2024-03-01T09:00:00+01:00".to_string()),
            binding_deadline: Some("2024-04-01T23:59:59+02:00".to_string()),
            ..Default::default()
        };

        let json = serde_json::to_string(&variant).unwrap();
        assert!(json.contains(r#""offerStatus":"VERBINDLICH""#));
        assert!(json.contains(r#""creationDate":"#));
        assert!(json.contains(r#""bindingDeadline":"#));
    }

    #[test]
    fn test_offer_variant_roundtrip() {
        let variant = OfferVariant {
            meta: Bo4eMeta::with_type("Angebotsvariante"),
            offer_status: Some(OfferStatus::NonBinding),
            creation_date: Some("2024-02-15T10:30:00+01:00".to_string()),
            binding_deadline: Some("2024-03-15T23:59:59+01:00".to_string()),
            parts_count: Some(2),
            total_quantity_value: Some(100000.0),
            total_cost_value: Some(25000.0),
        };

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

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