open_lark/service/cloud_docs/drive/v1/
file_version.rs1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::{
5 core::{
6 api_req::ApiRequest,
7 api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
8 config::Config,
9 constants::AccessTokenType,
10 http::Transport,
11 req_option::RequestOption,
12 SDKResult,
13 },
14 impl_executable_builder_owned,
15};
16
17pub struct FileVersionService {
19 config: Config,
20}
21
22impl FileVersionService {
23 pub fn new(config: Config) -> Self {
24 Self { config }
25 }
26
27 pub async fn create_version(
33 &self,
34 request: CreateVersionRequest,
35 option: Option<RequestOption>,
36 ) -> SDKResult<BaseResponse<CreateVersionRespData>> {
37 let mut api_req = ApiRequest {
38 http_method: Method::POST,
39 api_path: format!("/open-apis/drive/v1/files/{}/versions", request.file_token),
40 supported_access_token_types: vec![AccessTokenType::User, AccessTokenType::Tenant],
41 ..Default::default()
42 };
43
44 let body = serde_json::json!({
45 "name": request.name,
46 "obj_type": request.obj_type
47 });
48 api_req.body = serde_json::to_vec(&body)?;
49
50 let api_resp = Transport::request(api_req, &self.config, option).await?;
51 Ok(api_resp)
52 }
53
54 pub async fn delete_version(
60 &self,
61 request: DeleteVersionRequest,
62 option: Option<RequestOption>,
63 ) -> SDKResult<BaseResponse<DeleteVersionRespData>> {
64 let mut api_req = ApiRequest {
65 http_method: Method::DELETE,
66 api_path: format!(
67 "/open-apis/drive/v1/files/{}/versions/{}",
68 request.file_token, request.version_id
69 ),
70 ..Default::default()
71 };
72 api_req.supported_access_token_types = vec![AccessTokenType::User, AccessTokenType::Tenant];
73
74 let api_resp = Transport::request(api_req, &self.config, option).await?;
75 Ok(api_resp)
76 }
77
78 pub async fn get_version(
84 &self,
85 request: GetVersionRequest,
86 option: Option<RequestOption>,
87 ) -> SDKResult<BaseResponse<GetVersionRespData>> {
88 let mut api_req = ApiRequest {
89 http_method: Method::GET,
90 api_path: format!(
91 "/open-apis/drive/v1/files/{}/versions/{}",
92 request.file_token, request.version_id
93 ),
94 ..Default::default()
95 };
96 api_req.supported_access_token_types = vec![AccessTokenType::User, AccessTokenType::Tenant];
97
98 let api_resp = Transport::request(api_req, &self.config, option).await?;
99 Ok(api_resp)
100 }
101
102 pub async fn list_versions(
108 &self,
109 request: ListVersionsRequest,
110 option: Option<RequestOption>,
111 ) -> SDKResult<BaseResponse<ListVersionsRespData>> {
112 let mut api_req = ApiRequest {
113 http_method: Method::GET,
114 api_path: format!("/open-apis/drive/v1/files/{}/versions", request.file_token),
115 supported_access_token_types: vec![AccessTokenType::User, AccessTokenType::Tenant],
116 ..Default::default()
117 };
118
119 if let Some(page_token) = request.page_token {
121 api_req
122 .query_params
123 .insert("page_token".to_string(), page_token);
124 }
125 if let Some(page_size) = request.page_size {
126 api_req
127 .query_params
128 .insert("page_size".to_string(), page_size.to_string());
129 }
130
131 let api_resp = Transport::request(api_req, &self.config, option).await?;
132 Ok(api_resp)
133 }
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize, Default)]
140pub struct CreateVersionRequest {
141 pub file_token: String,
143 pub name: String,
145 pub obj_type: String,
147}
148
149impl CreateVersionRequest {
150 pub fn builder() -> CreateVersionRequestBuilder {
151 CreateVersionRequestBuilder::default()
152 }
153
154 pub fn new(
155 file_token: impl Into<String>,
156 name: impl Into<String>,
157 obj_type: impl Into<String>,
158 ) -> Self {
159 Self {
160 file_token: file_token.into(),
161 name: name.into(),
162 obj_type: obj_type.into(),
163 }
164 }
165}
166
167#[derive(Default)]
169pub struct CreateVersionRequestBuilder {
170 request: CreateVersionRequest,
171}
172
173impl CreateVersionRequestBuilder {
174 pub fn file_token(mut self, file_token: impl Into<String>) -> Self {
175 self.request.file_token = file_token.into();
176 self
177 }
178
179 pub fn name(mut self, name: impl Into<String>) -> Self {
180 self.request.name = name.into();
181 self
182 }
183
184 pub fn obj_type(mut self, obj_type: impl Into<String>) -> Self {
185 self.request.obj_type = obj_type.into();
186 self
187 }
188
189 pub fn build(self) -> CreateVersionRequest {
190 self.request
191 }
192}
193
194impl_executable_builder_owned!(
195 CreateVersionRequestBuilder,
196 FileVersionService,
197 CreateVersionRequest,
198 BaseResponse<CreateVersionRespData>,
199 create_version
200);
201
202#[derive(Debug, Clone, Serialize, Deserialize)]
204pub struct CreateVersionRespData {
205 pub version_id: String,
207 pub name: String,
209 pub create_time: String,
211 pub creator_id: String,
213}
214
215impl ApiResponseTrait for CreateVersionRespData {
216 fn data_format() -> ResponseFormat {
217 ResponseFormat::Data
218 }
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize, Default)]
223pub struct DeleteVersionRequest {
224 pub file_token: String,
226 pub version_id: String,
228}
229
230impl DeleteVersionRequest {
231 pub fn builder() -> DeleteVersionRequestBuilder {
232 DeleteVersionRequestBuilder::default()
233 }
234
235 pub fn new(file_token: impl Into<String>, version_id: impl Into<String>) -> Self {
236 Self {
237 file_token: file_token.into(),
238 version_id: version_id.into(),
239 }
240 }
241}
242
243#[derive(Default)]
245pub struct DeleteVersionRequestBuilder {
246 request: DeleteVersionRequest,
247}
248
249impl DeleteVersionRequestBuilder {
250 pub fn file_token(mut self, file_token: impl Into<String>) -> Self {
251 self.request.file_token = file_token.into();
252 self
253 }
254
255 pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
256 self.request.version_id = version_id.into();
257 self
258 }
259
260 pub fn build(self) -> DeleteVersionRequest {
261 self.request
262 }
263}
264
265impl_executable_builder_owned!(
266 DeleteVersionRequestBuilder,
267 FileVersionService,
268 DeleteVersionRequest,
269 BaseResponse<DeleteVersionRespData>,
270 delete_version
271);
272
273#[derive(Debug, Clone, Serialize, Deserialize)]
275pub struct DeleteVersionRespData {
276 pub success: bool,
278}
279
280impl ApiResponseTrait for DeleteVersionRespData {
281 fn data_format() -> ResponseFormat {
282 ResponseFormat::Data
283 }
284}
285
286#[derive(Debug, Clone, Serialize, Deserialize, Default)]
288pub struct GetVersionRequest {
289 pub file_token: String,
291 pub version_id: String,
293}
294
295impl GetVersionRequest {
296 pub fn builder() -> GetVersionRequestBuilder {
297 GetVersionRequestBuilder::default()
298 }
299
300 pub fn new(file_token: impl Into<String>, version_id: impl Into<String>) -> Self {
301 Self {
302 file_token: file_token.into(),
303 version_id: version_id.into(),
304 }
305 }
306}
307
308#[derive(Default)]
310pub struct GetVersionRequestBuilder {
311 request: GetVersionRequest,
312}
313
314impl GetVersionRequestBuilder {
315 pub fn file_token(mut self, file_token: impl Into<String>) -> Self {
316 self.request.file_token = file_token.into();
317 self
318 }
319
320 pub fn version_id(mut self, version_id: impl Into<String>) -> Self {
321 self.request.version_id = version_id.into();
322 self
323 }
324
325 pub fn build(self) -> GetVersionRequest {
326 self.request
327 }
328}
329
330impl_executable_builder_owned!(
331 GetVersionRequestBuilder,
332 FileVersionService,
333 GetVersionRequest,
334 BaseResponse<GetVersionRespData>,
335 get_version
336);
337
338#[derive(Debug, Clone, Serialize, Deserialize)]
340pub struct GetVersionRespData {
341 pub version: FileVersion,
343}
344
345#[derive(Debug, Clone, Serialize, Deserialize, Default)]
347pub struct ListVersionsRequest {
348 pub file_token: String,
350 pub page_token: Option<String>,
352 pub page_size: Option<i32>,
354}
355
356impl ListVersionsRequest {
357 pub fn builder() -> ListVersionsRequestBuilder {
358 ListVersionsRequestBuilder::default()
359 }
360
361 pub fn new(file_token: impl Into<String>) -> Self {
362 Self {
363 file_token: file_token.into(),
364 page_token: None,
365 page_size: None,
366 }
367 }
368
369 pub fn with_page_token(mut self, page_token: impl Into<String>) -> Self {
370 self.page_token = Some(page_token.into());
371 self
372 }
373
374 pub fn with_page_size(mut self, page_size: i32) -> Self {
375 self.page_size = Some(page_size);
376 self
377 }
378}
379
380#[derive(Default)]
382pub struct ListVersionsRequestBuilder {
383 request: ListVersionsRequest,
384}
385
386impl ListVersionsRequestBuilder {
387 pub fn file_token(mut self, file_token: impl Into<String>) -> Self {
388 self.request.file_token = file_token.into();
389 self
390 }
391
392 pub fn page_token(mut self, page_token: impl Into<String>) -> Self {
393 self.request.page_token = Some(page_token.into());
394 self
395 }
396
397 pub fn page_size(mut self, page_size: i32) -> Self {
398 self.request.page_size = Some(page_size);
399 self
400 }
401
402 pub fn build(self) -> ListVersionsRequest {
403 self.request
404 }
405}
406
407impl_executable_builder_owned!(
408 ListVersionsRequestBuilder,
409 FileVersionService,
410 ListVersionsRequest,
411 BaseResponse<ListVersionsRespData>,
412 list_versions
413);
414
415#[derive(Debug, Clone, Serialize, Deserialize)]
417pub struct ListVersionsRespData {
418 pub has_more: bool,
420 pub page_token: Option<String>,
422 pub items: Vec<FileVersion>,
424}
425
426impl ApiResponseTrait for ListVersionsRespData {
427 fn data_format() -> ResponseFormat {
428 ResponseFormat::Data
429 }
430}
431
432impl ApiResponseTrait for GetVersionRespData {
433 fn data_format() -> ResponseFormat {
434 ResponseFormat::Data
435 }
436}
437
438#[derive(Debug, Clone, Serialize, Deserialize)]
440pub struct FileVersion {
441 pub version_id: String,
443 pub name: String,
445 pub obj_token: String,
447 pub obj_type: String,
449 pub creator_id: String,
451 pub create_time: String,
453 pub status: String,
455 pub parent_version_id: Option<String>,
457}