1use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum OrganizationsOrganizationIdSecretsGetError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum OrganizationsOrganizationIdSecretsPostError {
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum OrganizationsOrganizationIdSecretsSyncGetError {
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum ProjectsProjectIdSecretsGetError {
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum SecretsDeletePostError {
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum SecretsGetByIdsPostError {
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum SecretsIdGetError {
63 UnknownValue(serde_json::Value),
64}
65
66#[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}