open_lark/service/cloud_docs/bitable/v1/app/
update.rs1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::{
5 core::{
6 api_req::ApiRequest,
7 api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
8 constants::AccessTokenType,
9 endpoints::cloud_docs::*,
10 http::Transport,
11 req_option::RequestOption,
12 SDKResult,
13 },
14 impl_executable_builder_owned,
15};
16
17use super::AppService;
18
19impl AppService {
20 pub async fn update(
24 &self,
25 request: UpdateAppRequest,
26 option: Option<RequestOption>,
27 ) -> SDKResult<BaseResponse<UpdateAppResponse>> {
28 let mut api_req = request.api_request;
29 api_req.http_method = Method::PUT;
30 api_req.api_path = BITABLE_V1_APP_UPDATE.replace("{app_token}", &request.app_token);
31 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
32 api_req.body = serde_json::to_vec(&UpdateAppRequestBody {
33 name: request.name,
34 is_advanced: request.is_advanced,
35 })?;
36
37 let api_resp = Transport::request(api_req, &self.config, option).await?;
38 Ok(api_resp)
39 }
40}
41
42#[derive(Debug, Default)]
44pub struct UpdateAppRequest {
45 api_request: ApiRequest,
46 app_token: String,
48 name: Option<String>,
50 is_advanced: Option<bool>,
52}
53
54impl UpdateAppRequest {
55 pub fn builder() -> UpdateAppRequestBuilder {
56 UpdateAppRequestBuilder::default()
57 }
58
59 pub fn new(app_token: impl ToString) -> Self {
61 Self {
62 api_request: ApiRequest::default(),
63 app_token: app_token.to_string(),
64 name: None,
65 is_advanced: None,
66 }
67 }
68}
69
70#[derive(Default)]
71pub struct UpdateAppRequestBuilder {
72 request: UpdateAppRequest,
73}
74
75impl UpdateAppRequestBuilder {
76 pub fn app_token(mut self, app_token: impl ToString) -> Self {
78 self.request.app_token = app_token.to_string();
79 self
80 }
81
82 pub fn name(mut self, name: impl ToString) -> Self {
84 self.request.name = Some(name.to_string());
85 self
86 }
87
88 pub fn is_advanced(mut self, is_advanced: bool) -> Self {
90 self.request.is_advanced = Some(is_advanced);
91 self
92 }
93
94 pub fn build(self) -> UpdateAppRequest {
95 self.request
96 }
97}
98
99impl_executable_builder_owned!(
100 UpdateAppRequestBuilder,
101 AppService,
102 UpdateAppRequest,
103 BaseResponse<UpdateAppResponse>,
104 update
105);
106
107#[derive(Serialize)]
108struct UpdateAppRequestBody {
109 #[serde(skip_serializing_if = "Option::is_none")]
110 name: Option<String>,
111 #[serde(skip_serializing_if = "Option::is_none")]
112 is_advanced: Option<bool>,
113}
114
115#[derive(Deserialize, Debug)]
116pub struct UpdateAppResponse {
117 pub app: UpdateAppResponseData,
119}
120
121#[derive(Deserialize, Debug)]
122pub struct UpdateAppResponseData {
123 pub app_token: String,
125 pub name: String,
127 pub revision: i32,
129 pub is_advanced: bool,
131}
132
133impl ApiResponseTrait for UpdateAppResponse {
134 fn data_format() -> ResponseFormat {
135 ResponseFormat::Data
136 }
137}
138
139#[cfg(test)]
140#[allow(unused_variables, unused_unsafe)]
141mod tests {
142 use super::*;
143 use serde_json::json;
144
145 #[test]
146 fn test_update_app_request() {
147 let request = UpdateAppRequest::builder()
148 .app_token("bascnmBA*****yGehy8")
149 .name("新的表格名称")
150 .is_advanced(true)
151 .build();
152
153 assert_eq!(request.app_token, "bascnmBA*****yGehy8");
154 assert_eq!(request.name, Some("新的表格名称".to_string()));
155 assert_eq!(request.is_advanced, Some(true));
156 }
157
158 #[test]
159 fn test_update_app_request_new() {
160 let request = UpdateAppRequest::new("bascnmBA*****yGehy8");
161 assert_eq!(request.app_token, "bascnmBA*****yGehy8");
162 assert_eq!(request.name, None);
163 assert_eq!(request.is_advanced, None);
164 }
165
166 #[test]
167 fn test_update_app_request_body_serialization() {
168 let body = UpdateAppRequestBody {
169 name: Some("新的表格名称".to_string()),
170 is_advanced: Some(true),
171 };
172
173 let serialized = serde_json::to_value(&body).unwrap();
174 let expected = json!({
175 "name": "新的表格名称",
176 "is_advanced": true
177 });
178
179 assert_eq!(serialized, expected);
180 }
181}