termii_rust/blocking/rest/switch/
campaign.rs

1//! Send and manage campaigns sent to your organization's phonebook.
2//!
3//! Create, view & manage phonebooks using these APIs.
4//!
5//! Each phonebook can be identified by a unique ID, which makes it easier to edit or delete a phonebook.
6
7use std::{collections::HashMap, rc::Rc};
8
9use crate::{
10    blocking::http::client,
11    common::{
12        errors, pagination,
13        switch::campaign::{
14            PhoneBookCreateUpdateDeleteResponse, PhoneBookCreateUpdateRequest, PhoneBookItem,
15            PhoneBookListResponse,
16        },
17    },
18};
19
20#[derive(Debug)]
21pub struct Campaign<'a> {
22    api_key: &'a str,
23    client: Rc<client::HttpClient>,
24}
25
26impl<'a> Campaign<'a> {
27    pub(crate) fn new(api_key: &'a str, client: Rc<client::HttpClient>) -> Campaign<'a> {
28        Campaign { api_key, client }
29    }
30
31    pub(crate) fn _get(&self, page: &str) -> Result<Vec<PhoneBookItem>, errors::HttpError> {
32        let mut params = HashMap::new();
33        params.insert("api_key", self.api_key);
34        params.insert("page", page);
35
36        let response = self.client.get("phonebooks", Some(params), None)?;
37
38        let campaign_item = response_or_error_text_blocking!(response, PhoneBookListResponse);
39
40        Ok(campaign_item.data)
41    }
42
43    /// Fetch Phonebooks.
44    ///
45    /// ## Examples
46    ///
47    /// ```rust
48    /// use termii_rust::{blocking::rest::termii, common::switch::campaign::PhoneBookItem};
49    ///
50    /// let client = termii::Termii::new("Your API key");
51    ///
52    /// let phonebooks: Vec<PhoneBookItem> = client.switch.campaign.get(Some(1)).unwrap();
53    ///
54    /// println!("{:?}", phonebooks);
55    /// ```
56    /// ### The above code is limited by termii's pagination. You can get all your phonebooks with the **all** function like such
57    ///
58    /// ```rust
59    /// let phonebooks: Vec<PhoneBookItem> = client.switch.campaign.all().unwrap();
60    /// ```
61    pub fn get(&self, page: Option<&str>) -> Result<Vec<PhoneBookItem>, errors::HttpError> {
62        let page = page.unwrap_or("1");
63        let campaign_items = self._get(page)?;
64        Ok(campaign_items)
65    }
66
67    /// Fetch Phonebooks.
68    ///
69    /// ## Examples
70    ///
71    /// ```rust
72    /// use termii_rust::{
73    ///     blocking::rest::termii,
74    ///     common::switch::campaign::{
75    ///         PhoneBookCreateUpdateDeleteResponse, PhoneBookCreateUpdateRequest,
76    ///     },
77    /// };
78    ///
79    /// let client = termii::Termii::new("Your API key");
80    ///
81    /// let phonebook_create_request = PhoneBookCreateUpdateRequest {
82    ///     phonebook_name: "My Phonebook".to_string(),
83    ///     description: "My Phonebook".to_string(),
84    /// };
85    ///
86    /// let phonebook_create_response: PhoneBookCreateUpdateDeleteResponse = client
87    ///     .switch
88    ///     .campaign
89    ///     .create(phonebook_create_request)
90    ///     .unwrap();
91    ///
92    /// println!("{:?}", phonebook_create_response);
93    /// ```
94    pub fn create(
95        &self,
96        mut payload: PhoneBookCreateUpdateRequest,
97    ) -> Result<PhoneBookCreateUpdateDeleteResponse, errors::HttpError> {
98        payload.set_api_key(self.api_key);
99
100        let response = self.client.post("phonebooks", None, None, Some(payload))?;
101
102        let campaign_create_response =
103            response_or_error_text_blocking!(response, PhoneBookCreateUpdateDeleteResponse);
104
105        Ok(campaign_create_response)
106    }
107
108    /// Update Phonebook.
109    ///
110    /// ## Examples
111    ///
112    /// ```rust
113    /// use termii_rust::{
114    ///     blocking::rest::termii,
115    ///     common::switch::campaign::{
116    ///         PhoneBookCreateUpdateDeleteResponse, PhoneBookCreateUpdateRequest,
117    ///     },
118    /// };
119    ///
120    /// let client = termii::Termii::new("Your API key");
121    ///
122    /// let phonebook_update_request = PhoneBookCreateUpdateRequest {
123    ///     phonebook_name: "My Phonebook".to_string(),
124    ///     description: "My Phonebook".to_string(),
125    /// };
126    ///
127    /// let phonebook_update_response: PhoneBookCreateUpdateDeleteResponse = client
128    ///     .switch
129    ///     .campaign
130    ///     .update(
131    ///         "f9c28de9-ab5a-4513-9c9f-338be8e1c390",
132    ///         phonebook_update_request,
133    ///     )
134    ///     .unwrap();
135    ///
136    /// println!("{:?}", phonebook_update_response);
137    /// ```
138    pub fn update(
139        &self,
140        phonebook_id: &str,
141        mut payload: PhoneBookCreateUpdateRequest,
142    ) -> Result<PhoneBookCreateUpdateDeleteResponse, errors::HttpError> {
143        payload.set_api_key(self.api_key);
144
145        let response = self.client.patch(
146            format!("phonebooks/{}", phonebook_id).as_str(),
147            None,
148            None,
149            Some(payload),
150        )?;
151
152        let campaign_update_response =
153            response_or_error_text_blocking!(response, PhoneBookCreateUpdateDeleteResponse);
154
155        Ok(campaign_update_response)
156    }
157
158    /// Delete Phonebook.
159    ///
160    /// ## Examples
161    ///
162    /// ```rust
163    /// use termii_rust::{
164    ///     blocking::rest::termii, common::switch::campaign::PhoneBookCreateUpdateDeleteResponse,
165    /// };
166    ///
167    /// let client = termii::Termii::new("Your API key");
168    ///
169    /// let phonebook_delete_response: PhoneBookCreateUpdateDeleteResponse = client
170    ///     .switch
171    ///     .campaign
172    ///     .delete("f9c28de9-ab5a-4513-9c9f-338be8e1c390")
173    ///     .unwrap();
174    ///
175    /// println!("{:?}", phonebook_delete_response);
176    /// ```
177    pub fn delete(
178        &self,
179        phonebook_id: &str,
180    ) -> Result<PhoneBookCreateUpdateDeleteResponse, errors::HttpError> {
181        let response =
182            self.client
183                .delete(format!("phonebooks/{}", phonebook_id).as_str(), None, None)?;
184
185        let campaign_delete_response =
186            response_or_error_text_blocking!(response, PhoneBookCreateUpdateDeleteResponse);
187
188        Ok(campaign_delete_response)
189    }
190}
191
192impl pagination::PaginatedResource for Campaign<'_> {
193    type Item = PhoneBookItem;
194
195    fn _get(&self, page: &str) -> Result<Vec<Self::Item>, errors::HttpError> {
196        Campaign::_get(self, page)
197    }
198}