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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Issue Statuses Rest API Endpoint definitions
//!
//! [Redmine Documentation](https://www.redmine.org/projects/redmine/wiki/Rest_IssueStatuses)
//!
//! - [x] all issue statuses endpoint

use derive_builder::Builder;
use reqwest::Method;
use std::borrow::Cow;

use crate::api::{Endpoint, ReturnsJsonResponse};

/// a minimal type for Redmine issue status used in
/// other Redmine objects (e.g. issue)
#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct IssueStatusEssentials {
    /// numeric id
    pub id: u64,
    /// is this status consided closed, only included in recent Redmine versions
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub is_closed: Option<bool>,
    /// display name
    pub name: String,
}

impl From<IssueStatus> for IssueStatusEssentials {
    fn from(v: IssueStatus) -> Self {
        IssueStatusEssentials {
            id: v.id,
            is_closed: Some(v.is_closed),
            name: v.name,
        }
    }
}

impl From<&IssueStatus> for IssueStatusEssentials {
    fn from(v: &IssueStatus) -> Self {
        IssueStatusEssentials {
            id: v.id,
            is_closed: Some(v.is_closed),
            name: v.name.to_owned(),
        }
    }
}

/// a type for issue status to use as an API return type
///
/// alternatively you can use your own type limited to the fields you need
#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct IssueStatus {
    /// numeric id
    pub id: u64,
    /// display name
    pub name: String,
    /// is this status considered closed
    pub is_closed: bool,
}

/// The endpoint for all issue statuses
#[derive(Debug, Builder)]
#[builder(setter(strip_option))]
pub struct ListIssueStatuses {}

impl ReturnsJsonResponse for ListIssueStatuses {}

impl ListIssueStatuses {
    /// Create a builder for the endpoint.
    #[must_use]
    pub fn builder() -> ListIssueStatusesBuilder {
        ListIssueStatusesBuilder::default()
    }
}

impl Endpoint for ListIssueStatuses {
    fn method(&self) -> Method {
        Method::GET
    }

    fn endpoint(&self) -> Cow<'static, str> {
        "issue_statuses.json".into()
    }
}

/// helper struct for outer layers with a issue_statuses field holding the inner data
#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct IssueStatusesWrapper<T> {
    /// to parse JSON with issue_statuses key
    pub issue_statuses: Vec<T>,
}

/// A lot of APIs in Redmine wrap their data in an extra layer, this is a
/// helper struct for outer layers with a issue_status field holding the inner data
#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct IssueStatusWrapper<T> {
    /// to parse JSON with an issue_status key
    pub issue_status: T,
}

#[cfg(test)]
mod test {
    use super::*;
    use pretty_assertions::assert_eq;
    use std::error::Error;
    use tracing_test::traced_test;

    #[traced_test]
    #[test]
    fn test_list_issue_statuses_no_pagination() -> Result<(), Box<dyn Error>> {
        dotenvy::dotenv()?;
        let redmine = crate::api::Redmine::from_env()?;
        let endpoint = ListIssueStatuses::builder().build()?;
        redmine.json_response_body::<_, IssueStatusesWrapper<IssueStatus>>(&endpoint)?;
        Ok(())
    }

    /// this tests if any of the results contain a field we are not deserializing
    ///
    /// this will only catch fields we missed if they are part of the response but
    /// it is better than nothing
    #[traced_test]
    #[test]
    fn test_completeness_issue_status_type() -> Result<(), Box<dyn Error>> {
        dotenvy::dotenv()?;
        let redmine = crate::api::Redmine::from_env()?;
        let endpoint = ListIssueStatuses::builder().build()?;
        let IssueStatusesWrapper {
            issue_statuses: values,
        } = redmine.json_response_body::<_, IssueStatusesWrapper<serde_json::Value>>(&endpoint)?;
        for value in values {
            let o: IssueStatus = serde_json::from_value(value.clone())?;
            let reserialized = serde_json::to_value(o)?;
            assert_eq!(value, reserialized);
        }
        Ok(())
    }
}