tmflib 0.1.37

Interface library for processing TMF payloads
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
162
163
164

//! Actual Cost

use serde::{Deserialize, Serialize};

use crate::{
    common::{attachment::AttachmentRefOrValue, note::Note, related_party::RelatedParty},
    vec_insert, HasAttachment, HasDescription, HasId, HasLastUpdate, HasName, HasNote,
    HasRelatedParty, TMFError, Uri,
};

use tmflib_derive::{
    HasAttachment, HasDescription, HasId, HasLastUpdate, HasName, HasNote, HasRelatedParty,
};

const CLASS_PATH: &str = "ActualCost";
use super::MOD_PATH;

/// Actual Cost Item State Type
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub enum ActualCostItemStateType {
    /// Cost Incurred
    Incurred,
    /// Cost Disputed
    Disputed,
    /// Cost Verified
    Verified,
    /// Cost Allocated
    #[default]
    Allocated,
    /// Cost Cancelled
    Cancelled,
}

/// Cost Item Type
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub enum CostItemType {
    /// Once of Charges
    OneTime,
    /// Ongoing Recurring Charges
    #[default]
    Recurring,
    /// Consumption Based Charges
    ConsumptionBased,
}

/// Actual Cost Item
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ActualCostItem {
    /// Unique identifier
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Quantity
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cost_item_type: Option<CostItemType>,
}

impl ActualCostItem {
    /// Create a new Actual Cost Item
    pub fn new(name: impl Into<String>) -> Self {
        Self {
            name: Some(name.into()),
            ..Default::default()
        }
    }
}

/// Cost Relationship
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CostRelationship {}

/// Actual Cost
#[derive(
    Debug,
    Default,
    Clone,
    HasId,
    HasName,
    HasAttachment,
    HasDescription,
    HasLastUpdate,
    HasNote,
    HasRelatedParty,
    Serialize,
    Deserialize,
)]
pub struct ActualCost {
    /// Unique identifier
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Hyperlink reference
    #[serde(skip_serializing_if = "Option::is_none")]
    pub href: Option<Uri>,
    /// Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Notes
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<Vec<Note>>,

    /// Related Parties
    #[serde(skip_serializing_if = "Option::is_none")]
    pub related_party: Option<Vec<RelatedParty>>,

    /// Last Update
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_update: Option<crate::DateTime>,
    /// Attachments
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attachment: Option<Vec<AttachmentRefOrValue>>,
    /// Cost Items
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cost_item: Option<Vec<ActualCostItem>>,
    /// Cost Relationships
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cost_relationship: Option<Vec<CostRelationship>>,
}

impl ActualCost {
    /// Create a new Actual Cost
    pub fn new(name: impl Into<String>) -> Self {
        Self::create_with_time().name(name.into())
    }

    /// Add an Actual Cost Item
    ///
    /// # Arguments
    /// * `item` - The Actual Cost Item to add
    /// # Returns
    /// * `Self` - The updated Actual Cost
    /// # Example
    /// ```rust
    /// use tmflib::tmf764::actual_cost::{ActualCost, ActualCostItem};
    /// let cost = ActualCost::new("Example Cost")
    ///     .item(ActualCostItem::new("Item 1"));
    /// ```
    pub fn item(mut self, item: ActualCostItem) -> Self {
        vec_insert(&mut self.cost_item, item);
        self
    }
}

impl From<ActualCost> for super::CostRef {
    fn from(cost: ActualCost) -> Self {
        crate::tmf764::CostRef {
            id: cost.get_id(),
            href: cost.get_href(),
            name: cost.name.clone(),
            base_type: None,
            referred_type: None,
            schema_location: None,
            r#type: Some(String::from("ActualCost")),
        }
    }
}