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