clientix_core/client/asynchronous/
response.rs

1use bytes::Bytes;
2use futures_util::TryStreamExt;
3use reqwest::Response;
4use serde::de::DeserializeOwned;
5use crate::client::asynchronous::stream::ClientixStream;
6use crate::client::asynchronous::stream::sse::ClientixSSEStream;
7use crate::client::response::{ClientixError, ClientixResponse, ClientixResult};
8
9pub struct AsyncResponseHandler {
10    result: ClientixResult<Response>
11}
12
13impl AsyncResponseHandler {
14
15    pub fn new(result: ClientixResult<Response>) -> AsyncResponseHandler {
16        AsyncResponseHandler { result }
17    }
18
19    pub async fn bytes(self) -> ClientixResult<ClientixResponse<Bytes>> {
20        match self.result {
21            Ok(response) => {
22                Ok(ClientixResponse::new(
23                    response.version(),
24                    response.content_length(),
25                    response.status(),
26                    response.url().clone(),
27                    response.remote_addr(),
28                    response.headers().clone(),
29                    response.bytes().await?
30                ))
31            },
32            Err(error) => Err(error),
33        }
34    }
35
36    pub fn bytes_stream(self) -> ClientixResult<ClientixStream> {
37        match self.result {
38            Ok(response) => {
39                Ok(ClientixStream::new(
40                    response.version(),
41                    response.content_length(),
42                    response.status(),
43                    response.url().clone(),
44                    response.remote_addr(),
45                    response.headers().clone(),
46                    response.bytes_stream().map_err(ClientixError::from)
47                ))
48            },
49            Err(error) => Err(error)
50        }
51    }
52
53    pub async fn text(self) -> ClientixResult<ClientixResponse<String>> {
54        match self.result {
55            Ok(response) => {
56                Ok(ClientixResponse::new(
57                    response.version(),
58                    response.content_length(),
59                    response.status(),
60                    response.url().clone(),
61                    response.remote_addr(),
62                    response.headers().clone(),
63                    response.text().await?
64                ))
65            },
66            Err(error) => Err(error),
67        }
68    }
69
70    pub async fn text_with_encoding(self, encoding: &str) -> ClientixResult<ClientixResponse<String>> {
71        match self.result {
72            Ok(response) => {
73                Ok(ClientixResponse::new(
74                    response.version(),
75                    response.content_length(),
76                    response.status(),
77                    response.url().clone(),
78                    response.remote_addr(),
79                    response.headers().clone(),
80                    response.text_with_charset(encoding).await?
81                ))
82            },
83            Err(error) => Err(error),
84        }
85    }
86
87    pub fn text_stream(self) -> ClientixResult<ClientixSSEStream<String>> {
88        Ok(self.bytes_stream()?.sse())
89    }
90
91    pub async fn json<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
92        match self.result {
93            Ok(response) => {
94                Ok(ClientixResponse::new(
95                    response.version(),
96                    response.content_length(),
97                    response.status(),
98                    response.url().clone(),
99                    response.remote_addr(),
100                    response.headers().clone(),
101                    serde_json::from_str::<T>(response.text().await?.as_str())?
102                ))
103            },
104            Err(error) => Err(error),
105        }
106    }
107
108    pub fn json_stream<T>(self) -> ClientixResult<ClientixSSEStream<T>> where T: DeserializeOwned + Clone {
109        Ok(self.text_stream()?.json_stream())
110    }
111
112    pub async fn xml<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
113        match self.result {
114            Ok(response) => {
115                Ok(ClientixResponse::new(
116                    response.version(),
117                    response.content_length(),
118                    response.status(),
119                    response.url().clone(),
120                    response.remote_addr(),
121                    response.headers().clone(),
122                    serde_xml_rs::from_str::<T>(response.text().await?.as_str())?
123                ))
124            },
125            Err(error) => Err(error),
126        }
127    }
128    
129    pub async fn xml_stream<T>(self) -> ClientixResult<ClientixSSEStream<T>> where T: DeserializeOwned + Clone {
130        Ok(self.text_stream()?.xml_stream())
131    }
132    
133    pub async fn urlencoded<T>(self) -> ClientixResult<ClientixResponse<T>> where T: DeserializeOwned + Clone {
134        match self.result {
135            Ok(response) => {
136                Ok(ClientixResponse::new(
137                    response.version(),
138                    response.content_length(),
139                    response.status(),
140                    response.url().clone(),
141                    response.remote_addr(),
142                    response.headers().clone(),
143                    serde_urlencoded::from_str::<T>(response.text().await?.as_str())?
144                ))
145            },
146            Err(error) => Err(error),
147        }
148    }
149    
150}
clientix_core/client/asynchronous/response.rs

clientix_core/client/asynchronous/
response.rs
