1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum GetFileError {
22 Status400(crate::models::AppError),
23 Status401(crate::models::AppError),
24 Status403(crate::models::AppError),
25 Status404(crate::models::AppError),
26 Status501(crate::models::AppError),
27 UnknownValue(serde_json::Value),
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum GetFileInfoError {
34 Status400(crate::models::AppError),
35 Status401(crate::models::AppError),
36 Status403(crate::models::AppError),
37 Status404(crate::models::AppError),
38 Status501(crate::models::AppError),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum GetFileLinkError {
46 Status400(crate::models::AppError),
47 Status401(crate::models::AppError),
48 Status403(crate::models::AppError),
49 Status404(crate::models::AppError),
50 Status501(crate::models::AppError),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum GetFilePreviewError {
58 Status400(crate::models::AppError),
59 Status401(crate::models::AppError),
60 Status403(crate::models::AppError),
61 Status404(crate::models::AppError),
62 Status501(crate::models::AppError),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum GetFilePublicError {
70 Status400(crate::models::AppError),
71 Status401(crate::models::AppError),
72 Status403(crate::models::AppError),
73 Status404(crate::models::AppError),
74 Status501(crate::models::AppError),
75 UnknownValue(serde_json::Value),
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
80#[serde(untagged)]
81pub enum GetFileThumbnailError {
82 Status400(crate::models::AppError),
83 Status401(crate::models::AppError),
84 Status403(crate::models::AppError),
85 Status404(crate::models::AppError),
86 Status501(crate::models::AppError),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum SearchFilesError {
94 Status400(crate::models::AppError),
95 Status401(crate::models::AppError),
96 Status403(crate::models::AppError),
97 UnknownValue(serde_json::Value),
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum UploadFileError {
104 Status400(crate::models::AppError),
105 Status401(crate::models::AppError),
106 Status403(crate::models::AppError),
107 Status413(crate::models::AppError),
108 Status501(crate::models::AppError),
109 UnknownValue(serde_json::Value),
110}
111
112
113pub async fn get_file(configuration: &configuration::Configuration, file_id: &str) -> Result<(), Error<GetFileError>> {
115 let local_var_configuration = configuration;
116
117 let local_var_client = &local_var_configuration.client;
118
119 let local_var_uri_str = format!("{}/files/{file_id}", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
120 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
121
122 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
123 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
124 }
125 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
126 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
127 };
128
129 let local_var_req = local_var_req_builder.build()?;
130 let local_var_resp = local_var_client.execute(local_var_req).await?;
131
132 let local_var_status = local_var_resp.status();
133 let local_var_content = local_var_resp.text().await?;
134
135 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
136 Ok(())
137 } else {
138 let local_var_entity: Option<GetFileError> = serde_json::from_str(&local_var_content).ok();
139 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
140 Err(Error::ResponseError(local_var_error))
141 }
142}
143
144pub async fn get_file_info(configuration: &configuration::Configuration, file_id: &str) -> Result<crate::models::FileInfo, Error<GetFileInfoError>> {
146 let local_var_configuration = configuration;
147
148 let local_var_client = &local_var_configuration.client;
149
150 let local_var_uri_str = format!("{}/files/{file_id}/info", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
151 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
152
153 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
154 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
155 }
156 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
157 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
158 };
159
160 let local_var_req = local_var_req_builder.build()?;
161 let local_var_resp = local_var_client.execute(local_var_req).await?;
162
163 let local_var_status = local_var_resp.status();
164 let local_var_content = local_var_resp.text().await?;
165
166 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
167 serde_json::from_str(&local_var_content).map_err(Error::from)
168 } else {
169 let local_var_entity: Option<GetFileInfoError> = serde_json::from_str(&local_var_content).ok();
170 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
171 Err(Error::ResponseError(local_var_error))
172 }
173}
174
175pub async fn get_file_link(configuration: &configuration::Configuration, file_id: &str) -> Result<crate::models::GetFileLink200Response, Error<GetFileLinkError>> {
177 let local_var_configuration = configuration;
178
179 let local_var_client = &local_var_configuration.client;
180
181 let local_var_uri_str = format!("{}/files/{file_id}/link", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
182 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
183
184 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
185 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
186 }
187 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
188 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
189 };
190
191 let local_var_req = local_var_req_builder.build()?;
192 let local_var_resp = local_var_client.execute(local_var_req).await?;
193
194 let local_var_status = local_var_resp.status();
195 let local_var_content = local_var_resp.text().await?;
196
197 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
198 serde_json::from_str(&local_var_content).map_err(Error::from)
199 } else {
200 let local_var_entity: Option<GetFileLinkError> = serde_json::from_str(&local_var_content).ok();
201 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
202 Err(Error::ResponseError(local_var_error))
203 }
204}
205
206pub async fn get_file_preview(configuration: &configuration::Configuration, file_id: &str) -> Result<(), Error<GetFilePreviewError>> {
208 let local_var_configuration = configuration;
209
210 let local_var_client = &local_var_configuration.client;
211
212 let local_var_uri_str = format!("{}/files/{file_id}/preview", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
213 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
214
215 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
216 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
217 }
218 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
219 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
220 };
221
222 let local_var_req = local_var_req_builder.build()?;
223 let local_var_resp = local_var_client.execute(local_var_req).await?;
224
225 let local_var_status = local_var_resp.status();
226 let local_var_content = local_var_resp.text().await?;
227
228 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
229 Ok(())
230 } else {
231 let local_var_entity: Option<GetFilePreviewError> = serde_json::from_str(&local_var_content).ok();
232 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
233 Err(Error::ResponseError(local_var_error))
234 }
235}
236
237pub async fn get_file_public(configuration: &configuration::Configuration, file_id: &str, h: &str) -> Result<(), Error<GetFilePublicError>> {
239 let local_var_configuration = configuration;
240
241 let local_var_client = &local_var_configuration.client;
242
243 let local_var_uri_str = format!("{}/files/{file_id}/public", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
244 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
245
246 local_var_req_builder = local_var_req_builder.query(&[("h", &h.to_string())]);
247 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
248 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
249 }
250 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
251 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
252 };
253
254 let local_var_req = local_var_req_builder.build()?;
255 let local_var_resp = local_var_client.execute(local_var_req).await?;
256
257 let local_var_status = local_var_resp.status();
258 let local_var_content = local_var_resp.text().await?;
259
260 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
261 Ok(())
262 } else {
263 let local_var_entity: Option<GetFilePublicError> = serde_json::from_str(&local_var_content).ok();
264 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
265 Err(Error::ResponseError(local_var_error))
266 }
267}
268
269pub async fn get_file_thumbnail(configuration: &configuration::Configuration, file_id: &str) -> Result<(), Error<GetFileThumbnailError>> {
271 let local_var_configuration = configuration;
272
273 let local_var_client = &local_var_configuration.client;
274
275 let local_var_uri_str = format!("{}/files/{file_id}/thumbnail", local_var_configuration.base_path, file_id=crate::apis::urlencode(file_id));
276 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
277
278 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
279 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
280 }
281 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
282 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
283 };
284
285 let local_var_req = local_var_req_builder.build()?;
286 let local_var_resp = local_var_client.execute(local_var_req).await?;
287
288 let local_var_status = local_var_resp.status();
289 let local_var_content = local_var_resp.text().await?;
290
291 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
292 Ok(())
293 } else {
294 let local_var_entity: Option<GetFileThumbnailError> = serde_json::from_str(&local_var_content).ok();
295 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
296 Err(Error::ResponseError(local_var_error))
297 }
298}
299
300pub async fn search_files(configuration: &configuration::Configuration, team_id: &str, terms: &str, is_or_search: bool, time_zone_offset: Option<i32>, include_deleted_channels: Option<bool>, page: Option<i32>, per_page: Option<i32>) -> Result<crate::models::FileInfoList, Error<SearchFilesError>> {
302 let local_var_configuration = configuration;
303
304 let local_var_client = &local_var_configuration.client;
305
306 let local_var_uri_str = format!("{}/teams/{team_id}/files/search", local_var_configuration.base_path, team_id=crate::apis::urlencode(team_id));
307 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
308
309 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
310 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
311 }
312 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
313 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
314 };
315 let mut local_var_form = reqwest::multipart::Form::new();
316 local_var_form = local_var_form.text("terms", terms.to_string());
317 local_var_form = local_var_form.text("is_or_search", is_or_search.to_string());
318 if let Some(local_var_param_value) = time_zone_offset {
319 local_var_form = local_var_form.text("time_zone_offset", local_var_param_value.to_string());
320 }
321 if let Some(local_var_param_value) = include_deleted_channels {
322 local_var_form = local_var_form.text("include_deleted_channels", local_var_param_value.to_string());
323 }
324 if let Some(local_var_param_value) = page {
325 local_var_form = local_var_form.text("page", local_var_param_value.to_string());
326 }
327 if let Some(local_var_param_value) = per_page {
328 local_var_form = local_var_form.text("per_page", local_var_param_value.to_string());
329 }
330 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
331
332 let local_var_req = local_var_req_builder.build()?;
333 let local_var_resp = local_var_client.execute(local_var_req).await?;
334
335 let local_var_status = local_var_resp.status();
336 let local_var_content = local_var_resp.text().await?;
337
338 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
339 serde_json::from_str(&local_var_content).map_err(Error::from)
340 } else {
341 let local_var_entity: Option<SearchFilesError> = serde_json::from_str(&local_var_content).ok();
342 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
343 Err(Error::ResponseError(local_var_error))
344 }
345}
346
347pub async fn upload_file(configuration: &configuration::Configuration, channel_id: Option<&str>, filename: Option<&str>, files: Option<std::path::PathBuf>, channel_id2: Option<&str>, client_ids: Option<&str>) -> Result<crate::models::UploadFile201Response, Error<UploadFileError>> {
349 let local_var_configuration = configuration;
350
351 let local_var_client = &local_var_configuration.client;
352
353 let local_var_uri_str = format!("{}/files", local_var_configuration.base_path);
354 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
355
356 if let Some(ref local_var_str) = channel_id {
357 local_var_req_builder = local_var_req_builder.query(&[("channel_id", &local_var_str.to_string())]);
358 }
359 if let Some(ref local_var_str) = filename {
360 local_var_req_builder = local_var_req_builder.query(&[("filename", &local_var_str.to_string())]);
361 }
362 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
363 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
364 }
365 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
366 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
367 };
368 let mut local_var_form = reqwest::multipart::Form::new();
369 if let Some(local_var_param_value) = channel_id2 {
371 local_var_form = local_var_form.text("channel_id", local_var_param_value.to_string());
372 }
373 if let Some(local_var_param_value) = client_ids {
374 local_var_form = local_var_form.text("client_ids", local_var_param_value.to_string());
375 }
376 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
377
378 let local_var_req = local_var_req_builder.build()?;
379 let local_var_resp = local_var_client.execute(local_var_req).await?;
380
381 let local_var_status = local_var_resp.status();
382 let local_var_content = local_var_resp.text().await?;
383
384 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
385 serde_json::from_str(&local_var_content).map_err(Error::from)
386 } else {
387 let local_var_entity: Option<UploadFileError> = serde_json::from_str(&local_var_content).ok();
388 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
389 Err(Error::ResponseError(local_var_error))
390 }
391}
392