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
137
138
139

#[derive(Debug)]
pub enum AccountSummaryError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status401 {
        message: String,
    },
    Status500 {
        error: String,
    },
}

impl From<reqwest::Error> for AccountSummaryError {
    fn from(error: reqwest::Error) -> AccountSummaryError {
        AccountSummaryError::RequestFailure(error)
    }
}

impl From<reqwest::header::InvalidHeaderValue> for AccountSummaryError {
    fn from(error: reqwest::header::InvalidHeaderValue) -> AccountSummaryError {
        AccountSummaryError::InvalidHeaderValue(error)
    }
}

impl AccountSummaryError {
    pub fn to_account_summary_endpoint_error(&self) -> Option<crate::model::AccountSummaryEndpointError> {
        match self {
            AccountSummaryError::Status401 { message } => Some(crate::model::AccountSummaryEndpointError::Unauthorized { message: message.clone() }), 
            AccountSummaryError::Status500 { error } => Some(crate::model::AccountSummaryEndpointError::Internal { error: error.clone() }), 
            _ => None
        }
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountSummaryEndpointErrorUnauthorizedPayload {
    pub message: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct AccountSummaryEndpointErrorInternalPayload {
    pub error: String,
}

#[async_trait::async_trait]
pub trait AccountSummary {
    async fn get_account_summary(&self, skip: i32, limit: i32, authorization: &str) -> Result<Vec<crate::model::AccountSummary>, AccountSummaryError>;
    async fn count_account_summary(&self, authorization: &str) -> Result<i64, AccountSummaryError>;
}

#[derive(Clone, Debug)]
pub struct AccountSummaryLive {
    pub base_url: reqwest::Url,
    pub allow_insecure: bool,
}

#[async_trait::async_trait]
impl AccountSummary for AccountSummaryLive {
    async fn get_account_summary(&self, skip: i32, limit: i32, authorization: &str) -> Result<Vec<crate::model::AccountSummary>, AccountSummaryError> {
        let mut url = self.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("admin")
            .push("accounts");
        url.query_pairs_mut().append_pair("skip", &format!("{skip}"));
        url.query_pairs_mut().append_pair("limit", &format!("{limit}"));
        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        {
            let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
            tracing::info!(method="get", url=url.to_string(), headers=?headers_vec, body="<no_body>", "get_account_summary");
        }
        let mut builder = reqwest::Client::builder();
        if self.allow_insecure {
            builder = builder.danger_accept_invalid_certs(true);
        }
        let client = builder.build()?;
        let result = client
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<Vec<crate::model::AccountSummary>>().await?;
                Ok(body)
            }
            401 => {
                let body = result.json::<AccountSummaryEndpointErrorUnauthorizedPayload>().await?;
                Err(AccountSummaryError::Status401 { message: body.message })
            }
            500 => {
                let body = result.json::<AccountSummaryEndpointErrorInternalPayload>().await?;
                Err(AccountSummaryError::Status500 { error: body.error })
            }
            _ => Err(AccountSummaryError::UnexpectedStatus(result.status()))
        }
    }

    async fn count_account_summary(&self, authorization: &str) -> Result<i64, AccountSummaryError> {
        let mut url = self.base_url.clone();
        url.path_segments_mut().unwrap()
            .push("admin")
            .push("accounts")
            .push("count");

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        {
            let headers_vec: Vec<(&str, String)> = headers.iter().map(|(k, v)| crate::hide_authorization(k, v)).collect();
            tracing::info!(method="get", url=url.to_string(), headers=?headers_vec, body="<no_body>", "count_account_summary");
        }
        let mut builder = reqwest::Client::builder();
        if self.allow_insecure {
            builder = builder.danger_accept_invalid_certs(true);
        }
        let client = builder.build()?;
        let result = client
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<i64>().await?;
                Ok(body)
            }
            401 => {
                let body = result.json::<AccountSummaryEndpointErrorUnauthorizedPayload>().await?;
                Err(AccountSummaryError::Status401 { message: body.message })
            }
            500 => {
                let body = result.json::<AccountSummaryEndpointErrorInternalPayload>().await?;
                Err(AccountSummaryError::Status500 { error: body.error })
            }
            _ => Err(AccountSummaryError::UnexpectedStatus(result.status()))
        }
    }
}