1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ConnectCallbackError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum ConnectSlackCallbackError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum ConnectSlackCallbackInstanceError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum CreateAccountError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum DisconnectAccountError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum DisconnectSlackError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum DisconnectTeamsError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum GetOAuthConnectError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum ListOAuthConnectsError {
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum ListOAuthLoginsError {
85 UnknownValue(serde_json::Value),
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum RefreshTokenError {
92 UnknownValue(serde_json::Value),
93}
94
95
96pub async fn connect_callback(configuration: &configuration::Configuration, client_name: &str, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<models::TokenResponse, Error<ConnectCallbackError>> {
97 let local_var_configuration = configuration;
98
99 let local_var_client = &local_var_configuration.client;
100
101 let local_var_uri_str = format!("{}/oauth/connect_callback/{client_name}", local_var_configuration.base_path, client_name=crate::apis::urlencode(client_name));
102 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
103
104 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
105 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
106 }
107 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
108 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
109 };
110 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
111
112 let local_var_req = local_var_req_builder.build()?;
113 let local_var_resp = local_var_client.execute(local_var_req).await?;
114
115 let local_var_status = local_var_resp.status();
116 let local_var_content = local_var_resp.text().await?;
117
118 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
119 crate::from_str_patched(&local_var_content).map_err(Error::from)
120 } else {
121 let local_var_entity: Option<ConnectCallbackError> = crate::from_str_patched(&local_var_content).ok();
122 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
123 Err(Error::ResponseError(local_var_error))
124 }
125}
126
127pub async fn connect_slack_callback(configuration: &configuration::Configuration, workspace: &str, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<String, Error<ConnectSlackCallbackError>> {
128 let local_var_configuration = configuration;
129
130 let local_var_client = &local_var_configuration.client;
131
132 let local_var_uri_str = format!("{}/w/{workspace}/oauth/connect_slack_callback", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
133 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
134
135 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
136 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
137 }
138 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
139 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
140 };
141 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
142
143 let local_var_req = local_var_req_builder.build()?;
144 let local_var_resp = local_var_client.execute(local_var_req).await?;
145
146 let local_var_status = local_var_resp.status();
147 let local_var_content = local_var_resp.text().await?;
148
149 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
150 crate::from_str_patched(&local_var_content).map_err(Error::from)
151 } else {
152 let local_var_entity: Option<ConnectSlackCallbackError> = crate::from_str_patched(&local_var_content).ok();
153 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
154 Err(Error::ResponseError(local_var_error))
155 }
156}
157
158pub async fn connect_slack_callback_instance(configuration: &configuration::Configuration, connect_slack_callback_request: models::ConnectSlackCallbackRequest) -> Result<String, Error<ConnectSlackCallbackInstanceError>> {
159 let local_var_configuration = configuration;
160
161 let local_var_client = &local_var_configuration.client;
162
163 let local_var_uri_str = format!("{}/oauth/connect_slack_callback", local_var_configuration.base_path);
164 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
165
166 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
167 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
168 }
169 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
170 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
171 };
172 local_var_req_builder = local_var_req_builder.json(&connect_slack_callback_request);
173
174 let local_var_req = local_var_req_builder.build()?;
175 let local_var_resp = local_var_client.execute(local_var_req).await?;
176
177 let local_var_status = local_var_resp.status();
178 let local_var_content = local_var_resp.text().await?;
179
180 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
181 crate::from_str_patched(&local_var_content).map_err(Error::from)
182 } else {
183 let local_var_entity: Option<ConnectSlackCallbackInstanceError> = crate::from_str_patched(&local_var_content).ok();
184 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
185 Err(Error::ResponseError(local_var_error))
186 }
187}
188
189pub async fn create_account(configuration: &configuration::Configuration, workspace: &str, create_account_request: models::CreateAccountRequest) -> Result<String, Error<CreateAccountError>> {
190 let local_var_configuration = configuration;
191
192 let local_var_client = &local_var_configuration.client;
193
194 let local_var_uri_str = format!("{}/w/{workspace}/oauth/create_account", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
195 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
196
197 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
198 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
199 }
200 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
201 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
202 };
203 local_var_req_builder = local_var_req_builder.json(&create_account_request);
204
205 let local_var_req = local_var_req_builder.build()?;
206 let local_var_resp = local_var_client.execute(local_var_req).await?;
207
208 let local_var_status = local_var_resp.status();
209 let local_var_content = local_var_resp.text().await?;
210
211 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
212 crate::from_str_patched(&local_var_content).map_err(Error::from)
213 } else {
214 let local_var_entity: Option<CreateAccountError> = crate::from_str_patched(&local_var_content).ok();
215 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
216 Err(Error::ResponseError(local_var_error))
217 }
218}
219
220pub async fn disconnect_account(configuration: &configuration::Configuration, workspace: &str, id: i32) -> Result<String, Error<DisconnectAccountError>> {
221 let local_var_configuration = configuration;
222
223 let local_var_client = &local_var_configuration.client;
224
225 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=id);
226 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
227
228 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
229 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
230 }
231 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
232 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
233 };
234
235 let local_var_req = local_var_req_builder.build()?;
236 let local_var_resp = local_var_client.execute(local_var_req).await?;
237
238 let local_var_status = local_var_resp.status();
239 let local_var_content = local_var_resp.text().await?;
240
241 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
242 crate::from_str_patched(&local_var_content).map_err(Error::from)
243 } else {
244 let local_var_entity: Option<DisconnectAccountError> = crate::from_str_patched(&local_var_content).ok();
245 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
246 Err(Error::ResponseError(local_var_error))
247 }
248}
249
250pub async fn disconnect_slack(configuration: &configuration::Configuration, workspace: &str) -> Result<String, Error<DisconnectSlackError>> {
251 let local_var_configuration = configuration;
252
253 let local_var_client = &local_var_configuration.client;
254
255 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect_slack", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
256 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
257
258 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
259 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
260 }
261 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
262 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
263 };
264
265 let local_var_req = local_var_req_builder.build()?;
266 let local_var_resp = local_var_client.execute(local_var_req).await?;
267
268 let local_var_status = local_var_resp.status();
269 let local_var_content = local_var_resp.text().await?;
270
271 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
272 crate::from_str_patched(&local_var_content).map_err(Error::from)
273 } else {
274 let local_var_entity: Option<DisconnectSlackError> = crate::from_str_patched(&local_var_content).ok();
275 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
276 Err(Error::ResponseError(local_var_error))
277 }
278}
279
280pub async fn disconnect_teams(configuration: &configuration::Configuration, workspace: &str) -> Result<String, Error<DisconnectTeamsError>> {
281 let local_var_configuration = configuration;
282
283 let local_var_client = &local_var_configuration.client;
284
285 let local_var_uri_str = format!("{}/w/{workspace}/oauth/disconnect_teams", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
286 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
287
288 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
289 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
290 }
291 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
292 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
293 };
294
295 let local_var_req = local_var_req_builder.build()?;
296 let local_var_resp = local_var_client.execute(local_var_req).await?;
297
298 let local_var_status = local_var_resp.status();
299 let local_var_content = local_var_resp.text().await?;
300
301 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
302 crate::from_str_patched(&local_var_content).map_err(Error::from)
303 } else {
304 let local_var_entity: Option<DisconnectTeamsError> = crate::from_str_patched(&local_var_content).ok();
305 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
306 Err(Error::ResponseError(local_var_error))
307 }
308}
309
310pub async fn get_o_auth_connect(configuration: &configuration::Configuration, client: &str) -> Result<models::GetOAuthConnect200Response, Error<GetOAuthConnectError>> {
311 let local_var_configuration = configuration;
312
313 let local_var_client = &local_var_configuration.client;
314
315 let local_var_uri_str = format!("{}/oauth/get_connect/{client}", local_var_configuration.base_path, client=crate::apis::urlencode(client));
316 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
317
318 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
319 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
320 }
321 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
322 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
323 };
324
325 let local_var_req = local_var_req_builder.build()?;
326 let local_var_resp = local_var_client.execute(local_var_req).await?;
327
328 let local_var_status = local_var_resp.status();
329 let local_var_content = local_var_resp.text().await?;
330
331 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
332 crate::from_str_patched(&local_var_content).map_err(Error::from)
333 } else {
334 let local_var_entity: Option<GetOAuthConnectError> = crate::from_str_patched(&local_var_content).ok();
335 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
336 Err(Error::ResponseError(local_var_error))
337 }
338}
339
340pub async fn list_o_auth_connects(configuration: &configuration::Configuration, ) -> Result<Vec<String>, Error<ListOAuthConnectsError>> {
341 let local_var_configuration = configuration;
342
343 let local_var_client = &local_var_configuration.client;
344
345 let local_var_uri_str = format!("{}/oauth/list_connects", local_var_configuration.base_path);
346 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
347
348 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
349 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
350 }
351 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
352 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
353 };
354
355 let local_var_req = local_var_req_builder.build()?;
356 let local_var_resp = local_var_client.execute(local_var_req).await?;
357
358 let local_var_status = local_var_resp.status();
359 let local_var_content = local_var_resp.text().await?;
360
361 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
362 crate::from_str_patched(&local_var_content).map_err(Error::from)
363 } else {
364 let local_var_entity: Option<ListOAuthConnectsError> = crate::from_str_patched(&local_var_content).ok();
365 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
366 Err(Error::ResponseError(local_var_error))
367 }
368}
369
370pub async fn list_o_auth_logins(configuration: &configuration::Configuration, ) -> Result<models::ListOAuthLogins200Response, Error<ListOAuthLoginsError>> {
371 let local_var_configuration = configuration;
372
373 let local_var_client = &local_var_configuration.client;
374
375 let local_var_uri_str = format!("{}/oauth/list_logins", local_var_configuration.base_path);
376 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
377
378 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
379 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
380 }
381 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
382 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
383 };
384
385 let local_var_req = local_var_req_builder.build()?;
386 let local_var_resp = local_var_client.execute(local_var_req).await?;
387
388 let local_var_status = local_var_resp.status();
389 let local_var_content = local_var_resp.text().await?;
390
391 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
392 crate::from_str_patched(&local_var_content).map_err(Error::from)
393 } else {
394 let local_var_entity: Option<ListOAuthLoginsError> = crate::from_str_patched(&local_var_content).ok();
395 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
396 Err(Error::ResponseError(local_var_error))
397 }
398}
399
400pub async fn refresh_token(configuration: &configuration::Configuration, workspace: &str, id: i32, refresh_token_request: models::RefreshTokenRequest) -> Result<String, Error<RefreshTokenError>> {
401 let local_var_configuration = configuration;
402
403 let local_var_client = &local_var_configuration.client;
404
405 let local_var_uri_str = format!("{}/w/{workspace}/oauth/refresh_token/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=id);
406 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
407
408 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
409 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
410 }
411 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
412 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
413 };
414 local_var_req_builder = local_var_req_builder.json(&refresh_token_request);
415
416 let local_var_req = local_var_req_builder.build()?;
417 let local_var_resp = local_var_client.execute(local_var_req).await?;
418
419 let local_var_status = local_var_resp.status();
420 let local_var_content = local_var_resp.text().await?;
421
422 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
423 crate::from_str_patched(&local_var_content).map_err(Error::from)
424 } else {
425 let local_var_entity: Option<RefreshTokenError> = crate::from_str_patched(&local_var_content).ok();
426 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
427 Err(Error::ResponseError(local_var_error))
428 }
429}
430