Skip to main content

babelforce_manager_sdk/resources/
phonebook.rs

1use std::path::PathBuf;
2use std::sync::Arc;
3
4use crate::error::{map_manager_err, ManagerError};
5use crate::gen::manager::apis::configuration::Configuration;
6use crate::gen::manager::apis::{manager_api, phonebook_entry_api as api};
7use crate::gen::manager::models;
8use crate::http::collect_all;
9use crate::retry::{with_retry, RetryPolicy};
10
11/// Phonebook entries — `/api/v2/phonebook`.
12pub struct PhonebookResource {
13    pub(crate) cfg: Arc<Configuration>,
14    pub(crate) retry: RetryPolicy,
15}
16
17impl PhonebookResource {
18    /// List all phonebook entries (auto-paginated).
19    pub async fn list_all(&self) -> Result<Vec<models::PhonebookEntry>, ManagerError> {
20        collect_all(&self.retry, map_manager_err, |page| async move {
21            let r = api::list_phonebook_entrys(self.cfg.as_ref(), Some(page), None).await?;
22            Ok((r.items, r.pagination.pages, r.pagination.current))
23        })
24        .await
25    }
26
27    /// Create a phonebook entry.
28    pub async fn create(
29        &self,
30        body: models::RestCreatePhonebookEntry,
31    ) -> Result<models::PhonebookEntryItemResponse, ManagerError> {
32        with_retry(&self.retry, false, || {
33            api::create_phonebook_entry(self.cfg.as_ref(), body.clone())
34        })
35        .await
36        .map_err(map_manager_err)
37    }
38
39    /// Get a phonebook entry by id.
40    pub async fn get(&self, id: &str) -> Result<models::PhonebookEntryItemResponse, ManagerError> {
41        with_retry(&self.retry, true, || {
42            api::get_phonebook_entry(self.cfg.as_ref(), id)
43        })
44        .await
45        .map_err(map_manager_err)
46    }
47
48    /// Update a phonebook entry.
49    pub async fn update(
50        &self,
51        id: &str,
52        body: models::RestUpdatePhonebookEntry,
53    ) -> Result<models::PhonebookEntryItemResponse, ManagerError> {
54        with_retry(&self.retry, false, || {
55            api::update_phonebook_entry(self.cfg.as_ref(), id, body.clone())
56        })
57        .await
58        .map_err(map_manager_err)
59    }
60
61    /// Delete a phonebook entry.
62    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
63        with_retry(&self.retry, false, || {
64            api::delete_phonebook_entry(self.cfg.as_ref(), id)
65        })
66        .await
67        .map_err(map_manager_err)?;
68        Ok(())
69    }
70
71    /// Download all phonebook entries as CSV text.
72    pub async fn download(&self) -> Result<String, ManagerError> {
73        with_retry(&self.retry, true, || {
74            manager_api::download_phonebook_entries(self.cfg.as_ref())
75        })
76        .await
77        .map_err(map_manager_err)
78    }
79
80    /// Bulk-upload phonebook entries from a CSV file. `overwrite` replaces existing entries.
81    pub async fn upload(&self, file: PathBuf, overwrite: bool) -> Result<(), ManagerError> {
82        with_retry(&self.retry, false, || {
83            manager_api::upload_phonebook_entries(self.cfg.as_ref(), file.clone(), Some(overwrite))
84        })
85        .await
86        .map_err(map_manager_err)?;
87        Ok(())
88    }
89
90    /// Bulk-delete phonebook entries by id.
91    pub async fn bulk_delete(
92        &self,
93        ids: Vec<String>,
94    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
95        let ids = ids
96            .iter()
97            .map(|id| {
98                uuid::Uuid::parse_str(id)
99                    .map_err(|e| ManagerError::InvalidArgument(format!("ids: {e}")))
100            })
101            .collect::<Result<Vec<_>, _>>()?;
102        let body = models::BulkIdsRequest { ids };
103        with_retry(&self.retry, false, || {
104            manager_api::bulk_delete_phonebook_entries(self.cfg.as_ref(), body.clone())
105        })
106        .await
107        .map_err(map_manager_err)
108    }
109}