Skip to main content

babelforce_manager_sdk/resources/
routing.rs

1use crate::error::{map_manager_err, ManagerError};
2use crate::gen::manager::apis::configuration::Configuration;
3use crate::gen::manager::apis::routing_api as api;
4use crate::gen::manager::models;
5use crate::http::collect_all;
6use crate::retry::{with_retry, RetryPolicy};
7use crate::token::SharedCfg;
8
9/// Routing rules — `/api/v2/routings`.
10pub struct RoutingResource {
11    pub(crate) cfg: SharedCfg<Configuration>,
12    pub(crate) retry: RetryPolicy,
13}
14
15impl RoutingResource {
16    /// List all routings (auto-paginated).
17    pub async fn list_all(&self) -> Result<Vec<models::Routing>, ManagerError> {
18        let cfg = self.cfg.get().await?;
19        let cfg = cfg.as_ref();
20        collect_all(&self.retry, map_manager_err, |page| async move {
21            let r = api::list_routings(cfg, Some(page), None).await?;
22            Ok((
23                r.items,
24                r.pagination.pages.unwrap_or(1),
25                r.pagination.current.unwrap_or(1),
26            ))
27        })
28        .await
29    }
30
31    /// Create a routing.
32    pub async fn create(
33        &self,
34        body: models::RestCreateRouting,
35    ) -> Result<models::RoutingItemResponse, ManagerError> {
36        let cfg = self.cfg.get().await?;
37        let cfg = cfg.as_ref();
38        with_retry(&self.retry, false, || {
39            api::create_routing(cfg, body.clone())
40        })
41        .await
42        .map_err(map_manager_err)
43    }
44
45    /// Get a routing by id.
46    pub async fn get(&self, id: &str) -> Result<models::RoutingItemResponse, ManagerError> {
47        let cfg = self.cfg.get().await?;
48        let cfg = cfg.as_ref();
49        with_retry(&self.retry, true, || api::get_routing(cfg, id))
50            .await
51            .map_err(map_manager_err)
52    }
53
54    /// Update a routing.
55    pub async fn update(
56        &self,
57        id: &str,
58        body: models::RestUpdateRouting,
59    ) -> Result<models::RoutingItemResponse, ManagerError> {
60        let cfg = self.cfg.get().await?;
61        let cfg = cfg.as_ref();
62        with_retry(&self.retry, false, || {
63            api::update_routing(cfg, id, body.clone())
64        })
65        .await
66        .map_err(map_manager_err)
67    }
68
69    /// Delete a routing.
70    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
71        let cfg = self.cfg.get().await?;
72        let cfg = cfg.as_ref();
73        with_retry(&self.retry, false, || api::delete_routing(cfg, id))
74            .await
75            .map_err(map_manager_err)?;
76        Ok(())
77    }
78}