box_open_sdk/managers/
file_versions.rs1use crate::internal::path_escape;
4use crate::runtime::{self, Error};
5
6#[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#[derive(Clone, Debug, Default)]
16pub struct FileVersionsGetFileVersionOptions {
17 pub fields: Option<Vec<String>>,
18}
19
20#[derive(Clone, Debug, Default)]
22pub struct FileVersionsDeleteFileVersionOptions {
23 pub if_match: Option<String>,
24}
25
26#[derive(Clone, Debug, Default)]
28pub struct FileVersionsCreateFileVersionCurrentOptions {
29 pub fields: Option<Vec<String>>,
30}
31
32pub 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 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
76pub 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 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::UpdateFileVersionRequest,
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::CreateFileVersionCurrentRequest,
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}