babelforce_manager_sdk/resources/
recordings.rs

1use crate::error::{map_manager_err, ManagerError};
2use crate::gen::manager::apis::configuration::Configuration;
3use crate::gen::manager::apis::recording_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/// Call recordings — `/api/v2/recordings`, including bulk actions and per-recording flagging.
10pub struct RecordingsResource {
11    pub(crate) cfg: SharedCfg<Configuration>,
12    pub(crate) retry: RetryPolicy,
13}
14
15impl RecordingsResource {
16    /// List all recordings (auto-paginated).
17    pub async fn list_all(&self) -> Result<Vec<models::Recording>, 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 = recording_api::list_recordings(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    /// List one page of recordings.
32    pub async fn list_page(
33        &self,
34        page: i32,
35        per_page: Option<i32>,
36    ) -> Result<Page<models::Recording>, ManagerError> {
37        let cfg = self.cfg.get().await?;
38        let cfg = cfg.as_ref();
39        fetch_page(&self.retry, map_manager_err, || async move {
40            let r = recording_api::list_recordings(cfg, Some(page), per_page).await?;
41            Ok((
42                r.items,
43                r.pagination.pages.unwrap_or(1),
44                r.pagination.current.unwrap_or(1),
45                r.pagination.total,
46            ))
47        })
48        .await
49    }
50
51    /// Start a recording for a call.
52    pub async fn start(
53        &self,
54        body: models::RecordingStartRequest,
55    ) -> Result<models::RecordingItemResponse, ManagerError> {
56        let cfg = self.cfg.get().await?;
57        let cfg = cfg.as_ref();
58        with_retry(&self.retry, false, || {
59            recording_api::start_recording(cfg, body.clone())
60        })
61        .await
62        .map_err(map_manager_err)
63    }
64
65    /// Get a recording by id.
66    pub async fn get(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
67        let cfg = self.cfg.get().await?;
68        let cfg = cfg.as_ref();
69        with_retry(&self.retry, true, || recording_api::get_recording(cfg, id))
70            .await
71            .map_err(map_manager_err)
72    }
73
74    /// Update a recording's metadata.
75    pub async fn update(
76        &self,
77        id: &str,
78        body: models::RecordingUpdateBody,
79    ) -> Result<models::RecordingItemResponse, ManagerError> {
80        let cfg = self.cfg.get().await?;
81        let cfg = cfg.as_ref();
82        with_retry(&self.retry, false, || {
83            recording_api::update_recording(cfg, id, body.clone())
84        })
85        .await
86        .map_err(map_manager_err)
87    }
88
89    /// Delete a recording.
90    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
91        let cfg = self.cfg.get().await?;
92        let cfg = cfg.as_ref();
93        with_retry(&self.retry, false, || {
94            recording_api::delete_recording(cfg, id)
95        })
96        .await
97        .map_err(map_manager_err)?;
98        Ok(())
99    }
100
101    /// Apply a bulk action to multiple recordings by id.
102    pub async fn bulk_action(
103        &self,
104        action: &str,
105        ids: Vec<String>,
106    ) -> Result<models::BulkActionResponse, ManagerError> {
107        let cfg = self.cfg.get().await?;
108        let cfg = cfg.as_ref();
109        let ids = ids
110            .iter()
111            .map(|id| {
112                uuid::Uuid::parse_str(id)
113                    .map_err(|e| ManagerError::InvalidArgument(format!("ids: {e}")))
114            })
115            .collect::<Result<Vec<_>, _>>()?;
116        let body = models::BulkIdsRequest { ids };
117        with_retry(&self.retry, false, || {
118            recording_api::bulk_recording_action(cfg, action, body.clone())
119        })
120        .await
121        .map_err(map_manager_err)
122    }
123
124    /// Get a recording's flag state.
125    pub async fn get_flag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
126        let cfg = self.cfg.get().await?;
127        let cfg = cfg.as_ref();
128        with_retry(&self.retry, true, || {
129            recording_api::get_recording_flag(cfg, id)
130        })
131        .await
132        .map_err(map_manager_err)
133    }
134
135    /// Flag a recording.
136    pub async fn flag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
137        let cfg = self.cfg.get().await?;
138        let cfg = cfg.as_ref();
139        with_retry(&self.retry, false, || {
140            recording_api::flag_recording(cfg, id)
141        })
142        .await
143        .map_err(map_manager_err)
144    }
145
146    /// Unflag a recording.
147    pub async fn unflag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
148        let cfg = self.cfg.get().await?;
149        let cfg = cfg.as_ref();
150        with_retry(&self.retry, false, || {
151            recording_api::unflag_recording(cfg, id)
152        })
153        .await
154        .map_err(map_manager_err)
155    }
156
157    /// Toggle a recording's flag.
158    pub async fn toggle_flag(
159        &self,
160        id: &str,
161    ) -> Result<models::RecordingItemResponse, ManagerError> {
162        let cfg = self.cfg.get().await?;
163        let cfg = cfg.as_ref();
164        with_retry(&self.retry, false, || {
165            recording_api::toggle_recording_flag(cfg, id)
166        })
167        .await
168        .map_err(map_manager_err)
169    }
170}
babelforce_manager_sdk/resources/recordings.rs

babelforce_manager_sdk/resources/
recordings.rs
