open_lark/service/cloud_docs/drive/v1/
file_version.rs

1use 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
17/// 文档版本服务
18pub struct FileVersionService {
19    config: Config,
20}
21
22impl FileVersionService {
23    pub fn new(config: Config) -> Self {
24        Self { config }
25    }
26
27    /// 创建文档版本
28    ///
29    /// 该接口用于创建文档版本。
30    ///
31    /// <https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/drive-v1/file-version/create>
32    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    /// 删除文档版本
55    ///
56    /// 该接口用于删除文档版本。
57    ///
58    /// <https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/drive-v1/file-version/delete>
59    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    /// 获取文档版本
79    ///
80    /// 该接口用于获取文档版本信息。
81    ///
82    /// <https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/drive-v1/file-version/get>
83    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    /// 获取文档版本列表
103    ///
104    /// 该接口用于获取文档的版本列表。
105    ///
106    /// <https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/drive-v1/file-version/list>
107    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        // 添加查询参数
120        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// === 数据结构定义 ===
137
138/// 创建文档版本请求参数
139#[derive(Debug, Clone, Serialize, Deserialize, Default)]
140pub struct CreateVersionRequest {
141    /// 文档token
142    pub file_token: String,
143    /// 版本名称
144    pub name: String,
145    /// 文档类型
146    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/// 创建文档版本请求构建器
168#[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/// 创建文档版本响应数据
203#[derive(Debug, Clone, Serialize, Deserialize)]
204pub struct CreateVersionRespData {
205    /// 版本ID
206    pub version_id: String,
207    /// 版本名称
208    pub name: String,
209    /// 版本创建时间
210    pub create_time: String,
211    /// 创建者ID
212    pub creator_id: String,
213}
214
215impl ApiResponseTrait for CreateVersionRespData {
216    fn data_format() -> ResponseFormat {
217        ResponseFormat::Data
218    }
219}
220
221/// 删除文档版本请求参数
222#[derive(Debug, Clone, Serialize, Deserialize, Default)]
223pub struct DeleteVersionRequest {
224    /// 文档token
225    pub file_token: String,
226    /// 版本ID
227    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/// 删除文档版本请求构建器
244#[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/// 删除文档版本响应数据
274#[derive(Debug, Clone, Serialize, Deserialize)]
275pub struct DeleteVersionRespData {
276    /// 删除结果
277    pub success: bool,
278}
279
280impl ApiResponseTrait for DeleteVersionRespData {
281    fn data_format() -> ResponseFormat {
282        ResponseFormat::Data
283    }
284}
285
286/// 获取文档版本请求参数
287#[derive(Debug, Clone, Serialize, Deserialize, Default)]
288pub struct GetVersionRequest {
289    /// 文档token
290    pub file_token: String,
291    /// 版本ID
292    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/// 获取文档版本请求构建器
309#[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/// 获取文档版本响应数据
339#[derive(Debug, Clone, Serialize, Deserialize)]
340pub struct GetVersionRespData {
341    /// 版本信息
342    pub version: FileVersion,
343}
344
345/// 获取文档版本列表请求参数
346#[derive(Debug, Clone, Serialize, Deserialize, Default)]
347pub struct ListVersionsRequest {
348    /// 文档token
349    pub file_token: String,
350    /// 分页token
351    pub page_token: Option<String>,
352    /// 分页大小
353    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/// 获取文档版本列表请求构建器
381#[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/// 获取文档版本列表响应数据
416#[derive(Debug, Clone, Serialize, Deserialize)]
417pub struct ListVersionsRespData {
418    /// 是否还有更多数据
419    pub has_more: bool,
420    /// 下一页token
421    pub page_token: Option<String>,
422    /// 版本列表
423    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/// 文档版本信息
439#[derive(Debug, Clone, Serialize, Deserialize)]
440pub struct FileVersion {
441    /// 版本ID
442    pub version_id: String,
443    /// 版本名称
444    pub name: String,
445    /// 文档token
446    pub obj_token: String,
447    /// 文档类型
448    pub obj_type: String,
449    /// 创建者ID
450    pub creator_id: String,
451    /// 创建时间
452    pub create_time: String,
453    /// 版本状态
454    pub status: String,
455    /// 版本父ID
456    pub parent_version_id: Option<String>,
457}