open_lark/service/cloud_docs/sheets/v3/data_validation/
query.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 service::sheets::v3::SpreadsheetSheetService,
15};
16
17use super::create::DataValidationRule;
18
19impl SpreadsheetSheetService {
20 pub async fn query_data_validations(
22 &self,
23 request: QueryDataValidationsRequest,
24 option: Option<RequestOption>,
25 ) -> SDKResult<BaseResponse<QueryDataValidationsResponseData>> {
26 let mut api_req = request.api_request;
27 api_req.http_method = Method::GET;
28 api_req.api_path = SHEETS_V3_SPREADSHEET_DATA_VALIDATION
29 .replace("{}", &request.spreadsheet_token)
30 .replace("{}", &request.sheet_id);
31 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
32
33 if let Some(range) = &request.range {
35 api_req.query_params.insert("range", range.clone());
36 }
37
38 let api_resp = Transport::request(api_req, &self.config, option).await?;
39
40 Ok(api_resp)
41 }
42}
43
44#[derive(Default, Debug, Serialize, Deserialize)]
46pub struct QueryDataValidationsRequest {
47 #[serde(skip)]
48 api_request: ApiRequest,
49 spreadsheet_token: String,
51 sheet_id: String,
53 #[serde(skip_serializing_if = "Option::is_none")]
55 range: Option<String>,
56}
57
58impl QueryDataValidationsRequest {
59 pub fn builder() -> QueryDataValidationsRequestBuilder {
60 QueryDataValidationsRequestBuilder::default()
61 }
62}
63
64#[derive(Default)]
65pub struct QueryDataValidationsRequestBuilder {
66 request: QueryDataValidationsRequest,
67}
68
69impl QueryDataValidationsRequestBuilder {
70 pub fn spreadsheet_token(mut self, spreadsheet_token: impl ToString) -> Self {
71 self.request.spreadsheet_token = spreadsheet_token.to_string();
72 self
73 }
74
75 pub fn sheet_id(mut self, sheet_id: impl ToString) -> Self {
76 self.request.sheet_id = sheet_id.to_string();
77 self
78 }
79
80 pub fn range(mut self, range: impl ToString) -> Self {
81 self.request.range = Some(range.to_string());
82 self
83 }
84
85 pub fn build(mut self) -> QueryDataValidationsRequest {
86 self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
87 self.request
88 }
89}
90
91#[derive(Deserialize, Debug)]
93pub struct DataValidationInfo {
94 pub data_validation_id: String,
96 #[serde(flatten)]
98 pub data_validation: DataValidationRule,
99}
100
101#[derive(Deserialize, Debug)]
103pub struct QueryDataValidationsResponseData {
104 pub items: Vec<DataValidationInfo>,
106 #[serde(default)]
108 pub has_more: bool,
109 #[serde(skip_serializing_if = "Option::is_none")]
111 pub page_token: Option<String>,
112}
113
114impl ApiResponseTrait for QueryDataValidationsResponseData {
115 fn data_format() -> ResponseFormat {
116 ResponseFormat::Data
117 }
118}
119
120#[cfg(test)]
121#[allow(unused_variables, unused_unsafe)]
122mod test {
123 use super::*;
124 use serde_json::json;
125
126 #[test]
127 fn test_query_data_validations_response() {
128 let json = json!({
129 "items": [
130 {
131 "data_validation_id": "dv_001",
132 "condition_type": "dropdown",
133 "range": "A1:A10",
134 "condition_values": ["选项1", "选项2"],
135 "strict": true,
136 "input_message": "请选择一个选项"
137 },
138 {
139 "data_validation_id": "dv_002",
140 "condition_type": "number_between",
141 "range": "B1:B10",
142 "condition_values": ["1", "100"],
143 "strict": true,
144 "error_message": "数字超出范围"
145 }
146 ],
147 "has_more": false
148 });
149
150 let response: QueryDataValidationsResponseData = serde_json::from_value(json).unwrap();
151 assert_eq!(response.items.len(), 2);
152 assert_eq!(response.items[0].data_validation_id, "dv_001");
153 assert_eq!(
154 response.items[1].data_validation.condition_type,
155 "number_between"
156 );
157 assert!(!response.has_more);
158 }
159}