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