1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17#[derive(Clone, Debug, Default)]
19pub struct CreateWorkflowSchemeDraftFromParentParams {
20 pub id: i64
22}
23
24#[derive(Clone, Debug, Default)]
26pub struct DeleteDraftDefaultWorkflowParams {
27 pub id: i64
29}
30
31#[derive(Clone, Debug, Default)]
33pub struct DeleteDraftWorkflowMappingParams {
34 pub id: i64,
36 pub workflow_name: String
38}
39
40#[derive(Clone, Debug, Default)]
42pub struct DeleteWorkflowSchemeDraftParams {
43 pub id: i64
45}
46
47#[derive(Clone, Debug, Default)]
49pub struct DeleteWorkflowSchemeDraftIssueTypeParams {
50 pub id: i64,
52 pub issue_type: String
54}
55
56#[derive(Clone, Debug, Default)]
58pub struct GetDraftDefaultWorkflowParams {
59 pub id: i64
61}
62
63#[derive(Clone, Debug, Default)]
65pub struct GetDraftWorkflowParams {
66 pub id: i64,
68 pub workflow_name: Option<String>
70}
71
72#[derive(Clone, Debug, Default)]
74pub struct GetWorkflowSchemeDraftParams {
75 pub id: i64
77}
78
79#[derive(Clone, Debug, Default)]
81pub struct GetWorkflowSchemeDraftIssueTypeParams {
82 pub id: i64,
84 pub issue_type: String
86}
87
88#[derive(Clone, Debug, Default)]
90pub struct PublishDraftWorkflowSchemeParams {
91 pub id: i64,
93 pub publish_draft_workflow_scheme: crate::models::PublishDraftWorkflowScheme,
95 pub validate_only: Option<bool>
97}
98
99#[derive(Clone, Debug, Default)]
101pub struct SetWorkflowSchemeDraftIssueTypeParams {
102 pub id: i64,
104 pub issue_type: String,
106 pub issue_type_workflow_mapping: crate::models::IssueTypeWorkflowMapping
108}
109
110#[derive(Clone, Debug, Default)]
112pub struct UpdateDraftDefaultWorkflowParams {
113 pub id: i64,
115 pub default_workflow: crate::models::DefaultWorkflow
117}
118
119#[derive(Clone, Debug, Default)]
121pub struct UpdateDraftWorkflowMappingParams {
122 pub id: i64,
124 pub workflow_name: String,
126 pub issue_types_workflow_mapping: crate::models::IssueTypesWorkflowMapping
127}
128
129#[derive(Clone, Debug, Default)]
131pub struct UpdateWorkflowSchemeDraftParams {
132 pub id: i64,
134 pub workflow_scheme: crate::models::WorkflowScheme
135}
136
137
138#[derive(Debug, Clone, Serialize, Deserialize)]
140#[serde(untagged)]
141pub enum CreateWorkflowSchemeDraftFromParentError {
142 Status400(),
143 Status401(),
144 Status403(),
145 UnknownValue(serde_json::Value),
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
150#[serde(untagged)]
151pub enum DeleteDraftDefaultWorkflowError {
152 Status401(),
153 Status403(),
154 Status404(),
155 UnknownValue(serde_json::Value),
156}
157
158#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum DeleteDraftWorkflowMappingError {
162 Status401(),
163 Status403(),
164 Status404(),
165 UnknownValue(serde_json::Value),
166}
167
168#[derive(Debug, Clone, Serialize, Deserialize)]
170#[serde(untagged)]
171pub enum DeleteWorkflowSchemeDraftError {
172 Status401(),
173 Status403(),
174 Status404(),
175 UnknownValue(serde_json::Value),
176}
177
178#[derive(Debug, Clone, Serialize, Deserialize)]
180#[serde(untagged)]
181pub enum DeleteWorkflowSchemeDraftIssueTypeError {
182 Status401(),
183 Status403(),
184 Status404(),
185 UnknownValue(serde_json::Value),
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize)]
190#[serde(untagged)]
191pub enum GetDraftDefaultWorkflowError {
192 Status401(),
193 Status403(),
194 Status404(),
195 UnknownValue(serde_json::Value),
196}
197
198#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(untagged)]
201pub enum GetDraftWorkflowError {
202 Status401(),
203 Status403(),
204 Status404(),
205 UnknownValue(serde_json::Value),
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize)]
210#[serde(untagged)]
211pub enum GetWorkflowSchemeDraftError {
212 Status401(),
213 Status403(),
214 Status404(),
215 UnknownValue(serde_json::Value),
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize)]
220#[serde(untagged)]
221pub enum GetWorkflowSchemeDraftIssueTypeError {
222 Status401(),
223 Status403(),
224 Status404(),
225 UnknownValue(serde_json::Value),
226}
227
228#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum PublishDraftWorkflowSchemeError {
232 Status400(),
233 Status401(),
234 Status403(),
235 Status404(),
236 UnknownValue(serde_json::Value),
237}
238
239#[derive(Debug, Clone, Serialize, Deserialize)]
241#[serde(untagged)]
242pub enum SetWorkflowSchemeDraftIssueTypeError {
243 Status400(),
244 Status401(),
245 Status403(),
246 Status404(),
247 UnknownValue(serde_json::Value),
248}
249
250#[derive(Debug, Clone, Serialize, Deserialize)]
252#[serde(untagged)]
253pub enum UpdateDraftDefaultWorkflowError {
254 Status400(),
255 Status401(),
256 Status403(),
257 Status404(),
258 UnknownValue(serde_json::Value),
259}
260
261#[derive(Debug, Clone, Serialize, Deserialize)]
263#[serde(untagged)]
264pub enum UpdateDraftWorkflowMappingError {
265 Status400(),
266 Status401(),
267 Status403(),
268 Status404(),
269 UnknownValue(serde_json::Value),
270}
271
272#[derive(Debug, Clone, Serialize, Deserialize)]
274#[serde(untagged)]
275pub enum UpdateWorkflowSchemeDraftError {
276 Status400(),
277 Status401(),
278 Status403(),
279 Status404(),
280 UnknownValue(serde_json::Value),
281}
282
283
284pub async fn create_workflow_scheme_draft_from_parent(configuration: &configuration::Configuration, params: CreateWorkflowSchemeDraftFromParentParams) -> Result<crate::models::WorkflowScheme, Error<CreateWorkflowSchemeDraftFromParentError>> {
286 let local_var_configuration = configuration;
287
288 let id = params.id;
290
291
292 let local_var_client = &local_var_configuration.client;
293
294 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/createdraft", local_var_configuration.base_path, id=id);
295 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
296
297 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
298 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
299 }
300 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
301 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
302 };
303 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
304 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
305 };
306
307 let local_var_req = local_var_req_builder.build()?;
308 let local_var_resp = local_var_client.execute(local_var_req).await?;
309
310 let local_var_status = local_var_resp.status();
311 let local_var_content = local_var_resp.text().await?;
312
313 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
314 serde_json::from_str(&local_var_content).map_err(Error::from)
315 } else {
316 let local_var_entity: Option<CreateWorkflowSchemeDraftFromParentError> = serde_json::from_str(&local_var_content).ok();
317 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
318 Err(Error::ResponseError(local_var_error))
319 }
320}
321
322pub async fn delete_draft_default_workflow(configuration: &configuration::Configuration, params: DeleteDraftDefaultWorkflowParams) -> Result<crate::models::WorkflowScheme, Error<DeleteDraftDefaultWorkflowError>> {
324 let local_var_configuration = configuration;
325
326 let id = params.id;
328
329
330 let local_var_client = &local_var_configuration.client;
331
332 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/default", local_var_configuration.base_path, id=id);
333 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
334
335 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
336 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
337 }
338 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
339 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
340 };
341 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
342 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
343 };
344
345 let local_var_req = local_var_req_builder.build()?;
346 let local_var_resp = local_var_client.execute(local_var_req).await?;
347
348 let local_var_status = local_var_resp.status();
349 let local_var_content = local_var_resp.text().await?;
350
351 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
352 serde_json::from_str(&local_var_content).map_err(Error::from)
353 } else {
354 let local_var_entity: Option<DeleteDraftDefaultWorkflowError> = serde_json::from_str(&local_var_content).ok();
355 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
356 Err(Error::ResponseError(local_var_error))
357 }
358}
359
360pub async fn delete_draft_workflow_mapping(configuration: &configuration::Configuration, params: DeleteDraftWorkflowMappingParams) -> Result<(), Error<DeleteDraftWorkflowMappingError>> {
362 let local_var_configuration = configuration;
363
364 let id = params.id;
366 let workflow_name = params.workflow_name;
367
368
369 let local_var_client = &local_var_configuration.client;
370
371 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/workflow", local_var_configuration.base_path, id=id);
372 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
373
374 local_var_req_builder = local_var_req_builder.query(&[("workflowName", &workflow_name.to_string())]);
375 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
376 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
377 }
378 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
379 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
380 };
381 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
382 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
383 };
384
385 let local_var_req = local_var_req_builder.build()?;
386 let local_var_resp = local_var_client.execute(local_var_req).await?;
387
388 let local_var_status = local_var_resp.status();
389 let local_var_content = local_var_resp.text().await?;
390
391 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
392 Ok(())
393 } else {
394 let local_var_entity: Option<DeleteDraftWorkflowMappingError> = serde_json::from_str(&local_var_content).ok();
395 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
396 Err(Error::ResponseError(local_var_error))
397 }
398}
399
400pub async fn delete_workflow_scheme_draft(configuration: &configuration::Configuration, params: DeleteWorkflowSchemeDraftParams) -> Result<(), Error<DeleteWorkflowSchemeDraftError>> {
402 let local_var_configuration = configuration;
403
404 let id = params.id;
406
407
408 let local_var_client = &local_var_configuration.client;
409
410 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft", local_var_configuration.base_path, id=id);
411 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
412
413 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
414 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
415 }
416 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
417 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
418 };
419 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
420 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
421 };
422
423 let local_var_req = local_var_req_builder.build()?;
424 let local_var_resp = local_var_client.execute(local_var_req).await?;
425
426 let local_var_status = local_var_resp.status();
427 let local_var_content = local_var_resp.text().await?;
428
429 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
430 Ok(())
431 } else {
432 let local_var_entity: Option<DeleteWorkflowSchemeDraftError> = serde_json::from_str(&local_var_content).ok();
433 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
434 Err(Error::ResponseError(local_var_error))
435 }
436}
437
438pub async fn delete_workflow_scheme_draft_issue_type(configuration: &configuration::Configuration, params: DeleteWorkflowSchemeDraftIssueTypeParams) -> Result<crate::models::WorkflowScheme, Error<DeleteWorkflowSchemeDraftIssueTypeError>> {
440 let local_var_configuration = configuration;
441
442 let id = params.id;
444 let issue_type = params.issue_type;
445
446
447 let local_var_client = &local_var_configuration.client;
448
449 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/issuetype/{issueType}", local_var_configuration.base_path, id=id, issueType=crate::apis::urlencode(issue_type));
450 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
451
452 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
453 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
454 }
455 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
456 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
457 };
458 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
459 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
460 };
461
462 let local_var_req = local_var_req_builder.build()?;
463 let local_var_resp = local_var_client.execute(local_var_req).await?;
464
465 let local_var_status = local_var_resp.status();
466 let local_var_content = local_var_resp.text().await?;
467
468 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
469 serde_json::from_str(&local_var_content).map_err(Error::from)
470 } else {
471 let local_var_entity: Option<DeleteWorkflowSchemeDraftIssueTypeError> = serde_json::from_str(&local_var_content).ok();
472 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
473 Err(Error::ResponseError(local_var_error))
474 }
475}
476
477pub async fn get_draft_default_workflow(configuration: &configuration::Configuration, params: GetDraftDefaultWorkflowParams) -> Result<crate::models::DefaultWorkflow, Error<GetDraftDefaultWorkflowError>> {
479 let local_var_configuration = configuration;
480
481 let id = params.id;
483
484
485 let local_var_client = &local_var_configuration.client;
486
487 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/default", local_var_configuration.base_path, id=id);
488 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
489
490 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
491 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
492 }
493 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
494 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
495 };
496 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
497 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
498 };
499
500 let local_var_req = local_var_req_builder.build()?;
501 let local_var_resp = local_var_client.execute(local_var_req).await?;
502
503 let local_var_status = local_var_resp.status();
504 let local_var_content = local_var_resp.text().await?;
505
506 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
507 serde_json::from_str(&local_var_content).map_err(Error::from)
508 } else {
509 let local_var_entity: Option<GetDraftDefaultWorkflowError> = serde_json::from_str(&local_var_content).ok();
510 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
511 Err(Error::ResponseError(local_var_error))
512 }
513}
514
515pub async fn get_draft_workflow(configuration: &configuration::Configuration, params: GetDraftWorkflowParams) -> Result<crate::models::IssueTypesWorkflowMapping, Error<GetDraftWorkflowError>> {
517 let local_var_configuration = configuration;
518
519 let id = params.id;
521 let workflow_name = params.workflow_name;
522
523
524 let local_var_client = &local_var_configuration.client;
525
526 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/workflow", local_var_configuration.base_path, id=id);
527 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
528
529 if let Some(ref local_var_str) = workflow_name {
530 local_var_req_builder = local_var_req_builder.query(&[("workflowName", &local_var_str.to_string())]);
531 }
532 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
533 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
534 }
535 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
536 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
537 };
538 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
539 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
540 };
541
542 let local_var_req = local_var_req_builder.build()?;
543 let local_var_resp = local_var_client.execute(local_var_req).await?;
544
545 let local_var_status = local_var_resp.status();
546 let local_var_content = local_var_resp.text().await?;
547
548 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
549 serde_json::from_str(&local_var_content).map_err(Error::from)
550 } else {
551 let local_var_entity: Option<GetDraftWorkflowError> = serde_json::from_str(&local_var_content).ok();
552 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
553 Err(Error::ResponseError(local_var_error))
554 }
555}
556
557pub async fn get_workflow_scheme_draft(configuration: &configuration::Configuration, params: GetWorkflowSchemeDraftParams) -> Result<crate::models::WorkflowScheme, Error<GetWorkflowSchemeDraftError>> {
559 let local_var_configuration = configuration;
560
561 let id = params.id;
563
564
565 let local_var_client = &local_var_configuration.client;
566
567 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft", local_var_configuration.base_path, id=id);
568 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
569
570 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
571 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
572 }
573 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
574 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
575 };
576 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
577 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
578 };
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 serde_json::from_str(&local_var_content).map_err(Error::from)
588 } else {
589 let local_var_entity: Option<GetWorkflowSchemeDraftError> = serde_json::from_str(&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 get_workflow_scheme_draft_issue_type(configuration: &configuration::Configuration, params: GetWorkflowSchemeDraftIssueTypeParams) -> Result<crate::models::IssueTypeWorkflowMapping, Error<GetWorkflowSchemeDraftIssueTypeError>> {
597 let local_var_configuration = configuration;
598
599 let id = params.id;
601 let issue_type = params.issue_type;
602
603
604 let local_var_client = &local_var_configuration.client;
605
606 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/issuetype/{issueType}", local_var_configuration.base_path, id=id, issueType=crate::apis::urlencode(issue_type));
607 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
608
609 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
610 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
611 }
612 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
613 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
614 };
615 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
616 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
617 };
618
619 let local_var_req = local_var_req_builder.build()?;
620 let local_var_resp = local_var_client.execute(local_var_req).await?;
621
622 let local_var_status = local_var_resp.status();
623 let local_var_content = local_var_resp.text().await?;
624
625 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
626 serde_json::from_str(&local_var_content).map_err(Error::from)
627 } else {
628 let local_var_entity: Option<GetWorkflowSchemeDraftIssueTypeError> = serde_json::from_str(&local_var_content).ok();
629 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
630 Err(Error::ResponseError(local_var_error))
631 }
632}
633
634pub async fn publish_draft_workflow_scheme(configuration: &configuration::Configuration, params: PublishDraftWorkflowSchemeParams) -> Result<(), Error<PublishDraftWorkflowSchemeError>> {
636 let local_var_configuration = configuration;
637
638 let id = params.id;
640 let publish_draft_workflow_scheme = params.publish_draft_workflow_scheme;
641 let validate_only = params.validate_only;
642
643
644 let local_var_client = &local_var_configuration.client;
645
646 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/publish", local_var_configuration.base_path, id=id);
647 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
648
649 if let Some(ref local_var_str) = validate_only {
650 local_var_req_builder = local_var_req_builder.query(&[("validateOnly", &local_var_str.to_string())]);
651 }
652 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
653 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
654 }
655 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
656 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
657 };
658 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
659 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
660 };
661 local_var_req_builder = local_var_req_builder.json(&publish_draft_workflow_scheme);
662
663 let local_var_req = local_var_req_builder.build()?;
664 let local_var_resp = local_var_client.execute(local_var_req).await?;
665
666 let local_var_status = local_var_resp.status();
667 let local_var_content = local_var_resp.text().await?;
668
669 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
670 Ok(())
671 } else {
672 let local_var_entity: Option<PublishDraftWorkflowSchemeError> = serde_json::from_str(&local_var_content).ok();
673 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
674 Err(Error::ResponseError(local_var_error))
675 }
676}
677
678pub async fn set_workflow_scheme_draft_issue_type(configuration: &configuration::Configuration, params: SetWorkflowSchemeDraftIssueTypeParams) -> Result<crate::models::WorkflowScheme, Error<SetWorkflowSchemeDraftIssueTypeError>> {
680 let local_var_configuration = configuration;
681
682 let id = params.id;
684 let issue_type = params.issue_type;
685 let issue_type_workflow_mapping = params.issue_type_workflow_mapping;
686
687
688 let local_var_client = &local_var_configuration.client;
689
690 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/issuetype/{issueType}", local_var_configuration.base_path, id=id, issueType=crate::apis::urlencode(issue_type));
691 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
692
693 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
694 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
695 }
696 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
697 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
698 };
699 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
700 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
701 };
702 local_var_req_builder = local_var_req_builder.json(&issue_type_workflow_mapping);
703
704 let local_var_req = local_var_req_builder.build()?;
705 let local_var_resp = local_var_client.execute(local_var_req).await?;
706
707 let local_var_status = local_var_resp.status();
708 let local_var_content = local_var_resp.text().await?;
709
710 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
711 serde_json::from_str(&local_var_content).map_err(Error::from)
712 } else {
713 let local_var_entity: Option<SetWorkflowSchemeDraftIssueTypeError> = serde_json::from_str(&local_var_content).ok();
714 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
715 Err(Error::ResponseError(local_var_error))
716 }
717}
718
719pub async fn update_draft_default_workflow(configuration: &configuration::Configuration, params: UpdateDraftDefaultWorkflowParams) -> Result<crate::models::WorkflowScheme, Error<UpdateDraftDefaultWorkflowError>> {
721 let local_var_configuration = configuration;
722
723 let id = params.id;
725 let default_workflow = params.default_workflow;
726
727
728 let local_var_client = &local_var_configuration.client;
729
730 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/default", local_var_configuration.base_path, id=id);
731 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
732
733 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
734 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
735 }
736 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
737 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
738 };
739 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
740 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
741 };
742 local_var_req_builder = local_var_req_builder.json(&default_workflow);
743
744 let local_var_req = local_var_req_builder.build()?;
745 let local_var_resp = local_var_client.execute(local_var_req).await?;
746
747 let local_var_status = local_var_resp.status();
748 let local_var_content = local_var_resp.text().await?;
749
750 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
751 serde_json::from_str(&local_var_content).map_err(Error::from)
752 } else {
753 let local_var_entity: Option<UpdateDraftDefaultWorkflowError> = serde_json::from_str(&local_var_content).ok();
754 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
755 Err(Error::ResponseError(local_var_error))
756 }
757}
758
759pub async fn update_draft_workflow_mapping(configuration: &configuration::Configuration, params: UpdateDraftWorkflowMappingParams) -> Result<crate::models::WorkflowScheme, Error<UpdateDraftWorkflowMappingError>> {
761 let local_var_configuration = configuration;
762
763 let id = params.id;
765 let workflow_name = params.workflow_name;
766 let issue_types_workflow_mapping = params.issue_types_workflow_mapping;
767
768
769 let local_var_client = &local_var_configuration.client;
770
771 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft/workflow", local_var_configuration.base_path, id=id);
772 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
773
774 local_var_req_builder = local_var_req_builder.query(&[("workflowName", &workflow_name.to_string())]);
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.oauth_access_token {
779 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
780 };
781 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
782 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
783 };
784 local_var_req_builder = local_var_req_builder.json(&issue_types_workflow_mapping);
785
786 let local_var_req = local_var_req_builder.build()?;
787 let local_var_resp = local_var_client.execute(local_var_req).await?;
788
789 let local_var_status = local_var_resp.status();
790 let local_var_content = local_var_resp.text().await?;
791
792 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
793 serde_json::from_str(&local_var_content).map_err(Error::from)
794 } else {
795 let local_var_entity: Option<UpdateDraftWorkflowMappingError> = serde_json::from_str(&local_var_content).ok();
796 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
797 Err(Error::ResponseError(local_var_error))
798 }
799}
800
801pub async fn update_workflow_scheme_draft(configuration: &configuration::Configuration, params: UpdateWorkflowSchemeDraftParams) -> Result<crate::models::WorkflowScheme, Error<UpdateWorkflowSchemeDraftError>> {
803 let local_var_configuration = configuration;
804
805 let id = params.id;
807 let workflow_scheme = params.workflow_scheme;
808
809
810 let local_var_client = &local_var_configuration.client;
811
812 let local_var_uri_str = format!("{}/rest/api/2/workflowscheme/{id}/draft", local_var_configuration.base_path, id=id);
813 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
814
815 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
816 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
817 }
818 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
819 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
820 };
821 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
822 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
823 };
824 local_var_req_builder = local_var_req_builder.json(&workflow_scheme);
825
826 let local_var_req = local_var_req_builder.build()?;
827 let local_var_resp = local_var_client.execute(local_var_req).await?;
828
829 let local_var_status = local_var_resp.status();
830 let local_var_content = local_var_resp.text().await?;
831
832 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
833 serde_json::from_str(&local_var_content).map_err(Error::from)
834 } else {
835 let local_var_entity: Option<UpdateWorkflowSchemeDraftError> = serde_json::from_str(&local_var_content).ok();
836 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
837 Err(Error::ResponseError(local_var_error))
838 }
839}
840