Skip to main content

babelforce_manager_sdk/resources/
phonebook.rs

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