omnitrack 0.3.0

Universal issue-tracker provider contracts and clients (Linear, Jira, ...) for Rust, in one crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::{ErrorKind, IssueResult, StatusCategory, error};
use reqwest::Method;
use serde::Deserialize;

use super::client::JiraClient;
use super::model::StatusCategoryNode;

#[derive(Deserialize)]
struct TransitionNode {
    id: String,
    name: String,
    to: Option<TransitionTarget>,
}

#[derive(Deserialize)]
struct TransitionTarget {
    name: String,
    #[serde(rename = "statusCategory")]
    status_category: Option<StatusCategoryNode>,
}

pub(crate) fn category_status_key(category: StatusCategory) -> &'static str {
    match category {
        StatusCategory::Backlog | StatusCategory::Unstarted => "new",
        StatusCategory::Started => "indeterminate",
        StatusCategory::Completed | StatusCategory::Canceled => "done",
    }
}

impl JiraClient {
    async fn transitions(&self, key: &str) -> IssueResult<Vec<TransitionNode>> {
        #[derive(Deserialize)]
        struct Response {
            #[serde(default)]
            transitions: Vec<TransitionNode>,
        }

        let path = format!("/rest/api/3/issue/{key}/transitions");
        let response: Response = self.request(Method::GET, &path, None).await?;
        Ok(response.transitions)
    }

    async fn apply_transition(&self, key: &str, transition_id: &str) -> IssueResult<()> {
        let path = format!("/rest/api/3/issue/{key}/transitions");
        let body = serde_json::json!({ "transition": { "id": transition_id } });
        self.request_unit(Method::POST, &path, Some(&body)).await
    }

    pub(crate) async fn transition_status(&self, key: &str, status: &str) -> IssueResult<()> {
        let wanted = status.to_lowercase();
        let target = self.transitions(key).await?.into_iter().find(|transition| {
            transition
                .to
                .as_ref()
                .map(|to| to.name.to_lowercase() == wanted)
                .unwrap_or(false)
                || transition.name.to_lowercase() == wanted
        });

        match target {
            Some(transition) => self.apply_transition(key, &transition.id).await,
            None => Err(error().of(
                ErrorKind::Provider,
                format!("jira issue has no transition to status {status}"),
            )),
        }
    }

    pub(crate) async fn transition_category(
        &self,
        key: &str,
        category: StatusCategory,
    ) -> IssueResult<()> {
        let wanted = category_status_key(category);
        let target = self.transitions(key).await?.into_iter().find(|transition| {
            transition
                .to
                .as_ref()
                .and_then(|to| to.status_category.as_ref())
                .map(|status_category| status_category.key == wanted)
                .unwrap_or(false)
        });

        match target {
            Some(transition) => self.apply_transition(key, &transition.id).await,
            None => Err(error().of(
                ErrorKind::Provider,
                format!("jira issue has no transition to category {wanted}"),
            )),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn category_status_keys_map_to_jira() {
        assert_eq!(category_status_key(StatusCategory::Backlog), "new");
        assert_eq!(
            category_status_key(StatusCategory::Started),
            "indeterminate"
        );
        assert_eq!(category_status_key(StatusCategory::Canceled), "done");
    }
}