golem_gateway_client/api/
api_certificate.rs

1use async_trait::async_trait;
2use crate::Context;
3use crate::Error;
4use crate::model::Certificate;
5use crate::model::CertificateRequest;
6use crate::model::ErrorBody;
7use crate::model::ErrorsBody;
8use crate::model::MessageBody;
9use uuid::Uuid;
10
11pub enum ApiCertificateError {
12    Error400(ErrorsBody),
13    Error401(ErrorBody),
14    Error403(ErrorBody),
15    Error404(MessageBody),
16    Error409(String),
17    Error500(ErrorBody),
18}
19
20#[async_trait]
21pub trait ApiCertificateClient {
22    async fn get(&self, project_id: &Uuid, certificate_id: Option<&Uuid>) -> Result<Vec<Certificate>, Error<ApiCertificateError>>;
23    async fn post(&self, value: &CertificateRequest) -> Result<Certificate, Error<ApiCertificateError>>;
24    async fn delete(&self, project_id: &Uuid, certificate_id: &Uuid) -> Result<String, Error<ApiCertificateError>>;
25}
26
27pub struct ApiCertificateClientLive {
28    pub context: Context,
29}
30
31#[async_trait]
32impl ApiCertificateClient for ApiCertificateClientLive {
33    async fn get(&self, project_id: &Uuid, certificate_id: Option<&Uuid>) -> Result<Vec<Certificate>, Error<ApiCertificateError>> {
34        let mut url = self.context.base_url.clone();
35        url.path_segments_mut().unwrap()
36            .push("v1")
37            .push("api")
38            .push("certificates");
39
40        url.query_pairs_mut().append_pair("project-id", &project_id.to_string());
41
42        if let Some(certificate_id) = certificate_id {
43            url.query_pairs_mut().append_pair("certificate-id", &certificate_id.to_string());
44        }
45
46        let mut request = self
47            .context
48            .client
49            .get(url.clone());
50
51        {
52            tracing::info!(method="get", endpoint="/v1/api/certificates", url=url.to_string(), "get");
53        }
54
55        if let Some(token) = self.context.bearer_token() {
56            request = request.bearer_auth(token);
57        }
58
59        let response = request.send().await?;
60
61        let status = response.status().as_u16();
62        match status {
63            200 => {
64                Ok(response.json::<Vec<Certificate>>().await?)
65            }
66            400 => {
67                let body = response.json::<ErrorsBody>().await?;
68                Err(Error::Item(ApiCertificateError::Error400(body)))
69            }
70            401 => {
71                let body = response.json::<ErrorBody>().await?;
72                Err(Error::Item(ApiCertificateError::Error401(body)))
73            }
74            403 => {
75                let body = response.json::<ErrorBody>().await?;
76                Err(Error::Item(ApiCertificateError::Error403(body)))
77            }
78            404 => {
79                let body = response.json::<MessageBody>().await?;
80                Err(Error::Item(ApiCertificateError::Error404(body)))
81            }
82            409 => {
83                let body = response.json::<String>().await?;
84                Err(Error::Item(ApiCertificateError::Error409(body)))
85            }
86            500 => {
87                let body = response.json::<ErrorBody>().await?;
88                Err(Error::Item(ApiCertificateError::Error500(body)))
89            }
90            _ => Err(Error::unexpected(status, response.bytes().await?)),
91        }
92    }
93
94    async fn post(&self, value: &CertificateRequest) -> Result<Certificate, Error<ApiCertificateError>> {
95        let mut url = self.context.base_url.clone();
96        url.path_segments_mut().unwrap()
97            .push("v1")
98            .push("api")
99            .push("certificates");
100
101        let mut request = self
102            .context
103            .client
104            .post(url.clone());
105
106        {
107            tracing::info!(method="post", endpoint="/v1/api/certificates", url=url.to_string(), body=serde_json::to_string(value)?, "post");
108        }
109
110        if let Some(token) = self.context.bearer_token() {
111            request = request.bearer_auth(token);
112        }
113
114        request = request.json(value);
115
116        let response = request.send().await?;
117
118        let status = response.status().as_u16();
119        match status {
120            200 => {
121                Ok(response.json::<Certificate>().await?)
122            }
123            400 => {
124                let body = response.json::<ErrorsBody>().await?;
125                Err(Error::Item(ApiCertificateError::Error400(body)))
126            }
127            401 => {
128                let body = response.json::<ErrorBody>().await?;
129                Err(Error::Item(ApiCertificateError::Error401(body)))
130            }
131            403 => {
132                let body = response.json::<ErrorBody>().await?;
133                Err(Error::Item(ApiCertificateError::Error403(body)))
134            }
135            404 => {
136                let body = response.json::<MessageBody>().await?;
137                Err(Error::Item(ApiCertificateError::Error404(body)))
138            }
139            409 => {
140                let body = response.json::<String>().await?;
141                Err(Error::Item(ApiCertificateError::Error409(body)))
142            }
143            500 => {
144                let body = response.json::<ErrorBody>().await?;
145                Err(Error::Item(ApiCertificateError::Error500(body)))
146            }
147            _ => Err(Error::unexpected(status, response.bytes().await?)),
148        }
149    }
150
151    async fn delete(&self, project_id: &Uuid, certificate_id: &Uuid) -> Result<String, Error<ApiCertificateError>> {
152        let mut url = self.context.base_url.clone();
153        url.path_segments_mut().unwrap()
154            .push("v1")
155            .push("api")
156            .push("certificates");
157
158        url.query_pairs_mut().append_pair("project-id", &project_id.to_string());
159
160        url.query_pairs_mut().append_pair("certificate-id", &certificate_id.to_string());
161
162        let mut request = self
163            .context
164            .client
165            .delete(url.clone());
166
167        {
168            tracing::info!(method="delete", endpoint="/v1/api/certificates", url=url.to_string(), "delete");
169        }
170
171        if let Some(token) = self.context.bearer_token() {
172            request = request.bearer_auth(token);
173        }
174
175        let response = request.send().await?;
176
177        let status = response.status().as_u16();
178        match status {
179            200 => {
180                Ok(response.json::<String>().await?)
181            }
182            400 => {
183                let body = response.json::<ErrorsBody>().await?;
184                Err(Error::Item(ApiCertificateError::Error400(body)))
185            }
186            401 => {
187                let body = response.json::<ErrorBody>().await?;
188                Err(Error::Item(ApiCertificateError::Error401(body)))
189            }
190            403 => {
191                let body = response.json::<ErrorBody>().await?;
192                Err(Error::Item(ApiCertificateError::Error403(body)))
193            }
194            404 => {
195                let body = response.json::<MessageBody>().await?;
196                Err(Error::Item(ApiCertificateError::Error404(body)))
197            }
198            409 => {
199                let body = response.json::<String>().await?;
200                Err(Error::Item(ApiCertificateError::Error409(body)))
201            }
202            500 => {
203                let body = response.json::<ErrorBody>().await?;
204                Err(Error::Item(ApiCertificateError::Error500(body)))
205            }
206            _ => Err(Error::unexpected(status, response.bytes().await?)),
207        }
208    }
209}
golem_gateway_client/api/api_certificate.rs

golem_gateway_client/api/
api_certificate.rs
