open_lark/service/cloud_docs/bitable/v1/app_table/
patch.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::AppTableService;
17
18impl AppTableService {
19 pub async fn patch(
21 &self,
22 request: PatchTableRequest,
23 option: Option<RequestOption>,
24 ) -> SDKResult<BaseResponse<PatchTableResponse>> {
25 let mut api_req = request.api_request;
26 api_req.http_method = Method::PATCH;
27 api_req.api_path = format!(
28 "/open-apis/bitable/v1/apps/{}/tables/{}",
29 request.app_token, request.table_id
30 );
31 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
32 api_req.body = serde_json::to_vec(&PatchTableRequestBody { name: request.name })?;
33
34 let api_resp = Transport::request(api_req, &self.config, option).await?;
35 Ok(api_resp)
36 }
37}
38
39#[derive(Debug, Default)]
41pub struct PatchTableRequest {
42 api_request: ApiRequest,
43 app_token: String,
45 table_id: String,
47 name: Option<String>,
49}
50
51impl PatchTableRequest {
52 pub fn builder() -> PatchTableRequestBuilder {
53 PatchTableRequestBuilder::default()
54 }
55
56 pub fn new(app_token: impl ToString, table_id: impl ToString) -> Self {
58 Self {
59 api_request: ApiRequest::default(),
60 app_token: app_token.to_string(),
61 table_id: table_id.to_string(),
62 name: None,
63 }
64 }
65}
66
67#[derive(Default)]
68pub struct PatchTableRequestBuilder {
69 request: PatchTableRequest,
70}
71
72impl PatchTableRequestBuilder {
73 pub fn app_token(mut self, app_token: impl ToString) -> Self {
75 self.request.app_token = app_token.to_string();
76 self
77 }
78
79 pub fn table_id(mut self, table_id: impl ToString) -> Self {
81 self.request.table_id = table_id.to_string();
82 self
83 }
84
85 pub fn name(mut self, name: impl ToString) -> Self {
87 self.request.name = Some(name.to_string());
88 self
89 }
90
91 pub fn build(self) -> PatchTableRequest {
92 self.request
93 }
94}
95
96impl_executable_builder_owned!(
97 PatchTableRequestBuilder,
98 AppTableService,
99 PatchTableRequest,
100 BaseResponse<PatchTableResponse>,
101 patch
102);
103
104#[derive(Serialize)]
105struct PatchTableRequestBody {
106 #[serde(skip_serializing_if = "Option::is_none")]
107 name: Option<String>,
108}
109
110#[derive(Deserialize, Debug)]
111pub struct PatchTableResponse {
112 pub name: String,
114}
115
116impl ApiResponseTrait for PatchTableResponse {
117 fn data_format() -> ResponseFormat {
118 ResponseFormat::Data
119 }
120}
121
122#[cfg(test)]
123mod tests {
124 use super::*;
125 use serde_json::json;
126
127 #[test]
128 fn test_patch_table_request() {
129 let request = PatchTableRequest::builder()
130 .app_token("bascnmBA*****yGehy8")
131 .table_id("tblsRc9GRRXKqhvW")
132 .name("更新后的表名")
133 .build();
134
135 assert_eq!(request.app_token, "bascnmBA*****yGehy8");
136 assert_eq!(request.table_id, "tblsRc9GRRXKqhvW");
137 assert_eq!(request.name, Some("更新后的表名".to_string()));
138 }
139
140 #[test]
141 fn test_patch_table_request_new() {
142 let request = PatchTableRequest::new("bascnmBA*****yGehy8", "tblsRc9GRRXKqhvW");
143 assert_eq!(request.app_token, "bascnmBA*****yGehy8");
144 assert_eq!(request.table_id, "tblsRc9GRRXKqhvW");
145 assert_eq!(request.name, None);
146 }
147
148 #[test]
149 fn test_patch_table_request_body_serialization() {
150 let body = PatchTableRequestBody {
151 name: Some("新表名".to_string()),
152 };
153
154 let serialized = serde_json::to_value(&body).unwrap();
155 let expected = json!({
156 "name": "新表名"
157 });
158
159 assert_eq!(serialized, expected);
160 }
161}