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

babelforce_manager_sdk/resources/
recordings.rs
