1#![allow(dead_code)]
15
16use serde::{Deserialize, Serialize};
17
18#[derive(Debug, Clone, Deserialize)]
23pub struct JiraUser {
24 #[serde(default, rename = "accountId")]
26 pub account_id: Option<String>,
27 #[serde(default)]
29 pub name: Option<String>,
30 #[serde(default, rename = "displayName")]
31 pub display_name: Option<String>,
32 #[serde(default, rename = "emailAddress")]
33 pub email_address: Option<String>,
34}
35
36#[derive(Debug, Clone, Deserialize)]
41pub struct JiraIssue {
42 pub id: String,
43 pub key: String,
45 pub fields: JiraIssueFields,
46}
47
48#[derive(Debug, Clone, Deserialize)]
49pub struct JiraIssueFields {
50 #[serde(default)]
51 pub summary: Option<String>,
52 #[serde(default)]
54 pub description: Option<serde_json::Value>,
55 #[serde(default)]
56 pub status: Option<JiraStatus>,
57 #[serde(default)]
58 pub priority: Option<JiraPriority>,
59 #[serde(default)]
60 pub assignee: Option<JiraUser>,
61 #[serde(default)]
63 pub reporter: Option<JiraUser>,
64 #[serde(default)]
65 pub labels: Vec<String>,
66 #[serde(default)]
68 pub created: Option<String>,
69 #[serde(default)]
71 pub updated: Option<String>,
72 #[serde(default)]
76 pub issuetype: Option<JiraIssueTypeRef>,
77 #[serde(default)]
79 pub parent: Option<Box<JiraIssue>>,
80 #[serde(default)]
82 pub subtasks: Vec<JiraIssue>,
83 #[serde(default)]
84 pub issuelinks: Vec<JiraIssueLink>,
85 #[serde(default)]
88 pub attachment: Vec<JiraAttachment>,
89 #[serde(flatten, default)]
95 pub extras: std::collections::HashMap<String, serde_json::Value>,
96}
97
98#[derive(Debug, Clone, Deserialize)]
101pub struct JiraIssueTypeRef {
102 pub name: String,
103}
104
105#[derive(Debug, Clone, Deserialize)]
107pub struct JiraAttachment {
108 pub id: String,
110 #[serde(default)]
111 pub filename: Option<String>,
112 #[serde(default)]
114 pub content: Option<String>,
115 #[serde(default)]
116 pub size: Option<u64>,
117 #[serde(default, rename = "mimeType")]
118 pub mime_type: Option<String>,
119 #[serde(default)]
121 pub created: Option<String>,
122 #[serde(default)]
124 pub author: Option<JiraUser>,
125}
126
127#[derive(Debug, Clone, Deserialize)]
128#[serde(rename_all = "camelCase")]
129pub struct JiraStatus {
130 pub name: String,
131 #[serde(default)]
133 pub status_category: Option<JiraStatusCategory>,
134}
135
136#[derive(Debug, Clone, Deserialize)]
137pub struct JiraStatusCategory {
138 pub key: String,
140}
141
142#[derive(Debug, Clone, Deserialize)]
143pub struct JiraPriority {
144 pub name: String,
145}
146
147#[derive(Debug, Clone, Deserialize)]
152pub struct JiraIssueLink {
153 #[serde(default)]
155 pub id: Option<String>,
156 #[serde(rename = "type")]
157 pub link_type: JiraIssueLinkType,
158 #[serde(default, rename = "inwardIssue")]
160 pub inward_issue: Option<Box<JiraIssue>>,
161 #[serde(default, rename = "outwardIssue")]
163 pub outward_issue: Option<Box<JiraIssue>>,
164}
165
166#[derive(Debug, Clone, Deserialize)]
167pub struct JiraIssueLinkType {
168 pub name: String,
170 #[serde(default)]
172 pub inward: Option<String>,
173 #[serde(default)]
175 pub outward: Option<String>,
176}
177
178#[derive(Debug, Clone, Deserialize)]
184pub struct JiraSearchResponse {
185 pub issues: Vec<JiraIssue>,
186 #[serde(default, rename = "startAt")]
188 pub start_at: Option<u32>,
189 #[serde(default, rename = "maxResults")]
191 pub max_results: Option<u32>,
192 #[serde(default)]
194 pub total: Option<u32>,
195}
196
197#[derive(Debug, Clone, Deserialize)]
199pub struct JiraCloudSearchResponse {
200 pub issues: Vec<JiraIssue>,
201 #[serde(default, rename = "nextPageToken")]
202 pub next_page_token: Option<String>,
203}
204
205#[derive(Debug, Clone, Deserialize)]
211pub struct JiraComment {
212 pub id: String,
214 #[serde(default)]
216 pub body: Option<serde_json::Value>,
217 #[serde(default)]
219 pub author: Option<JiraUser>,
220 #[serde(default)]
222 pub created: Option<String>,
223 #[serde(default)]
225 pub updated: Option<String>,
226}
227
228#[derive(Debug, Clone, Deserialize)]
230pub struct JiraCommentsResponse {
231 pub comments: Vec<JiraComment>,
232}
233
234#[derive(Debug, Clone, Deserialize)]
240pub struct JiraTransition {
241 pub id: String,
243 pub name: String,
245 pub to: JiraStatus,
247}
248
249#[derive(Debug, Clone, Deserialize)]
251pub struct JiraTransitionsResponse {
252 pub transitions: Vec<JiraTransition>,
254}
255
256#[derive(Debug, Clone, Serialize)]
262pub struct CreateIssuePayload {
263 pub fields: CreateIssueFields,
265}
266
267#[derive(Debug, Clone, Serialize)]
269pub struct CreateIssueFields {
270 pub project: ProjectKey,
271 pub summary: String,
273 pub issuetype: IssueType,
275 #[serde(skip_serializing_if = "Option::is_none")]
277 pub description: Option<serde_json::Value>,
278 #[serde(skip_serializing_if = "Option::is_none")]
279 pub labels: Option<Vec<String>>,
280 #[serde(skip_serializing_if = "Option::is_none")]
281 pub priority: Option<PriorityName>,
282 #[serde(skip_serializing_if = "Option::is_none")]
283 pub assignee: Option<serde_json::Value>,
284 #[serde(skip_serializing_if = "Option::is_none")]
286 pub components: Option<Vec<ComponentRef>>,
287 #[serde(rename = "fixVersions", skip_serializing_if = "Option::is_none")]
290 pub fix_versions: Option<Vec<VersionRef>>,
291 #[serde(skip_serializing_if = "Option::is_none")]
298 pub parent: Option<IssueKeyRef>,
299}
300
301#[derive(Debug, Clone, Serialize, Deserialize)]
311pub struct ComponentRef {
312 pub name: String,
313}
314
315#[derive(Debug, Clone, Serialize, Deserialize)]
322pub struct VersionRef {
323 pub name: String,
324}
325
326#[derive(Debug, Clone, Serialize)]
328pub struct ProjectKey {
329 pub key: String,
331}
332
333#[derive(Debug, Clone, Serialize)]
335pub struct IssueType {
336 pub name: String,
338}
339
340#[derive(Debug, Clone, Serialize)]
342pub struct PriorityName {
343 pub name: String,
345}
346
347#[derive(Debug, Clone, Serialize)]
349pub struct UpdateIssuePayload {
350 pub fields: UpdateIssueFields,
352}
353
354#[derive(Debug, Clone, Serialize, Default)]
356pub struct UpdateIssueFields {
357 #[serde(skip_serializing_if = "Option::is_none")]
359 pub summary: Option<String>,
360 #[serde(skip_serializing_if = "Option::is_none")]
362 pub description: Option<serde_json::Value>,
363 #[serde(skip_serializing_if = "Option::is_none")]
364 pub labels: Option<Vec<String>>,
365 #[serde(skip_serializing_if = "Option::is_none")]
366 pub priority: Option<PriorityName>,
367 #[serde(skip_serializing_if = "Option::is_none")]
368 pub assignee: Option<serde_json::Value>,
369 #[serde(skip_serializing_if = "Option::is_none")]
372 pub components: Option<Vec<ComponentRef>>,
373 #[serde(rename = "fixVersions", skip_serializing_if = "Option::is_none")]
377 pub fix_versions: Option<Vec<VersionRef>>,
378}
379
380#[derive(Debug, Clone, Serialize)]
382pub struct TransitionPayload {
383 pub transition: TransitionId,
385}
386
387#[derive(Debug, Clone, Serialize)]
389pub struct TransitionId {
390 pub id: String,
392}
393
394#[derive(Debug, Clone, Deserialize)]
396pub struct CreateIssueResponse {
397 pub id: String,
399 pub key: String,
401}
402
403#[derive(Debug, Clone, Serialize)]
405pub struct AddCommentPayload {
406 pub body: serde_json::Value,
408}
409
410#[derive(Debug, Clone, Serialize, Deserialize)]
422pub struct JiraField {
423 pub id: String,
426 pub name: String,
428 #[serde(default)]
431 pub custom: bool,
432 #[serde(default)]
434 pub schema: Option<JiraFieldSchema>,
435}
436
437#[derive(Debug, Clone, Serialize, Deserialize)]
441pub struct JiraFieldSchema {
442 #[serde(default, rename = "type")]
444 pub field_type: Option<String>,
445 #[serde(default)]
447 pub items: Option<String>,
448 #[serde(default)]
451 pub custom: Option<String>,
452 #[serde(default, rename = "customId")]
454 pub custom_id: Option<i64>,
455 #[serde(default)]
457 pub system: Option<String>,
458}
459
460#[derive(Debug, Clone, Deserialize)]
467pub struct JiraIssueTypeStatuses {
468 #[serde(default)]
470 pub name: Option<String>,
471 #[serde(default)]
473 pub statuses: Vec<JiraProjectStatus>,
474}
475
476#[derive(Debug, Clone, Deserialize)]
478#[serde(rename_all = "camelCase")]
479pub struct JiraProjectStatus {
480 pub name: String,
482 #[serde(default)]
484 pub id: Option<String>,
485 #[serde(default)]
486 pub status_category: Option<JiraStatusCategory>,
487}
488
489#[derive(Debug, Clone, Serialize)]
495#[serde(rename_all = "camelCase")]
496pub struct CreateIssueLinkPayload {
497 #[serde(rename = "type")]
498 pub link_type: IssueLinkTypeName,
499 pub inward_issue: IssueKeyRef,
501 pub outward_issue: IssueKeyRef,
503}
504
505#[derive(Debug, Clone, Serialize)]
507pub struct IssueLinkTypeName {
508 pub name: String,
510}
511
512#[derive(Debug, Clone, Serialize)]
514pub struct IssueKeyRef {
515 pub key: String,
517}
518
519#[derive(Debug, Clone, Deserialize)]
525pub struct JiraStructure {
526 pub id: u64,
527 pub name: String,
528 #[serde(default)]
529 pub description: Option<String>,
530}
531
532#[derive(Debug, Clone, Deserialize)]
534pub struct JiraStructureListResponse {
535 pub structures: Vec<JiraStructure>,
536}
537
538#[derive(Debug, Clone, Deserialize)]
540#[serde(rename_all = "camelCase")]
541pub struct JiraForestRow {
542 pub id: u64,
543 #[serde(default)]
544 pub item_id: Option<String>,
545 #[serde(default)]
546 pub item_type: Option<String>,
547}
548
549#[derive(Debug, Clone, Deserialize)]
551#[serde(rename_all = "camelCase")]
552pub struct JiraForestResponse {
553 pub version: u64,
554 #[serde(default)]
555 pub rows: Vec<JiraForestRow>,
556 #[serde(default)]
557 pub depths: Vec<u32>,
558 #[serde(default)]
559 pub total_count: Option<u64>,
560}
561
562#[derive(Debug, Clone, Deserialize)]
564pub struct JiraForestModifyResponse {
565 pub version: u64,
566 #[serde(default)]
567 pub rows: Vec<JiraForestRow>,
568}
569
570#[derive(Debug, Clone, Deserialize)]
572#[serde(rename_all = "camelCase")]
573pub struct JiraStructureView {
574 pub id: u64,
575 pub name: String,
576 pub structure_id: u64,
581 #[serde(default)]
582 pub columns: Vec<JiraStructureViewColumn>,
583 #[serde(default)]
584 pub group_by: Option<String>,
585 #[serde(default)]
586 pub sort_by: Option<String>,
587 #[serde(default)]
588 pub filter: Option<String>,
589}
590
591#[derive(Debug, Clone, Deserialize, Serialize)]
593pub struct JiraStructureViewColumn {
594 #[serde(default)]
595 pub id: Option<String>,
596 #[serde(default)]
597 pub field: Option<String>,
598 #[serde(default)]
599 pub formula: Option<String>,
600 #[serde(default)]
601 pub width: Option<u32>,
602}
603
604#[derive(Debug, Clone, Deserialize)]
606pub struct JiraStructureViewListResponse {
607 pub views: Vec<JiraStructureView>,
608}
609
610#[derive(Debug, Clone, Deserialize)]
612#[serde(rename_all = "camelCase")]
613pub struct JiraStructureValueEntry {
614 pub row_id: u64,
615 #[serde(default)]
616 pub column_id: Option<String>,
617 #[serde(default)]
618 pub value: serde_json::Value,
619}
620
621#[derive(Debug, Clone, Deserialize)]
623pub struct JiraStructureValuesResponse {
624 pub values: Vec<JiraStructureValueEntry>,
625}
626
627#[derive(Debug, Clone, Deserialize)]
637#[serde(rename_all = "camelCase")]
638pub struct JiraVersionDto {
639 pub id: String,
640 pub name: String,
641 #[serde(default)]
644 pub project: Option<String>,
645 #[serde(default)]
646 pub project_id: Option<u64>,
647 #[serde(default)]
648 pub description: Option<String>,
649 #[serde(default)]
650 pub start_date: Option<String>,
651 #[serde(default)]
652 pub release_date: Option<String>,
653 #[serde(default)]
654 pub released: bool,
655 #[serde(default)]
656 pub archived: bool,
657 #[serde(default)]
660 pub overdue: Option<bool>,
661 #[serde(default)]
664 pub issues_status_for_fix_version: Option<JiraVersionIssueStatusCounts>,
665 #[serde(default)]
669 pub issues_unresolved_count: Option<u32>,
670}
671
672#[derive(Debug, Clone, Deserialize, Default)]
674#[serde(rename_all = "camelCase")]
675pub struct JiraVersionIssueStatusCounts {
676 #[serde(default)]
677 pub unmapped: u32,
678 #[serde(default)]
679 pub to_do: u32,
680 #[serde(default)]
681 pub in_progress: u32,
682 #[serde(default)]
683 pub done: u32,
684}
685
686impl JiraVersionIssueStatusCounts {
687 pub fn total(&self) -> u32 {
688 self.unmapped
689 .saturating_add(self.to_do)
690 .saturating_add(self.in_progress)
691 .saturating_add(self.done)
692 }
693}
694
695#[derive(Debug, Clone, Serialize, Default)]
702#[serde(rename_all = "camelCase")]
703pub struct CreateVersionPayload {
704 pub name: String,
705 #[serde(skip_serializing_if = "Option::is_none")]
706 pub project: Option<String>,
707 #[serde(skip_serializing_if = "Option::is_none")]
708 pub project_id: Option<u64>,
709 #[serde(skip_serializing_if = "Option::is_none")]
710 pub description: Option<String>,
711 #[serde(skip_serializing_if = "Option::is_none")]
712 pub start_date: Option<String>,
713 #[serde(skip_serializing_if = "Option::is_none")]
714 pub release_date: Option<String>,
715 #[serde(skip_serializing_if = "Option::is_none")]
716 pub released: Option<bool>,
717 #[serde(skip_serializing_if = "Option::is_none")]
718 pub archived: Option<bool>,
719}
720
721#[derive(Debug, Clone, Serialize, Default)]
725#[serde(rename_all = "camelCase")]
726pub struct UpdateVersionPayload {
727 #[serde(skip_serializing_if = "Option::is_none")]
728 pub name: Option<String>,
729 #[serde(skip_serializing_if = "Option::is_none")]
730 pub description: Option<String>,
731 #[serde(skip_serializing_if = "Option::is_none")]
732 pub start_date: Option<String>,
733 #[serde(skip_serializing_if = "Option::is_none")]
734 pub release_date: Option<String>,
735 #[serde(skip_serializing_if = "Option::is_none")]
736 pub released: Option<bool>,
737 #[serde(skip_serializing_if = "Option::is_none")]
738 pub archived: Option<bool>,
739}