open_lark/service/cloud_docs/sheets/v3/data_operation/
prepend_data.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 standard_response::StandardResponse,
13 SDKResult,
14 },
15 impl_executable_builder_owned,
16 service::sheets::v3::DataOperationService,
17};
18
19use super::{UpdatesInfo, ValueRangeRequest};
20
21impl DataOperationService {
22 pub async fn prepend_data(
24 &self,
25 request: PrependDataRequest,
26 option: Option<RequestOption>,
27 ) -> SDKResult<PrependDataResponseData> {
28 let mut api_req = request.api_request;
29 api_req.http_method = Method::POST;
30 api_req.api_path = SHEETS_V3_SPREADSHEET_VALUES_PREPEND
31 .replace("{}", &request.spreadsheet_token)
32 .replace("{}", &request.range);
33 api_req.supported_access_token_types = vec![AccessTokenType::Tenant, AccessTokenType::User];
34
35 let api_resp: BaseResponse<PrependDataResponseData> =
36 Transport::request(api_req, &self.config, option).await?;
37 api_resp.into_result()
38 }
39}
40
41#[derive(Default, Debug, Serialize, Deserialize)]
43pub struct PrependDataRequest {
44 #[serde(skip)]
45 api_request: ApiRequest,
46 spreadsheet_token: String,
48 range: String,
50 #[serde(rename = "insertDataOption")]
52 insert_data_option: Option<String>,
53 #[serde(rename = "valueRange")]
55 value_range: ValueRangeRequest,
56}
57
58impl PrependDataRequest {
59 pub fn builder() -> PrependDataRequestBuilder {
60 PrependDataRequestBuilder::default()
61 }
62}
63
64#[derive(Default)]
65pub struct PrependDataRequestBuilder {
66 request: PrependDataRequest,
67}
68
69impl PrependDataRequestBuilder {
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 range(mut self, range: impl ToString) -> Self {
76 self.request.range = range.to_string();
77 self
78 }
79
80 pub fn insert_data_option(mut self, insert_data_option: impl ToString) -> Self {
81 self.request.insert_data_option = Some(insert_data_option.to_string());
82 self
83 }
84
85 pub fn values(mut self, values: Vec<Vec<serde_json::Value>>) -> Self {
86 self.request.value_range = ValueRangeRequest {
87 range: self.request.range.clone(),
88 values,
89 };
90 self
91 }
92
93 pub fn build(mut self) -> PrependDataRequest {
94 self.request.api_request.body = serde_json::to_vec(&self.request).unwrap();
95 self.request
96 }
97}
98
99impl_executable_builder_owned!(
101 PrependDataRequestBuilder,
102 DataOperationService,
103 PrependDataRequest,
104 PrependDataResponseData,
105 prepend_data
106);
107
108#[derive(Deserialize, Debug)]
110pub struct PrependDataResponseData {
111 #[serde(rename = "spreadsheetToken")]
113 pub spreadsheet_token: String,
114 #[serde(rename = "tableRange")]
116 pub table_range: String,
117 pub revision: i32,
119 pub updates: UpdatesInfo,
121}
122
123impl ApiResponseTrait for PrependDataResponseData {
124 fn data_format() -> ResponseFormat {
125 ResponseFormat::Data
126 }
127}
128
129#[cfg(test)]
130#[allow(unused_variables, unused_unsafe)]
131mod test {
132 use serde_json::json;
133
134 use super::PrependDataResponseData;
135
136 #[test]
137 fn test_prepend_data_response() {
138 let json = json!({
139 "spreadsheetToken": "shtcnmBA*****yGehy8",
140 "tableRange": "Sheet1!A1:B2",
141 "revision": 123,
142 "updates": {
143 "updatedRange": "Sheet1!A1:B1",
144 "updatedRows": 1,
145 "updatedColumns": 2,
146 "updatedCells": 2
147 }
148 });
149
150 let response: PrependDataResponseData = serde_json::from_value(json).unwrap();
151 assert_eq!(response.spreadsheet_token, "shtcnmBA*****yGehy8");
152 assert_eq!(response.updates.updated_rows, 1);
153 }
154}