nile_client_rs/apis/
workspaces_api.rs

1/*
2 * Nile API
3 *
4 * Making SaaS chill.
5 *
6 * The version of the OpenAPI document: 0.1.0-fdd7cd5
7 * Contact: support@thenile.dev
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::ResponseContent;
15use serde::{Deserialize, Serialize};
16
17/// struct for typed errors of method [`create_access_token`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum CreateAccessTokenError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`create_workspace`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum CreateWorkspaceError {
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`delete_access_token`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum DeleteAccessTokenError {
35    UnknownValue(serde_json::Value),
36}
37
38/// struct for typed errors of method [`get_access_token`]
39#[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/// struct for typed errors of method [`get_workspace_open_api`]
48#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(untagged)]
50pub enum GetWorkspaceOpenApiError {
51    Status401(crate::models::Error),
52    UnknownValue(serde_json::Value),
53}
54
55/// struct for typed errors of method [`list_access_tokens`]
56#[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/// struct for typed errors of method [`list_workspaces`]
65#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum ListWorkspacesError {
68    UnknownValue(serde_json::Value),
69}
70
71/// struct for typed errors of method [`update_access_token`]
72#[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
80/// Create a workspace token. Workspace tokens have authorization to perform most actions within a workspace.
81pub 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
162/// Delete a workspace access token. Any users or services using this token will no longer be able to access the workspace.
163pub 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
206/// Get information about a workspace access token.
207pub 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
291/// List all workspace access tokens.
292pub 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
369/// Update a workspace access token.
370pub 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}