bitwarden_api_api/apis/
secrets_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`organizations_organization_id_secrets_get`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum OrganizationsOrganizationIdSecretsGetError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`organizations_organization_id_secrets_post`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum OrganizationsOrganizationIdSecretsPostError {
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`organizations_organization_id_secrets_sync_get`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum OrganizationsOrganizationIdSecretsSyncGetError {
35    UnknownValue(serde_json::Value),
36}
37
38/// struct for typed errors of method [`projects_project_id_secrets_get`]
39#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum ProjectsProjectIdSecretsGetError {
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`secrets_delete_post`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum SecretsDeletePostError {
49    UnknownValue(serde_json::Value),
50}
51
52/// struct for typed errors of method [`secrets_get_by_ids_post`]
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum SecretsGetByIdsPostError {
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`secrets_id_get`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum SecretsIdGetError {
63    UnknownValue(serde_json::Value),
64}
65
66/// struct for typed errors of method [`secrets_id_put`]
67#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum SecretsIdPutError {
70    UnknownValue(serde_json::Value),
71}
72
73pub async fn organizations_organization_id_secrets_get(
74    configuration: &configuration::Configuration,
75    organization_id: uuid::Uuid,
76) -> Result<
77    models::SecretWithProjectsListResponseModel,
78    Error<OrganizationsOrganizationIdSecretsGetError>,
79> {
80    let local_var_configuration = configuration;
81
82    let local_var_client = &local_var_configuration.client;
83
84    let local_var_uri_str = format!(
85        "{}/organizations/{organizationId}/secrets",
86        local_var_configuration.base_path,
87        organizationId = crate::apis::urlencode(organization_id.to_string())
88    );
89    let mut local_var_req_builder =
90        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
91
92    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
93        local_var_req_builder =
94            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
95    }
96    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
97        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
98    };
99
100    let local_var_req = local_var_req_builder.build()?;
101    let local_var_resp = local_var_client.execute(local_var_req).await?;
102
103    let local_var_status = local_var_resp.status();
104    let local_var_content = local_var_resp.text().await?;
105
106    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
107        serde_json::from_str(&local_var_content).map_err(Error::from)
108    } else {
109        let local_var_entity: Option<OrganizationsOrganizationIdSecretsGetError> =
110            serde_json::from_str(&local_var_content).ok();
111        let local_var_error = ResponseContent {
112            status: local_var_status,
113            content: local_var_content,
114            entity: local_var_entity,
115        };
116        Err(Error::ResponseError(local_var_error))
117    }
118}
119
120pub async fn organizations_organization_id_secrets_post(
121    configuration: &configuration::Configuration,
122    organization_id: uuid::Uuid,
123    secret_create_request_model: Option<models::SecretCreateRequestModel>,
124) -> Result<models::SecretResponseModel, Error<OrganizationsOrganizationIdSecretsPostError>> {
125    let local_var_configuration = configuration;
126
127    let local_var_client = &local_var_configuration.client;
128
129    let local_var_uri_str = format!(
130        "{}/organizations/{organizationId}/secrets",
131        local_var_configuration.base_path,
132        organizationId = crate::apis::urlencode(organization_id.to_string())
133    );
134    let mut local_var_req_builder =
135        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
136
137    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
138        local_var_req_builder =
139            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
140    }
141    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
142        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
143    };
144    local_var_req_builder = local_var_req_builder.json(&secret_create_request_model);
145
146    let local_var_req = local_var_req_builder.build()?;
147    let local_var_resp = local_var_client.execute(local_var_req).await?;
148
149    let local_var_status = local_var_resp.status();
150    let local_var_content = local_var_resp.text().await?;
151
152    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
153        serde_json::from_str(&local_var_content).map_err(Error::from)
154    } else {
155        let local_var_entity: Option<OrganizationsOrganizationIdSecretsPostError> =
156            serde_json::from_str(&local_var_content).ok();
157        let local_var_error = ResponseContent {
158            status: local_var_status,
159            content: local_var_content,
160            entity: local_var_entity,
161        };
162        Err(Error::ResponseError(local_var_error))
163    }
164}
165
166pub async fn organizations_organization_id_secrets_sync_get(
167    configuration: &configuration::Configuration,
168    organization_id: uuid::Uuid,
169    last_synced_date: Option<String>,
170) -> Result<models::SecretsSyncResponseModel, Error<OrganizationsOrganizationIdSecretsSyncGetError>>
171{
172    let local_var_configuration = configuration;
173
174    let local_var_client = &local_var_configuration.client;
175
176    let local_var_uri_str = format!(
177        "{}/organizations/{organizationId}/secrets/sync",
178        local_var_configuration.base_path,
179        organizationId = crate::apis::urlencode(organization_id.to_string())
180    );
181    let mut local_var_req_builder =
182        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
183
184    if let Some(ref local_var_str) = last_synced_date {
185        local_var_req_builder =
186            local_var_req_builder.query(&[("lastSyncedDate", &local_var_str.to_string())]);
187    }
188    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
189        local_var_req_builder =
190            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
191    }
192    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
193        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
194    };
195
196    let local_var_req = local_var_req_builder.build()?;
197    let local_var_resp = local_var_client.execute(local_var_req).await?;
198
199    let local_var_status = local_var_resp.status();
200    let local_var_content = local_var_resp.text().await?;
201
202    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
203        serde_json::from_str(&local_var_content).map_err(Error::from)
204    } else {
205        let local_var_entity: Option<OrganizationsOrganizationIdSecretsSyncGetError> =
206            serde_json::from_str(&local_var_content).ok();
207        let local_var_error = ResponseContent {
208            status: local_var_status,
209            content: local_var_content,
210            entity: local_var_entity,
211        };
212        Err(Error::ResponseError(local_var_error))
213    }
214}
215
216pub async fn projects_project_id_secrets_get(
217    configuration: &configuration::Configuration,
218    project_id: uuid::Uuid,
219) -> Result<models::SecretWithProjectsListResponseModel, Error<ProjectsProjectIdSecretsGetError>> {
220    let local_var_configuration = configuration;
221
222    let local_var_client = &local_var_configuration.client;
223
224    let local_var_uri_str = format!(
225        "{}/projects/{projectId}/secrets",
226        local_var_configuration.base_path,
227        projectId = crate::apis::urlencode(project_id.to_string())
228    );
229    let mut local_var_req_builder =
230        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
231
232    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
233        local_var_req_builder =
234            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
235    }
236    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
237        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
238    };
239
240    let local_var_req = local_var_req_builder.build()?;
241    let local_var_resp = local_var_client.execute(local_var_req).await?;
242
243    let local_var_status = local_var_resp.status();
244    let local_var_content = local_var_resp.text().await?;
245
246    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
247        serde_json::from_str(&local_var_content).map_err(Error::from)
248    } else {
249        let local_var_entity: Option<ProjectsProjectIdSecretsGetError> =
250            serde_json::from_str(&local_var_content).ok();
251        let local_var_error = ResponseContent {
252            status: local_var_status,
253            content: local_var_content,
254            entity: local_var_entity,
255        };
256        Err(Error::ResponseError(local_var_error))
257    }
258}
259
260pub async fn secrets_delete_post(
261    configuration: &configuration::Configuration,
262    uuid_colon_colon_uuid: Option<Vec<uuid::Uuid>>,
263) -> Result<models::BulkDeleteResponseModelListResponseModel, Error<SecretsDeletePostError>> {
264    let local_var_configuration = configuration;
265
266    let local_var_client = &local_var_configuration.client;
267
268    let local_var_uri_str = format!("{}/secrets/delete", local_var_configuration.base_path);
269    let mut local_var_req_builder =
270        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
271
272    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
273        local_var_req_builder =
274            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
275    }
276    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
277        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
278    };
279    local_var_req_builder = local_var_req_builder.json(&uuid_colon_colon_uuid);
280
281    let local_var_req = local_var_req_builder.build()?;
282    let local_var_resp = local_var_client.execute(local_var_req).await?;
283
284    let local_var_status = local_var_resp.status();
285    let local_var_content = local_var_resp.text().await?;
286
287    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
288        serde_json::from_str(&local_var_content).map_err(Error::from)
289    } else {
290        let local_var_entity: Option<SecretsDeletePostError> =
291            serde_json::from_str(&local_var_content).ok();
292        let local_var_error = ResponseContent {
293            status: local_var_status,
294            content: local_var_content,
295            entity: local_var_entity,
296        };
297        Err(Error::ResponseError(local_var_error))
298    }
299}
300
301pub async fn secrets_get_by_ids_post(
302    configuration: &configuration::Configuration,
303    get_secrets_request_model: Option<models::GetSecretsRequestModel>,
304) -> Result<models::BaseSecretResponseModelListResponseModel, Error<SecretsGetByIdsPostError>> {
305    let local_var_configuration = configuration;
306
307    let local_var_client = &local_var_configuration.client;
308
309    let local_var_uri_str = format!("{}/secrets/get-by-ids", local_var_configuration.base_path);
310    let mut local_var_req_builder =
311        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
312
313    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
314        local_var_req_builder =
315            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
316    }
317    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
318        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
319    };
320    local_var_req_builder = local_var_req_builder.json(&get_secrets_request_model);
321
322    let local_var_req = local_var_req_builder.build()?;
323    let local_var_resp = local_var_client.execute(local_var_req).await?;
324
325    let local_var_status = local_var_resp.status();
326    let local_var_content = local_var_resp.text().await?;
327
328    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
329        serde_json::from_str(&local_var_content).map_err(Error::from)
330    } else {
331        let local_var_entity: Option<SecretsGetByIdsPostError> =
332            serde_json::from_str(&local_var_content).ok();
333        let local_var_error = ResponseContent {
334            status: local_var_status,
335            content: local_var_content,
336            entity: local_var_entity,
337        };
338        Err(Error::ResponseError(local_var_error))
339    }
340}
341
342pub async fn secrets_id_get(
343    configuration: &configuration::Configuration,
344    id: uuid::Uuid,
345) -> Result<models::SecretResponseModel, Error<SecretsIdGetError>> {
346    let local_var_configuration = configuration;
347
348    let local_var_client = &local_var_configuration.client;
349
350    let local_var_uri_str = format!(
351        "{}/secrets/{id}",
352        local_var_configuration.base_path,
353        id = crate::apis::urlencode(id.to_string())
354    );
355    let mut local_var_req_builder =
356        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
357
358    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
359        local_var_req_builder =
360            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
361    }
362    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
363        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
364    };
365
366    let local_var_req = local_var_req_builder.build()?;
367    let local_var_resp = local_var_client.execute(local_var_req).await?;
368
369    let local_var_status = local_var_resp.status();
370    let local_var_content = local_var_resp.text().await?;
371
372    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
373        serde_json::from_str(&local_var_content).map_err(Error::from)
374    } else {
375        let local_var_entity: Option<SecretsIdGetError> =
376            serde_json::from_str(&local_var_content).ok();
377        let local_var_error = ResponseContent {
378            status: local_var_status,
379            content: local_var_content,
380            entity: local_var_entity,
381        };
382        Err(Error::ResponseError(local_var_error))
383    }
384}
385
386pub async fn secrets_id_put(
387    configuration: &configuration::Configuration,
388    id: uuid::Uuid,
389    secret_update_request_model: Option<models::SecretUpdateRequestModel>,
390) -> Result<models::SecretResponseModel, Error<SecretsIdPutError>> {
391    let local_var_configuration = configuration;
392
393    let local_var_client = &local_var_configuration.client;
394
395    let local_var_uri_str = format!(
396        "{}/secrets/{id}",
397        local_var_configuration.base_path,
398        id = crate::apis::urlencode(id.to_string())
399    );
400    let mut local_var_req_builder =
401        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
402
403    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
404        local_var_req_builder =
405            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
406    }
407    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
408        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
409    };
410    local_var_req_builder = local_var_req_builder.json(&secret_update_request_model);
411
412    let local_var_req = local_var_req_builder.build()?;
413    let local_var_resp = local_var_client.execute(local_var_req).await?;
414
415    let local_var_status = local_var_resp.status();
416    let local_var_content = local_var_resp.text().await?;
417
418    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
419        serde_json::from_str(&local_var_content).map_err(Error::from)
420    } else {
421        let local_var_entity: Option<SecretsIdPutError> =
422            serde_json::from_str(&local_var_content).ok();
423        let local_var_error = ResponseContent {
424            status: local_var_status,
425            content: local_var_content,
426            entity: local_var_entity,
427        };
428        Err(Error::ResponseError(local_var_error))
429    }
430}