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

pub enum GetAccountSummaryError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

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

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

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

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

pub enum CountAccountSummaryError {
    RequestFailure(reqwest::Error),
    InvalidHeaderValue(reqwest::header::InvalidHeaderValue),
    UnexpectedStatus(reqwest::StatusCode),
    Status500 {
        error: String,
    },
}

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

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

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

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

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

#[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>, GetAccountSummaryError> {
        let mut url = self.base_url.clone();
        url.set_path("admin/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 result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<Vec<crate::model::AccountSummary>>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<AccountSummaryEndpointErrorInternalPayload>().await?;
                Err(GetAccountSummaryError::Status500 { error: body.error })
            }
            _ => Err(GetAccountSummaryError::UnexpectedStatus(result.status()))
        }
    }

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

        let mut headers = reqwest::header::HeaderMap::new();
        headers.append("authorization", reqwest::header::HeaderValue::from_str(&format!("{authorization}"))?);
        let result = reqwest::Client::builder()
            .build()?
            .get(url)
            .headers(headers)
            .send()
            .await?;
        match result.status().as_u16() {
            200 => {
                let body = result.json::<i64>().await?;
                Ok(body)
            }
            500 => {
                let body = result.json::<AccountSummaryEndpointErrorInternalPayload>().await?;
                Err(CountAccountSummaryError::Status500 { error: body.error })
            }
            _ => Err(CountAccountSummaryError::UnexpectedStatus(result.status()))
        }
    }
}