open_lark/service/cloud_docs/wiki/v2/space_node/
move.rs1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::core::{
5 api_req::ApiRequest,
6 api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
7 config::Config,
8 constants::AccessTokenType,
9 http::Transport,
10 req_option::RequestOption,
11 SDKResult,
12};
13
14#[derive(Debug, Serialize, Default)]
16pub struct MoveSpaceNodeRequest {
17 #[serde(skip)]
18 api_request: ApiRequest,
19 #[serde(skip)]
21 space_id: String,
22 #[serde(skip)]
24 node_token: String,
25 #[serde(skip_serializing_if = "Option::is_none")]
27 target_parent_token: Option<String>,
28 #[serde(skip_serializing_if = "Option::is_none")]
30 target_prev_token: Option<String>,
31}
32
33impl MoveSpaceNodeRequest {
34 pub fn builder() -> MoveSpaceNodeRequestBuilder {
35 MoveSpaceNodeRequestBuilder::default()
36 }
37
38 pub fn new(space_id: impl ToString, node_token: impl ToString) -> Self {
39 Self {
40 space_id: space_id.to_string(),
41 node_token: node_token.to_string(),
42 ..Default::default()
43 }
44 }
45}
46
47#[derive(Default)]
48pub struct MoveSpaceNodeRequestBuilder {
49 request: MoveSpaceNodeRequest,
50}
51
52impl MoveSpaceNodeRequestBuilder {
53 pub fn space_id(mut self, space_id: impl ToString) -> Self {
55 self.request.space_id = space_id.to_string();
56 self
57 }
58
59 pub fn node_token(mut self, node_token: impl ToString) -> Self {
61 self.request.node_token = node_token.to_string();
62 self
63 }
64
65 pub fn target_parent_token(mut self, target_parent_token: impl ToString) -> Self {
67 self.request.target_parent_token = Some(target_parent_token.to_string());
68 self
69 }
70
71 pub fn move_to_root(mut self) -> Self {
73 self.request.target_parent_token = None;
74 self
75 }
76
77 pub fn target_prev_token(mut self, target_prev_token: impl ToString) -> Self {
79 self.request.target_prev_token = Some(target_prev_token.to_string());
80 self
81 }
82
83 pub fn append_to_end(mut self) -> Self {
85 self.request.target_prev_token = None;
86 self
87 }
88
89 pub fn build(mut self) -> MoveSpaceNodeRequest {
90 self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
91 self.request
92 }
93}
94
95#[derive(Debug, Deserialize)]
97pub struct MovedNode {
98 pub space_id: String,
100 pub node_token: String,
102 pub obj_type: String,
104 pub parent_node_token: Option<String>,
106 pub node_type: Option<String>,
108 pub obj_token: Option<String>,
110 pub title: Option<String>,
112}
113
114#[derive(Debug, Deserialize)]
116pub struct MoveSpaceNodeResponse {
117 pub node: MovedNode,
119}
120
121impl ApiResponseTrait for MoveSpaceNodeResponse {
122 fn data_format() -> ResponseFormat {
123 ResponseFormat::Data
124 }
125}
126
127pub async fn move_space_node(
129 request: MoveSpaceNodeRequest,
130 config: &Config,
131 option: Option<RequestOption>,
132) -> SDKResult<BaseResponse<MoveSpaceNodeResponse>> {
133 let mut api_req = request.api_request;
134 api_req.http_method = Method::POST;
135 api_req.api_path = format!(
136 "/open-apis/wiki/v2/spaces/{}/nodes/{}/move",
137 request.space_id, request.node_token
138 );
139 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
140
141 let api_resp = Transport::request(api_req, config, option).await?;
142 Ok(api_resp)
143}
144
145#[cfg(test)]
146mod tests {
147 use super::*;
148
149 #[test]
150 fn test_move_space_node_request_builder() {
151 let request = MoveSpaceNodeRequest::builder()
152 .space_id("spcxxxxxx")
153 .node_token("wikcnxxxxxx")
154 .target_parent_token("wikcnyyyyyyy")
155 .target_prev_token("wikcnzzzzzzz")
156 .build();
157
158 assert_eq!(request.space_id, "spcxxxxxx");
159 assert_eq!(request.node_token, "wikcnxxxxxx");
160 assert_eq!(
161 request.target_parent_token,
162 Some("wikcnyyyyyyy".to_string())
163 );
164 assert_eq!(request.target_prev_token, Some("wikcnzzzzzzz".to_string()));
165 }
166
167 #[test]
168 fn test_move_to_root() {
169 let request = MoveSpaceNodeRequest::builder()
170 .space_id("spcxxxxxx")
171 .node_token("wikcnxxxxxx")
172 .move_to_root()
173 .append_to_end()
174 .build();
175
176 assert_eq!(request.space_id, "spcxxxxxx");
177 assert_eq!(request.node_token, "wikcnxxxxxx");
178 assert_eq!(request.target_parent_token, None);
179 assert_eq!(request.target_prev_token, None);
180 }
181}