1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum CreateVariableError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum DeleteVariableError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum EncryptValueError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum ExistsVariableError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum GetVariableError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum GetVariableValueError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum ListContextualVariablesError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum ListVariableError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum UpdateVariableError {
78 UnknownValue(serde_json::Value),
79}
80
81
82pub async fn create_variable(configuration: &configuration::Configuration, workspace: &str, create_variable: models::CreateVariable, already_encrypted: Option<bool>) -> Result<String, Error<CreateVariableError>> {
83 let local_var_configuration = configuration;
84
85 let local_var_client = &local_var_configuration.client;
86
87 let local_var_uri_str = format!("{}/w/{workspace}/variables/create", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
88 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
89
90 if let Some(ref local_var_str) = already_encrypted {
91 local_var_req_builder = local_var_req_builder.query(&[("already_encrypted", &local_var_str.to_string())]);
92 }
93 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
94 local_var_req_builder = 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.bearer_access_token {
97 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
98 };
99 local_var_req_builder = local_var_req_builder.json(&create_variable);
100
101 let local_var_req = local_var_req_builder.build()?;
102 let local_var_resp = local_var_client.execute(local_var_req).await?;
103
104 let local_var_status = local_var_resp.status();
105 let local_var_content = local_var_resp.text().await?;
106
107 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
108 crate::from_str_patched(&local_var_content).map_err(Error::from)
109 } else {
110 let local_var_entity: Option<CreateVariableError> = crate::from_str_patched(&local_var_content).ok();
111 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
112 Err(Error::ResponseError(local_var_error))
113 }
114}
115
116pub async fn delete_variable(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<String, Error<DeleteVariableError>> {
117 let local_var_configuration = configuration;
118
119 let local_var_client = &local_var_configuration.client;
120
121 let local_var_uri_str = format!("{}/w/{workspace}/variables/delete/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
122 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
123
124 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
125 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
126 }
127 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
128 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
129 };
130
131 let local_var_req = local_var_req_builder.build()?;
132 let local_var_resp = local_var_client.execute(local_var_req).await?;
133
134 let local_var_status = local_var_resp.status();
135 let local_var_content = local_var_resp.text().await?;
136
137 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
138 crate::from_str_patched(&local_var_content).map_err(Error::from)
139 } else {
140 let local_var_entity: Option<DeleteVariableError> = crate::from_str_patched(&local_var_content).ok();
141 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
142 Err(Error::ResponseError(local_var_error))
143 }
144}
145
146pub async fn encrypt_value(configuration: &configuration::Configuration, workspace: &str, body: &str) -> Result<String, Error<EncryptValueError>> {
147 let local_var_configuration = configuration;
148
149 let local_var_client = &local_var_configuration.client;
150
151 let local_var_uri_str = format!("{}/w/{workspace}/variables/encrypt", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
152 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
153
154 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
155 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
156 }
157 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
158 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
159 };
160 local_var_req_builder = local_var_req_builder.json(&body);
161
162 let local_var_req = local_var_req_builder.build()?;
163 let local_var_resp = local_var_client.execute(local_var_req).await?;
164
165 let local_var_status = local_var_resp.status();
166 let local_var_content = local_var_resp.text().await?;
167
168 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
169 crate::from_str_patched(&local_var_content).map_err(Error::from)
170 } else {
171 let local_var_entity: Option<EncryptValueError> = crate::from_str_patched(&local_var_content).ok();
172 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
173 Err(Error::ResponseError(local_var_error))
174 }
175}
176
177pub async fn exists_variable(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<bool, Error<ExistsVariableError>> {
178 let local_var_configuration = configuration;
179
180 let local_var_client = &local_var_configuration.client;
181
182 let local_var_uri_str = format!("{}/w/{workspace}/variables/exists/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
183 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
184
185 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
186 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
187 }
188 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
189 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
190 };
191
192 let local_var_req = local_var_req_builder.build()?;
193 let local_var_resp = local_var_client.execute(local_var_req).await?;
194
195 let local_var_status = local_var_resp.status();
196 let local_var_content = local_var_resp.text().await?;
197
198 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
199 crate::from_str_patched(&local_var_content).map_err(Error::from)
200 } else {
201 let local_var_entity: Option<ExistsVariableError> = crate::from_str_patched(&local_var_content).ok();
202 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
203 Err(Error::ResponseError(local_var_error))
204 }
205}
206
207pub async fn get_variable(configuration: &configuration::Configuration, workspace: &str, path: &str, decrypt_secret: Option<bool>, include_encrypted: Option<bool>) -> Result<models::ListableVariable, Error<GetVariableError>> {
208 let local_var_configuration = configuration;
209
210 let local_var_client = &local_var_configuration.client;
211
212 let local_var_uri_str = format!("{}/w/{workspace}/variables/get/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
213 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
214
215 if let Some(ref local_var_str) = decrypt_secret {
216 local_var_req_builder = local_var_req_builder.query(&[("decrypt_secret", &local_var_str.to_string())]);
217 }
218 if let Some(ref local_var_str) = include_encrypted {
219 local_var_req_builder = local_var_req_builder.query(&[("include_encrypted", &local_var_str.to_string())]);
220 }
221 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
222 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
223 }
224 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
225 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
226 };
227
228 let local_var_req = local_var_req_builder.build()?;
229 let local_var_resp = local_var_client.execute(local_var_req).await?;
230
231 let local_var_status = local_var_resp.status();
232 let local_var_content = local_var_resp.text().await?;
233
234 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
235 crate::from_str_patched(&local_var_content).map_err(Error::from)
236 } else {
237 let local_var_entity: Option<GetVariableError> = crate::from_str_patched(&local_var_content).ok();
238 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
239 Err(Error::ResponseError(local_var_error))
240 }
241}
242
243pub async fn get_variable_value(configuration: &configuration::Configuration, workspace: &str, path: &str, allow_cache: Option<bool>) -> Result<String, Error<GetVariableValueError>> {
244 let local_var_configuration = configuration;
245
246 let local_var_client = &local_var_configuration.client;
247
248 let local_var_uri_str = format!("{}/w/{workspace}/variables/get_value/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
249 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
250
251 if let Some(ref local_var_str) = allow_cache {
252 local_var_req_builder = local_var_req_builder.query(&[("allow_cache", &local_var_str.to_string())]);
253 }
254 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
255 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
256 }
257 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
258 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
259 };
260
261 let local_var_req = local_var_req_builder.build()?;
262 let local_var_resp = local_var_client.execute(local_var_req).await?;
263
264 let local_var_status = local_var_resp.status();
265 let local_var_content = local_var_resp.text().await?;
266
267 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
268 crate::from_str_patched(&local_var_content).map_err(Error::from)
269 } else {
270 let local_var_entity: Option<GetVariableValueError> = crate::from_str_patched(&local_var_content).ok();
271 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
272 Err(Error::ResponseError(local_var_error))
273 }
274}
275
276pub async fn list_contextual_variables(configuration: &configuration::Configuration, workspace: &str) -> Result<Vec<models::ContextualVariable>, Error<ListContextualVariablesError>> {
277 let local_var_configuration = configuration;
278
279 let local_var_client = &local_var_configuration.client;
280
281 let local_var_uri_str = format!("{}/w/{workspace}/variables/list_contextual", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
282 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
283
284 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
285 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
286 }
287 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
288 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
289 };
290
291 let local_var_req = local_var_req_builder.build()?;
292 let local_var_resp = local_var_client.execute(local_var_req).await?;
293
294 let local_var_status = local_var_resp.status();
295 let local_var_content = local_var_resp.text().await?;
296
297 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
298 crate::from_str_patched(&local_var_content).map_err(Error::from)
299 } else {
300 let local_var_entity: Option<ListContextualVariablesError> = crate::from_str_patched(&local_var_content).ok();
301 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
302 Err(Error::ResponseError(local_var_error))
303 }
304}
305
306pub async fn list_variable(configuration: &configuration::Configuration, workspace: &str, path_start: Option<&str>, page: Option<i32>, per_page: Option<i32>) -> Result<Vec<models::ListableVariable>, Error<ListVariableError>> {
307 let local_var_configuration = configuration;
308
309 let local_var_client = &local_var_configuration.client;
310
311 let local_var_uri_str = format!("{}/w/{workspace}/variables/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
312 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
313
314 if let Some(ref local_var_str) = path_start {
315 local_var_req_builder = local_var_req_builder.query(&[("path_start", &local_var_str.to_string())]);
316 }
317 if let Some(ref local_var_str) = page {
318 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
319 }
320 if let Some(ref local_var_str) = per_page {
321 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
322 }
323 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
324 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
325 }
326 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
327 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
328 };
329
330 let local_var_req = local_var_req_builder.build()?;
331 let local_var_resp = local_var_client.execute(local_var_req).await?;
332
333 let local_var_status = local_var_resp.status();
334 let local_var_content = local_var_resp.text().await?;
335
336 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
337 crate::from_str_patched(&local_var_content).map_err(Error::from)
338 } else {
339 let local_var_entity: Option<ListVariableError> = crate::from_str_patched(&local_var_content).ok();
340 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
341 Err(Error::ResponseError(local_var_error))
342 }
343}
344
345pub async fn update_variable(configuration: &configuration::Configuration, workspace: &str, path: &str, edit_variable: models::EditVariable, already_encrypted: Option<bool>) -> Result<String, Error<UpdateVariableError>> {
346 let local_var_configuration = configuration;
347
348 let local_var_client = &local_var_configuration.client;
349
350 let local_var_uri_str = format!("{}/w/{workspace}/variables/update/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
351 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
352
353 if let Some(ref local_var_str) = already_encrypted {
354 local_var_req_builder = local_var_req_builder.query(&[("already_encrypted", &local_var_str.to_string())]);
355 }
356 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
357 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
358 }
359 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
360 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
361 };
362 local_var_req_builder = local_var_req_builder.json(&edit_variable);
363
364 let local_var_req = local_var_req_builder.build()?;
365 let local_var_resp = local_var_client.execute(local_var_req).await?;
366
367 let local_var_status = local_var_resp.status();
368 let local_var_content = local_var_resp.text().await?;
369
370 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
371 crate::from_str_patched(&local_var_content).map_err(Error::from)
372 } else {
373 let local_var_entity: Option<UpdateVariableError> = crate::from_str_patched(&local_var_content).ok();
374 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
375 Err(Error::ResponseError(local_var_error))
376 }
377}
378