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 BatchReRunJobsError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum CancelPersistentQueuedJobsError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum CancelQueuedJobError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum CancelSelectionError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum CancelSuspendedJobGetError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum CancelSuspendedJobPostError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum CountCompletedJobsError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum CountJobsByTagError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum CreateJobSignatureError {
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum DeleteCompletedJobError {
85 UnknownValue(serde_json::Value),
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum ForceCancelQueuedJobError {
92 UnknownValue(serde_json::Value),
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum GetCompletedCountError {
99 UnknownValue(serde_json::Value),
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum GetCompletedJobError {
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum GetCompletedJobResultError {
113 UnknownValue(serde_json::Value),
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum GetCompletedJobResultMaybeError {
120 UnknownValue(serde_json::Value),
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum GetDbClockError {
127 UnknownValue(serde_json::Value),
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum GetFlowDebugInfoError {
134 UnknownValue(serde_json::Value),
135}
136
137#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum GetFlowUserStateError {
141 UnknownValue(serde_json::Value),
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum GetJobError {
148 UnknownValue(serde_json::Value),
149}
150
151#[derive(Debug, Clone, Serialize, Deserialize)]
153#[serde(untagged)]
154pub enum GetJobArgsError {
155 UnknownValue(serde_json::Value),
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum GetJobLogsError {
162 UnknownValue(serde_json::Value),
163}
164
165#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(untagged)]
168pub enum GetJobUpdatesError {
169 UnknownValue(serde_json::Value),
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum GetJobUpdatesSseError {
176 UnknownValue(serde_json::Value),
177}
178
179#[derive(Debug, Clone, Serialize, Deserialize)]
181#[serde(untagged)]
182pub enum GetLogFileFromStoreError {
183 UnknownValue(serde_json::Value),
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum GetQueueCountError {
190 UnknownValue(serde_json::Value),
191}
192
193#[derive(Debug, Clone, Serialize, Deserialize)]
195#[serde(untagged)]
196pub enum GetResumeUrlsError {
197 UnknownValue(serde_json::Value),
198}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum GetRootJobIdError {
204 UnknownValue(serde_json::Value),
205}
206
207#[derive(Debug, Clone, Serialize, Deserialize)]
209#[serde(untagged)]
210pub enum GetSlackApprovalPayloadError {
211 UnknownValue(serde_json::Value),
212}
213
214#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum GetSuspendedJobFlowError {
218 UnknownValue(serde_json::Value),
219}
220
221#[derive(Debug, Clone, Serialize, Deserialize)]
223#[serde(untagged)]
224pub enum GetTeamsApprovalPayloadError {
225 UnknownValue(serde_json::Value),
226}
227
228#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum ListCompletedJobsError {
232 UnknownValue(serde_json::Value),
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
237#[serde(untagged)]
238pub enum ListExtendedJobsError {
239 UnknownValue(serde_json::Value),
240}
241
242#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum ListFilteredJobsUuidsError {
246 UnknownValue(serde_json::Value),
247}
248
249#[derive(Debug, Clone, Serialize, Deserialize)]
251#[serde(untagged)]
252pub enum ListFilteredQueueUuidsError {
253 UnknownValue(serde_json::Value),
254}
255
256#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum ListJobsError {
260 UnknownValue(serde_json::Value),
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize)]
265#[serde(untagged)]
266pub enum ListQueueError {
267 UnknownValue(serde_json::Value),
268}
269
270#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum ListSelectedJobGroupsError {
274 UnknownValue(serde_json::Value),
275}
276
277#[derive(Debug, Clone, Serialize, Deserialize)]
279#[serde(untagged)]
280pub enum OpenaiSyncFlowByPathError {
281 UnknownValue(serde_json::Value),
282}
283
284#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum OpenaiSyncScriptByPathError {
288 UnknownValue(serde_json::Value),
289}
290
291#[derive(Debug, Clone, Serialize, Deserialize)]
293#[serde(untagged)]
294pub enum RestartFlowAtStepError {
295 UnknownValue(serde_json::Value),
296}
297
298#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum ResultByIdError {
302 UnknownValue(serde_json::Value),
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize)]
307#[serde(untagged)]
308pub enum ResumeSuspendedFlowAsOwnerError {
309 UnknownValue(serde_json::Value),
310}
311
312#[derive(Debug, Clone, Serialize, Deserialize)]
314#[serde(untagged)]
315pub enum ResumeSuspendedJobGetError {
316 UnknownValue(serde_json::Value),
317}
318
319#[derive(Debug, Clone, Serialize, Deserialize)]
321#[serde(untagged)]
322pub enum ResumeSuspendedJobPostError {
323 UnknownValue(serde_json::Value),
324}
325
326#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum RunCodeWorkflowTaskError {
330 UnknownValue(serde_json::Value),
331}
332
333#[derive(Debug, Clone, Serialize, Deserialize)]
335#[serde(untagged)]
336pub enum RunFlowByPathError {
337 UnknownValue(serde_json::Value),
338}
339
340#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum RunFlowPreviewError {
344 UnknownValue(serde_json::Value),
345}
346
347#[derive(Debug, Clone, Serialize, Deserialize)]
349#[serde(untagged)]
350pub enum RunRawScriptDependenciesError {
351 UnknownValue(serde_json::Value),
352}
353
354#[derive(Debug, Clone, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum RunScriptByHashError {
358 UnknownValue(serde_json::Value),
359}
360
361#[derive(Debug, Clone, Serialize, Deserialize)]
363#[serde(untagged)]
364pub enum RunScriptByPathError {
365 UnknownValue(serde_json::Value),
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum RunScriptPreviewError {
372 UnknownValue(serde_json::Value),
373}
374
375#[derive(Debug, Clone, Serialize, Deserialize)]
377#[serde(untagged)]
378pub enum RunWaitResultFlowByPathError {
379 UnknownValue(serde_json::Value),
380}
381
382#[derive(Debug, Clone, Serialize, Deserialize)]
384#[serde(untagged)]
385pub enum RunWaitResultScriptByPathError {
386 UnknownValue(serde_json::Value),
387}
388
389#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(untagged)]
392pub enum RunWaitResultScriptByPathGetError {
393 UnknownValue(serde_json::Value),
394}
395
396#[derive(Debug, Clone, Serialize, Deserialize)]
398#[serde(untagged)]
399pub enum SetFlowUserStateError {
400 UnknownValue(serde_json::Value),
401}
402
403
404pub async fn batch_re_run_jobs(configuration: &configuration::Configuration, workspace: &str, batch_re_run_jobs_request: models::BatchReRunJobsRequest) -> Result<String, Error<BatchReRunJobsError>> {
405 let local_var_configuration = configuration;
406
407 let local_var_client = &local_var_configuration.client;
408
409 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/batch_rerun_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
410 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
411
412 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
413 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
414 }
415 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
416 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
417 };
418 local_var_req_builder = local_var_req_builder.json(&batch_re_run_jobs_request);
419
420 let local_var_req = local_var_req_builder.build()?;
421 let local_var_resp = local_var_client.execute(local_var_req).await?;
422
423 let local_var_status = local_var_resp.status();
424 let local_var_content = local_var_resp.text().await?;
425
426 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
427 crate::from_str_patched(&local_var_content).map_err(Error::from)
428 } else {
429 let local_var_entity: Option<BatchReRunJobsError> = crate::from_str_patched(&local_var_content).ok();
430 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
431 Err(Error::ResponseError(local_var_error))
432 }
433}
434
435pub async fn cancel_persistent_queued_jobs(configuration: &configuration::Configuration, workspace: &str, path: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<CancelPersistentQueuedJobsError>> {
436 let local_var_configuration = configuration;
437
438 let local_var_client = &local_var_configuration.client;
439
440 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/cancel_persistent/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
441 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
442
443 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
444 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
445 }
446 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
447 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
448 };
449 local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
450
451 let local_var_req = local_var_req_builder.build()?;
452 let local_var_resp = local_var_client.execute(local_var_req).await?;
453
454 let local_var_status = local_var_resp.status();
455 let local_var_content = local_var_resp.text().await?;
456
457 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
458 crate::from_str_patched(&local_var_content).map_err(Error::from)
459 } else {
460 let local_var_entity: Option<CancelPersistentQueuedJobsError> = crate::from_str_patched(&local_var_content).ok();
461 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
462 Err(Error::ResponseError(local_var_error))
463 }
464}
465
466pub async fn cancel_queued_job(configuration: &configuration::Configuration, workspace: &str, id: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<CancelQueuedJobError>> {
467 let local_var_configuration = configuration;
468
469 let local_var_client = &local_var_configuration.client;
470
471 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/cancel/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
472 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
473
474 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
475 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
476 }
477 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
478 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
479 };
480 local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
481
482 let local_var_req = local_var_req_builder.build()?;
483 let local_var_resp = local_var_client.execute(local_var_req).await?;
484
485 let local_var_status = local_var_resp.status();
486 let local_var_content = local_var_resp.text().await?;
487
488 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
489 crate::from_str_patched(&local_var_content).map_err(Error::from)
490 } else {
491 let local_var_entity: Option<CancelQueuedJobError> = crate::from_str_patched(&local_var_content).ok();
492 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
493 Err(Error::ResponseError(local_var_error))
494 }
495}
496
497pub async fn cancel_selection(configuration: &configuration::Configuration, workspace: &str, request_body: Vec<String>) -> Result<Vec<String>, Error<CancelSelectionError>> {
498 let local_var_configuration = configuration;
499
500 let local_var_client = &local_var_configuration.client;
501
502 let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/cancel_selection", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
503 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
504
505 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
506 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
507 }
508 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
509 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
510 };
511 local_var_req_builder = local_var_req_builder.json(&request_body);
512
513 let local_var_req = local_var_req_builder.build()?;
514 let local_var_resp = local_var_client.execute(local_var_req).await?;
515
516 let local_var_status = local_var_resp.status();
517 let local_var_content = local_var_resp.text().await?;
518
519 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
520 crate::from_str_patched(&local_var_content).map_err(Error::from)
521 } else {
522 let local_var_entity: Option<CancelSelectionError> = crate::from_str_patched(&local_var_content).ok();
523 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
524 Err(Error::ResponseError(local_var_error))
525 }
526}
527
528pub async fn cancel_suspended_job_get(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, approver: Option<&str>) -> Result<String, Error<CancelSuspendedJobGetError>> {
529 let local_var_configuration = configuration;
530
531 let local_var_client = &local_var_configuration.client;
532
533 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
534 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
535
536 if let Some(ref local_var_str) = approver {
537 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
538 }
539 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
540 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
541 }
542 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
543 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
544 };
545
546 let local_var_req = local_var_req_builder.build()?;
547 let local_var_resp = local_var_client.execute(local_var_req).await?;
548
549 let local_var_status = local_var_resp.status();
550 let local_var_content = local_var_resp.text().await?;
551
552 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
553 crate::from_str_patched(&local_var_content).map_err(Error::from)
554 } else {
555 let local_var_entity: Option<CancelSuspendedJobGetError> = crate::from_str_patched(&local_var_content).ok();
556 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
557 Err(Error::ResponseError(local_var_error))
558 }
559}
560
561pub async fn cancel_suspended_job_post(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, body: serde_json::Value, approver: Option<&str>) -> Result<String, Error<CancelSuspendedJobPostError>> {
562 let local_var_configuration = configuration;
563
564 let local_var_client = &local_var_configuration.client;
565
566 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/cancel/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
567 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
568
569 if let Some(ref local_var_str) = approver {
570 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
571 }
572 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
573 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
574 }
575 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
576 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
577 };
578 local_var_req_builder = local_var_req_builder.json(&body);
579
580 let local_var_req = local_var_req_builder.build()?;
581 let local_var_resp = local_var_client.execute(local_var_req).await?;
582
583 let local_var_status = local_var_resp.status();
584 let local_var_content = local_var_resp.text().await?;
585
586 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
587 crate::from_str_patched(&local_var_content).map_err(Error::from)
588 } else {
589 let local_var_entity: Option<CancelSuspendedJobPostError> = crate::from_str_patched(&local_var_content).ok();
590 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
591 Err(Error::ResponseError(local_var_error))
592 }
593}
594
595pub async fn count_completed_jobs(configuration: &configuration::Configuration, workspace: &str, completed_after_s_ago: Option<i32>, success: Option<bool>, tags: Option<&str>, all_workspaces: Option<bool>) -> Result<i32, Error<CountCompletedJobsError>> {
596 let local_var_configuration = configuration;
597
598 let local_var_client = &local_var_configuration.client;
599
600 let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/count_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
601 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
602
603 if let Some(ref local_var_str) = completed_after_s_ago {
604 local_var_req_builder = local_var_req_builder.query(&[("completed_after_s_ago", &local_var_str.to_string())]);
605 }
606 if let Some(ref local_var_str) = success {
607 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
608 }
609 if let Some(ref local_var_str) = tags {
610 local_var_req_builder = local_var_req_builder.query(&[("tags", &local_var_str.to_string())]);
611 }
612 if let Some(ref local_var_str) = all_workspaces {
613 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
614 }
615 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
616 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
617 }
618 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
619 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
620 };
621
622 let local_var_req = local_var_req_builder.build()?;
623 let local_var_resp = local_var_client.execute(local_var_req).await?;
624
625 let local_var_status = local_var_resp.status();
626 let local_var_content = local_var_resp.text().await?;
627
628 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
629 crate::from_str_patched(&local_var_content).map_err(Error::from)
630 } else {
631 let local_var_entity: Option<CountCompletedJobsError> = crate::from_str_patched(&local_var_content).ok();
632 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
633 Err(Error::ResponseError(local_var_error))
634 }
635}
636
637pub async fn count_jobs_by_tag(configuration: &configuration::Configuration, horizon_secs: Option<i32>, workspace_id: Option<&str>) -> Result<Vec<models::CountJobsByTag200ResponseInner>, Error<CountJobsByTagError>> {
638 let local_var_configuration = configuration;
639
640 let local_var_client = &local_var_configuration.client;
641
642 let local_var_uri_str = format!("{}/jobs/completed/count_by_tag", local_var_configuration.base_path);
643 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
644
645 if let Some(ref local_var_str) = horizon_secs {
646 local_var_req_builder = local_var_req_builder.query(&[("horizon_secs", &local_var_str.to_string())]);
647 }
648 if let Some(ref local_var_str) = workspace_id {
649 local_var_req_builder = local_var_req_builder.query(&[("workspace_id", &local_var_str.to_string())]);
650 }
651 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
652 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
653 }
654 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
655 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
656 };
657
658 let local_var_req = local_var_req_builder.build()?;
659 let local_var_resp = local_var_client.execute(local_var_req).await?;
660
661 let local_var_status = local_var_resp.status();
662 let local_var_content = local_var_resp.text().await?;
663
664 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
665 crate::from_str_patched(&local_var_content).map_err(Error::from)
666 } else {
667 let local_var_entity: Option<CountJobsByTagError> = crate::from_str_patched(&local_var_content).ok();
668 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
669 Err(Error::ResponseError(local_var_error))
670 }
671}
672
673pub async fn create_job_signature(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, approver: Option<&str>) -> Result<String, Error<CreateJobSignatureError>> {
674 let local_var_configuration = configuration;
675
676 let local_var_client = &local_var_configuration.client;
677
678 let local_var_uri_str = format!("{}/w/{workspace}/jobs/job_signature/{id}/{resume_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id);
679 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
680
681 if let Some(ref local_var_str) = approver {
682 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
683 }
684 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
685 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
686 }
687 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
688 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
689 };
690
691 let local_var_req = local_var_req_builder.build()?;
692 let local_var_resp = local_var_client.execute(local_var_req).await?;
693
694 let local_var_status = local_var_resp.status();
695 let local_var_content = local_var_resp.text().await?;
696
697 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
698 crate::from_str_patched(&local_var_content).map_err(Error::from)
699 } else {
700 let local_var_entity: Option<CreateJobSignatureError> = crate::from_str_patched(&local_var_content).ok();
701 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
702 Err(Error::ResponseError(local_var_error))
703 }
704}
705
706pub async fn delete_completed_job(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<models::CompletedJob, Error<DeleteCompletedJobError>> {
707 let local_var_configuration = configuration;
708
709 let local_var_client = &local_var_configuration.client;
710
711 let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/delete/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
712 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
713
714 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
715 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
716 }
717 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
718 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
719 };
720
721 let local_var_req = local_var_req_builder.build()?;
722 let local_var_resp = local_var_client.execute(local_var_req).await?;
723
724 let local_var_status = local_var_resp.status();
725 let local_var_content = local_var_resp.text().await?;
726
727 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
728 crate::from_str_patched(&local_var_content).map_err(Error::from)
729 } else {
730 let local_var_entity: Option<DeleteCompletedJobError> = crate::from_str_patched(&local_var_content).ok();
731 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
732 Err(Error::ResponseError(local_var_error))
733 }
734}
735
736pub async fn force_cancel_queued_job(configuration: &configuration::Configuration, workspace: &str, id: &str, cancel_queued_job_request: models::CancelQueuedJobRequest) -> Result<String, Error<ForceCancelQueuedJobError>> {
737 let local_var_configuration = configuration;
738
739 let local_var_client = &local_var_configuration.client;
740
741 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/queue/force_cancel/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
742 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
743
744 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
745 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
746 }
747 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
748 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
749 };
750 local_var_req_builder = local_var_req_builder.json(&cancel_queued_job_request);
751
752 let local_var_req = local_var_req_builder.build()?;
753 let local_var_resp = local_var_client.execute(local_var_req).await?;
754
755 let local_var_status = local_var_resp.status();
756 let local_var_content = local_var_resp.text().await?;
757
758 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
759 crate::from_str_patched(&local_var_content).map_err(Error::from)
760 } else {
761 let local_var_entity: Option<ForceCancelQueuedJobError> = crate::from_str_patched(&local_var_content).ok();
762 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
763 Err(Error::ResponseError(local_var_error))
764 }
765}
766
767pub async fn get_completed_count(configuration: &configuration::Configuration, workspace: &str) -> Result<models::GetCompletedCount200Response, Error<GetCompletedCountError>> {
768 let local_var_configuration = configuration;
769
770 let local_var_client = &local_var_configuration.client;
771
772 let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/count", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
773 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
774
775 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
776 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
777 }
778 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
779 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
780 };
781
782 let local_var_req = local_var_req_builder.build()?;
783 let local_var_resp = local_var_client.execute(local_var_req).await?;
784
785 let local_var_status = local_var_resp.status();
786 let local_var_content = local_var_resp.text().await?;
787
788 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
789 crate::from_str_patched(&local_var_content).map_err(Error::from)
790 } else {
791 let local_var_entity: Option<GetCompletedCountError> = crate::from_str_patched(&local_var_content).ok();
792 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
793 Err(Error::ResponseError(local_var_error))
794 }
795}
796
797pub async fn get_completed_job(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<models::CompletedJob, Error<GetCompletedJobError>> {
798 let local_var_configuration = configuration;
799
800 let local_var_client = &local_var_configuration.client;
801
802 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
803 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
804
805 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
806 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
807 }
808 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
809 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
810 };
811
812 let local_var_req = local_var_req_builder.build()?;
813 let local_var_resp = local_var_client.execute(local_var_req).await?;
814
815 let local_var_status = local_var_resp.status();
816 let local_var_content = local_var_resp.text().await?;
817
818 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
819 crate::from_str_patched(&local_var_content).map_err(Error::from)
820 } else {
821 let local_var_entity: Option<GetCompletedJobError> = crate::from_str_patched(&local_var_content).ok();
822 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
823 Err(Error::ResponseError(local_var_error))
824 }
825}
826
827pub async fn get_completed_job_result(configuration: &configuration::Configuration, workspace: &str, id: &str, suspended_job: Option<&str>, resume_id: Option<i32>, secret: Option<&str>, approver: Option<&str>) -> Result<serde_json::Value, Error<GetCompletedJobResultError>> {
828 let local_var_configuration = configuration;
829
830 let local_var_client = &local_var_configuration.client;
831
832 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get_result/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
833 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
834
835 if let Some(ref local_var_str) = suspended_job {
836 local_var_req_builder = local_var_req_builder.query(&[("suspended_job", &local_var_str.to_string())]);
837 }
838 if let Some(ref local_var_str) = resume_id {
839 local_var_req_builder = local_var_req_builder.query(&[("resume_id", &local_var_str.to_string())]);
840 }
841 if let Some(ref local_var_str) = secret {
842 local_var_req_builder = local_var_req_builder.query(&[("secret", &local_var_str.to_string())]);
843 }
844 if let Some(ref local_var_str) = approver {
845 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
846 }
847 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
848 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
849 }
850 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
851 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
852 };
853
854 let local_var_req = local_var_req_builder.build()?;
855 let local_var_resp = local_var_client.execute(local_var_req).await?;
856
857 let local_var_status = local_var_resp.status();
858 let local_var_content = local_var_resp.text().await?;
859
860 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
861 crate::from_str_patched(&local_var_content).map_err(Error::from)
862 } else {
863 let local_var_entity: Option<GetCompletedJobResultError> = crate::from_str_patched(&local_var_content).ok();
864 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
865 Err(Error::ResponseError(local_var_error))
866 }
867}
868
869pub async fn get_completed_job_result_maybe(configuration: &configuration::Configuration, workspace: &str, id: &str, get_started: Option<bool>) -> Result<models::GetCompletedJobResultMaybe200Response, Error<GetCompletedJobResultMaybeError>> {
870 let local_var_configuration = configuration;
871
872 let local_var_client = &local_var_configuration.client;
873
874 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/completed/get_result_maybe/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
875 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
876
877 if let Some(ref local_var_str) = get_started {
878 local_var_req_builder = local_var_req_builder.query(&[("get_started", &local_var_str.to_string())]);
879 }
880 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
881 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
882 }
883 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
884 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
885 };
886
887 let local_var_req = local_var_req_builder.build()?;
888 let local_var_resp = local_var_client.execute(local_var_req).await?;
889
890 let local_var_status = local_var_resp.status();
891 let local_var_content = local_var_resp.text().await?;
892
893 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
894 crate::from_str_patched(&local_var_content).map_err(Error::from)
895 } else {
896 let local_var_entity: Option<GetCompletedJobResultMaybeError> = crate::from_str_patched(&local_var_content).ok();
897 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
898 Err(Error::ResponseError(local_var_error))
899 }
900}
901
902pub async fn get_db_clock(configuration: &configuration::Configuration, ) -> Result<i32, Error<GetDbClockError>> {
903 let local_var_configuration = configuration;
904
905 let local_var_client = &local_var_configuration.client;
906
907 let local_var_uri_str = format!("{}/jobs/db_clock", local_var_configuration.base_path);
908 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
909
910 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
911 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
912 }
913 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
914 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
915 };
916
917 let local_var_req = local_var_req_builder.build()?;
918 let local_var_resp = local_var_client.execute(local_var_req).await?;
919
920 let local_var_status = local_var_resp.status();
921 let local_var_content = local_var_resp.text().await?;
922
923 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
924 crate::from_str_patched(&local_var_content).map_err(Error::from)
925 } else {
926 let local_var_entity: Option<GetDbClockError> = crate::from_str_patched(&local_var_content).ok();
927 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
928 Err(Error::ResponseError(local_var_error))
929 }
930}
931
932pub async fn get_flow_debug_info(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<serde_json::Value, Error<GetFlowDebugInfoError>> {
933 let local_var_configuration = configuration;
934
935 let local_var_client = &local_var_configuration.client;
936
937 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_flow_debug_info/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
938 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
939
940 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
941 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
942 }
943 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
944 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
945 };
946
947 let local_var_req = local_var_req_builder.build()?;
948 let local_var_resp = local_var_client.execute(local_var_req).await?;
949
950 let local_var_status = local_var_resp.status();
951 let local_var_content = local_var_resp.text().await?;
952
953 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
954 crate::from_str_patched(&local_var_content).map_err(Error::from)
955 } else {
956 let local_var_entity: Option<GetFlowDebugInfoError> = crate::from_str_patched(&local_var_content).ok();
957 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
958 Err(Error::ResponseError(local_var_error))
959 }
960}
961
962pub async fn get_flow_user_state(configuration: &configuration::Configuration, workspace: &str, id: &str, key: &str) -> Result<serde_json::Value, Error<GetFlowUserStateError>> {
963 let local_var_configuration = configuration;
964
965 let local_var_client = &local_var_configuration.client;
966
967 let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/user_states/{id}/{key}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), key=crate::apis::urlencode(key));
968 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
969
970 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
971 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
972 }
973 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
974 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
975 };
976
977 let local_var_req = local_var_req_builder.build()?;
978 let local_var_resp = local_var_client.execute(local_var_req).await?;
979
980 let local_var_status = local_var_resp.status();
981 let local_var_content = local_var_resp.text().await?;
982
983 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
984 crate::from_str_patched(&local_var_content).map_err(Error::from)
985 } else {
986 let local_var_entity: Option<GetFlowUserStateError> = crate::from_str_patched(&local_var_content).ok();
987 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
988 Err(Error::ResponseError(local_var_error))
989 }
990}
991
992pub async fn get_job(configuration: &configuration::Configuration, workspace: &str, id: &str, no_logs: Option<bool>, no_code: Option<bool>) -> Result<models::Job, Error<GetJobError>> {
993 let local_var_configuration = configuration;
994
995 let local_var_client = &local_var_configuration.client;
996
997 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
998 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
999
1000 if let Some(ref local_var_str) = no_logs {
1001 local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1002 }
1003 if let Some(ref local_var_str) = no_code {
1004 local_var_req_builder = local_var_req_builder.query(&[("no_code", &local_var_str.to_string())]);
1005 }
1006 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1007 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1008 }
1009 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1010 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1011 };
1012
1013 let local_var_req = local_var_req_builder.build()?;
1014 let local_var_resp = local_var_client.execute(local_var_req).await?;
1015
1016 let local_var_status = local_var_resp.status();
1017 let local_var_content = local_var_resp.text().await?;
1018
1019 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1020 crate::from_str_patched(&local_var_content).map_err(Error::from)
1021 } else {
1022 let local_var_entity: Option<GetJobError> = crate::from_str_patched(&local_var_content).ok();
1023 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1024 Err(Error::ResponseError(local_var_error))
1025 }
1026}
1027
1028pub async fn get_job_args(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<serde_json::Value, Error<GetJobArgsError>> {
1029 let local_var_configuration = configuration;
1030
1031 let local_var_client = &local_var_configuration.client;
1032
1033 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_args/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1034 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1035
1036 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1037 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1038 }
1039 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1040 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1041 };
1042
1043 let local_var_req = local_var_req_builder.build()?;
1044 let local_var_resp = local_var_client.execute(local_var_req).await?;
1045
1046 let local_var_status = local_var_resp.status();
1047 let local_var_content = local_var_resp.text().await?;
1048
1049 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1050 crate::from_str_patched(&local_var_content).map_err(Error::from)
1051 } else {
1052 let local_var_entity: Option<GetJobArgsError> = crate::from_str_patched(&local_var_content).ok();
1053 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1054 Err(Error::ResponseError(local_var_error))
1055 }
1056}
1057
1058pub async fn get_job_logs(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<String, Error<GetJobLogsError>> {
1059 let local_var_configuration = configuration;
1060
1061 let local_var_client = &local_var_configuration.client;
1062
1063 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_logs/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1064 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1065
1066 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1067 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1068 }
1069 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1070 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1071 };
1072
1073 let local_var_req = local_var_req_builder.build()?;
1074 let local_var_resp = local_var_client.execute(local_var_req).await?;
1075
1076 let local_var_status = local_var_resp.status();
1077 let local_var_content = local_var_resp.text().await?;
1078
1079 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1080 crate::from_str_patched(&local_var_content).map_err(Error::from)
1081 } else {
1082 let local_var_entity: Option<GetJobLogsError> = crate::from_str_patched(&local_var_content).ok();
1083 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1084 Err(Error::ResponseError(local_var_error))
1085 }
1086}
1087
1088pub async fn get_job_updates(configuration: &configuration::Configuration, workspace: &str, id: &str, running: Option<bool>, log_offset: Option<i32>, stream_offset: Option<i32>, get_progress: Option<bool>, no_logs: Option<bool>) -> Result<models::GetJobUpdates200Response, Error<GetJobUpdatesError>> {
1089 let local_var_configuration = configuration;
1090
1091 let local_var_client = &local_var_configuration.client;
1092
1093 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/getupdate/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1094 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1095
1096 if let Some(ref local_var_str) = running {
1097 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1098 }
1099 if let Some(ref local_var_str) = log_offset {
1100 local_var_req_builder = local_var_req_builder.query(&[("log_offset", &local_var_str.to_string())]);
1101 }
1102 if let Some(ref local_var_str) = stream_offset {
1103 local_var_req_builder = local_var_req_builder.query(&[("stream_offset", &local_var_str.to_string())]);
1104 }
1105 if let Some(ref local_var_str) = get_progress {
1106 local_var_req_builder = local_var_req_builder.query(&[("get_progress", &local_var_str.to_string())]);
1107 }
1108 if let Some(ref local_var_str) = no_logs {
1109 local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1110 }
1111 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1112 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1113 }
1114 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1115 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1116 };
1117
1118 let local_var_req = local_var_req_builder.build()?;
1119 let local_var_resp = local_var_client.execute(local_var_req).await?;
1120
1121 let local_var_status = local_var_resp.status();
1122 let local_var_content = local_var_resp.text().await?;
1123
1124 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1125 crate::from_str_patched(&local_var_content).map_err(Error::from)
1126 } else {
1127 let local_var_entity: Option<GetJobUpdatesError> = crate::from_str_patched(&local_var_content).ok();
1128 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1129 Err(Error::ResponseError(local_var_error))
1130 }
1131}
1132
1133pub async fn get_job_updates_sse(configuration: &configuration::Configuration, workspace: &str, id: &str, running: Option<bool>, log_offset: Option<i32>, get_progress: Option<bool>, only_result: Option<bool>, no_logs: Option<bool>) -> Result<String, Error<GetJobUpdatesSseError>> {
1134 let local_var_configuration = configuration;
1135
1136 let local_var_client = &local_var_configuration.client;
1137
1138 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/getupdate_sse/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1139 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1140
1141 if let Some(ref local_var_str) = running {
1142 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1143 }
1144 if let Some(ref local_var_str) = log_offset {
1145 local_var_req_builder = local_var_req_builder.query(&[("log_offset", &local_var_str.to_string())]);
1146 }
1147 if let Some(ref local_var_str) = get_progress {
1148 local_var_req_builder = local_var_req_builder.query(&[("get_progress", &local_var_str.to_string())]);
1149 }
1150 if let Some(ref local_var_str) = only_result {
1151 local_var_req_builder = local_var_req_builder.query(&[("only_result", &local_var_str.to_string())]);
1152 }
1153 if let Some(ref local_var_str) = no_logs {
1154 local_var_req_builder = local_var_req_builder.query(&[("no_logs", &local_var_str.to_string())]);
1155 }
1156 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1157 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1158 }
1159 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1160 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1161 };
1162
1163 let local_var_req = local_var_req_builder.build()?;
1164 let local_var_resp = local_var_client.execute(local_var_req).await?;
1165
1166 let local_var_status = local_var_resp.status();
1167 let local_var_content = local_var_resp.text().await?;
1168
1169 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1170 crate::from_str_patched(&local_var_content).map_err(Error::from)
1171 } else {
1172 let local_var_entity: Option<GetJobUpdatesSseError> = crate::from_str_patched(&local_var_content).ok();
1173 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1174 Err(Error::ResponseError(local_var_error))
1175 }
1176}
1177
1178pub async fn get_log_file_from_store(configuration: &configuration::Configuration, workspace: &str, path: &str) -> Result<String, Error<GetLogFileFromStoreError>> {
1179 let local_var_configuration = configuration;
1180
1181 let local_var_client = &local_var_configuration.client;
1182
1183 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_log_file/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
1184 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1185
1186 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1187 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1188 }
1189 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1190 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1191 };
1192
1193 let local_var_req = local_var_req_builder.build()?;
1194 let local_var_resp = local_var_client.execute(local_var_req).await?;
1195
1196 let local_var_status = local_var_resp.status();
1197 let local_var_content = local_var_resp.text().await?;
1198
1199 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1200 crate::from_str_patched(&local_var_content).map_err(Error::from)
1201 } else {
1202 let local_var_entity: Option<GetLogFileFromStoreError> = crate::from_str_patched(&local_var_content).ok();
1203 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1204 Err(Error::ResponseError(local_var_error))
1205 }
1206}
1207
1208pub async fn get_queue_count(configuration: &configuration::Configuration, workspace: &str, all_workspaces: Option<bool>) -> Result<models::GetQueueCount200Response, Error<GetQueueCountError>> {
1209 let local_var_configuration = configuration;
1210
1211 let local_var_client = &local_var_configuration.client;
1212
1213 let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/count", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1214 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1215
1216 if let Some(ref local_var_str) = all_workspaces {
1217 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1218 }
1219 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1220 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1221 }
1222 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1223 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1224 };
1225
1226 let local_var_req = local_var_req_builder.build()?;
1227 let local_var_resp = local_var_client.execute(local_var_req).await?;
1228
1229 let local_var_status = local_var_resp.status();
1230 let local_var_content = local_var_resp.text().await?;
1231
1232 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1233 crate::from_str_patched(&local_var_content).map_err(Error::from)
1234 } else {
1235 let local_var_entity: Option<GetQueueCountError> = crate::from_str_patched(&local_var_content).ok();
1236 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1237 Err(Error::ResponseError(local_var_error))
1238 }
1239}
1240
1241pub async fn get_resume_urls(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, approver: Option<&str>) -> Result<models::GetResumeUrls200Response, Error<GetResumeUrlsError>> {
1242 let local_var_configuration = configuration;
1243
1244 let local_var_client = &local_var_configuration.client;
1245
1246 let local_var_uri_str = format!("{}/w/{workspace}/jobs/resume_urls/{id}/{resume_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id);
1247 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1248
1249 if let Some(ref local_var_str) = approver {
1250 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1251 }
1252 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1253 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1254 }
1255 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1256 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1257 };
1258
1259 let local_var_req = local_var_req_builder.build()?;
1260 let local_var_resp = local_var_client.execute(local_var_req).await?;
1261
1262 let local_var_status = local_var_resp.status();
1263 let local_var_content = local_var_resp.text().await?;
1264
1265 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1266 crate::from_str_patched(&local_var_content).map_err(Error::from)
1267 } else {
1268 let local_var_entity: Option<GetResumeUrlsError> = crate::from_str_patched(&local_var_content).ok();
1269 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1270 Err(Error::ResponseError(local_var_error))
1271 }
1272}
1273
1274pub async fn get_root_job_id(configuration: &configuration::Configuration, workspace: &str, id: &str) -> Result<String, Error<GetRootJobIdError>> {
1275 let local_var_configuration = configuration;
1276
1277 let local_var_client = &local_var_configuration.client;
1278
1279 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_root_job_id/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1280 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1281
1282 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1283 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1284 }
1285 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1286 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1287 };
1288
1289 let local_var_req = local_var_req_builder.build()?;
1290 let local_var_resp = local_var_client.execute(local_var_req).await?;
1291
1292 let local_var_status = local_var_resp.status();
1293 let local_var_content = local_var_resp.text().await?;
1294
1295 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1296 crate::from_str_patched(&local_var_content).map_err(Error::from)
1297 } else {
1298 let local_var_entity: Option<GetRootJobIdError> = crate::from_str_patched(&local_var_content).ok();
1299 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1300 Err(Error::ResponseError(local_var_error))
1301 }
1302}
1303
1304pub async fn get_slack_approval_payload(configuration: &configuration::Configuration, workspace: &str, id: &str, slack_resource_path: &str, channel_id: &str, flow_step_id: &str, approver: Option<&str>, message: Option<&str>, default_args_json: Option<&str>, dynamic_enums_json: Option<&str>) -> Result<(), Error<GetSlackApprovalPayloadError>> {
1305 let local_var_configuration = configuration;
1306
1307 let local_var_client = &local_var_configuration.client;
1308
1309 let local_var_uri_str = format!("{}/w/{workspace}/jobs/slack_approval/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1310 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1311
1312 if let Some(ref local_var_str) = approver {
1313 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1314 }
1315 if let Some(ref local_var_str) = message {
1316 local_var_req_builder = local_var_req_builder.query(&[("message", &local_var_str.to_string())]);
1317 }
1318 local_var_req_builder = local_var_req_builder.query(&[("slack_resource_path", &slack_resource_path.to_string())]);
1319 local_var_req_builder = local_var_req_builder.query(&[("channel_id", &channel_id.to_string())]);
1320 local_var_req_builder = local_var_req_builder.query(&[("flow_step_id", &flow_step_id.to_string())]);
1321 if let Some(ref local_var_str) = default_args_json {
1322 local_var_req_builder = local_var_req_builder.query(&[("default_args_json", &local_var_str.to_string())]);
1323 }
1324 if let Some(ref local_var_str) = dynamic_enums_json {
1325 local_var_req_builder = local_var_req_builder.query(&[("dynamic_enums_json", &local_var_str.to_string())]);
1326 }
1327 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1328 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1329 }
1330 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1331 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1332 };
1333
1334 let local_var_req = local_var_req_builder.build()?;
1335 let local_var_resp = local_var_client.execute(local_var_req).await?;
1336
1337 let local_var_status = local_var_resp.status();
1338 let local_var_content = local_var_resp.text().await?;
1339
1340 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1341 Ok(())
1342 } else {
1343 let local_var_entity: Option<GetSlackApprovalPayloadError> = crate::from_str_patched(&local_var_content).ok();
1344 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1345 Err(Error::ResponseError(local_var_error))
1346 }
1347}
1348
1349pub async fn get_suspended_job_flow(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, approver: Option<&str>) -> Result<models::GetSuspendedJobFlow200Response, Error<GetSuspendedJobFlowError>> {
1350 let local_var_configuration = configuration;
1351
1352 let local_var_client = &local_var_configuration.client;
1353
1354 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/get_flow/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
1355 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1356
1357 if let Some(ref local_var_str) = approver {
1358 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1359 }
1360 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1361 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1362 }
1363 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1364 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1365 };
1366
1367 let local_var_req = local_var_req_builder.build()?;
1368 let local_var_resp = local_var_client.execute(local_var_req).await?;
1369
1370 let local_var_status = local_var_resp.status();
1371 let local_var_content = local_var_resp.text().await?;
1372
1373 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1374 crate::from_str_patched(&local_var_content).map_err(Error::from)
1375 } else {
1376 let local_var_entity: Option<GetSuspendedJobFlowError> = crate::from_str_patched(&local_var_content).ok();
1377 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1378 Err(Error::ResponseError(local_var_error))
1379 }
1380}
1381
1382pub async fn get_teams_approval_payload(configuration: &configuration::Configuration, workspace: &str, id: &str, team_name: &str, channel_name: &str, flow_step_id: &str, approver: Option<&str>, message: Option<&str>, default_args_json: Option<&str>, dynamic_enums_json: Option<&str>) -> Result<(), Error<GetTeamsApprovalPayloadError>> {
1383 let local_var_configuration = configuration;
1384
1385 let local_var_client = &local_var_configuration.client;
1386
1387 let local_var_uri_str = format!("{}/w/{workspace}/jobs/teams_approval/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
1388 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1389
1390 if let Some(ref local_var_str) = approver {
1391 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
1392 }
1393 if let Some(ref local_var_str) = message {
1394 local_var_req_builder = local_var_req_builder.query(&[("message", &local_var_str.to_string())]);
1395 }
1396 local_var_req_builder = local_var_req_builder.query(&[("team_name", &team_name.to_string())]);
1397 local_var_req_builder = local_var_req_builder.query(&[("channel_name", &channel_name.to_string())]);
1398 local_var_req_builder = local_var_req_builder.query(&[("flow_step_id", &flow_step_id.to_string())]);
1399 if let Some(ref local_var_str) = default_args_json {
1400 local_var_req_builder = local_var_req_builder.query(&[("default_args_json", &local_var_str.to_string())]);
1401 }
1402 if let Some(ref local_var_str) = dynamic_enums_json {
1403 local_var_req_builder = local_var_req_builder.query(&[("dynamic_enums_json", &local_var_str.to_string())]);
1404 }
1405 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1406 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1407 }
1408 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1409 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1410 };
1411
1412 let local_var_req = local_var_req_builder.build()?;
1413 let local_var_resp = local_var_client.execute(local_var_req).await?;
1414
1415 let local_var_status = local_var_resp.status();
1416 let local_var_content = local_var_resp.text().await?;
1417
1418 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1419 Ok(())
1420 } else {
1421 let local_var_entity: Option<GetTeamsApprovalPayloadError> = crate::from_str_patched(&local_var_content).ok();
1422 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1423 Err(Error::ResponseError(local_var_error))
1424 }
1425}
1426
1427pub async fn list_completed_jobs(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, job_kinds: Option<&str>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<models::CompletedJob>, Error<ListCompletedJobsError>> {
1428 let local_var_configuration = configuration;
1429
1430 let local_var_client = &local_var_configuration.client;
1431
1432 let local_var_uri_str = format!("{}/w/{workspace}/jobs/completed/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1433 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1434
1435 if let Some(ref local_var_str) = order_desc {
1436 local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
1437 }
1438 if let Some(ref local_var_str) = created_by {
1439 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1440 }
1441 if let Some(ref local_var_str) = label {
1442 local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
1443 }
1444 if let Some(ref local_var_str) = worker {
1445 local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
1446 }
1447 if let Some(ref local_var_str) = parent_job {
1448 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
1449 }
1450 if let Some(ref local_var_str) = script_path_exact {
1451 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
1452 }
1453 if let Some(ref local_var_str) = script_path_start {
1454 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
1455 }
1456 if let Some(ref local_var_str) = schedule_path {
1457 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
1458 }
1459 if let Some(ref local_var_str) = script_hash {
1460 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
1461 }
1462 if let Some(ref local_var_str) = started_before {
1463 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
1464 }
1465 if let Some(ref local_var_str) = started_after {
1466 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
1467 }
1468 if let Some(ref local_var_str) = success {
1469 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
1470 }
1471 if let Some(ref local_var_str) = job_kinds {
1472 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
1473 }
1474 if let Some(ref local_var_str) = args {
1475 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
1476 }
1477 if let Some(ref local_var_str) = result {
1478 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
1479 }
1480 if let Some(ref local_var_str) = allow_wildcards {
1481 local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
1482 }
1483 if let Some(ref local_var_str) = tag {
1484 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
1485 }
1486 if let Some(ref local_var_str) = page {
1487 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1488 }
1489 if let Some(ref local_var_str) = per_page {
1490 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1491 }
1492 if let Some(ref local_var_str) = is_skipped {
1493 local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
1494 }
1495 if let Some(ref local_var_str) = is_flow_step {
1496 local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
1497 }
1498 if let Some(ref local_var_str) = has_null_parent {
1499 local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
1500 }
1501 if let Some(ref local_var_str) = is_not_schedule {
1502 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
1503 }
1504 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1505 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1506 }
1507 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1508 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1509 };
1510
1511 let local_var_req = local_var_req_builder.build()?;
1512 let local_var_resp = local_var_client.execute(local_var_req).await?;
1513
1514 let local_var_status = local_var_resp.status();
1515 let local_var_content = local_var_resp.text().await?;
1516
1517 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1518 crate::from_str_patched(&local_var_content).map_err(Error::from)
1519 } else {
1520 let local_var_entity: Option<ListCompletedJobsError> = crate::from_str_patched(&local_var_content).ok();
1521 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1522 Err(Error::ResponseError(local_var_error))
1523 }
1524}
1525
1526pub async fn list_extended_jobs(configuration: &configuration::Configuration, workspace: &str, concurrency_key: Option<&str>, row_limit: Option<f64>, created_by: Option<&str>, label: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, created_or_started_before: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, created_or_started_after: Option<String>, created_or_started_after_completed_jobs: Option<String>, job_kinds: Option<&str>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<models::ExtendedJobs, Error<ListExtendedJobsError>> {
1527 let local_var_configuration = configuration;
1528
1529 let local_var_client = &local_var_configuration.client;
1530
1531 let local_var_uri_str = format!("{}/w/{workspace}/concurrency_groups/list_jobs", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1532 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1533
1534 if let Some(ref local_var_str) = concurrency_key {
1535 local_var_req_builder = local_var_req_builder.query(&[("concurrency_key", &local_var_str.to_string())]);
1536 }
1537 if let Some(ref local_var_str) = row_limit {
1538 local_var_req_builder = local_var_req_builder.query(&[("row_limit", &local_var_str.to_string())]);
1539 }
1540 if let Some(ref local_var_str) = created_by {
1541 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1542 }
1543 if let Some(ref local_var_str) = label {
1544 local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
1545 }
1546 if let Some(ref local_var_str) = parent_job {
1547 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
1548 }
1549 if let Some(ref local_var_str) = script_path_exact {
1550 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
1551 }
1552 if let Some(ref local_var_str) = script_path_start {
1553 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
1554 }
1555 if let Some(ref local_var_str) = schedule_path {
1556 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
1557 }
1558 if let Some(ref local_var_str) = script_hash {
1559 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
1560 }
1561 if let Some(ref local_var_str) = started_before {
1562 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
1563 }
1564 if let Some(ref local_var_str) = started_after {
1565 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
1566 }
1567 if let Some(ref local_var_str) = created_or_started_before {
1568 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_before", &local_var_str.to_string())]);
1569 }
1570 if let Some(ref local_var_str) = running {
1571 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1572 }
1573 if let Some(ref local_var_str) = scheduled_for_before_now {
1574 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
1575 }
1576 if let Some(ref local_var_str) = created_or_started_after {
1577 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after", &local_var_str.to_string())]);
1578 }
1579 if let Some(ref local_var_str) = created_or_started_after_completed_jobs {
1580 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after_completed_jobs", &local_var_str.to_string())]);
1581 }
1582 if let Some(ref local_var_str) = job_kinds {
1583 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
1584 }
1585 if let Some(ref local_var_str) = args {
1586 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
1587 }
1588 if let Some(ref local_var_str) = tag {
1589 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
1590 }
1591 if let Some(ref local_var_str) = result {
1592 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
1593 }
1594 if let Some(ref local_var_str) = allow_wildcards {
1595 local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
1596 }
1597 if let Some(ref local_var_str) = page {
1598 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1599 }
1600 if let Some(ref local_var_str) = per_page {
1601 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1602 }
1603 if let Some(ref local_var_str) = is_skipped {
1604 local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
1605 }
1606 if let Some(ref local_var_str) = is_flow_step {
1607 local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
1608 }
1609 if let Some(ref local_var_str) = has_null_parent {
1610 local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
1611 }
1612 if let Some(ref local_var_str) = success {
1613 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
1614 }
1615 if let Some(ref local_var_str) = all_workspaces {
1616 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1617 }
1618 if let Some(ref local_var_str) = is_not_schedule {
1619 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
1620 }
1621 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1622 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1623 }
1624 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1625 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1626 };
1627
1628 let local_var_req = local_var_req_builder.build()?;
1629 let local_var_resp = local_var_client.execute(local_var_req).await?;
1630
1631 let local_var_status = local_var_resp.status();
1632 let local_var_content = local_var_resp.text().await?;
1633
1634 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1635 crate::from_str_patched(&local_var_content).map_err(Error::from)
1636 } else {
1637 let local_var_entity: Option<ListExtendedJobsError> = crate::from_str_patched(&local_var_content).ok();
1638 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1639 Err(Error::ResponseError(local_var_error))
1640 }
1641}
1642
1643pub async fn list_filtered_jobs_uuids(configuration: &configuration::Configuration, workspace: &str, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, created_before: Option<String>, created_after: Option<String>, created_or_started_before: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, created_or_started_after: Option<String>, created_or_started_after_completed_jobs: Option<String>, job_kinds: Option<&str>, suspended: Option<bool>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<String>, Error<ListFilteredJobsUuidsError>> {
1644 let local_var_configuration = configuration;
1645
1646 let local_var_client = &local_var_configuration.client;
1647
1648 let local_var_uri_str = format!("{}/w/{workspace}/jobs/list_filtered_uuids", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1649 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1650
1651 if let Some(ref local_var_str) = created_by {
1652 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1653 }
1654 if let Some(ref local_var_str) = label {
1655 local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
1656 }
1657 if let Some(ref local_var_str) = worker {
1658 local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
1659 }
1660 if let Some(ref local_var_str) = parent_job {
1661 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
1662 }
1663 if let Some(ref local_var_str) = script_path_exact {
1664 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
1665 }
1666 if let Some(ref local_var_str) = script_path_start {
1667 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
1668 }
1669 if let Some(ref local_var_str) = schedule_path {
1670 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
1671 }
1672 if let Some(ref local_var_str) = script_hash {
1673 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
1674 }
1675 if let Some(ref local_var_str) = started_before {
1676 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
1677 }
1678 if let Some(ref local_var_str) = started_after {
1679 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
1680 }
1681 if let Some(ref local_var_str) = created_before {
1682 local_var_req_builder = local_var_req_builder.query(&[("created_before", &local_var_str.to_string())]);
1683 }
1684 if let Some(ref local_var_str) = created_after {
1685 local_var_req_builder = local_var_req_builder.query(&[("created_after", &local_var_str.to_string())]);
1686 }
1687 if let Some(ref local_var_str) = created_or_started_before {
1688 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_before", &local_var_str.to_string())]);
1689 }
1690 if let Some(ref local_var_str) = running {
1691 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1692 }
1693 if let Some(ref local_var_str) = scheduled_for_before_now {
1694 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
1695 }
1696 if let Some(ref local_var_str) = created_or_started_after {
1697 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after", &local_var_str.to_string())]);
1698 }
1699 if let Some(ref local_var_str) = created_or_started_after_completed_jobs {
1700 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after_completed_jobs", &local_var_str.to_string())]);
1701 }
1702 if let Some(ref local_var_str) = job_kinds {
1703 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
1704 }
1705 if let Some(ref local_var_str) = suspended {
1706 local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
1707 }
1708 if let Some(ref local_var_str) = args {
1709 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
1710 }
1711 if let Some(ref local_var_str) = tag {
1712 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
1713 }
1714 if let Some(ref local_var_str) = result {
1715 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
1716 }
1717 if let Some(ref local_var_str) = page {
1718 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1719 }
1720 if let Some(ref local_var_str) = per_page {
1721 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1722 }
1723 if let Some(ref local_var_str) = is_skipped {
1724 local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
1725 }
1726 if let Some(ref local_var_str) = is_flow_step {
1727 local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
1728 }
1729 if let Some(ref local_var_str) = has_null_parent {
1730 local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
1731 }
1732 if let Some(ref local_var_str) = success {
1733 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
1734 }
1735 if let Some(ref local_var_str) = all_workspaces {
1736 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1737 }
1738 if let Some(ref local_var_str) = is_not_schedule {
1739 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
1740 }
1741 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1742 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1743 }
1744 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1745 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1746 };
1747
1748 let local_var_req = local_var_req_builder.build()?;
1749 let local_var_resp = local_var_client.execute(local_var_req).await?;
1750
1751 let local_var_status = local_var_resp.status();
1752 let local_var_content = local_var_resp.text().await?;
1753
1754 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1755 crate::from_str_patched(&local_var_content).map_err(Error::from)
1756 } else {
1757 let local_var_entity: Option<ListFilteredJobsUuidsError> = crate::from_str_patched(&local_var_content).ok();
1758 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1759 Err(Error::ResponseError(local_var_error))
1760 }
1761}
1762
1763pub async fn list_filtered_queue_uuids(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, running: Option<bool>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, concurrency_key: Option<&str>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<String>, Error<ListFilteredQueueUuidsError>> {
1764 let local_var_configuration = configuration;
1765
1766 let local_var_client = &local_var_configuration.client;
1767
1768 let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/list_filtered_uuids", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1769 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1770
1771 if let Some(ref local_var_str) = order_desc {
1772 local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
1773 }
1774 if let Some(ref local_var_str) = created_by {
1775 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1776 }
1777 if let Some(ref local_var_str) = parent_job {
1778 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
1779 }
1780 if let Some(ref local_var_str) = script_path_exact {
1781 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
1782 }
1783 if let Some(ref local_var_str) = script_path_start {
1784 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
1785 }
1786 if let Some(ref local_var_str) = schedule_path {
1787 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
1788 }
1789 if let Some(ref local_var_str) = script_hash {
1790 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
1791 }
1792 if let Some(ref local_var_str) = started_before {
1793 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
1794 }
1795 if let Some(ref local_var_str) = started_after {
1796 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
1797 }
1798 if let Some(ref local_var_str) = success {
1799 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
1800 }
1801 if let Some(ref local_var_str) = scheduled_for_before_now {
1802 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
1803 }
1804 if let Some(ref local_var_str) = job_kinds {
1805 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
1806 }
1807 if let Some(ref local_var_str) = suspended {
1808 local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
1809 }
1810 if let Some(ref local_var_str) = running {
1811 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1812 }
1813 if let Some(ref local_var_str) = args {
1814 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
1815 }
1816 if let Some(ref local_var_str) = result {
1817 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
1818 }
1819 if let Some(ref local_var_str) = allow_wildcards {
1820 local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
1821 }
1822 if let Some(ref local_var_str) = tag {
1823 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
1824 }
1825 if let Some(ref local_var_str) = page {
1826 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1827 }
1828 if let Some(ref local_var_str) = per_page {
1829 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1830 }
1831 if let Some(ref local_var_str) = concurrency_key {
1832 local_var_req_builder = local_var_req_builder.query(&[("concurrency_key", &local_var_str.to_string())]);
1833 }
1834 if let Some(ref local_var_str) = all_workspaces {
1835 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1836 }
1837 if let Some(ref local_var_str) = is_not_schedule {
1838 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
1839 }
1840 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1841 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1842 }
1843 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1844 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1845 };
1846
1847 let local_var_req = local_var_req_builder.build()?;
1848 let local_var_resp = local_var_client.execute(local_var_req).await?;
1849
1850 let local_var_status = local_var_resp.status();
1851 let local_var_content = local_var_resp.text().await?;
1852
1853 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1854 crate::from_str_patched(&local_var_content).map_err(Error::from)
1855 } else {
1856 let local_var_entity: Option<ListFilteredQueueUuidsError> = crate::from_str_patched(&local_var_content).ok();
1857 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1858 Err(Error::ResponseError(local_var_error))
1859 }
1860}
1861
1862pub async fn list_jobs(configuration: &configuration::Configuration, workspace: &str, created_by: Option<&str>, label: Option<&str>, worker: Option<&str>, parent_job: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, created_before: Option<String>, created_after: Option<String>, created_or_started_before: Option<String>, running: Option<bool>, scheduled_for_before_now: Option<bool>, created_or_started_after: Option<String>, created_or_started_after_completed_jobs: Option<String>, job_kinds: Option<&str>, suspended: Option<bool>, args: Option<&str>, tag: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, page: Option<i32>, per_page: Option<i32>, is_skipped: Option<bool>, is_flow_step: Option<bool>, has_null_parent: Option<bool>, success: Option<bool>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<models::Job>, Error<ListJobsError>> {
1863 let local_var_configuration = configuration;
1864
1865 let local_var_client = &local_var_configuration.client;
1866
1867 let local_var_uri_str = format!("{}/w/{workspace}/jobs/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1868 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1869
1870 if let Some(ref local_var_str) = created_by {
1871 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1872 }
1873 if let Some(ref local_var_str) = label {
1874 local_var_req_builder = local_var_req_builder.query(&[("label", &local_var_str.to_string())]);
1875 }
1876 if let Some(ref local_var_str) = worker {
1877 local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
1878 }
1879 if let Some(ref local_var_str) = parent_job {
1880 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
1881 }
1882 if let Some(ref local_var_str) = script_path_exact {
1883 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
1884 }
1885 if let Some(ref local_var_str) = script_path_start {
1886 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
1887 }
1888 if let Some(ref local_var_str) = schedule_path {
1889 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
1890 }
1891 if let Some(ref local_var_str) = script_hash {
1892 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
1893 }
1894 if let Some(ref local_var_str) = started_before {
1895 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
1896 }
1897 if let Some(ref local_var_str) = started_after {
1898 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
1899 }
1900 if let Some(ref local_var_str) = created_before {
1901 local_var_req_builder = local_var_req_builder.query(&[("created_before", &local_var_str.to_string())]);
1902 }
1903 if let Some(ref local_var_str) = created_after {
1904 local_var_req_builder = local_var_req_builder.query(&[("created_after", &local_var_str.to_string())]);
1905 }
1906 if let Some(ref local_var_str) = created_or_started_before {
1907 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_before", &local_var_str.to_string())]);
1908 }
1909 if let Some(ref local_var_str) = running {
1910 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
1911 }
1912 if let Some(ref local_var_str) = scheduled_for_before_now {
1913 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
1914 }
1915 if let Some(ref local_var_str) = created_or_started_after {
1916 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after", &local_var_str.to_string())]);
1917 }
1918 if let Some(ref local_var_str) = created_or_started_after_completed_jobs {
1919 local_var_req_builder = local_var_req_builder.query(&[("created_or_started_after_completed_jobs", &local_var_str.to_string())]);
1920 }
1921 if let Some(ref local_var_str) = job_kinds {
1922 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
1923 }
1924 if let Some(ref local_var_str) = suspended {
1925 local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
1926 }
1927 if let Some(ref local_var_str) = args {
1928 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
1929 }
1930 if let Some(ref local_var_str) = tag {
1931 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
1932 }
1933 if let Some(ref local_var_str) = result {
1934 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
1935 }
1936 if let Some(ref local_var_str) = allow_wildcards {
1937 local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
1938 }
1939 if let Some(ref local_var_str) = page {
1940 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
1941 }
1942 if let Some(ref local_var_str) = per_page {
1943 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
1944 }
1945 if let Some(ref local_var_str) = is_skipped {
1946 local_var_req_builder = local_var_req_builder.query(&[("is_skipped", &local_var_str.to_string())]);
1947 }
1948 if let Some(ref local_var_str) = is_flow_step {
1949 local_var_req_builder = local_var_req_builder.query(&[("is_flow_step", &local_var_str.to_string())]);
1950 }
1951 if let Some(ref local_var_str) = has_null_parent {
1952 local_var_req_builder = local_var_req_builder.query(&[("has_null_parent", &local_var_str.to_string())]);
1953 }
1954 if let Some(ref local_var_str) = success {
1955 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
1956 }
1957 if let Some(ref local_var_str) = all_workspaces {
1958 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
1959 }
1960 if let Some(ref local_var_str) = is_not_schedule {
1961 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
1962 }
1963 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1964 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1965 }
1966 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
1967 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1968 };
1969
1970 let local_var_req = local_var_req_builder.build()?;
1971 let local_var_resp = local_var_client.execute(local_var_req).await?;
1972
1973 let local_var_status = local_var_resp.status();
1974 let local_var_content = local_var_resp.text().await?;
1975
1976 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1977 crate::from_str_patched(&local_var_content).map_err(Error::from)
1978 } else {
1979 let local_var_entity: Option<ListJobsError> = crate::from_str_patched(&local_var_content).ok();
1980 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1981 Err(Error::ResponseError(local_var_error))
1982 }
1983}
1984
1985pub async fn list_queue(configuration: &configuration::Configuration, workspace: &str, order_desc: Option<bool>, created_by: Option<&str>, parent_job: Option<&str>, worker: Option<&str>, script_path_exact: Option<&str>, script_path_start: Option<&str>, schedule_path: Option<&str>, script_hash: Option<&str>, started_before: Option<String>, started_after: Option<String>, success: Option<bool>, scheduled_for_before_now: Option<bool>, job_kinds: Option<&str>, suspended: Option<bool>, running: Option<bool>, args: Option<&str>, result: Option<&str>, allow_wildcards: Option<bool>, tag: Option<&str>, page: Option<i32>, per_page: Option<i32>, all_workspaces: Option<bool>, is_not_schedule: Option<bool>) -> Result<Vec<models::QueuedJob>, Error<ListQueueError>> {
1986 let local_var_configuration = configuration;
1987
1988 let local_var_client = &local_var_configuration.client;
1989
1990 let local_var_uri_str = format!("{}/w/{workspace}/jobs/queue/list", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
1991 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1992
1993 if let Some(ref local_var_str) = order_desc {
1994 local_var_req_builder = local_var_req_builder.query(&[("order_desc", &local_var_str.to_string())]);
1995 }
1996 if let Some(ref local_var_str) = created_by {
1997 local_var_req_builder = local_var_req_builder.query(&[("created_by", &local_var_str.to_string())]);
1998 }
1999 if let Some(ref local_var_str) = parent_job {
2000 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2001 }
2002 if let Some(ref local_var_str) = worker {
2003 local_var_req_builder = local_var_req_builder.query(&[("worker", &local_var_str.to_string())]);
2004 }
2005 if let Some(ref local_var_str) = script_path_exact {
2006 local_var_req_builder = local_var_req_builder.query(&[("script_path_exact", &local_var_str.to_string())]);
2007 }
2008 if let Some(ref local_var_str) = script_path_start {
2009 local_var_req_builder = local_var_req_builder.query(&[("script_path_start", &local_var_str.to_string())]);
2010 }
2011 if let Some(ref local_var_str) = schedule_path {
2012 local_var_req_builder = local_var_req_builder.query(&[("schedule_path", &local_var_str.to_string())]);
2013 }
2014 if let Some(ref local_var_str) = script_hash {
2015 local_var_req_builder = local_var_req_builder.query(&[("script_hash", &local_var_str.to_string())]);
2016 }
2017 if let Some(ref local_var_str) = started_before {
2018 local_var_req_builder = local_var_req_builder.query(&[("started_before", &local_var_str.to_string())]);
2019 }
2020 if let Some(ref local_var_str) = started_after {
2021 local_var_req_builder = local_var_req_builder.query(&[("started_after", &local_var_str.to_string())]);
2022 }
2023 if let Some(ref local_var_str) = success {
2024 local_var_req_builder = local_var_req_builder.query(&[("success", &local_var_str.to_string())]);
2025 }
2026 if let Some(ref local_var_str) = scheduled_for_before_now {
2027 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for_before_now", &local_var_str.to_string())]);
2028 }
2029 if let Some(ref local_var_str) = job_kinds {
2030 local_var_req_builder = local_var_req_builder.query(&[("job_kinds", &local_var_str.to_string())]);
2031 }
2032 if let Some(ref local_var_str) = suspended {
2033 local_var_req_builder = local_var_req_builder.query(&[("suspended", &local_var_str.to_string())]);
2034 }
2035 if let Some(ref local_var_str) = running {
2036 local_var_req_builder = local_var_req_builder.query(&[("running", &local_var_str.to_string())]);
2037 }
2038 if let Some(ref local_var_str) = args {
2039 local_var_req_builder = local_var_req_builder.query(&[("args", &local_var_str.to_string())]);
2040 }
2041 if let Some(ref local_var_str) = result {
2042 local_var_req_builder = local_var_req_builder.query(&[("result", &local_var_str.to_string())]);
2043 }
2044 if let Some(ref local_var_str) = allow_wildcards {
2045 local_var_req_builder = local_var_req_builder.query(&[("allow_wildcards", &local_var_str.to_string())]);
2046 }
2047 if let Some(ref local_var_str) = tag {
2048 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2049 }
2050 if let Some(ref local_var_str) = page {
2051 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
2052 }
2053 if let Some(ref local_var_str) = per_page {
2054 local_var_req_builder = local_var_req_builder.query(&[("per_page", &local_var_str.to_string())]);
2055 }
2056 if let Some(ref local_var_str) = all_workspaces {
2057 local_var_req_builder = local_var_req_builder.query(&[("all_workspaces", &local_var_str.to_string())]);
2058 }
2059 if let Some(ref local_var_str) = is_not_schedule {
2060 local_var_req_builder = local_var_req_builder.query(&[("is_not_schedule", &local_var_str.to_string())]);
2061 }
2062 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2063 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2064 }
2065 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2066 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2067 };
2068
2069 let local_var_req = local_var_req_builder.build()?;
2070 let local_var_resp = local_var_client.execute(local_var_req).await?;
2071
2072 let local_var_status = local_var_resp.status();
2073 let local_var_content = local_var_resp.text().await?;
2074
2075 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2076 crate::from_str_patched(&local_var_content).map_err(Error::from)
2077 } else {
2078 let local_var_entity: Option<ListQueueError> = crate::from_str_patched(&local_var_content).ok();
2079 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2080 Err(Error::ResponseError(local_var_error))
2081 }
2082}
2083
2084pub async fn list_selected_job_groups(configuration: &configuration::Configuration, workspace: &str, uuid_colon_colon_uuid: Vec<uuid::Uuid>) -> Result<Vec<models::ListSelectedJobGroups200ResponseInner>, Error<ListSelectedJobGroupsError>> {
2085 let local_var_configuration = configuration;
2086
2087 let local_var_client = &local_var_configuration.client;
2088
2089 let local_var_uri_str = format!("{}/w/{workspace}/jobs/list_selected_job_groups", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2090 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2091
2092 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2093 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2094 }
2095 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2096 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2097 };
2098 local_var_req_builder = local_var_req_builder.json(&uuid_colon_colon_uuid);
2099
2100 let local_var_req = local_var_req_builder.build()?;
2101 let local_var_resp = local_var_client.execute(local_var_req).await?;
2102
2103 let local_var_status = local_var_resp.status();
2104 let local_var_content = local_var_resp.text().await?;
2105
2106 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2107 crate::from_str_patched(&local_var_content).map_err(Error::from)
2108 } else {
2109 let local_var_entity: Option<ListSelectedJobGroupsError> = crate::from_str_patched(&local_var_content).ok();
2110 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2111 Err(Error::ResponseError(local_var_error))
2112 }
2113}
2114
2115pub async fn openai_sync_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>) -> Result<serde_json::Value, Error<OpenaiSyncFlowByPathError>> {
2116 let local_var_configuration = configuration;
2117
2118 let local_var_client = &local_var_configuration.client;
2119
2120 let local_var_uri_str = format!("{}/w/{workspace}/jobs/openai_sync/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2121 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2122
2123 if let Some(ref local_var_str) = include_header {
2124 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2125 }
2126 if let Some(ref local_var_str) = queue_limit {
2127 local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2128 }
2129 if let Some(ref local_var_str) = job_id {
2130 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2131 }
2132 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2133 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2134 }
2135 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2136 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2137 };
2138 local_var_req_builder = local_var_req_builder.json(&request_body);
2139
2140 let local_var_req = local_var_req_builder.build()?;
2141 let local_var_resp = local_var_client.execute(local_var_req).await?;
2142
2143 let local_var_status = local_var_resp.status();
2144 let local_var_content = local_var_resp.text().await?;
2145
2146 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2147 crate::from_str_patched(&local_var_content).map_err(Error::from)
2148 } else {
2149 let local_var_entity: Option<OpenaiSyncFlowByPathError> = crate::from_str_patched(&local_var_content).ok();
2150 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2151 Err(Error::ResponseError(local_var_error))
2152 }
2153}
2154
2155pub async fn openai_sync_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, parent_job: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>) -> Result<serde_json::Value, Error<OpenaiSyncScriptByPathError>> {
2156 let local_var_configuration = configuration;
2157
2158 let local_var_client = &local_var_configuration.client;
2159
2160 let local_var_uri_str = format!("{}/w/{workspace}/jobs/openai_sync/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2161 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2162
2163 if let Some(ref local_var_str) = parent_job {
2164 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2165 }
2166 if let Some(ref local_var_str) = job_id {
2167 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2168 }
2169 if let Some(ref local_var_str) = include_header {
2170 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2171 }
2172 if let Some(ref local_var_str) = queue_limit {
2173 local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2174 }
2175 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2176 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2177 }
2178 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2179 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2180 };
2181 local_var_req_builder = local_var_req_builder.json(&request_body);
2182
2183 let local_var_req = local_var_req_builder.build()?;
2184 let local_var_resp = local_var_client.execute(local_var_req).await?;
2185
2186 let local_var_status = local_var_resp.status();
2187 let local_var_content = local_var_resp.text().await?;
2188
2189 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2190 crate::from_str_patched(&local_var_content).map_err(Error::from)
2191 } else {
2192 let local_var_entity: Option<OpenaiSyncScriptByPathError> = crate::from_str_patched(&local_var_content).ok();
2193 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2194 Err(Error::ResponseError(local_var_error))
2195 }
2196}
2197
2198pub async fn restart_flow_at_step(configuration: &configuration::Configuration, workspace: &str, id: &str, step_id: &str, branch_or_iteration_n: i32, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, parent_job: Option<&str>, tag: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RestartFlowAtStepError>> {
2199 let local_var_configuration = configuration;
2200
2201 let local_var_client = &local_var_configuration.client;
2202
2203 let local_var_uri_str = format!("{}/w/{workspace}/jobs/restart/f/{id}/from/{step_id}/{branch_or_iteration_n}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), step_id=crate::apis::urlencode(step_id), branch_or_iteration_n=branch_or_iteration_n);
2204 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2205
2206 if let Some(ref local_var_str) = scheduled_for {
2207 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
2208 }
2209 if let Some(ref local_var_str) = scheduled_in_secs {
2210 local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
2211 }
2212 if let Some(ref local_var_str) = parent_job {
2213 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2214 }
2215 if let Some(ref local_var_str) = tag {
2216 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2217 }
2218 if let Some(ref local_var_str) = job_id {
2219 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2220 }
2221 if let Some(ref local_var_str) = include_header {
2222 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2223 }
2224 if let Some(ref local_var_str) = invisible_to_owner {
2225 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2226 }
2227 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2228 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2229 }
2230 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2231 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2232 };
2233 local_var_req_builder = local_var_req_builder.json(&request_body);
2234
2235 let local_var_req = local_var_req_builder.build()?;
2236 let local_var_resp = local_var_client.execute(local_var_req).await?;
2237
2238 let local_var_status = local_var_resp.status();
2239 let local_var_content = local_var_resp.text().await?;
2240
2241 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2242 crate::from_str_patched(&local_var_content).map_err(Error::from)
2243 } else {
2244 let local_var_entity: Option<RestartFlowAtStepError> = crate::from_str_patched(&local_var_content).ok();
2245 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2246 Err(Error::ResponseError(local_var_error))
2247 }
2248}
2249
2250pub async fn result_by_id(configuration: &configuration::Configuration, workspace: &str, flow_job_id: &str, node_id: &str) -> Result<serde_json::Value, Error<ResultByIdError>> {
2251 let local_var_configuration = configuration;
2252
2253 let local_var_client = &local_var_configuration.client;
2254
2255 let local_var_uri_str = format!("{}/w/{workspace}/jobs/result_by_id/{flow_job_id}/{node_id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), flow_job_id=crate::apis::urlencode(flow_job_id), node_id=crate::apis::urlencode(node_id));
2256 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2257
2258 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2259 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2260 }
2261 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2262 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2263 };
2264
2265 let local_var_req = local_var_req_builder.build()?;
2266 let local_var_resp = local_var_client.execute(local_var_req).await?;
2267
2268 let local_var_status = local_var_resp.status();
2269 let local_var_content = local_var_resp.text().await?;
2270
2271 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2272 crate::from_str_patched(&local_var_content).map_err(Error::from)
2273 } else {
2274 let local_var_entity: Option<ResultByIdError> = crate::from_str_patched(&local_var_content).ok();
2275 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2276 Err(Error::ResponseError(local_var_error))
2277 }
2278}
2279
2280pub async fn resume_suspended_flow_as_owner(configuration: &configuration::Configuration, workspace: &str, id: &str, body: serde_json::Value) -> Result<String, Error<ResumeSuspendedFlowAsOwnerError>> {
2281 let local_var_configuration = configuration;
2282
2283 let local_var_client = &local_var_configuration.client;
2284
2285 let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/resume/{id}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id));
2286 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2287
2288 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2289 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2290 }
2291 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2292 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2293 };
2294 local_var_req_builder = local_var_req_builder.json(&body);
2295
2296 let local_var_req = local_var_req_builder.build()?;
2297 let local_var_resp = local_var_client.execute(local_var_req).await?;
2298
2299 let local_var_status = local_var_resp.status();
2300 let local_var_content = local_var_resp.text().await?;
2301
2302 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2303 crate::from_str_patched(&local_var_content).map_err(Error::from)
2304 } else {
2305 let local_var_entity: Option<ResumeSuspendedFlowAsOwnerError> = crate::from_str_patched(&local_var_content).ok();
2306 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2307 Err(Error::ResponseError(local_var_error))
2308 }
2309}
2310
2311pub async fn resume_suspended_job_get(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, payload: Option<&str>, approver: Option<&str>) -> Result<String, Error<ResumeSuspendedJobGetError>> {
2312 let local_var_configuration = configuration;
2313
2314 let local_var_client = &local_var_configuration.client;
2315
2316 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
2317 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2318
2319 if let Some(ref local_var_str) = payload {
2320 local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
2321 }
2322 if let Some(ref local_var_str) = approver {
2323 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
2324 }
2325 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2326 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2327 }
2328 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2329 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2330 };
2331
2332 let local_var_req = local_var_req_builder.build()?;
2333 let local_var_resp = local_var_client.execute(local_var_req).await?;
2334
2335 let local_var_status = local_var_resp.status();
2336 let local_var_content = local_var_resp.text().await?;
2337
2338 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2339 crate::from_str_patched(&local_var_content).map_err(Error::from)
2340 } else {
2341 let local_var_entity: Option<ResumeSuspendedJobGetError> = crate::from_str_patched(&local_var_content).ok();
2342 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2343 Err(Error::ResponseError(local_var_error))
2344 }
2345}
2346
2347pub async fn resume_suspended_job_post(configuration: &configuration::Configuration, workspace: &str, id: &str, resume_id: i32, signature: &str, body: serde_json::Value, approver: Option<&str>) -> Result<String, Error<ResumeSuspendedJobPostError>> {
2348 let local_var_configuration = configuration;
2349
2350 let local_var_client = &local_var_configuration.client;
2351
2352 let local_var_uri_str = format!("{}/w/{workspace}/jobs_u/resume/{id}/{resume_id}/{signature}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), resume_id=resume_id, signature=crate::apis::urlencode(signature));
2353 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2354
2355 if let Some(ref local_var_str) = approver {
2356 local_var_req_builder = local_var_req_builder.query(&[("approver", &local_var_str.to_string())]);
2357 }
2358 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2359 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2360 }
2361 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2362 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2363 };
2364 local_var_req_builder = local_var_req_builder.json(&body);
2365
2366 let local_var_req = local_var_req_builder.build()?;
2367 let local_var_resp = local_var_client.execute(local_var_req).await?;
2368
2369 let local_var_status = local_var_resp.status();
2370 let local_var_content = local_var_resp.text().await?;
2371
2372 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2373 crate::from_str_patched(&local_var_content).map_err(Error::from)
2374 } else {
2375 let local_var_entity: Option<ResumeSuspendedJobPostError> = crate::from_str_patched(&local_var_content).ok();
2376 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2377 Err(Error::ResponseError(local_var_error))
2378 }
2379}
2380
2381pub async fn run_code_workflow_task(configuration: &configuration::Configuration, workspace: &str, job_id: &str, entrypoint: &str, workflow_task: models::WorkflowTask) -> Result<uuid::Uuid, Error<RunCodeWorkflowTaskError>> {
2382 let local_var_configuration = configuration;
2383
2384 let local_var_client = &local_var_configuration.client;
2385
2386 let local_var_uri_str = format!("{}/w/{workspace}/jobs/workflow_as_code/{job_id}/{entrypoint}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), job_id=crate::apis::urlencode(job_id), entrypoint=crate::apis::urlencode(entrypoint));
2387 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2388
2389 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2390 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2391 }
2392 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2393 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2394 };
2395 local_var_req_builder = local_var_req_builder.json(&workflow_task);
2396
2397 let local_var_req = local_var_req_builder.build()?;
2398 let local_var_resp = local_var_client.execute(local_var_req).await?;
2399
2400 let local_var_status = local_var_resp.status();
2401 let local_var_content = local_var_resp.text().await?;
2402
2403 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2404 crate::from_str_patched(&local_var_content).map_err(Error::from)
2405 } else {
2406 let local_var_entity: Option<RunCodeWorkflowTaskError> = crate::from_str_patched(&local_var_content).ok();
2407 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2408 Err(Error::ResponseError(local_var_error))
2409 }
2410}
2411
2412pub async fn run_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RunFlowByPathError>> {
2413 let local_var_configuration = configuration;
2414
2415 let local_var_client = &local_var_configuration.client;
2416
2417 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2418 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2419
2420 if let Some(ref local_var_str) = scheduled_for {
2421 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
2422 }
2423 if let Some(ref local_var_str) = scheduled_in_secs {
2424 local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
2425 }
2426 if let Some(ref local_var_str) = skip_preprocessor {
2427 local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
2428 }
2429 if let Some(ref local_var_str) = parent_job {
2430 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2431 }
2432 if let Some(ref local_var_str) = tag {
2433 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2434 }
2435 if let Some(ref local_var_str) = job_id {
2436 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2437 }
2438 if let Some(ref local_var_str) = include_header {
2439 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2440 }
2441 if let Some(ref local_var_str) = invisible_to_owner {
2442 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2443 }
2444 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2445 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2446 }
2447 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2448 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2449 };
2450 local_var_req_builder = local_var_req_builder.json(&request_body);
2451
2452 let local_var_req = local_var_req_builder.build()?;
2453 let local_var_resp = local_var_client.execute(local_var_req).await?;
2454
2455 let local_var_status = local_var_resp.status();
2456 let local_var_content = local_var_resp.text().await?;
2457
2458 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2459 crate::from_str_patched(&local_var_content).map_err(Error::from)
2460 } else {
2461 let local_var_entity: Option<RunFlowByPathError> = crate::from_str_patched(&local_var_content).ok();
2462 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2463 Err(Error::ResponseError(local_var_error))
2464 }
2465}
2466
2467pub async fn run_flow_preview(configuration: &configuration::Configuration, workspace: &str, flow_preview: models::FlowPreview, include_header: Option<&str>, invisible_to_owner: Option<bool>, job_id: Option<&str>) -> Result<uuid::Uuid, Error<RunFlowPreviewError>> {
2468 let local_var_configuration = configuration;
2469
2470 let local_var_client = &local_var_configuration.client;
2471
2472 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/preview_flow", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2473 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2474
2475 if let Some(ref local_var_str) = include_header {
2476 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2477 }
2478 if let Some(ref local_var_str) = invisible_to_owner {
2479 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2480 }
2481 if let Some(ref local_var_str) = job_id {
2482 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2483 }
2484 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2485 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2486 }
2487 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2488 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2489 };
2490 local_var_req_builder = local_var_req_builder.json(&flow_preview);
2491
2492 let local_var_req = local_var_req_builder.build()?;
2493 let local_var_resp = local_var_client.execute(local_var_req).await?;
2494
2495 let local_var_status = local_var_resp.status();
2496 let local_var_content = local_var_resp.text().await?;
2497
2498 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2499 crate::from_str_patched(&local_var_content).map_err(Error::from)
2500 } else {
2501 let local_var_entity: Option<RunFlowPreviewError> = crate::from_str_patched(&local_var_content).ok();
2502 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2503 Err(Error::ResponseError(local_var_error))
2504 }
2505}
2506
2507pub async fn run_raw_script_dependencies(configuration: &configuration::Configuration, workspace: &str, run_raw_script_dependencies_request: models::RunRawScriptDependenciesRequest) -> Result<models::RunRawScriptDependencies201Response, Error<RunRawScriptDependenciesError>> {
2508 let local_var_configuration = configuration;
2509
2510 let local_var_client = &local_var_configuration.client;
2511
2512 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/dependencies", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2513 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2514
2515 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2516 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2517 }
2518 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2519 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2520 };
2521 local_var_req_builder = local_var_req_builder.json(&run_raw_script_dependencies_request);
2522
2523 let local_var_req = local_var_req_builder.build()?;
2524 let local_var_resp = local_var_client.execute(local_var_req).await?;
2525
2526 let local_var_status = local_var_resp.status();
2527 let local_var_content = local_var_resp.text().await?;
2528
2529 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2530 crate::from_str_patched(&local_var_content).map_err(Error::from)
2531 } else {
2532 let local_var_entity: Option<RunRawScriptDependenciesError> = crate::from_str_patched(&local_var_content).ok();
2533 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2534 Err(Error::ResponseError(local_var_error))
2535 }
2536}
2537
2538pub async fn run_script_by_hash(configuration: &configuration::Configuration, workspace: &str, hash: &str, body: serde_json::Value, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RunScriptByHashError>> {
2539 let local_var_configuration = configuration;
2540
2541 let local_var_client = &local_var_configuration.client;
2542
2543 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/h/{hash}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), hash=crate::apis::urlencode(hash));
2544 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2545
2546 if let Some(ref local_var_str) = scheduled_for {
2547 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
2548 }
2549 if let Some(ref local_var_str) = scheduled_in_secs {
2550 local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
2551 }
2552 if let Some(ref local_var_str) = skip_preprocessor {
2553 local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
2554 }
2555 if let Some(ref local_var_str) = parent_job {
2556 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2557 }
2558 if let Some(ref local_var_str) = tag {
2559 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2560 }
2561 if let Some(ref local_var_str) = cache_ttl {
2562 local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
2563 }
2564 if let Some(ref local_var_str) = job_id {
2565 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2566 }
2567 if let Some(ref local_var_str) = include_header {
2568 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2569 }
2570 if let Some(ref local_var_str) = invisible_to_owner {
2571 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2572 }
2573 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2574 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2575 }
2576 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2577 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2578 };
2579 local_var_req_builder = local_var_req_builder.json(&body);
2580
2581 let local_var_req = local_var_req_builder.build()?;
2582 let local_var_resp = local_var_client.execute(local_var_req).await?;
2583
2584 let local_var_status = local_var_resp.status();
2585 let local_var_content = local_var_resp.text().await?;
2586
2587 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2588 crate::from_str_patched(&local_var_content).map_err(Error::from)
2589 } else {
2590 let local_var_entity: Option<RunScriptByHashError> = crate::from_str_patched(&local_var_content).ok();
2591 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2592 Err(Error::ResponseError(local_var_error))
2593 }
2594}
2595
2596pub async fn run_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, scheduled_for: Option<String>, scheduled_in_secs: Option<i32>, skip_preprocessor: Option<bool>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, invisible_to_owner: Option<bool>) -> Result<uuid::Uuid, Error<RunScriptByPathError>> {
2597 let local_var_configuration = configuration;
2598
2599 let local_var_client = &local_var_configuration.client;
2600
2601 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2602 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2603
2604 if let Some(ref local_var_str) = scheduled_for {
2605 local_var_req_builder = local_var_req_builder.query(&[("scheduled_for", &local_var_str.to_string())]);
2606 }
2607 if let Some(ref local_var_str) = scheduled_in_secs {
2608 local_var_req_builder = local_var_req_builder.query(&[("scheduled_in_secs", &local_var_str.to_string())]);
2609 }
2610 if let Some(ref local_var_str) = skip_preprocessor {
2611 local_var_req_builder = local_var_req_builder.query(&[("skip_preprocessor", &local_var_str.to_string())]);
2612 }
2613 if let Some(ref local_var_str) = parent_job {
2614 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2615 }
2616 if let Some(ref local_var_str) = tag {
2617 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2618 }
2619 if let Some(ref local_var_str) = cache_ttl {
2620 local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
2621 }
2622 if let Some(ref local_var_str) = job_id {
2623 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2624 }
2625 if let Some(ref local_var_str) = invisible_to_owner {
2626 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2627 }
2628 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2629 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2630 }
2631 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2632 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2633 };
2634 local_var_req_builder = local_var_req_builder.json(&request_body);
2635
2636 let local_var_req = local_var_req_builder.build()?;
2637 let local_var_resp = local_var_client.execute(local_var_req).await?;
2638
2639 let local_var_status = local_var_resp.status();
2640 let local_var_content = local_var_resp.text().await?;
2641
2642 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2643 crate::from_str_patched(&local_var_content).map_err(Error::from)
2644 } else {
2645 let local_var_entity: Option<RunScriptByPathError> = crate::from_str_patched(&local_var_content).ok();
2646 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2647 Err(Error::ResponseError(local_var_error))
2648 }
2649}
2650
2651pub async fn run_script_preview(configuration: &configuration::Configuration, workspace: &str, preview: models::Preview, include_header: Option<&str>, invisible_to_owner: Option<bool>, job_id: Option<&str>) -> Result<uuid::Uuid, Error<RunScriptPreviewError>> {
2652 let local_var_configuration = configuration;
2653
2654 let local_var_client = &local_var_configuration.client;
2655
2656 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run/preview", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace));
2657 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2658
2659 if let Some(ref local_var_str) = include_header {
2660 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2661 }
2662 if let Some(ref local_var_str) = invisible_to_owner {
2663 local_var_req_builder = local_var_req_builder.query(&[("invisible_to_owner", &local_var_str.to_string())]);
2664 }
2665 if let Some(ref local_var_str) = job_id {
2666 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2667 }
2668 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2669 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2670 }
2671 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2672 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2673 };
2674 local_var_req_builder = local_var_req_builder.json(&preview);
2675
2676 let local_var_req = local_var_req_builder.build()?;
2677 let local_var_resp = local_var_client.execute(local_var_req).await?;
2678
2679 let local_var_status = local_var_resp.status();
2680 let local_var_content = local_var_resp.text().await?;
2681
2682 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2683 crate::from_str_patched(&local_var_content).map_err(Error::from)
2684 } else {
2685 let local_var_entity: Option<RunScriptPreviewError> = crate::from_str_patched(&local_var_content).ok();
2686 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2687 Err(Error::ResponseError(local_var_error))
2688 }
2689}
2690
2691pub async fn run_wait_result_flow_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, include_header: Option<&str>, queue_limit: Option<&str>, job_id: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultFlowByPathError>> {
2692 let local_var_configuration = configuration;
2693
2694 let local_var_client = &local_var_configuration.client;
2695
2696 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/f/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2697 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2698
2699 if let Some(ref local_var_str) = include_header {
2700 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2701 }
2702 if let Some(ref local_var_str) = queue_limit {
2703 local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2704 }
2705 if let Some(ref local_var_str) = job_id {
2706 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2707 }
2708 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2709 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2710 }
2711 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2712 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2713 };
2714 local_var_req_builder = local_var_req_builder.json(&request_body);
2715
2716 let local_var_req = local_var_req_builder.build()?;
2717 let local_var_resp = local_var_client.execute(local_var_req).await?;
2718
2719 let local_var_status = local_var_resp.status();
2720 let local_var_content = local_var_resp.text().await?;
2721
2722 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2723 crate::from_str_patched(&local_var_content).map_err(Error::from)
2724 } else {
2725 let local_var_entity: Option<RunWaitResultFlowByPathError> = crate::from_str_patched(&local_var_content).ok();
2726 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2727 Err(Error::ResponseError(local_var_error))
2728 }
2729}
2730
2731pub async fn run_wait_result_script_by_path(configuration: &configuration::Configuration, workspace: &str, path: &str, request_body: std::collections::HashMap<String, serde_json::Value>, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultScriptByPathError>> {
2732 let local_var_configuration = configuration;
2733
2734 let local_var_client = &local_var_configuration.client;
2735
2736 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2737 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2738
2739 if let Some(ref local_var_str) = parent_job {
2740 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2741 }
2742 if let Some(ref local_var_str) = tag {
2743 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2744 }
2745 if let Some(ref local_var_str) = cache_ttl {
2746 local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
2747 }
2748 if let Some(ref local_var_str) = job_id {
2749 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2750 }
2751 if let Some(ref local_var_str) = include_header {
2752 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2753 }
2754 if let Some(ref local_var_str) = queue_limit {
2755 local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2756 }
2757 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2758 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2759 }
2760 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2761 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2762 };
2763 local_var_req_builder = local_var_req_builder.json(&request_body);
2764
2765 let local_var_req = local_var_req_builder.build()?;
2766 let local_var_resp = local_var_client.execute(local_var_req).await?;
2767
2768 let local_var_status = local_var_resp.status();
2769 let local_var_content = local_var_resp.text().await?;
2770
2771 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2772 crate::from_str_patched(&local_var_content).map_err(Error::from)
2773 } else {
2774 let local_var_entity: Option<RunWaitResultScriptByPathError> = crate::from_str_patched(&local_var_content).ok();
2775 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2776 Err(Error::ResponseError(local_var_error))
2777 }
2778}
2779
2780pub async fn run_wait_result_script_by_path_get(configuration: &configuration::Configuration, workspace: &str, path: &str, parent_job: Option<&str>, tag: Option<&str>, cache_ttl: Option<&str>, job_id: Option<&str>, include_header: Option<&str>, queue_limit: Option<&str>, payload: Option<&str>) -> Result<serde_json::Value, Error<RunWaitResultScriptByPathGetError>> {
2781 let local_var_configuration = configuration;
2782
2783 let local_var_client = &local_var_configuration.client;
2784
2785 let local_var_uri_str = format!("{}/w/{workspace}/jobs/run_wait_result/p/{path}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), path=crate::apis::urlencode(path));
2786 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
2787
2788 if let Some(ref local_var_str) = parent_job {
2789 local_var_req_builder = local_var_req_builder.query(&[("parent_job", &local_var_str.to_string())]);
2790 }
2791 if let Some(ref local_var_str) = tag {
2792 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
2793 }
2794 if let Some(ref local_var_str) = cache_ttl {
2795 local_var_req_builder = local_var_req_builder.query(&[("cache_ttl", &local_var_str.to_string())]);
2796 }
2797 if let Some(ref local_var_str) = job_id {
2798 local_var_req_builder = local_var_req_builder.query(&[("job_id", &local_var_str.to_string())]);
2799 }
2800 if let Some(ref local_var_str) = include_header {
2801 local_var_req_builder = local_var_req_builder.query(&[("include_header", &local_var_str.to_string())]);
2802 }
2803 if let Some(ref local_var_str) = queue_limit {
2804 local_var_req_builder = local_var_req_builder.query(&[("queue_limit", &local_var_str.to_string())]);
2805 }
2806 if let Some(ref local_var_str) = payload {
2807 local_var_req_builder = local_var_req_builder.query(&[("payload", &local_var_str.to_string())]);
2808 }
2809 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2810 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2811 }
2812 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2813 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2814 };
2815
2816 let local_var_req = local_var_req_builder.build()?;
2817 let local_var_resp = local_var_client.execute(local_var_req).await?;
2818
2819 let local_var_status = local_var_resp.status();
2820 let local_var_content = local_var_resp.text().await?;
2821
2822 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2823 crate::from_str_patched(&local_var_content).map_err(Error::from)
2824 } else {
2825 let local_var_entity: Option<RunWaitResultScriptByPathGetError> = crate::from_str_patched(&local_var_content).ok();
2826 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2827 Err(Error::ResponseError(local_var_error))
2828 }
2829}
2830
2831pub async fn set_flow_user_state(configuration: &configuration::Configuration, workspace: &str, id: &str, key: &str, body: Option<serde_json::Value>) -> Result<String, Error<SetFlowUserStateError>> {
2832 let local_var_configuration = configuration;
2833
2834 let local_var_client = &local_var_configuration.client;
2835
2836 let local_var_uri_str = format!("{}/w/{workspace}/jobs/flow/user_states/{id}/{key}", local_var_configuration.base_path, workspace=crate::apis::urlencode(workspace), id=crate::apis::urlencode(id), key=crate::apis::urlencode(key));
2837 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2838
2839 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2840 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2841 }
2842 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
2843 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
2844 };
2845 local_var_req_builder = local_var_req_builder.json(&body);
2846
2847 let local_var_req = local_var_req_builder.build()?;
2848 let local_var_resp = local_var_client.execute(local_var_req).await?;
2849
2850 let local_var_status = local_var_resp.status();
2851 let local_var_content = local_var_resp.text().await?;
2852
2853 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2854 crate::from_str_patched(&local_var_content).map_err(Error::from)
2855 } else {
2856 let local_var_entity: Option<SetFlowUserStateError> = crate::from_str_patched(&local_var_content).ok();
2857 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2858 Err(Error::ResponseError(local_var_error))
2859 }
2860}
2861