retarus 0.1.0

The official Rust SDK provided by Retarus to contact our messaging services with the lightning speed of the rust programming language.
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

use super::{document::Document};

/// This represents a fax job that will be transmitted  to the Retarus server to send a fax.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Job {
    /// A list of all numbers that should receive a fax.
    recipients: Vec<Number>,
    /// List of documents that should be send as fax to the specified numbers.
    documents: Vec<Document>,
}
impl Job {
    /// Create new fax job.
    /// # Examples
    /// ```rust
    /// use retarus::fax::document::Document;
    /// use retarus::fax::job::Job;
    /// use retarus::fax::job::Number;
    /// // first create a document
    /// let docs = vec![Document::new(String::from("important_document.pdf"), "abc_content".as_bytes().to_vec(), None )];
    /// // Then get a vec of all your number
    /// let numbers = vec!["491231255903".to_string()];
    /// // Create and send the job
    /// let response = Job::builder().add_recipients(numbers).add_documents(docs);
    /// ```
    fn new(numbers: Vec<Number>, documents: Vec<Document>) -> Job {
        Job {
            recipients: numbers,
            documents,
        }
    }
    pub fn builder() -> JobBuilder {
        JobBuilder::default()
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Number {
    number: String,
}

/// Build a Job using this builder. Use defaults specified in the Fax4App SDK.
/// # Examples
///
/// ```rust
/// use retarus::fax::job::JobBuilder;
/// let numbers = vec!["+498900000000".to_string(), "+48090000000".to_string()];
/// let job = JobBuilder::default()
///             .add_recipients(numbers)
///             .build();
/// ```
pub struct JobBuilder {
    recipients: Vec<Number>,
    documents: Vec<Document>,
}
impl JobBuilder {
    /// Create a JobBuilder instance
    pub fn default() -> JobBuilder {
        JobBuilder {
            recipients: Vec::new(),
            documents: Vec::new(),
        }
    }

    /// Add a vector of recipients to the job (recipient number)
    pub fn add_recipients(mut self, recipients: Vec<String>) -> JobBuilder {
        for recipient in recipients.iter() {
            self.recipients.push(Number {
                number: recipient.to_owned(),
            })
        }
        self
    }

    /// To add a single phone number to the job.
    pub fn add_recipient(mut self, recipient: String) -> JobBuilder {
        self.recipients.push(Number { number: recipient });
        self
    }

    pub fn add_document(mut self, doc: Document) -> JobBuilder {
        self.documents.push(doc);
        self
    }

    pub fn add_documents(mut self, docs: Vec<Document>) -> JobBuilder {
        self.documents = docs;
        self
    }
    /// Build a job from the given arguments.
    pub fn build(self) -> Job {
        Job {
            recipients: self.recipients,
            documents: self.documents,
        }
    }
}


#[test]
fn test_job_builder() {
    let number = "+490000000000";
    let numbers = vec!["+499000000000".to_string(), "+49800000000000".to_string()];
    let job = JobBuilder::default()
    .add_recipient(number.to_string())
    .add_recipients(numbers)
    .build();
    assert_eq!(job.recipients.len(), 3)
}