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

//! Work Order Mobule V4

use super::{work_order_item::WorkOrderItem, MOD_PATH};
use crate::common::{note::Note, related_party::RelatedParty, tmf_error::TMFError};
use crate::tmf646::appointment::AppointmentRef;
use crate::{vec_insert, HasId, HasNote, HasRelatedParty, Uri};
use serde::{Deserialize, Serialize};
use tmflib_derive::{HasId, HasNote, HasRelatedParty};

const CLASS_PATH: &str = "workorder";

/// Work Order States
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub enum WorkOrderStateType {
    #[default]
    /// Acknowledged
    Acknowledged,
    /// WO is rejected
    Rejected,
    /// WO is pending an action
    Pending,
    /// WO is held
    Held,
    /// WO is in progress
    InProgress,
    /// WO has been cancelled
    Cancelled,
    /// WO has been completed
    Completed,
    /// WO has failed
    Failed,
    /// WO has been partially completed
    Partial,
    /// WO is under accessment for cancellation
    AccessingCancellation,
    /// WO is awaiting cancellation
    PendingCancellation,
}

/// Work Order
#[derive(Clone, Debug, Default, Deserialize, HasId, HasNote, HasRelatedParty, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkOrder {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "@type")]
    r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "@baseType")]
    base_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "@schemaLocation")]
    schema_location: Option<String>,
    /// HTTP Reference
    #[serde(skip_serializing_if = "Option::is_none")]
    pub href: Option<Uri>,
    /// Unique Id
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Work Order Status@type
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<WorkOrderStateType>,
    // Referenced structures
    /// Appointment
    #[serde(skip_serializing_if = "Option::is_none")]
    pub appointment: Option<AppointmentRef>,
    /// Work Order Items
    pub work_order_item: Option<Vec<WorkOrderItem>>,
    /// Work Order Notes
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<Vec<Note>>,
    /// Related parties for party specific catalogs
    #[serde(skip_serializing_if = "Option::is_none")]
    related_party: Option<Vec<RelatedParty>>,
}

impl WorkOrder {
    /// Create a new Work Order instance
    pub fn new() -> WorkOrder {
        // Use create() to define remainint fields
        WorkOrder {
            state: Some(WorkOrderStateType::default()),
            r#type: Some(WorkOrder::get_class()),
            base_type: Some(WorkOrder::get_class()),
            ..WorkOrder::create()
        }
    }

    /// Add a work order item to this WorkOrder
    /// ```
    /// use tmflib::tmf697::v4::work_order::WorkOrder;
    /// use tmflib::tmf697::v4::work_order_item::WorkOrderItem;
    /// use tmflib::tmf697::v4::work::{WorkRefOrValue,Work};
    ///
    /// let mut wo = WorkOrder::new();
    /// let work = Work::new("Some Work");
    /// let work_item = WorkOrderItem::with(WorkRefOrValue::from(work));
    /// wo.add_item(work_item);
    /// ```
    pub fn add_item(&mut self, item: WorkOrderItem) {
        // Safely add item
        vec_insert(&mut self.work_order_item, item);
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::tmf697::v4::work::{Work, WorkRefOrValue};

    const WORK_NAME: &str = "WorkName";

    #[test]
    fn test_work_order_new() {
        let wo = WorkOrder::new();

        assert_eq!(wo.state.is_some(), true);
        assert_eq!(wo.state.unwrap(), WorkOrderStateType::default());
    }

    #[test]
    fn test_work_order_add_item() {
        let item1 = WorkOrderItem::with(WorkRefOrValue::from(Work::new(WORK_NAME)));
        let mut wo = WorkOrder::new();

        wo.add_item(item1);

        assert_eq!(wo.work_order_item.is_some(), true);

        let item2 = WorkOrderItem::with(WorkRefOrValue::from(Work::new(WORK_NAME)));

        wo.add_item(item2);

        assert_eq!(wo.work_order_item.unwrap().len(), 2);
    }
}