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

//! Shopping Cart Item

use super::shopping_cart::CartPrice;
use crate::common::note::Note;
#[cfg(all(feature = "tmf620", feature = "build-V4"))]
use crate::tmf620::product_offering::ProductOfferingRef;
#[cfg(all(feature = "tmf620", feature = "build-V5"))]
use crate::tmf620::product_offering_v5::ProductOfferingRef;
use serde::{Deserialize, Serialize};

use std::convert::From;
use uuid::Uuid;

/// Shopping Cart Item Reference
#[derive(Clone, Default, Debug, Serialize, Deserialize)]
pub struct ItemRef {
    id: String,
}

impl From<CartItem> for ItemRef {
    fn from(value: CartItem) -> Self {
        ItemRef {
            id: value.id.unwrap_or_default().clone(),
        }
    }
}
/// Shopping Cart Item
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CartItem {
    id: Option<String>,
    /// Notes for this Cart Item
    pub note: Vec<Note>,
    /// Product Offering in cart
    pub product_offering: Option<ProductOfferingRef>,
    /// Quantity
    pub quantity: u16,
    /// Item Price
    pub item_price: Option<Vec<CartPrice>>,
}

impl CartItem {
    /// Add a note to this cart item
    pub fn add_note(&mut self, note: Note) {
        self.note.push(note);
    }
}

impl From<ProductOfferingRef> for CartItem {
    fn from(value: ProductOfferingRef) -> Self {
        let id = Uuid::new_v4().simple().to_string();
        CartItem {
            id: Some(id),
            quantity: 1,
            product_offering: Some(value),
            ..Default::default()
        }
    }
}

#[cfg(test)]
mod test {
    use crate::common::note::Note;
    #[cfg(feature = "build-V4")]
    use crate::tmf620::product_offering::{ProductOffering, ProductOfferingRef};
    #[cfg(feature = "build-V5")]
    use crate::tmf620::product_offering_v5::{ProductOffering, ProductOfferingRef};

    use super::CartItem;

    const OFFER_NAME: &str = "OfferName";

    const CART_JSON: &str = "{
        \"id\" : \"CI123\",
        \"note\" : [],
        \"quantity\" : 1,
        \"itemPrice\" : []
    }";
    #[test]
    fn test_cartitem_add_note() {
        let note = Note::from("A Note");

        let mut cart_item = CartItem::default();
        cart_item.add_note(note);

        assert_eq!(cart_item.note.len(), 1);
    }

    #[test]
    fn test_cartitem_from_offeringref() {
        let offer = ProductOffering::new(OFFER_NAME);

        let cart_item = CartItem::from(ProductOfferingRef::from(offer));

        assert_eq!(cart_item.quantity, 1);
        assert_eq!(cart_item.product_offering.is_some(), true);
        assert_eq!(
            cart_item.product_offering.unwrap().name,
            OFFER_NAME.to_string()
        );
    }

    #[test]
    fn test_cartitem_deserialization() {
        let cartitem: CartItem = serde_json::from_str(CART_JSON).unwrap();

        assert_eq!(cartitem.id.is_some(), true);
        assert_eq!(cartitem.quantity, 1);
    }
}