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

babelforce_manager_sdk/resources/
queues.rs
