1use super::{configuration, Error};
12use crate::gen::apis::ResponseContent;
13use crate::gen::models;
14
15#[derive(Clone, Debug)]
17pub struct CreateWorkflowSchemeDraftFromParentParams {
18 pub id: i64,
20}
21
22#[derive(Clone, Debug)]
24pub struct DeleteDraftDefaultWorkflowParams {
25 pub id: i64,
27}
28
29#[derive(Clone, Debug)]
31pub struct DeleteDraftWorkflowMappingParams {
32 pub id: i64,
34 pub workflow_name: String,
36}
37
38#[derive(Clone, Debug)]
40pub struct DeleteWorkflowSchemeDraftParams {
41 pub id: i64,
43}
44
45#[derive(Clone, Debug)]
47pub struct DeleteWorkflowSchemeDraftIssueTypeParams {
48 pub id: i64,
50 pub issue_type: String,
52}
53
54#[derive(Clone, Debug)]
56pub struct GetDraftDefaultWorkflowParams {
57 pub id: i64,
59}
60
61#[derive(Clone, Debug)]
63pub struct GetDraftWorkflowParams {
64 pub id: i64,
66 pub workflow_name: Option<String>,
68}
69
70#[derive(Clone, Debug)]
72pub struct GetWorkflowSchemeDraftParams {
73 pub id: i64,
75}
76
77#[derive(Clone, Debug)]
79pub struct GetWorkflowSchemeDraftIssueTypeParams {
80 pub id: i64,
82 pub issue_type: String,
84}
85
86#[derive(Clone, Debug)]
88pub struct SetWorkflowSchemeDraftIssueTypeParams {
89 pub id: i64,
91 pub issue_type: String,
93 pub issue_type_workflow_mapping: models::IssueTypeWorkflowMapping,
95}
96
97#[derive(Clone, Debug)]
99pub struct UpdateDraftDefaultWorkflowParams {
100 pub id: i64,
102 pub default_workflow: models::DefaultWorkflow,
104}
105
106#[derive(Clone, Debug)]
108pub struct UpdateDraftWorkflowMappingParams {
109 pub id: i64,
111 pub workflow_name: String,
113 pub issue_types_workflow_mapping: models::IssueTypesWorkflowMapping,
114}
115
116#[derive(Clone, Debug)]
118pub struct UpdateWorkflowSchemeDraftParams {
119 pub id: i64,
121 pub workflow_scheme: models::WorkflowScheme,
122}
123
124#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum CreateWorkflowSchemeDraftFromParentError {
128 Status400(),
129 Status401(),
130 Status403(),
131 UnknownValue(serde_json::Value),
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(untagged)]
137pub enum DeleteDraftDefaultWorkflowError {
138 Status401(),
139 Status403(),
140 Status404(),
141 UnknownValue(serde_json::Value),
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum DeleteDraftWorkflowMappingError {
148 Status401(),
149 Status403(),
150 Status404(),
151 UnknownValue(serde_json::Value),
152}
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum DeleteWorkflowSchemeDraftError {
158 Status401(),
159 Status403(),
160 Status404(),
161 UnknownValue(serde_json::Value),
162}
163
164#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(untagged)]
167pub enum DeleteWorkflowSchemeDraftIssueTypeError {
168 Status401(),
169 Status403(),
170 Status404(),
171 UnknownValue(serde_json::Value),
172}
173
174#[derive(Debug, Clone, Serialize, Deserialize)]
176#[serde(untagged)]
177pub enum GetDraftDefaultWorkflowError {
178 Status401(),
179 Status403(),
180 Status404(),
181 UnknownValue(serde_json::Value),
182}
183
184#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(untagged)]
187pub enum GetDraftWorkflowError {
188 Status401(),
189 Status403(),
190 Status404(),
191 UnknownValue(serde_json::Value),
192}
193
194#[derive(Debug, Clone, Serialize, Deserialize)]
196#[serde(untagged)]
197pub enum GetWorkflowSchemeDraftError {
198 Status401(),
199 Status403(),
200 Status404(),
201 UnknownValue(serde_json::Value),
202}
203
204#[derive(Debug, Clone, Serialize, Deserialize)]
206#[serde(untagged)]
207pub enum GetWorkflowSchemeDraftIssueTypeError {
208 Status401(),
209 Status403(),
210 Status404(),
211 UnknownValue(serde_json::Value),
212}
213
214#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum SetWorkflowSchemeDraftIssueTypeError {
218 Status400(),
219 Status401(),
220 Status403(),
221 Status404(),
222 UnknownValue(serde_json::Value),
223}
224
225#[derive(Debug, Clone, Serialize, Deserialize)]
227#[serde(untagged)]
228pub enum UpdateDraftDefaultWorkflowError {
229 Status400(),
230 Status401(),
231 Status403(),
232 Status404(),
233 UnknownValue(serde_json::Value),
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
238#[serde(untagged)]
239pub enum UpdateDraftWorkflowMappingError {
240 Status400(),
241 Status401(),
242 Status403(),
243 Status404(),
244 UnknownValue(serde_json::Value),
245}
246
247#[derive(Debug, Clone, Serialize, Deserialize)]
249#[serde(untagged)]
250pub enum UpdateWorkflowSchemeDraftError {
251 Status400(),
252 Status401(),
253 Status403(),
254 Status404(),
255 UnknownValue(serde_json::Value),
256}
257
258pub async fn create_workflow_scheme_draft_from_parent(
260 configuration: &configuration::Configuration,
261 params: CreateWorkflowSchemeDraftFromParentParams,
262) -> Result<models::WorkflowScheme, Error<CreateWorkflowSchemeDraftFromParentError>> {
263 let id = params.id;
265
266 let local_var_client = &configuration.client;
267
268 let local_var_uri_str = format!(
269 "{}/rest/api/3/workflowscheme/{id}/createdraft",
270 configuration.base_path,
271 id = id
272 );
273 let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
274
275 if let Some(ref local_var_user_agent) = configuration.user_agent {
276 local_var_req_builder =
277 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
278 }
279 if let Some(ref local_var_token) = configuration.oauth_access_token {
280 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
281 };
282 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
283 local_var_req_builder = local_var_req_builder.basic_auth(
284 local_var_auth_conf.0.to_owned(),
285 local_var_auth_conf.1.to_owned(),
286 );
287 };
288
289 let local_var_req = local_var_req_builder.build()?;
290 let local_var_resp = local_var_client.execute(local_var_req).await?;
291
292 let local_var_status = local_var_resp.status();
293 let local_var_content = local_var_resp.text().await?;
294
295 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
296 serde_json::from_str(&local_var_content).map_err(Error::from)
297 } else {
298 let local_var_entity: Option<CreateWorkflowSchemeDraftFromParentError> =
299 serde_json::from_str(&local_var_content).ok();
300 let local_var_error = ResponseContent {
301 status: local_var_status,
302 content: local_var_content,
303 entity: local_var_entity,
304 };
305 Err(Error::ResponseError(local_var_error))
306 }
307}
308
309pub async fn delete_draft_default_workflow(
311 configuration: &configuration::Configuration,
312 params: DeleteDraftDefaultWorkflowParams,
313) -> Result<models::WorkflowScheme, Error<DeleteDraftDefaultWorkflowError>> {
314 let id = params.id;
316
317 let local_var_client = &configuration.client;
318
319 let local_var_uri_str = format!(
320 "{}/rest/api/3/workflowscheme/{id}/draft/default",
321 configuration.base_path,
322 id = id
323 );
324 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
325
326 if let Some(ref local_var_user_agent) = configuration.user_agent {
327 local_var_req_builder =
328 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
329 }
330 if let Some(ref local_var_token) = configuration.oauth_access_token {
331 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
332 };
333 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
334 local_var_req_builder = local_var_req_builder.basic_auth(
335 local_var_auth_conf.0.to_owned(),
336 local_var_auth_conf.1.to_owned(),
337 );
338 };
339
340 let local_var_req = local_var_req_builder.build()?;
341 let local_var_resp = local_var_client.execute(local_var_req).await?;
342
343 let local_var_status = local_var_resp.status();
344 let local_var_content = local_var_resp.text().await?;
345
346 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
347 serde_json::from_str(&local_var_content).map_err(Error::from)
348 } else {
349 let local_var_entity: Option<DeleteDraftDefaultWorkflowError> =
350 serde_json::from_str(&local_var_content).ok();
351 let local_var_error = ResponseContent {
352 status: local_var_status,
353 content: local_var_content,
354 entity: local_var_entity,
355 };
356 Err(Error::ResponseError(local_var_error))
357 }
358}
359
360pub async fn delete_draft_workflow_mapping(
362 configuration: &configuration::Configuration,
363 params: DeleteDraftWorkflowMappingParams,
364) -> Result<(), Error<DeleteDraftWorkflowMappingError>> {
365 let id = params.id;
367 let workflow_name = params.workflow_name;
368
369 let local_var_client = &configuration.client;
370
371 let local_var_uri_str = format!(
372 "{}/rest/api/3/workflowscheme/{id}/draft/workflow",
373 configuration.base_path,
374 id = id
375 );
376 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
377
378 local_var_req_builder =
379 local_var_req_builder.query(&[("workflowName", &workflow_name.to_string())]);
380 if let Some(ref local_var_user_agent) = configuration.user_agent {
381 local_var_req_builder =
382 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
383 }
384 if let Some(ref local_var_token) = configuration.oauth_access_token {
385 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
386 };
387 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
388 local_var_req_builder = local_var_req_builder.basic_auth(
389 local_var_auth_conf.0.to_owned(),
390 local_var_auth_conf.1.to_owned(),
391 );
392 };
393
394 let local_var_req = local_var_req_builder.build()?;
395 let local_var_resp = local_var_client.execute(local_var_req).await?;
396
397 let local_var_status = local_var_resp.status();
398 let local_var_content = local_var_resp.text().await?;
399
400 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
401 Ok(())
402 } else {
403 let local_var_entity: Option<DeleteDraftWorkflowMappingError> =
404 serde_json::from_str(&local_var_content).ok();
405 let local_var_error = ResponseContent {
406 status: local_var_status,
407 content: local_var_content,
408 entity: local_var_entity,
409 };
410 Err(Error::ResponseError(local_var_error))
411 }
412}
413
414pub async fn delete_workflow_scheme_draft(
416 configuration: &configuration::Configuration,
417 params: DeleteWorkflowSchemeDraftParams,
418) -> Result<(), Error<DeleteWorkflowSchemeDraftError>> {
419 let id = params.id;
421
422 let local_var_client = &configuration.client;
423
424 let local_var_uri_str = format!(
425 "{}/rest/api/3/workflowscheme/{id}/draft",
426 configuration.base_path,
427 id = id
428 );
429 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
430
431 if let Some(ref local_var_user_agent) = configuration.user_agent {
432 local_var_req_builder =
433 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
434 }
435 if let Some(ref local_var_token) = configuration.oauth_access_token {
436 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
437 };
438 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
439 local_var_req_builder = local_var_req_builder.basic_auth(
440 local_var_auth_conf.0.to_owned(),
441 local_var_auth_conf.1.to_owned(),
442 );
443 };
444
445 let local_var_req = local_var_req_builder.build()?;
446 let local_var_resp = local_var_client.execute(local_var_req).await?;
447
448 let local_var_status = local_var_resp.status();
449 let local_var_content = local_var_resp.text().await?;
450
451 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
452 Ok(())
453 } else {
454 let local_var_entity: Option<DeleteWorkflowSchemeDraftError> =
455 serde_json::from_str(&local_var_content).ok();
456 let local_var_error = ResponseContent {
457 status: local_var_status,
458 content: local_var_content,
459 entity: local_var_entity,
460 };
461 Err(Error::ResponseError(local_var_error))
462 }
463}
464
465pub async fn delete_workflow_scheme_draft_issue_type(
467 configuration: &configuration::Configuration,
468 params: DeleteWorkflowSchemeDraftIssueTypeParams,
469) -> Result<models::WorkflowScheme, Error<DeleteWorkflowSchemeDraftIssueTypeError>> {
470 let id = params.id;
472 let issue_type = params.issue_type;
473
474 let local_var_client = &configuration.client;
475
476 let local_var_uri_str = format!(
477 "{}/rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}",
478 configuration.base_path,
479 id = id,
480 issueType = crate::gen::apis::urlencode(issue_type)
481 );
482 let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
483
484 if let Some(ref local_var_user_agent) = configuration.user_agent {
485 local_var_req_builder =
486 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
487 }
488 if let Some(ref local_var_token) = configuration.oauth_access_token {
489 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
490 };
491 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
492 local_var_req_builder = local_var_req_builder.basic_auth(
493 local_var_auth_conf.0.to_owned(),
494 local_var_auth_conf.1.to_owned(),
495 );
496 };
497
498 let local_var_req = local_var_req_builder.build()?;
499 let local_var_resp = local_var_client.execute(local_var_req).await?;
500
501 let local_var_status = local_var_resp.status();
502 let local_var_content = local_var_resp.text().await?;
503
504 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
505 serde_json::from_str(&local_var_content).map_err(Error::from)
506 } else {
507 let local_var_entity: Option<DeleteWorkflowSchemeDraftIssueTypeError> =
508 serde_json::from_str(&local_var_content).ok();
509 let local_var_error = ResponseContent {
510 status: local_var_status,
511 content: local_var_content,
512 entity: local_var_entity,
513 };
514 Err(Error::ResponseError(local_var_error))
515 }
516}
517
518pub async fn get_draft_default_workflow(
520 configuration: &configuration::Configuration,
521 params: GetDraftDefaultWorkflowParams,
522) -> Result<models::DefaultWorkflow, Error<GetDraftDefaultWorkflowError>> {
523 let id = params.id;
525
526 let local_var_client = &configuration.client;
527
528 let local_var_uri_str = format!(
529 "{}/rest/api/3/workflowscheme/{id}/draft/default",
530 configuration.base_path,
531 id = id
532 );
533 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
534
535 if let Some(ref local_var_user_agent) = configuration.user_agent {
536 local_var_req_builder =
537 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
538 }
539 if let Some(ref local_var_token) = configuration.oauth_access_token {
540 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
541 };
542 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
543 local_var_req_builder = local_var_req_builder.basic_auth(
544 local_var_auth_conf.0.to_owned(),
545 local_var_auth_conf.1.to_owned(),
546 );
547 };
548
549 let local_var_req = local_var_req_builder.build()?;
550 let local_var_resp = local_var_client.execute(local_var_req).await?;
551
552 let local_var_status = local_var_resp.status();
553 let local_var_content = local_var_resp.text().await?;
554
555 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
556 serde_json::from_str(&local_var_content).map_err(Error::from)
557 } else {
558 let local_var_entity: Option<GetDraftDefaultWorkflowError> =
559 serde_json::from_str(&local_var_content).ok();
560 let local_var_error = ResponseContent {
561 status: local_var_status,
562 content: local_var_content,
563 entity: local_var_entity,
564 };
565 Err(Error::ResponseError(local_var_error))
566 }
567}
568
569pub async fn get_draft_workflow(
571 configuration: &configuration::Configuration,
572 params: GetDraftWorkflowParams,
573) -> Result<models::IssueTypesWorkflowMapping, Error<GetDraftWorkflowError>> {
574 let id = params.id;
576 let workflow_name = params.workflow_name;
577
578 let local_var_client = &configuration.client;
579
580 let local_var_uri_str = format!(
581 "{}/rest/api/3/workflowscheme/{id}/draft/workflow",
582 configuration.base_path,
583 id = id
584 );
585 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
586
587 if let Some(ref local_var_str) = workflow_name {
588 local_var_req_builder =
589 local_var_req_builder.query(&[("workflowName", &local_var_str.to_string())]);
590 }
591 if let Some(ref local_var_user_agent) = configuration.user_agent {
592 local_var_req_builder =
593 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
594 }
595 if let Some(ref local_var_token) = configuration.oauth_access_token {
596 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
597 };
598 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
599 local_var_req_builder = local_var_req_builder.basic_auth(
600 local_var_auth_conf.0.to_owned(),
601 local_var_auth_conf.1.to_owned(),
602 );
603 };
604
605 let local_var_req = local_var_req_builder.build()?;
606 let local_var_resp = local_var_client.execute(local_var_req).await?;
607
608 let local_var_status = local_var_resp.status();
609 let local_var_content = local_var_resp.text().await?;
610
611 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
612 serde_json::from_str(&local_var_content).map_err(Error::from)
613 } else {
614 let local_var_entity: Option<GetDraftWorkflowError> =
615 serde_json::from_str(&local_var_content).ok();
616 let local_var_error = ResponseContent {
617 status: local_var_status,
618 content: local_var_content,
619 entity: local_var_entity,
620 };
621 Err(Error::ResponseError(local_var_error))
622 }
623}
624
625pub async fn get_workflow_scheme_draft(
627 configuration: &configuration::Configuration,
628 params: GetWorkflowSchemeDraftParams,
629) -> Result<models::WorkflowScheme, Error<GetWorkflowSchemeDraftError>> {
630 let id = params.id;
632
633 let local_var_client = &configuration.client;
634
635 let local_var_uri_str = format!(
636 "{}/rest/api/3/workflowscheme/{id}/draft",
637 configuration.base_path,
638 id = id
639 );
640 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
641
642 if let Some(ref local_var_user_agent) = configuration.user_agent {
643 local_var_req_builder =
644 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
645 }
646 if let Some(ref local_var_token) = configuration.oauth_access_token {
647 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
648 };
649 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
650 local_var_req_builder = local_var_req_builder.basic_auth(
651 local_var_auth_conf.0.to_owned(),
652 local_var_auth_conf.1.to_owned(),
653 );
654 };
655
656 let local_var_req = local_var_req_builder.build()?;
657 let local_var_resp = local_var_client.execute(local_var_req).await?;
658
659 let local_var_status = local_var_resp.status();
660 let local_var_content = local_var_resp.text().await?;
661
662 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
663 serde_json::from_str(&local_var_content).map_err(Error::from)
664 } else {
665 let local_var_entity: Option<GetWorkflowSchemeDraftError> =
666 serde_json::from_str(&local_var_content).ok();
667 let local_var_error = ResponseContent {
668 status: local_var_status,
669 content: local_var_content,
670 entity: local_var_entity,
671 };
672 Err(Error::ResponseError(local_var_error))
673 }
674}
675
676pub async fn get_workflow_scheme_draft_issue_type(
678 configuration: &configuration::Configuration,
679 params: GetWorkflowSchemeDraftIssueTypeParams,
680) -> Result<models::IssueTypeWorkflowMapping, Error<GetWorkflowSchemeDraftIssueTypeError>> {
681 let id = params.id;
683 let issue_type = params.issue_type;
684
685 let local_var_client = &configuration.client;
686
687 let local_var_uri_str = format!(
688 "{}/rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}",
689 configuration.base_path,
690 id = id,
691 issueType = crate::gen::apis::urlencode(issue_type)
692 );
693 let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
694
695 if let Some(ref local_var_user_agent) = configuration.user_agent {
696 local_var_req_builder =
697 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
698 }
699 if let Some(ref local_var_token) = configuration.oauth_access_token {
700 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
701 };
702 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
703 local_var_req_builder = local_var_req_builder.basic_auth(
704 local_var_auth_conf.0.to_owned(),
705 local_var_auth_conf.1.to_owned(),
706 );
707 };
708
709 let local_var_req = local_var_req_builder.build()?;
710 let local_var_resp = local_var_client.execute(local_var_req).await?;
711
712 let local_var_status = local_var_resp.status();
713 let local_var_content = local_var_resp.text().await?;
714
715 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
716 serde_json::from_str(&local_var_content).map_err(Error::from)
717 } else {
718 let local_var_entity: Option<GetWorkflowSchemeDraftIssueTypeError> =
719 serde_json::from_str(&local_var_content).ok();
720 let local_var_error = ResponseContent {
721 status: local_var_status,
722 content: local_var_content,
723 entity: local_var_entity,
724 };
725 Err(Error::ResponseError(local_var_error))
726 }
727}
728
729pub async fn set_workflow_scheme_draft_issue_type(
731 configuration: &configuration::Configuration,
732 params: SetWorkflowSchemeDraftIssueTypeParams,
733) -> Result<models::WorkflowScheme, Error<SetWorkflowSchemeDraftIssueTypeError>> {
734 let id = params.id;
736 let issue_type = params.issue_type;
737 let issue_type_workflow_mapping = params.issue_type_workflow_mapping;
738
739 let local_var_client = &configuration.client;
740
741 let local_var_uri_str = format!(
742 "{}/rest/api/3/workflowscheme/{id}/draft/issuetype/{issueType}",
743 configuration.base_path,
744 id = id,
745 issueType = crate::gen::apis::urlencode(issue_type)
746 );
747 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
748
749 if let Some(ref local_var_user_agent) = configuration.user_agent {
750 local_var_req_builder =
751 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
752 }
753 if let Some(ref local_var_token) = configuration.oauth_access_token {
754 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
755 };
756 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
757 local_var_req_builder = local_var_req_builder.basic_auth(
758 local_var_auth_conf.0.to_owned(),
759 local_var_auth_conf.1.to_owned(),
760 );
761 };
762 local_var_req_builder = local_var_req_builder.json(&issue_type_workflow_mapping);
763
764 let local_var_req = local_var_req_builder.build()?;
765 let local_var_resp = local_var_client.execute(local_var_req).await?;
766
767 let local_var_status = local_var_resp.status();
768 let local_var_content = local_var_resp.text().await?;
769
770 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
771 serde_json::from_str(&local_var_content).map_err(Error::from)
772 } else {
773 let local_var_entity: Option<SetWorkflowSchemeDraftIssueTypeError> =
774 serde_json::from_str(&local_var_content).ok();
775 let local_var_error = ResponseContent {
776 status: local_var_status,
777 content: local_var_content,
778 entity: local_var_entity,
779 };
780 Err(Error::ResponseError(local_var_error))
781 }
782}
783
784pub async fn update_draft_default_workflow(
786 configuration: &configuration::Configuration,
787 params: UpdateDraftDefaultWorkflowParams,
788) -> Result<models::WorkflowScheme, Error<UpdateDraftDefaultWorkflowError>> {
789 let id = params.id;
791 let default_workflow = params.default_workflow;
792
793 let local_var_client = &configuration.client;
794
795 let local_var_uri_str = format!(
796 "{}/rest/api/3/workflowscheme/{id}/draft/default",
797 configuration.base_path,
798 id = id
799 );
800 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
801
802 if let Some(ref local_var_user_agent) = configuration.user_agent {
803 local_var_req_builder =
804 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
805 }
806 if let Some(ref local_var_token) = configuration.oauth_access_token {
807 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
808 };
809 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
810 local_var_req_builder = local_var_req_builder.basic_auth(
811 local_var_auth_conf.0.to_owned(),
812 local_var_auth_conf.1.to_owned(),
813 );
814 };
815 local_var_req_builder = local_var_req_builder.json(&default_workflow);
816
817 let local_var_req = local_var_req_builder.build()?;
818 let local_var_resp = local_var_client.execute(local_var_req).await?;
819
820 let local_var_status = local_var_resp.status();
821 let local_var_content = local_var_resp.text().await?;
822
823 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
824 serde_json::from_str(&local_var_content).map_err(Error::from)
825 } else {
826 let local_var_entity: Option<UpdateDraftDefaultWorkflowError> =
827 serde_json::from_str(&local_var_content).ok();
828 let local_var_error = ResponseContent {
829 status: local_var_status,
830 content: local_var_content,
831 entity: local_var_entity,
832 };
833 Err(Error::ResponseError(local_var_error))
834 }
835}
836
837pub async fn update_draft_workflow_mapping(
839 configuration: &configuration::Configuration,
840 params: UpdateDraftWorkflowMappingParams,
841) -> Result<models::WorkflowScheme, Error<UpdateDraftWorkflowMappingError>> {
842 let id = params.id;
844 let workflow_name = params.workflow_name;
845 let issue_types_workflow_mapping = params.issue_types_workflow_mapping;
846
847 let local_var_client = &configuration.client;
848
849 let local_var_uri_str = format!(
850 "{}/rest/api/3/workflowscheme/{id}/draft/workflow",
851 configuration.base_path,
852 id = id
853 );
854 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
855
856 local_var_req_builder =
857 local_var_req_builder.query(&[("workflowName", &workflow_name.to_string())]);
858 if let Some(ref local_var_user_agent) = configuration.user_agent {
859 local_var_req_builder =
860 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
861 }
862 if let Some(ref local_var_token) = configuration.oauth_access_token {
863 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
864 };
865 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
866 local_var_req_builder = local_var_req_builder.basic_auth(
867 local_var_auth_conf.0.to_owned(),
868 local_var_auth_conf.1.to_owned(),
869 );
870 };
871 local_var_req_builder = local_var_req_builder.json(&issue_types_workflow_mapping);
872
873 let local_var_req = local_var_req_builder.build()?;
874 let local_var_resp = local_var_client.execute(local_var_req).await?;
875
876 let local_var_status = local_var_resp.status();
877 let local_var_content = local_var_resp.text().await?;
878
879 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
880 serde_json::from_str(&local_var_content).map_err(Error::from)
881 } else {
882 let local_var_entity: Option<UpdateDraftWorkflowMappingError> =
883 serde_json::from_str(&local_var_content).ok();
884 let local_var_error = ResponseContent {
885 status: local_var_status,
886 content: local_var_content,
887 entity: local_var_entity,
888 };
889 Err(Error::ResponseError(local_var_error))
890 }
891}
892
893pub async fn update_workflow_scheme_draft(
895 configuration: &configuration::Configuration,
896 params: UpdateWorkflowSchemeDraftParams,
897) -> Result<models::WorkflowScheme, Error<UpdateWorkflowSchemeDraftError>> {
898 let id = params.id;
900 let workflow_scheme = params.workflow_scheme;
901
902 let local_var_client = &configuration.client;
903
904 let local_var_uri_str = format!(
905 "{}/rest/api/3/workflowscheme/{id}/draft",
906 configuration.base_path,
907 id = id
908 );
909 let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
910
911 if let Some(ref local_var_user_agent) = configuration.user_agent {
912 local_var_req_builder =
913 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
914 }
915 if let Some(ref local_var_token) = configuration.oauth_access_token {
916 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
917 };
918 if let Some(ref local_var_auth_conf) = configuration.basic_auth {
919 local_var_req_builder = local_var_req_builder.basic_auth(
920 local_var_auth_conf.0.to_owned(),
921 local_var_auth_conf.1.to_owned(),
922 );
923 };
924 local_var_req_builder = local_var_req_builder.json(&workflow_scheme);
925
926 let local_var_req = local_var_req_builder.build()?;
927 let local_var_resp = local_var_client.execute(local_var_req).await?;
928
929 let local_var_status = local_var_resp.status();
930 let local_var_content = local_var_resp.text().await?;
931
932 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
933 serde_json::from_str(&local_var_content).map_err(Error::from)
934 } else {
935 let local_var_entity: Option<UpdateWorkflowSchemeDraftError> =
936 serde_json::from_str(&local_var_content).ok();
937 let local_var_error = ResponseContent {
938 status: local_var_status,
939 content: local_var_content,
940 entity: local_var_entity,
941 };
942 Err(Error::ResponseError(local_var_error))
943 }
944}