printnanny_api_client/apis/
workspaces_api.rs1use reqwest;
13
14use bytes::Bytes;
15use crate::apis::ResponseContent;
16use super::{Error, configuration};
17
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
21#[serde(untagged)]
22pub enum AssignPiToWorkspaceError {
23 Status409(crate::models::ErrorDetail),
24 Status400(crate::models::ErrorDetail),
25 Status401(crate::models::ErrorDetail),
26 Status403(crate::models::ErrorDetail),
27 Status500(crate::models::ErrorDetail),
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum WorkspacesCreateError {
35 Status409(crate::models::ErrorDetail),
36 Status400(crate::models::ErrorDetail),
37 Status401(crate::models::ErrorDetail),
38 Status403(crate::models::ErrorDetail),
39 Status500(crate::models::ErrorDetail),
40 UnknownValue(serde_json::Value),
41}
42
43#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(untagged)]
46pub enum WorkspacesCreateInviteError {
47 Status409(crate::models::ErrorDetail),
48 Status400(crate::models::ErrorDetail),
49 Status401(crate::models::ErrorDetail),
50 Status403(crate::models::ErrorDetail),
51 Status500(crate::models::ErrorDetail),
52 UnknownValue(serde_json::Value),
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum WorkspacesListError {
59 Status400(crate::models::ErrorDetail),
60 Status401(crate::models::ErrorDetail),
61 Status403(crate::models::ErrorDetail),
62 Status500(crate::models::ErrorDetail),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum WorkspacesPartialUpdateError {
70 Status409(crate::models::ErrorDetail),
71 Status400(crate::models::ErrorDetail),
72 Status401(crate::models::ErrorDetail),
73 Status403(crate::models::ErrorDetail),
74 Status500(crate::models::ErrorDetail),
75 UnknownValue(serde_json::Value),
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize)]
80#[serde(untagged)]
81pub enum WorkspacesRemindInviteError {
82 Status409(crate::models::ErrorDetail),
83 Status400(crate::models::ErrorDetail),
84 Status401(crate::models::ErrorDetail),
85 Status403(crate::models::ErrorDetail),
86 Status500(crate::models::ErrorDetail),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum WorkspacesRetrieveError {
94 Status404(crate::models::ErrorDetail),
95 Status400(crate::models::ErrorDetail),
96 Status401(crate::models::ErrorDetail),
97 Status403(crate::models::ErrorDetail),
98 Status500(crate::models::ErrorDetail),
99 UnknownValue(serde_json::Value),
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum WorkspacesUpdateError {
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum WorkspacesVerifyInviteError {
113 Status409(crate::models::ErrorDetail),
114 Status400(crate::models::ErrorDetail),
115 Status401(crate::models::ErrorDetail),
116 Status403(crate::models::ErrorDetail),
117 Status500(crate::models::ErrorDetail),
118 UnknownValue(serde_json::Value),
119}
120
121
122pub async fn assign_pi_to_workspace(configuration: &configuration::Configuration, pi_id: i32, workspace_id: i32) -> Result<crate::models::Pi, Error<AssignPiToWorkspaceError>> {
123 let local_var_configuration = configuration;
124
125 let local_var_client = &local_var_configuration.client;
126
127 let local_var_uri_str = format!("{}/api/pis/{pi_id}/assign-workspace/{workspace_id}/", local_var_configuration.base_path, pi_id=pi_id, workspace_id=workspace_id);
128 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
129
130 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
131 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
132 }
133 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
134 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
135 };
136
137 let local_var_req = local_var_req_builder.build()?;
138 let local_var_resp = local_var_client.execute(local_var_req).await?;
139
140 let local_var_status = local_var_resp.status();
141 let local_var_content = local_var_resp.text().await?;
142
143 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
144 serde_json::from_str(&local_var_content).map_err(Error::from)
145 } else {
146 let local_var_entity: Option<AssignPiToWorkspaceError> = serde_json::from_str(&local_var_content).ok();
147 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
148 Err(Error::ResponseError(local_var_error))
149 }
150}
151
152pub async fn workspaces_create(configuration: &configuration::Configuration, workspace_request: crate::models::WorkspaceRequest) -> Result<crate::models::Workspace, Error<WorkspacesCreateError>> {
153 let local_var_configuration = configuration;
154
155 let local_var_client = &local_var_configuration.client;
156
157 let local_var_uri_str = format!("{}/api/workspaces/", local_var_configuration.base_path);
158 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
159
160 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
161 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
162 }
163 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
164 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
165 };
166 local_var_req_builder = local_var_req_builder.json(&workspace_request);
167
168 let local_var_req = local_var_req_builder.build()?;
169 let local_var_resp = local_var_client.execute(local_var_req).await?;
170
171 let local_var_status = local_var_resp.status();
172 let local_var_content = local_var_resp.text().await?;
173
174 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
175 serde_json::from_str(&local_var_content).map_err(Error::from)
176 } else {
177 let local_var_entity: Option<WorkspacesCreateError> = serde_json::from_str(&local_var_content).ok();
178 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
179 Err(Error::ResponseError(local_var_error))
180 }
181}
182
183pub async fn workspaces_create_invite(configuration: &configuration::Configuration, workspace_invite_create_request: crate::models::WorkspaceInviteCreateRequest) -> Result<crate::models::WorkspaceInvite, Error<WorkspacesCreateInviteError>> {
184 let local_var_configuration = configuration;
185
186 let local_var_client = &local_var_configuration.client;
187
188 let local_var_uri_str = format!("{}/api/workspaces/invite/", local_var_configuration.base_path);
189 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
190
191 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
192 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
193 }
194 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
195 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
196 };
197 local_var_req_builder = local_var_req_builder.json(&workspace_invite_create_request);
198
199 let local_var_req = local_var_req_builder.build()?;
200 let local_var_resp = local_var_client.execute(local_var_req).await?;
201
202 let local_var_status = local_var_resp.status();
203 let local_var_content = local_var_resp.text().await?;
204
205 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
206 serde_json::from_str(&local_var_content).map_err(Error::from)
207 } else {
208 let local_var_entity: Option<WorkspacesCreateInviteError> = serde_json::from_str(&local_var_content).ok();
209 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
210 Err(Error::ResponseError(local_var_error))
211 }
212}
213
214pub async fn workspaces_list(configuration: &configuration::Configuration, page: Option<i32>) -> Result<crate::models::PaginatedWorkspaceList, Error<WorkspacesListError>> {
215 let local_var_configuration = configuration;
216
217 let local_var_client = &local_var_configuration.client;
218
219 let local_var_uri_str = format!("{}/api/workspaces/", local_var_configuration.base_path);
220 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
221
222 if let Some(ref local_var_str) = page {
223 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
224 }
225 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
226 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
227 }
228 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
229 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
230 };
231
232 let local_var_req = local_var_req_builder.build()?;
233 let local_var_resp = local_var_client.execute(local_var_req).await?;
234
235 let local_var_status = local_var_resp.status();
236 let local_var_content = local_var_resp.text().await?;
237
238 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
239 serde_json::from_str(&local_var_content).map_err(Error::from)
240 } else {
241 let local_var_entity: Option<WorkspacesListError> = serde_json::from_str(&local_var_content).ok();
242 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
243 Err(Error::ResponseError(local_var_error))
244 }
245}
246
247pub async fn workspaces_partial_update(configuration: &configuration::Configuration, id: i32, page: Option<i32>, patched_workspace_request: Option<crate::models::PatchedWorkspaceRequest>) -> Result<crate::models::PaginatedWorkspaceList, Error<WorkspacesPartialUpdateError>> {
248 let local_var_configuration = configuration;
249
250 let local_var_client = &local_var_configuration.client;
251
252 let local_var_uri_str = format!("{}/api/workspaces/{id}/", local_var_configuration.base_path, id=id);
253 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
254
255 if let Some(ref local_var_str) = page {
256 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
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 local_var_req_builder = local_var_req_builder.json(&patched_workspace_request);
265
266 let local_var_req = local_var_req_builder.build()?;
267 let local_var_resp = local_var_client.execute(local_var_req).await?;
268
269 let local_var_status = local_var_resp.status();
270 let local_var_content = local_var_resp.text().await?;
271
272 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
273 serde_json::from_str(&local_var_content).map_err(Error::from)
274 } else {
275 let local_var_entity: Option<WorkspacesPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
276 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
277 Err(Error::ResponseError(local_var_error))
278 }
279}
280
281pub async fn workspaces_remind_invite(configuration: &configuration::Configuration, workspace_invite_remind_request: crate::models::WorkspaceInviteRemindRequest) -> Result<crate::models::WorkspaceInvite, Error<WorkspacesRemindInviteError>> {
282 let local_var_configuration = configuration;
283
284 let local_var_client = &local_var_configuration.client;
285
286 let local_var_uri_str = format!("{}/api/workspaces/remind/", local_var_configuration.base_path);
287 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
288
289 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
290 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
291 }
292 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
293 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
294 };
295 local_var_req_builder = local_var_req_builder.json(&workspace_invite_remind_request);
296
297 let local_var_req = local_var_req_builder.build()?;
298 let local_var_resp = local_var_client.execute(local_var_req).await?;
299
300 let local_var_status = local_var_resp.status();
301 let local_var_content = local_var_resp.text().await?;
302
303 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
304 serde_json::from_str(&local_var_content).map_err(Error::from)
305 } else {
306 let local_var_entity: Option<WorkspacesRemindInviteError> = serde_json::from_str(&local_var_content).ok();
307 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
308 Err(Error::ResponseError(local_var_error))
309 }
310}
311
312pub async fn workspaces_retrieve(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::Workspace, Error<WorkspacesRetrieveError>> {
313 let local_var_configuration = configuration;
314
315 let local_var_client = &local_var_configuration.client;
316
317 let local_var_uri_str = format!("{}/api/workspaces/{id}/", local_var_configuration.base_path, id=id);
318 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
319
320 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
321 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
322 }
323 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
324 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
325 };
326
327 let local_var_req = local_var_req_builder.build()?;
328 let local_var_resp = local_var_client.execute(local_var_req).await?;
329
330 let local_var_status = local_var_resp.status();
331 let local_var_content = local_var_resp.text().await?;
332
333 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
334 serde_json::from_str(&local_var_content).map_err(Error::from)
335 } else {
336 let local_var_entity: Option<WorkspacesRetrieveError> = serde_json::from_str(&local_var_content).ok();
337 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
338 Err(Error::ResponseError(local_var_error))
339 }
340}
341
342pub async fn workspaces_update(configuration: &configuration::Configuration, id: i32, workspace_request: crate::models::WorkspaceRequest) -> Result<crate::models::Workspace, Error<WorkspacesUpdateError>> {
343 let local_var_configuration = configuration;
344
345 let local_var_client = &local_var_configuration.client;
346
347 let local_var_uri_str = format!("{}/api/workspaces/{id}/", local_var_configuration.base_path, id=id);
348 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
349
350 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
351 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
352 }
353 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
354 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
355 };
356 local_var_req_builder = local_var_req_builder.json(&workspace_request);
357
358 let local_var_req = local_var_req_builder.build()?;
359 let local_var_resp = local_var_client.execute(local_var_req).await?;
360
361 let local_var_status = local_var_resp.status();
362 let local_var_content = local_var_resp.text().await?;
363
364 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
365 serde_json::from_str(&local_var_content).map_err(Error::from)
366 } else {
367 let local_var_entity: Option<WorkspacesUpdateError> = serde_json::from_str(&local_var_content).ok();
368 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
369 Err(Error::ResponseError(local_var_error))
370 }
371}
372
373pub async fn workspaces_verify_invite(configuration: &configuration::Configuration, workspace_invite_verify_request: crate::models::WorkspaceInviteVerifyRequest) -> Result<crate::models::WorkspaceInvite, Error<WorkspacesVerifyInviteError>> {
374 let local_var_configuration = configuration;
375
376 let local_var_client = &local_var_configuration.client;
377
378 let local_var_uri_str = format!("{}/api/workspace-invites/verify/", local_var_configuration.base_path);
379 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
380
381 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
382 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
383 }
384 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
385 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
386 };
387 local_var_req_builder = local_var_req_builder.json(&workspace_invite_verify_request);
388
389 let local_var_req = local_var_req_builder.build()?;
390 let local_var_resp = local_var_client.execute(local_var_req).await?;
391
392 let local_var_status = local_var_resp.status();
393 let local_var_content = local_var_resp.text().await?;
394
395 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
396 serde_json::from_str(&local_var_content).map_err(Error::from)
397 } else {
398 let local_var_entity: Option<WorkspacesVerifyInviteError> = serde_json::from_str(&local_var_content).ok();
399 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
400 Err(Error::ResponseError(local_var_error))
401 }
402}
403