open_lark/service/cloud_docs/wiki/v2/space_node/
create.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 endpoints::{cloud_docs::*, EndpointBuilder},
11 http::Transport,
12 req_option::RequestOption,
13 SDKResult,
14 },
15 impl_executable_builder_owned,
16};
17
18#[derive(Debug, Serialize, Default)]
20pub struct CreateSpaceNodeRequest {
21 #[serde(skip)]
22 api_request: ApiRequest,
23 #[serde(skip)]
25 space_id: String,
26 obj_type: String,
28 #[serde(skip_serializing_if = "Option::is_none")]
30 parent_node_token: Option<String>,
31 #[serde(skip_serializing_if = "Option::is_none")]
33 node_type: Option<String>,
34 #[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 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 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 pub fn with_doc_type(mut self) -> Self {
73 self.request.obj_type = "doc".to_string();
74 self
75 }
76
77 pub fn with_sheet_type(mut self) -> Self {
79 self.request.obj_type = "sheet".to_string();
80 self
81 }
82
83 pub fn with_mindnote_type(mut self) -> Self {
85 self.request.obj_type = "mindnote".to_string();
86 self
87 }
88
89 pub fn with_bitable_type(mut self) -> Self {
91 self.request.obj_type = "bitable".to_string();
92 self
93 }
94
95 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 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 pub fn with_origin_node(mut self) -> Self {
109 self.request.node_type = Some("origin".to_string());
110 self
111 }
112
113 pub fn with_shortcut_node(mut self) -> Self {
115 self.request.node_type = Some("shortcut".to_string());
116 self
117 }
118
119 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#[derive(Debug, Deserialize)]
141pub struct CreatedNode {
142 pub space_id: String,
144 pub node_token: String,
146 pub obj_type: String,
148 pub parent_node_token: Option<String>,
150 pub node_type: Option<String>,
152 pub obj_token: Option<String>,
154 pub title: Option<String>,
156}
157
158#[derive(Debug, Deserialize)]
160pub struct CreateSpaceNodeResponse {
161 pub node: CreatedNode,
163}
164
165impl ApiResponseTrait for CreateSpaceNodeResponse {
166 fn data_format() -> ResponseFormat {
167 ResponseFormat::Data
168 }
169}
170
171pub 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}