open_lark/service/cloud_docs/wiki/v2/space_node/
create.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        endpoints::{cloud_docs::*, EndpointBuilder},
11        http::Transport,
12        req_option::RequestOption,
13        SDKResult,
14    },
15    impl_executable_builder_owned,
16};
17
18/// 创建知识空间节点请求
19#[derive(Debug, Serialize, Default)]
20pub struct CreateSpaceNodeRequest {
21    #[serde(skip)]
22    api_request: ApiRequest,
23    /// 知识空间id
24    #[serde(skip)]
25    space_id: String,
26    /// 文档类型:doc(文档)、sheet(电子表格)、mindnote(思维笔记)、bitable(多维表格)
27    obj_type: String,
28    /// 父节点token,创建根节点时可以为空
29    #[serde(skip_serializing_if = "Option::is_none")]
30    parent_node_token: Option<String>,
31    /// 节点类型:origin(正常节点)、shortcut(快捷方式)
32    #[serde(skip_serializing_if = "Option::is_none")]
33    node_type: Option<String>,
34    /// 文档标题
35    #[serde(skip_serializing_if = "Option::is_none")]
36    title: Option<String>,
37}
38
39impl CreateSpaceNodeRequest {
40    pub fn builder() -> CreateSpaceNodeRequestBuilder {
41        CreateSpaceNodeRequestBuilder::default()
42    }
43
44    pub fn new(space_id: impl ToString, obj_type: impl ToString) -> Self {
45        Self {
46            space_id: space_id.to_string(),
47            obj_type: obj_type.to_string(),
48            ..Default::default()
49        }
50    }
51}
52
53#[derive(Default)]
54pub struct CreateSpaceNodeRequestBuilder {
55    request: CreateSpaceNodeRequest,
56}
57
58impl CreateSpaceNodeRequestBuilder {
59    /// 知识空间id
60    pub fn space_id(mut self, space_id: impl ToString) -> Self {
61        self.request.space_id = space_id.to_string();
62        self
63    }
64
65    /// 文档类型:doc(文档)、sheet(电子表格)、mindnote(思维笔记)、bitable(多维表格)
66    pub fn obj_type(mut self, obj_type: impl ToString) -> Self {
67        self.request.obj_type = obj_type.to_string();
68        self
69    }
70
71    /// 创建文档类型节点
72    pub fn with_doc_type(mut self) -> Self {
73        self.request.obj_type = "doc".to_string();
74        self
75    }
76
77    /// 创建电子表格类型节点
78    pub fn with_sheet_type(mut self) -> Self {
79        self.request.obj_type = "sheet".to_string();
80        self
81    }
82
83    /// 创建思维笔记类型节点
84    pub fn with_mindnote_type(mut self) -> Self {
85        self.request.obj_type = "mindnote".to_string();
86        self
87    }
88
89    /// 创建多维表格类型节点
90    pub fn with_bitable_type(mut self) -> Self {
91        self.request.obj_type = "bitable".to_string();
92        self
93    }
94
95    /// 父节点token,创建根节点时可以为空
96    pub fn parent_node_token(mut self, parent_node_token: impl ToString) -> Self {
97        self.request.parent_node_token = Some(parent_node_token.to_string());
98        self
99    }
100
101    /// 节点类型:origin(正常节点)、shortcut(快捷方式)
102    pub fn node_type(mut self, node_type: impl ToString) -> Self {
103        self.request.node_type = Some(node_type.to_string());
104        self
105    }
106
107    /// 设置为正常节点
108    pub fn with_origin_node(mut self) -> Self {
109        self.request.node_type = Some("origin".to_string());
110        self
111    }
112
113    /// 设置为快捷方式
114    pub fn with_shortcut_node(mut self) -> Self {
115        self.request.node_type = Some("shortcut".to_string());
116        self
117    }
118
119    /// 文档标题
120    pub fn title(mut self, title: impl ToString) -> Self {
121        self.request.title = Some(title.to_string());
122        self
123    }
124
125    pub fn build(mut self) -> CreateSpaceNodeRequest {
126        self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
127        self.request
128    }
129}
130
131impl_executable_builder_owned!(
132    CreateSpaceNodeRequestBuilder,
133    crate::service::cloud_docs::wiki::v2::space_node::SpaceNodeService,
134    CreateSpaceNodeRequest,
135    CreateSpaceNodeResponse,
136    create
137);
138
139/// 创建的节点信息
140#[derive(Debug, Deserialize)]
141pub struct CreatedNode {
142    /// 知识空间id
143    pub space_id: String,
144    /// 节点token
145    pub node_token: String,
146    /// 文档类型
147    pub obj_type: String,
148    /// 父节点token
149    pub parent_node_token: Option<String>,
150    /// 节点类型
151    pub node_type: Option<String>,
152    /// 原始文档token
153    pub obj_token: Option<String>,
154    /// 文档标题
155    pub title: Option<String>,
156}
157
158/// 创建知识空间节点响应
159#[derive(Debug, Deserialize)]
160pub struct CreateSpaceNodeResponse {
161    /// 创建的节点信息
162    pub node: CreatedNode,
163}
164
165impl ApiResponseTrait for CreateSpaceNodeResponse {
166    fn data_format() -> ResponseFormat {
167        ResponseFormat::Data
168    }
169}
170
171/// 创建知识空间节点
172pub async fn create_space_node(
173    request: CreateSpaceNodeRequest,
174    config: &Config,
175    option: Option<RequestOption>,
176) -> SDKResult<BaseResponse<CreateSpaceNodeResponse>> {
177    let mut api_req = request.api_request;
178    api_req.http_method = Method::POST;
179    api_req.api_path =
180        EndpointBuilder::replace_param(WIKI_V2_SPACE_NODES, "space_id", &request.space_id);
181    api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
182
183    let api_resp = Transport::request(api_req, config, option).await?;
184    Ok(api_resp)
185}
186
187#[cfg(test)]
188#[allow(unused_variables, unused_unsafe)]
189mod tests {
190    use super::*;
191
192    #[test]
193    fn test_create_space_node_request_builder() {
194        let request = CreateSpaceNodeRequest::builder()
195            .space_id("spcxxxxxx")
196            .with_doc_type()
197            .parent_node_token("wikcnxxxxxx")
198            .with_origin_node()
199            .title("我的文档")
200            .build();
201
202        assert_eq!(request.space_id, "spcxxxxxx");
203        assert_eq!(request.obj_type, "doc");
204        assert_eq!(request.parent_node_token, Some("wikcnxxxxxx".to_string()));
205        assert_eq!(request.node_type, Some("origin".to_string()));
206        assert_eq!(request.title, Some("我的文档".to_string()));
207    }
208}