babelforce_manager_sdk/resources/
files.rs

1use crate::error::{map_manager_err, ManagerError};
2use crate::gen::manager::apis::configuration::Configuration;
3use crate::gen::manager::apis::file_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/// Stored files — `/api/v2/files` (recordings, prompts and backups).
10pub struct FilesResource {
11    pub(crate) cfg: SharedCfg<Configuration>,
12    pub(crate) retry: RetryPolicy,
13}
14
15impl FilesResource {
16    /// List all files (auto-paginated).
17    pub async fn list_all(&self) -> Result<Vec<models::StoredFile>, 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 = file_api::list_files(cfg, Some(page), None, None, None, None, None, None, None)
22                .await?;
23            Ok((r.items, r.pagination.pages, r.pagination.current))
24        })
25        .await
26    }
27
28    /// List one page of files, optionally narrowed to one storage type.
29    pub async fn list_page(
30        &self,
31        page: i32,
32        per_page: Option<i32>,
33        file_type: Option<models::StorageType>,
34    ) -> Result<Page<models::StoredFile>, 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 = file_api::list_files(
39                cfg,
40                Some(page),
41                per_page,
42                None,
43                None,
44                file_type,
45                None,
46                None,
47                None,
48            )
49            .await?;
50            Ok((
51                r.items,
52                r.pagination.pages,
53                r.pagination.current,
54                Some(r.pagination.total),
55            ))
56        })
57        .await
58    }
59
60    /// List files of a given storage type (single, non-paginated response).
61    pub async fn list_by_type(
62        &self,
63        file_type: models::StorageType,
64    ) -> Result<Vec<models::StoredFile>, ManagerError> {
65        let cfg = self.cfg.get().await?;
66        let cfg = cfg.as_ref();
67        let r = with_retry(&self.retry, true, || {
68            file_api::list_files_by_type(cfg, file_type)
69        })
70        .await
71        .map_err(map_manager_err)?;
72        Ok(r.items)
73    }
74
75    /// List all backup files.
76    pub async fn backups(&self) -> Result<Vec<models::StoredFile>, ManagerError> {
77        let cfg = self.cfg.get().await?;
78        let cfg = cfg.as_ref();
79        let r = with_retry(&self.retry, true, || file_api::list_backup_files(cfg))
80            .await
81            .map_err(map_manager_err)?;
82        Ok(r.items)
83    }
84
85    /// List all recording files.
86    pub async fn recordings(&self) -> Result<Vec<models::StoredFile>, ManagerError> {
87        let cfg = self.cfg.get().await?;
88        let cfg = cfg.as_ref();
89        let r = with_retry(&self.retry, true, || file_api::list_recording_files(cfg))
90            .await
91            .map_err(map_manager_err)?;
92        Ok(r.items)
93    }
94
95    /// List all prompt files.
96    pub async fn prompts(&self) -> Result<Vec<models::StoredFile>, ManagerError> {
97        let cfg = self.cfg.get().await?;
98        let cfg = cfg.as_ref();
99        let r = with_retry(&self.retry, true, || file_api::list_prompt_files(cfg))
100            .await
101            .map_err(map_manager_err)?;
102        Ok(r.items)
103    }
104
105    /// Get a file by id.
106    pub async fn get(&self, id: &str) -> Result<models::StoredFileItemResponse, ManagerError> {
107        let cfg = self.cfg.get().await?;
108        let cfg = cfg.as_ref();
109        with_retry(&self.retry, true, || file_api::get_file(cfg, id))
110            .await
111            .map_err(map_manager_err)
112    }
113
114    /// Delete a file by id.
115    pub async fn delete(&self, id: &str) -> Result<models::DefaultV2MessageResponse, ManagerError> {
116        let cfg = self.cfg.get().await?;
117        let cfg = cfg.as_ref();
118        with_retry(&self.retry, false, || file_api::delete_file(cfg, id))
119            .await
120            .map_err(map_manager_err)
121    }
122
123    /// Trigger a download for a file by id.
124    ///
125    /// The underlying endpoint redirects to a download link; the generated client discards the
126    /// response body, so this returns `()` once the server-side download has been triggered.
127    /// Use [`bulk_download`](Self::bulk_download) / [`bulk_download_post`](Self::bulk_download_post)
128    /// when you need the actual bytes.
129    pub async fn download(&self, id: &str) -> Result<(), ManagerError> {
130        let cfg = self.cfg.get().await?;
131        let cfg = cfg.as_ref();
132        with_retry(&self.retry, true, || file_api::download_file(cfg, id))
133            .await
134            .map_err(map_manager_err)?;
135        Ok(())
136    }
137
138    /// Bulk-delete files by id. Each `id` must be a valid UUID.
139    pub async fn bulk_delete(
140        &self,
141        ids: Vec<String>,
142    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
143        let cfg = self.cfg.get().await?;
144        let cfg = cfg.as_ref();
145        let ids = ids
146            .iter()
147            .map(|id| {
148                uuid::Uuid::parse_str(id)
149                    .map_err(|e| ManagerError::InvalidArgument(format!("id {id:?}: {e}")))
150            })
151            .collect::<Result<Vec<_>, _>>()?;
152        let body = models::FileBulkDeleteRequest { ids };
153        with_retry(&self.retry, false, || {
154            file_api::bulk_delete_files(cfg, body.clone())
155        })
156        .await
157        .map_err(map_manager_err)
158    }
159
160    /// Download multiple files as a ZIP archive (GET), returning the raw bytes.
161    pub async fn bulk_download(&self, ids: Vec<String>) -> Result<Vec<u8>, ManagerError> {
162        let cfg = self.cfg.get().await?;
163        let cfg = cfg.as_ref();
164        let ids_joined = ids.join(",");
165        let resp = file_api::get_bulk_file_download(cfg, &ids_joined)
166            .await
167            .map_err(map_manager_err)?;
168        let bytes = resp
169            .bytes()
170            .await
171            .map_err(|e| ManagerError::Network(e.to_string()))?
172            .to_vec();
173        Ok(bytes)
174    }
175
176    /// Download multiple files as a ZIP archive (POST), returning the raw bytes.
177    /// Each `id` must be a valid UUID.
178    pub async fn bulk_download_post(&self, ids: Vec<String>) -> Result<Vec<u8>, ManagerError> {
179        let cfg = self.cfg.get().await?;
180        let cfg = cfg.as_ref();
181        let ids = ids
182            .iter()
183            .map(|id| {
184                uuid::Uuid::parse_str(id)
185                    .map_err(|e| ManagerError::InvalidArgument(format!("id {id:?}: {e}")))
186            })
187            .collect::<Result<Vec<_>, _>>()?;
188        let body = models::FileBulkDownloadRequest { ids };
189        let resp = file_api::post_bulk_file_download(cfg, body)
190            .await
191            .map_err(map_manager_err)?;
192        let bytes = resp
193            .bytes()
194            .await
195            .map_err(|e| ManagerError::Network(e.to_string()))?
196            .to_vec();
197        Ok(bytes)
198    }
199}
babelforce_manager_sdk/resources/files.rs

babelforce_manager_sdk/resources/
files.rs
