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