1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum CronWorkflowServiceCreateCronWorkflowError {
22 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum CronWorkflowServiceDeleteCronWorkflowError {
30 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum CronWorkflowServiceGetCronWorkflowError {
38 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum CronWorkflowServiceLintCronWorkflowError {
46 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum CronWorkflowServiceListCronWorkflowsError {
54 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum CronWorkflowServiceResumeCronWorkflowError {
62 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum CronWorkflowServiceSuspendCronWorkflowError {
70 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum CronWorkflowServiceUpdateCronWorkflowError {
78 DefaultResponse(crate::models::GrpcPeriodGatewayPeriodRuntimePeriodError),
79 UnknownValue(serde_json::Value),
80}
81
82
83pub async fn cron_workflow_service_create_cron_workflow(configuration: &configuration::Configuration, namespace: &str, body: crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCreateCronWorkflowRequest) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceCreateCronWorkflowError>> {
84 let local_var_configuration = configuration;
85
86 let local_var_client = &local_var_configuration.client;
87
88 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace));
89 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
90
91 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
92 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
93 }
94 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
95 let local_var_key = local_var_apikey.key.clone();
96 let local_var_value = match local_var_apikey.prefix {
97 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
98 None => local_var_key,
99 };
100 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
101 };
102 local_var_req_builder = local_var_req_builder.json(&body);
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<CronWorkflowServiceCreateCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
114 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
115 Err(Error::ResponseError(local_var_error))
116 }
117}
118
119pub async fn cron_workflow_service_delete_cron_workflow(configuration: &configuration::Configuration, namespace: &str, name: &str, delete_options_period_grace_period_seconds: Option<&str>, delete_options_period_preconditions_period_uid: Option<&str>, delete_options_period_preconditions_period_resource_version: Option<&str>, delete_options_period_orphan_dependents: Option<bool>, delete_options_period_propagation_policy: Option<&str>, delete_options_period_dry_run: Option<Vec<String>>) -> Result<serde_json::Value, Error<CronWorkflowServiceDeleteCronWorkflowError>> {
120 let local_var_configuration = configuration;
121
122 let local_var_client = &local_var_configuration.client;
123
124 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/{name}", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace), name=crate::apis::urlencode(name));
125 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
126
127 if let Some(ref local_var_str) = delete_options_period_grace_period_seconds {
128 local_var_req_builder = local_var_req_builder.query(&[("deleteOptions.gracePeriodSeconds", &local_var_str.to_string())]);
129 }
130 if let Some(ref local_var_str) = delete_options_period_preconditions_period_uid {
131 local_var_req_builder = local_var_req_builder.query(&[("deleteOptions.preconditions.uid", &local_var_str.to_string())]);
132 }
133 if let Some(ref local_var_str) = delete_options_period_preconditions_period_resource_version {
134 local_var_req_builder = local_var_req_builder.query(&[("deleteOptions.preconditions.resourceVersion", &local_var_str.to_string())]);
135 }
136 if let Some(ref local_var_str) = delete_options_period_orphan_dependents {
137 local_var_req_builder = local_var_req_builder.query(&[("deleteOptions.orphanDependents", &local_var_str.to_string())]);
138 }
139 if let Some(ref local_var_str) = delete_options_period_propagation_policy {
140 local_var_req_builder = local_var_req_builder.query(&[("deleteOptions.propagationPolicy", &local_var_str.to_string())]);
141 }
142 if let Some(ref local_var_str) = delete_options_period_dry_run {
143 local_var_req_builder = match "multi" {
144 "multi" => local_var_req_builder.query(&local_var_str.into_iter().map(|p| ("deleteOptions.dryRun".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
145 _ => local_var_req_builder.query(&[("deleteOptions.dryRun", &local_var_str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
146 };
147 }
148 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
149 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
150 }
151 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
152 let local_var_key = local_var_apikey.key.clone();
153 let local_var_value = match local_var_apikey.prefix {
154 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
155 None => local_var_key,
156 };
157 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
158 };
159
160 let local_var_req = local_var_req_builder.build()?;
161 let local_var_resp = local_var_client.execute(local_var_req).await?;
162
163 let local_var_status = local_var_resp.status();
164 let local_var_content = local_var_resp.text().await?;
165
166 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
167 serde_json::from_str(&local_var_content).map_err(Error::from)
168 } else {
169 let local_var_entity: Option<CronWorkflowServiceDeleteCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
170 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
171 Err(Error::ResponseError(local_var_error))
172 }
173}
174
175pub async fn cron_workflow_service_get_cron_workflow(configuration: &configuration::Configuration, namespace: &str, name: &str, get_options_period_resource_version: Option<&str>) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceGetCronWorkflowError>> {
176 let local_var_configuration = configuration;
177
178 let local_var_client = &local_var_configuration.client;
179
180 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/{name}", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace), name=crate::apis::urlencode(name));
181 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
182
183 if let Some(ref local_var_str) = get_options_period_resource_version {
184 local_var_req_builder = local_var_req_builder.query(&[("getOptions.resourceVersion", &local_var_str.to_string())]);
185 }
186 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
187 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
188 }
189 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
190 let local_var_key = local_var_apikey.key.clone();
191 let local_var_value = match local_var_apikey.prefix {
192 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
193 None => local_var_key,
194 };
195 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
196 };
197
198 let local_var_req = local_var_req_builder.build()?;
199 let local_var_resp = local_var_client.execute(local_var_req).await?;
200
201 let local_var_status = local_var_resp.status();
202 let local_var_content = local_var_resp.text().await?;
203
204 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
205 serde_json::from_str(&local_var_content).map_err(Error::from)
206 } else {
207 let local_var_entity: Option<CronWorkflowServiceGetCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
208 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
209 Err(Error::ResponseError(local_var_error))
210 }
211}
212
213pub async fn cron_workflow_service_lint_cron_workflow(configuration: &configuration::Configuration, namespace: &str, body: crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodLintCronWorkflowRequest) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceLintCronWorkflowError>> {
214 let local_var_configuration = configuration;
215
216 let local_var_client = &local_var_configuration.client;
217
218 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/lint", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace));
219 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
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_apikey) = local_var_configuration.api_key {
225 let local_var_key = local_var_apikey.key.clone();
226 let local_var_value = match local_var_apikey.prefix {
227 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
228 None => local_var_key,
229 };
230 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
231 };
232 local_var_req_builder = local_var_req_builder.json(&body);
233
234 let local_var_req = local_var_req_builder.build()?;
235 let local_var_resp = local_var_client.execute(local_var_req).await?;
236
237 let local_var_status = local_var_resp.status();
238 let local_var_content = local_var_resp.text().await?;
239
240 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
241 serde_json::from_str(&local_var_content).map_err(Error::from)
242 } else {
243 let local_var_entity: Option<CronWorkflowServiceLintCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
244 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
245 Err(Error::ResponseError(local_var_error))
246 }
247}
248
249pub async fn cron_workflow_service_list_cron_workflows(configuration: &configuration::Configuration, namespace: &str, list_options_period_label_selector: Option<&str>, list_options_period_field_selector: Option<&str>, list_options_period_watch: Option<bool>, list_options_period_allow_watch_bookmarks: Option<bool>, list_options_period_resource_version: Option<&str>, list_options_period_resource_version_match: Option<&str>, list_options_period_timeout_seconds: Option<&str>, list_options_period_limit: Option<&str>, list_options_period_continue: Option<&str>) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflowList, Error<CronWorkflowServiceListCronWorkflowsError>> {
250 let local_var_configuration = configuration;
251
252 let local_var_client = &local_var_configuration.client;
253
254 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace));
255 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
256
257 if let Some(ref local_var_str) = list_options_period_label_selector {
258 local_var_req_builder = local_var_req_builder.query(&[("listOptions.labelSelector", &local_var_str.to_string())]);
259 }
260 if let Some(ref local_var_str) = list_options_period_field_selector {
261 local_var_req_builder = local_var_req_builder.query(&[("listOptions.fieldSelector", &local_var_str.to_string())]);
262 }
263 if let Some(ref local_var_str) = list_options_period_watch {
264 local_var_req_builder = local_var_req_builder.query(&[("listOptions.watch", &local_var_str.to_string())]);
265 }
266 if let Some(ref local_var_str) = list_options_period_allow_watch_bookmarks {
267 local_var_req_builder = local_var_req_builder.query(&[("listOptions.allowWatchBookmarks", &local_var_str.to_string())]);
268 }
269 if let Some(ref local_var_str) = list_options_period_resource_version {
270 local_var_req_builder = local_var_req_builder.query(&[("listOptions.resourceVersion", &local_var_str.to_string())]);
271 }
272 if let Some(ref local_var_str) = list_options_period_resource_version_match {
273 local_var_req_builder = local_var_req_builder.query(&[("listOptions.resourceVersionMatch", &local_var_str.to_string())]);
274 }
275 if let Some(ref local_var_str) = list_options_period_timeout_seconds {
276 local_var_req_builder = local_var_req_builder.query(&[("listOptions.timeoutSeconds", &local_var_str.to_string())]);
277 }
278 if let Some(ref local_var_str) = list_options_period_limit {
279 local_var_req_builder = local_var_req_builder.query(&[("listOptions.limit", &local_var_str.to_string())]);
280 }
281 if let Some(ref local_var_str) = list_options_period_continue {
282 local_var_req_builder = local_var_req_builder.query(&[("listOptions.continue", &local_var_str.to_string())]);
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_apikey) = local_var_configuration.api_key {
288 let local_var_key = local_var_apikey.key.clone();
289 let local_var_value = match local_var_apikey.prefix {
290 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
291 None => local_var_key,
292 };
293 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
294 };
295
296 let local_var_req = local_var_req_builder.build()?;
297 let local_var_resp = local_var_client.execute(local_var_req).await?;
298
299 let local_var_status = local_var_resp.status();
300 let local_var_content = local_var_resp.text().await?;
301
302 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
303 serde_json::from_str(&local_var_content).map_err(Error::from)
304 } else {
305 let local_var_entity: Option<CronWorkflowServiceListCronWorkflowsError> = serde_json::from_str(&local_var_content).ok();
306 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
307 Err(Error::ResponseError(local_var_error))
308 }
309}
310
311pub async fn cron_workflow_service_resume_cron_workflow(configuration: &configuration::Configuration, namespace: &str, name: &str, body: crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflowResumeRequest) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceResumeCronWorkflowError>> {
312 let local_var_configuration = configuration;
313
314 let local_var_client = &local_var_configuration.client;
315
316 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/{name}/resume", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace), name=crate::apis::urlencode(name));
317 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
318
319 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
320 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
321 }
322 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
323 let local_var_key = local_var_apikey.key.clone();
324 let local_var_value = match local_var_apikey.prefix {
325 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
326 None => local_var_key,
327 };
328 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
329 };
330 local_var_req_builder = local_var_req_builder.json(&body);
331
332 let local_var_req = local_var_req_builder.build()?;
333 let local_var_resp = local_var_client.execute(local_var_req).await?;
334
335 let local_var_status = local_var_resp.status();
336 let local_var_content = local_var_resp.text().await?;
337
338 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
339 serde_json::from_str(&local_var_content).map_err(Error::from)
340 } else {
341 let local_var_entity: Option<CronWorkflowServiceResumeCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
342 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
343 Err(Error::ResponseError(local_var_error))
344 }
345}
346
347pub async fn cron_workflow_service_suspend_cron_workflow(configuration: &configuration::Configuration, namespace: &str, name: &str, body: crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflowSuspendRequest) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceSuspendCronWorkflowError>> {
348 let local_var_configuration = configuration;
349
350 let local_var_client = &local_var_configuration.client;
351
352 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/{name}/suspend", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace), name=crate::apis::urlencode(name));
353 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
354
355 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
356 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
357 }
358 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
359 let local_var_key = local_var_apikey.key.clone();
360 let local_var_value = match local_var_apikey.prefix {
361 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
362 None => local_var_key,
363 };
364 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
365 };
366 local_var_req_builder = local_var_req_builder.json(&body);
367
368 let local_var_req = local_var_req_builder.build()?;
369 let local_var_resp = local_var_client.execute(local_var_req).await?;
370
371 let local_var_status = local_var_resp.status();
372 let local_var_content = local_var_resp.text().await?;
373
374 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
375 serde_json::from_str(&local_var_content).map_err(Error::from)
376 } else {
377 let local_var_entity: Option<CronWorkflowServiceSuspendCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
378 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
379 Err(Error::ResponseError(local_var_error))
380 }
381}
382
383pub async fn cron_workflow_service_update_cron_workflow(configuration: &configuration::Configuration, namespace: &str, name: &str, body: crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodUpdateCronWorkflowRequest) -> Result<crate::models::IoPeriodArgoprojPeriodWorkflowPeriodV1alpha1PeriodCronWorkflow, Error<CronWorkflowServiceUpdateCronWorkflowError>> {
384 let local_var_configuration = configuration;
385
386 let local_var_client = &local_var_configuration.client;
387
388 let local_var_uri_str = format!("{}/api/v1/cron-workflows/{namespace}/{name}", local_var_configuration.base_path, namespace=crate::apis::urlencode(namespace), name=crate::apis::urlencode(name));
389 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
390
391 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
392 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
393 }
394 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
395 let local_var_key = local_var_apikey.key.clone();
396 let local_var_value = match local_var_apikey.prefix {
397 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
398 None => local_var_key,
399 };
400 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
401 };
402 local_var_req_builder = local_var_req_builder.json(&body);
403
404 let local_var_req = local_var_req_builder.build()?;
405 let local_var_resp = local_var_client.execute(local_var_req).await?;
406
407 let local_var_status = local_var_resp.status();
408 let local_var_content = local_var_resp.text().await?;
409
410 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
411 serde_json::from_str(&local_var_content).map_err(Error::from)
412 } else {
413 let local_var_entity: Option<CronWorkflowServiceUpdateCronWorkflowError> = serde_json::from_str(&local_var_content).ok();
414 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
415 Err(Error::ResponseError(local_var_error))
416 }
417}
418