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

//! Customer Bill Management v5
//!

use super::MOD_PATH;
use serde::{Deserialize, Serialize};

use crate::common::attachment::AttachmentRefOrValue;
use crate::common::money::Money;
use crate::common::related_party::RelatedParty;
use crate::{DateTime, HasAttachment, HasId, HasLastUpdate, TimePeriod, Uri};
use tmflib_derive::{HasId, HasLastUpdate};

const CLASS_PATH: &str = "customer_bill";

/// Customer Bill Run Type
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub enum CustomerBillRunType {
    /// Inside regular bill cycle
    #[default]
    OnCycle,
    /// Outside regular bill cycle
    OffCycle,
}

/// Customer Bill Status
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub enum CustomerBillStateType {
    /// New Bill
    #[default]
    New,
    /// Bill has been paused
    OnHold,
    /// Bill has passed validation
    Validated,
    /// Bill has been sent to customer
    Sent,
    /// Bill has been paid
    Settled,
    /// Bill has been partially paid
    PartialPaid,
}

/// Customer Bill
#[derive(Clone, Debug, Default, Deserialize, HasId, HasLastUpdate, Serialize)]
pub struct CustomerBill {
    amount_due: Option<Money>,
    bill_date: Option<DateTime>,
    bill_no: String,
    billing_period: TimePeriod,
    category: String,
    /// Uri
    pub href: Option<Uri>,
    /// Unique Id
    pub id: Option<String>,
    /// Last update of bill
    pub last_update: Option<DateTime>,
    next_bill_date: DateTime,
    payment_due_date: DateTime,
    remaining_amount: Money,
    run_type: CustomerBillRunType,
    state: Option<CustomerBillStateType>,
    tax_excluded_amount: Money,
    tax_included_amount: Money,

    // Referenced Fields
    /// Related Parties
    pub related_party: Option<Vec<RelatedParty>>,
    /// Invoice / Bill documents
    pub bill_document: Option<Vec<AttachmentRefOrValue>>,
}

impl CustomerBill {
    /// Create a new customer bill
    pub fn new() -> CustomerBill {
        let mut bill = CustomerBill::create();
        bill.state = Some(CustomerBillStateType::default());
        bill
    }
}

impl HasAttachment for CustomerBill {
    fn add(&mut self, attachment: &AttachmentRefOrValue) {
        match self.bill_document.as_mut() {
            Some(v) => {
                v.push(attachment.clone());
            }
            None => {
                self.bill_document = Some(vec![attachment.clone()]);
            }
        }
    }
    fn position(&self, name: impl Into<String>) -> Option<usize> {
        match self.bill_document.as_ref() {
            Some(v) => {
                let pattern: String = name.into();
                v.iter().position(|a| a.name == Some(pattern.clone()))
            }
            None => None,
        }
    }
    fn find(&self, name: impl Into<String>) -> Option<&AttachmentRefOrValue> {
        match self.bill_document.as_ref() {
            Some(v) => {
                let pattern: String = name.into();
                v.iter().find(|a| a.name == Some(pattern.clone()))
            }
            None => None,
        }
    }
    fn get(&self, position: usize) -> Option<AttachmentRefOrValue> {
        match self.bill_document.as_ref() {
            Some(v) => v.get(position).cloned(),
            None => None,
        }
    }
    fn remove(&mut self, position: usize) -> Option<AttachmentRefOrValue> {
        self.bill_document.as_mut().map(|v| v.remove(position))
    }
    fn attachment(mut self, attachment: AttachmentRefOrValue) -> Self {
        self.add(&attachment);
        self
    }
}