Skip to main content

box_open_sdk/managers/
file_versions.rs

1// Code generated by box-gantry. DO NOT EDIT.
2
3use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6/// Optional parameters for [`FileVersionsManager::list_file_versions`].
7#[derive(Clone, Debug, Default)]
8pub struct FileVersionsListFileVersionsOptions {
9    pub fields: Option<Vec<String>>,
10    pub limit: Option<i64>,
11    pub offset: Option<i64>,
12}
13
14/// Optional parameters for [`FileVersionsManager::get_file_version`].
15#[derive(Clone, Debug, Default)]
16pub struct FileVersionsGetFileVersionOptions {
17    pub fields: Option<Vec<String>>,
18}
19
20/// Optional parameters for [`FileVersionsManager::delete_file_version`].
21#[derive(Clone, Debug, Default)]
22pub struct FileVersionsDeleteFileVersionOptions {
23    pub if_match: Option<String>,
24}
25
26/// Optional parameters for [`FileVersionsManager::create_file_version_current`].
27#[derive(Clone, Debug, Default)]
28pub struct FileVersionsCreateFileVersionCurrentOptions {
29    pub fields: Option<Vec<String>>,
30}
31
32/// Async paginator over [`FileVersionsManager::list_file_versions`], yielding one `crate::models::schemas::FileVersionFull`
33/// per item across pages (FR-7.3).
34pub struct FileVersionsListFileVersionsPaginator {
35    manager: FileVersionsManager,
36    file_id: String,
37    options: FileVersionsListFileVersionsOptions,
38    buffer: std::vec::IntoIter<crate::models::schemas::FileVersionFull>,
39    done: bool,
40}
41
42impl FileVersionsListFileVersionsPaginator {
43    /// The next item, advancing pages as needed; `None` at the end.
44    /// An error is yielded once, then iteration stops.
45    pub async fn next(&mut self) -> Option<Result<crate::models::schemas::FileVersionFull, Error>> {
46        loop {
47            if let Some(item) = self.buffer.next() {
48                return Some(Ok(item));
49            }
50            if self.done {
51                return None;
52            }
53            let page = match self
54                .manager
55                .list_file_versions_page(self.file_id.clone(), Some(self.options.clone()))
56                .await
57            {
58                Ok(page) => page,
59                Err(err) => {
60                    self.done = true;
61                    return Some(Err(err));
62                }
63            };
64            let items = page.entries.unwrap_or_default();
65            if items.is_empty() {
66                self.done = true;
67            } else {
68                let next = self.options.offset.unwrap_or(0) + items.len() as i64;
69                self.options.offset = Some(next);
70            }
71            self.buffer = items.into_iter();
72        }
73    }
74}
75
76/// Operations for the "file_versions" API area.
77pub struct FileVersionsManager {
78    session: std::sync::Arc<runtime::Client>,
79}
80
81impl FileVersionsManager {
82    pub(crate) fn new(session: std::sync::Arc<runtime::Client>) -> Self {
83        Self { session }
84    }
85
86    async fn list_file_versions_page(
87        &self,
88        file_id: String,
89        opts: Option<FileVersionsListFileVersionsOptions>,
90    ) -> Result<crate::models::schemas::FileVersions, Error> {
91        let mut url = self.session.base_url("api");
92        url.push_str("/files");
93        url.push('/');
94        let seg = path_escape(&file_id);
95        url.push_str(&seg);
96        url.push_str("/versions");
97        let mut req = self.session.new_request("GET", &url);
98        let opts = opts.unwrap_or_default();
99        if let Some(value) = opts.fields {
100            req = runtime::with_query(req, "fields", &value.join(","));
101        }
102        if let Some(value) = opts.limit {
103            req = runtime::with_query(req, "limit", &value.to_string());
104        }
105        if let Some(value) = opts.offset {
106            req = runtime::with_query(req, "offset", &value.to_string());
107        }
108        let resp = self.session.fetch(req).await?;
109        let data = runtime::response_bytes(&resp)?;
110        Ok(serde_json::from_slice(&data)?)
111    }
112
113    /// Iterate every `crate::models::schemas::FileVersionFull` across pages, threading the cursor.
114    pub fn list_file_versions(
115        &self,
116        file_id: String,
117        opts: Option<FileVersionsListFileVersionsOptions>,
118    ) -> FileVersionsListFileVersionsPaginator {
119        FileVersionsListFileVersionsPaginator {
120            manager: FileVersionsManager::new(self.session.clone()),
121            file_id,
122            options: opts.unwrap_or_default(),
123            buffer: Vec::new().into_iter(),
124            done: false,
125        }
126    }
127
128    pub async fn get_file_version(
129        &self,
130        file_id: String,
131        file_version_id: String,
132        opts: Option<FileVersionsGetFileVersionOptions>,
133    ) -> Result<crate::models::schemas::FileVersionFull, Error> {
134        let mut url = self.session.base_url("api");
135        url.push_str("/files");
136        url.push('/');
137        let seg = path_escape(&file_id);
138        url.push_str(&seg);
139        url.push_str("/versions");
140        url.push('/');
141        let seg = path_escape(&file_version_id);
142        url.push_str(&seg);
143        let mut req = self.session.new_request("GET", &url);
144        let opts = opts.unwrap_or_default();
145        if let Some(value) = opts.fields {
146            req = runtime::with_query(req, "fields", &value.join(","));
147        }
148        let resp = self.session.fetch(req).await?;
149        let data = runtime::response_bytes(&resp)?;
150        Ok(serde_json::from_slice(&data)?)
151    }
152
153    pub async fn update_file_version(
154        &self,
155        file_id: String,
156        file_version_id: String,
157        body: crate::models::schemas::FileVersionUpdateRequest,
158    ) -> Result<crate::models::schemas::FileVersionFull, Error> {
159        let mut url = self.session.base_url("api");
160        url.push_str("/files");
161        url.push('/');
162        let seg = path_escape(&file_id);
163        url.push_str(&seg);
164        url.push_str("/versions");
165        url.push('/');
166        let seg = path_escape(&file_version_id);
167        url.push_str(&seg);
168        let mut req = self.session.new_request("PUT", &url);
169        let payload = serde_json::to_vec(&body)?;
170        req = runtime::with_json_body(req, &payload);
171        let resp = self.session.fetch(req).await?;
172        let data = runtime::response_bytes(&resp)?;
173        Ok(serde_json::from_slice(&data)?)
174    }
175
176    pub async fn delete_file_version(
177        &self,
178        file_id: String,
179        file_version_id: String,
180        opts: Option<FileVersionsDeleteFileVersionOptions>,
181    ) -> Result<(), Error> {
182        let mut url = self.session.base_url("api");
183        url.push_str("/files");
184        url.push('/');
185        let seg = path_escape(&file_id);
186        url.push_str(&seg);
187        url.push_str("/versions");
188        url.push('/');
189        let seg = path_escape(&file_version_id);
190        url.push_str(&seg);
191        let mut req = self.session.new_request("DELETE", &url);
192        let opts = opts.unwrap_or_default();
193        if let Some(value) = opts.if_match {
194            req = runtime::with_header(req, "if-match", &value);
195        }
196        let _ = self.session.fetch(req).await?;
197        Ok(())
198    }
199
200    pub async fn create_file_version_current(
201        &self,
202        file_id: String,
203        body: crate::models::schemas::FileVersionCurrentCreateRequest,
204        opts: Option<FileVersionsCreateFileVersionCurrentOptions>,
205    ) -> Result<crate::models::schemas::FileVersionFull, Error> {
206        let mut url = self.session.base_url("api");
207        url.push_str("/files");
208        url.push('/');
209        let seg = path_escape(&file_id);
210        url.push_str(&seg);
211        url.push_str("/versions");
212        url.push_str("/current");
213        let mut req = self.session.new_request("POST", &url);
214        let opts = opts.unwrap_or_default();
215        if let Some(value) = opts.fields {
216            req = runtime::with_query(req, "fields", &value.join(","));
217        }
218        let payload = serde_json::to_vec(&body)?;
219        req = runtime::with_json_body(req, &payload);
220        let resp = self.session.fetch(req).await?;
221        let data = runtime::response_bytes(&resp)?;
222        Ok(serde_json::from_slice(&data)?)
223    }
224}