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

//! Billing Account Module

use serde::{Deserialize, Serialize};

use crate::common::{contact::Contact, money::Money, related_party::RelatedParty};
use crate::{DateTime, HasDescription, HasId, HasLastUpdate, HasName};
use tmflib_derive::{HasDescription, HasId, HasLastUpdate, HasName};

use super::{
    financial_account::FinancialAccountRef, AccountBalance, AccountRef, AccountTaxExemption,
    PaymentMethodRef, PaymentPlan, MOD_PATH,
};

const CLASS_PATH: &str = "account";

/// Billing Account
#[derive(
    Clone, Debug, Default, Deserialize, HasId, HasName, HasLastUpdate, HasDescription, Serialize,
)]
#[serde(rename_all = "camelCase")]
pub struct BillingAccount {
    #[serde(skip_serializing_if = "Option::is_none")]
    account_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    credit_limit: Option<Money>,
    /// Account Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Unique Identifier
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// HTTP URI
    #[serde(skip_serializing_if = "Option::is_none")]
    pub href: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    last_modified: Option<DateTime>,
    #[serde(skip_serializing_if = "Option::is_none")]
    name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    payment_status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    rating_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    last_update: Option<DateTime>,
    related_party: Vec<RelatedParty>,
    #[serde(skip_serializing_if = "Option::is_none")]
    contact: Option<Vec<Contact>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    account_balance: Option<Vec<AccountBalance>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tax_exemption: Option<Vec<AccountTaxExemption>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    financial_account: Option<FinancialAccountRef>,
    #[serde(skip_serializing_if = "Option::is_none")]
    payment_plan: Option<Vec<PaymentPlan>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    default_payment_method: Option<PaymentMethodRef>,
}

impl BillingAccount {
    /// Create new Billing Account
    pub fn new(name: impl Into<String>) -> BillingAccount {
        let mut account = BillingAccount::create();
        account.name = Some(name.into());
        account
    }
}

impl From<BillingAccount> for AccountRef {
    fn from(value: BillingAccount) -> Self {
        AccountRef {
            id: value.get_id(),
            href: value.get_href(),
            name: value.get_name(),
            description: value.description.clone(),
        }
    }
}

/// Billing Account Reference
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct BillingAccountRef {
    /// Referenced Id
    id: String,
    /// Referenced HREF
    href: String,
    /// Referenced Name
    name: String,
}

impl From<BillingAccount> for BillingAccountRef {
    fn from(value: BillingAccount) -> Self {
        BillingAccountRef {
            id: value.get_id(),
            href: value.get_href(),
            name: value.get_name(),
        }
    }
}

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

    const ACCOUNT: &str = "BillingAccount";

    #[test]
    fn test_billing_account_new_name() {
        let account = BillingAccount::new(ACCOUNT);

        assert_eq!(account.name, Some(ACCOUNT.into()));
    }

    #[test]
    fn test_ref_from_billing_account() {
        let account = BillingAccount::new(ACCOUNT);

        let account_ref = AccountRef::from(account.clone());

        assert_eq!(account_ref.id, account.get_id());
        assert_eq!(account_ref.href, account.get_href());
        assert_eq!(account_ref.name, account.get_name());
    }

    #[test]
    fn test_billingref_from_billing_account() {
        let account = BillingAccount::new(ACCOUNT);

        let account_ref = BillingAccountRef::from(account.clone());

        assert_eq!(account_ref.id, account.get_id());
        assert_eq!(account_ref.href, account.get_href());
        assert_eq!(account_ref.name, account.get_name());
    }
}