babelforce_manager_sdk/resources/
queues.rs

1use crate::error::{map_manager_err, ManagerError};
2use crate::gen::manager::apis::configuration::Configuration;
3use crate::gen::manager::apis::{manager_api, queue_api, queue_selection_api};
4use crate::gen::manager::models;
5use crate::http::{collect_all, fetch_page, Page};
6use crate::retry::{with_retry, RetryPolicy};
7use crate::token::SharedCfg;
8
9/// Queues — `/api/v2/queues`, with a nested `selections` sub-resource.
10pub struct QueuesResource {
11    pub(crate) cfg: SharedCfg<Configuration>,
12    pub(crate) retry: RetryPolicy,
13    /// Queue selections — `/api/v2/queues/{queueId}/selections`.
14    pub selections: QueueSelectionsResource,
15}
16
17impl QueuesResource {
18    /// List all queues (auto-paginated).
19    pub async fn list_all(&self) -> Result<Vec<models::Queue>, ManagerError> {
20        let cfg = self.cfg.get().await?;
21        let cfg = cfg.as_ref();
22        collect_all(&self.retry, map_manager_err, |page| async move {
23            let r = queue_api::list_queues(cfg, Some(page), None).await?;
24            Ok((r.items, r.pagination.pages, r.pagination.current))
25        })
26        .await
27    }
28
29    /// List one page of queues.
30    pub async fn list_page(
31        &self,
32        page: i32,
33        per_page: Option<i32>,
34    ) -> Result<Page<models::Queue>, ManagerError> {
35        let cfg = self.cfg.get().await?;
36        let cfg = cfg.as_ref();
37        fetch_page(&self.retry, map_manager_err, || async move {
38            let r = queue_api::list_queues(cfg, Some(page), per_page).await?;
39            Ok((
40                r.items,
41                r.pagination.pages,
42                r.pagination.current,
43                Some(r.pagination.total),
44            ))
45        })
46        .await
47    }
48
49    /// Create a queue.
50    pub async fn create(
51        &self,
52        body: models::RestCreateQueue,
53    ) -> Result<models::QueueItemResponse, ManagerError> {
54        let cfg = self.cfg.get().await?;
55        let cfg = cfg.as_ref();
56        with_retry(&self.retry, false, || {
57            queue_api::create_queue(cfg, body.clone())
58        })
59        .await
60        .map_err(map_manager_err)
61    }
62
63    /// Get a queue by id.
64    pub async fn get(&self, id: &str) -> Result<models::QueueItemResponse, ManagerError> {
65        let cfg = self.cfg.get().await?;
66        let cfg = cfg.as_ref();
67        with_retry(&self.retry, true, || queue_api::get_queue(cfg, id))
68            .await
69            .map_err(map_manager_err)
70    }
71
72    /// Update a queue.
73    pub async fn update(
74        &self,
75        id: &str,
76        body: models::RestUpdateQueue,
77    ) -> Result<models::QueueItemResponse, ManagerError> {
78        let cfg = self.cfg.get().await?;
79        let cfg = cfg.as_ref();
80        with_retry(&self.retry, false, || {
81            queue_api::update_queue(cfg, id, body.clone())
82        })
83        .await
84        .map_err(map_manager_err)
85    }
86
87    /// Delete a queue.
88    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
89        let cfg = self.cfg.get().await?;
90        let cfg = cfg.as_ref();
91        with_retry(&self.retry, false, || queue_api::delete_queue(cfg, id))
92            .await
93            .map_err(map_manager_err)?;
94        Ok(())
95    }
96
97    /// List the triggers attached to a queue.
98    pub async fn list_triggers(
99        &self,
100        queue_id: &str,
101    ) -> Result<models::QueueTriggerListResponse, ManagerError> {
102        let cfg = self.cfg.get().await?;
103        let cfg = cfg.as_ref();
104        with_retry(&self.retry, true, || {
105            queue_api::list_queue_triggers(cfg, queue_id)
106        })
107        .await
108        .map_err(map_manager_err)
109    }
110
111    /// Bulk-update queues; returns the updated queues.
112    pub async fn bulk_update(
113        &self,
114        body: models::QueueBulkUpdateRequest,
115    ) -> Result<models::QueueListResponse, ManagerError> {
116        let cfg = self.cfg.get().await?;
117        let cfg = cfg.as_ref();
118        with_retry(&self.retry, false, || {
119            queue_api::bulk_update_queues(cfg, body.clone())
120        })
121        .await
122        .map_err(map_manager_err)
123    }
124
125    /// List queue selections across all queues.
126    pub async fn global_selections(
127        &self,
128    ) -> Result<models::GlobalQueueSelectionListResponse, ManagerError> {
129        let cfg = self.cfg.get().await?;
130        let cfg = cfg.as_ref();
131        with_retry(&self.retry, true, || {
132            queue_api::list_global_queue_selections(cfg, None, None, None, None, None)
133        })
134        .await
135        .map_err(map_manager_err)
136    }
137}
138
139/// Queue selections (routing rules) and their agent/group/tag membership.
140pub struct QueueSelectionsResource {
141    pub(crate) cfg: SharedCfg<Configuration>,
142    pub(crate) retry: RetryPolicy,
143}
144
145impl QueueSelectionsResource {
146    /// List all selections for a queue (auto-paginated).
147    pub async fn list_all(
148        &self,
149        queue_id: &str,
150    ) -> Result<Vec<models::QueueSelection>, ManagerError> {
151        let cfg = self.cfg.get().await?;
152        let cfg = cfg.as_ref();
153        collect_all(&self.retry, map_manager_err, |page| async move {
154            let r =
155                queue_selection_api::list_queue_selections(cfg, queue_id, Some(page), None).await?;
156            Ok((r.items, r.pagination.pages, r.pagination.current))
157        })
158        .await
159    }
160
161    /// Create a selection on a queue.
162    pub async fn create(
163        &self,
164        queue_id: &str,
165        body: models::RestCreateQueueSelection,
166    ) -> Result<models::QueueSelectionItemResponse, ManagerError> {
167        let cfg = self.cfg.get().await?;
168        let cfg = cfg.as_ref();
169        with_retry(&self.retry, false, || {
170            queue_selection_api::create_queue_selection(cfg, queue_id, body.clone())
171        })
172        .await
173        .map_err(map_manager_err)
174    }
175
176    /// Get a selection.
177    pub async fn get(
178        &self,
179        queue_id: &str,
180        id: &str,
181    ) -> Result<models::QueueSelectionItemResponse, ManagerError> {
182        let cfg = self.cfg.get().await?;
183        let cfg = cfg.as_ref();
184        with_retry(&self.retry, true, || {
185            queue_selection_api::get_queue_selection(cfg, queue_id, id)
186        })
187        .await
188        .map_err(map_manager_err)
189    }
190
191    /// Update a selection.
192    pub async fn update(
193        &self,
194        queue_id: &str,
195        id: &str,
196        body: models::RestUpdateQueueSelection,
197    ) -> Result<models::QueueSelectionItemResponse, ManagerError> {
198        let cfg = self.cfg.get().await?;
199        let cfg = cfg.as_ref();
200        with_retry(&self.retry, false, || {
201            queue_selection_api::update_queue_selection(cfg, queue_id, id, body.clone())
202        })
203        .await
204        .map_err(map_manager_err)
205    }
206
207    /// Delete a selection.
208    pub async fn delete(&self, queue_id: &str, id: &str) -> Result<(), ManagerError> {
209        let cfg = self.cfg.get().await?;
210        let cfg = cfg.as_ref();
211        with_retry(&self.retry, false, || {
212            queue_selection_api::delete_queue_selection(cfg, queue_id, id)
213        })
214        .await
215        .map_err(map_manager_err)?;
216        Ok(())
217    }
218
219    /// Resolve the agents currently selected for a queue.
220    pub async fn select_agents(
221        &self,
222        queue_id: &str,
223    ) -> Result<models::QueueSelectionResponse, ManagerError> {
224        let cfg = self.cfg.get().await?;
225        let cfg = cfg.as_ref();
226        with_retry(&self.retry, true, || {
227            manager_api::get_agents_for_queue_selection(cfg, queue_id, None)
228        })
229        .await
230        .map_err(map_manager_err)
231    }
232
233    /// Add an agent to a selection.
234    pub async fn add_agent(
235        &self,
236        queue_id: &str,
237        selection_id: &str,
238        agent_id: &str,
239    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
240        let cfg = self.cfg.get().await?;
241        let cfg = cfg.as_ref();
242        with_retry(&self.retry, false, || {
243            manager_api::add_agent_to_queue_selection(
244                cfg,
245                queue_id,
246                selection_id,
247                Some(addition(agent_id)),
248            )
249        })
250        .await
251        .map_err(map_manager_err)
252    }
253
254    /// Remove an agent from a selection.
255    pub async fn remove_agent(
256        &self,
257        queue_id: &str,
258        selection_id: &str,
259        id: &str,
260    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
261        let cfg = self.cfg.get().await?;
262        let cfg = cfg.as_ref();
263        with_retry(&self.retry, false, || {
264            manager_api::remove_agent_from_queue_selection(cfg, queue_id, selection_id, id)
265        })
266        .await
267        .map_err(map_manager_err)
268    }
269
270    /// Add an agent group to a selection.
271    pub async fn add_group(
272        &self,
273        queue_id: &str,
274        selection_id: &str,
275        group_id: &str,
276    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
277        let cfg = self.cfg.get().await?;
278        let cfg = cfg.as_ref();
279        with_retry(&self.retry, false, || {
280            manager_api::add_group_to_queue_selection(
281                cfg,
282                queue_id,
283                selection_id,
284                Some(addition(group_id)),
285            )
286        })
287        .await
288        .map_err(map_manager_err)
289    }
290
291    /// Remove an agent group from a selection.
292    pub async fn remove_group(
293        &self,
294        queue_id: &str,
295        selection_id: &str,
296        id: &str,
297    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
298        let cfg = self.cfg.get().await?;
299        let cfg = cfg.as_ref();
300        with_retry(&self.retry, false, || {
301            manager_api::remove_group_from_queue_selection(cfg, queue_id, selection_id, id)
302        })
303        .await
304        .map_err(map_manager_err)
305    }
306
307    /// Add a tag to a selection.
308    pub async fn add_tag(
309        &self,
310        queue_id: &str,
311        selection_id: &str,
312        tag_id: &str,
313    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
314        let cfg = self.cfg.get().await?;
315        let cfg = cfg.as_ref();
316        with_retry(&self.retry, false, || {
317            manager_api::add_tag_to_queue_selection(
318                cfg,
319                queue_id,
320                selection_id,
321                Some(addition(tag_id)),
322            )
323        })
324        .await
325        .map_err(map_manager_err)
326    }
327
328    /// Remove a tag from a selection.
329    pub async fn remove_tag(
330        &self,
331        queue_id: &str,
332        selection_id: &str,
333        id: &str,
334    ) -> Result<models::QueueSelectionModificationResponse, ManagerError> {
335        let cfg = self.cfg.get().await?;
336        let cfg = cfg.as_ref();
337        with_retry(&self.retry, false, || {
338            manager_api::remove_tag_from_queue_selection(cfg, queue_id, selection_id, id)
339        })
340        .await
341        .map_err(map_manager_err)
342    }
343
344    /// Set the priority order of a queue's selections.
345    pub async fn set_priority(
346        &self,
347        queue_id: &str,
348        items: Vec<models::QueueSelectionPriorityItem>,
349    ) -> Result<models::QueueSelectionListResponse, ManagerError> {
350        let cfg = self.cfg.get().await?;
351        let cfg = cfg.as_ref();
352        with_retry(&self.retry, false, || {
353            queue_api::set_queue_selections_priority(cfg, queue_id, items.clone())
354        })
355        .await
356        .map_err(map_manager_err)
357    }
358}
359
360fn addition(id: &str) -> models::QueueSelectionAddition {
361    models::QueueSelectionAddition {
362        id: Some(id.to_string()),
363    }
364}
babelforce_manager_sdk/resources/queues.rs

babelforce_manager_sdk/resources/
queues.rs
