open_lark/service/search/v2/data_source/
mod.rs1use reqwest::Method;
2use serde::{Deserialize, Serialize};
3
4use crate::{
5 core::{
6 api_req::ApiRequest,
7 api_resp::{ApiResponseTrait, BaseResponse, ResponseFormat},
8 config::Config,
9 constants::AccessTokenType,
10 endpoints::EndpointBuilder,
11 http::Transport,
12 req_option::RequestOption,
13 trait_system::Service,
14 SDKResult,
15 },
16 service::search::v2::models::{
17 CreateDataSourceRequest, DataSource, ListDataSourceRequest, ListDataSourceResponse,
18 UpdateDataSourceRequest,
19 },
20};
21
22pub struct DataSourceService {
24 pub config: Config,
25}
26
27#[derive(Debug, Serialize, Deserialize)]
29pub struct CreateDataSourceResponse {
30 pub data_source: DataSource,
32}
33
34impl ApiResponseTrait for CreateDataSourceResponse {
35 fn data_format() -> ResponseFormat {
36 ResponseFormat::Data
37 }
38}
39
40#[derive(Debug, Serialize, Deserialize)]
42pub struct GetDataSourceResponse {
43 pub data_source: DataSource,
45}
46
47impl ApiResponseTrait for GetDataSourceResponse {
48 fn data_format() -> ResponseFormat {
49 ResponseFormat::Data
50 }
51}
52
53#[derive(Debug, Serialize, Deserialize)]
55pub struct UpdateDataSourceResponse {
56 pub data_source: DataSource,
58}
59
60impl ApiResponseTrait for UpdateDataSourceResponse {
61 fn data_format() -> ResponseFormat {
62 ResponseFormat::Data
63 }
64}
65
66#[derive(Debug, Serialize, Deserialize)]
68pub struct EmptyDataSourceResponse {}
69
70impl ApiResponseTrait for EmptyDataSourceResponse {
71 fn data_format() -> ResponseFormat {
72 ResponseFormat::Data
73 }
74}
75
76impl ApiResponseTrait for ListDataSourceResponse {
77 fn data_format() -> ResponseFormat {
78 ResponseFormat::Data
79 }
80}
81
82impl DataSourceService {
83 pub fn new(config: Config) -> Self {
84 Self { config }
85 }
86
87 pub async fn create(
100 &self,
101 request: CreateDataSourceRequest,
102 option: Option<RequestOption>,
103 ) -> SDKResult<BaseResponse<CreateDataSourceResponse>> {
104 let api_req = ApiRequest {
105 http_method: Method::POST,
106 api_path: crate::core::endpoints::search::SEARCH_V2_DATA_SOURCES.to_string(),
107 supported_access_token_types: vec![AccessTokenType::Tenant, AccessTokenType::User],
108 body: serde_json::to_vec(&request)?,
109 ..Default::default()
110 };
111
112 Transport::request(api_req, &self.config, option).await
113 }
114
115 pub async fn delete(
124 &self,
125 data_source_id: &str,
126 option: Option<RequestOption>,
127 ) -> SDKResult<BaseResponse<EmptyDataSourceResponse>> {
128 let api_req = ApiRequest {
129 http_method: Method::DELETE,
130 api_path: EndpointBuilder::replace_param(
131 crate::core::endpoints::search::SEARCH_V2_DATA_SOURCE_OPERATION,
132 "data_source_id",
133 data_source_id,
134 ),
135 supported_access_token_types: vec![AccessTokenType::Tenant, AccessTokenType::User],
136 ..Default::default()
137 };
138
139 Transport::request(api_req, &self.config, option).await
140 }
141
142 pub async fn patch(
152 &self,
153 data_source_id: &str,
154 request: UpdateDataSourceRequest,
155 option: Option<RequestOption>,
156 ) -> SDKResult<BaseResponse<UpdateDataSourceResponse>> {
157 let api_req = ApiRequest {
158 http_method: Method::PATCH,
159 api_path: EndpointBuilder::replace_param(
160 crate::core::endpoints::search::SEARCH_V2_DATA_SOURCE_OPERATION,
161 "data_source_id",
162 data_source_id,
163 ),
164 supported_access_token_types: vec![AccessTokenType::Tenant, AccessTokenType::User],
165 body: serde_json::to_vec(&request)?,
166 ..Default::default()
167 };
168
169 Transport::request(api_req, &self.config, option).await
170 }
171
172 pub async fn get(
181 &self,
182 data_source_id: &str,
183 option: Option<RequestOption>,
184 ) -> SDKResult<BaseResponse<GetDataSourceResponse>> {
185 let api_req = ApiRequest {
186 http_method: Method::GET,
187 api_path: EndpointBuilder::replace_param(
188 crate::core::endpoints::search::SEARCH_V2_DATA_SOURCE_OPERATION,
189 "data_source_id",
190 data_source_id,
191 ),
192 supported_access_token_types: vec![AccessTokenType::Tenant, AccessTokenType::User],
193 ..Default::default()
194 };
195
196 Transport::request(api_req, &self.config, option).await
197 }
198
199 pub async fn list(
208 &self,
209 request: Option<ListDataSourceRequest>,
210 option: Option<RequestOption>,
211 ) -> SDKResult<BaseResponse<ListDataSourceResponse>> {
212 let mut api_req = ApiRequest {
213 http_method: Method::GET,
214 api_path: crate::core::endpoints::search::SEARCH_V2_DATA_SOURCES.to_string(),
215 supported_access_token_types: vec![AccessTokenType::Tenant, AccessTokenType::User],
216 ..Default::default()
217 };
218
219 if let Some(req) = request {
221 if let Some(page_size) = req.page_size {
222 api_req
223 .query_params
224 .insert("page_size", page_size.to_string());
225 }
226 if let Some(page_token) = req.page_token {
227 api_req.query_params.insert("page_token", page_token);
228 }
229 }
230
231 Transport::request(api_req, &self.config, option).await
232 }
233}
234
235impl Service for DataSourceService {
236 fn config(&self) -> &Config {
237 &self.config
238 }
239
240 fn service_name() -> &'static str {
241 "data_source"
242 }
243
244 fn service_version() -> &'static str {
245 "v2"
246 }
247}