clientix_core/client/blocking/
request.rs

1use http::Method;
2use strfmt::strfmt;
3use crate::client::blocking::client::BlockingClient;
4use crate::client::blocking::response::BlockingResponseHandler;
5use crate::client::request::{ClientixRequestBuilder, RequestConfig};
6use crate::client::response::{ClientixError, ClientixErrorData, ClientixResult};
7
8pub struct BlockingRequest {
9    client: BlockingClient,
10    method: Method,
11    config: RequestConfig,
12    result: ClientixResult<()>,
13}
14
15impl ClientixRequestBuilder for BlockingRequest {
16
17    fn config(&mut self) -> &mut RequestConfig {
18        &mut self.config
19    }
20
21    fn result(&mut self) -> &mut ClientixResult<()> {
22        &mut self.result
23    }
24    
25}
26
27impl BlockingRequest {
28
29    pub fn new(client: BlockingClient, method: Method) -> Self {
30        BlockingRequest {
31            client,
32            method,
33            config: Default::default(),
34            result: Ok(())
35        }
36    }
37
38    pub fn builder(client: BlockingClient, method: Method) -> Self {
39        BlockingRequest::new(client, method)
40    }
41
42    pub fn send(self) -> BlockingResponseHandler {
43        if let Err(error) = self.result {
44            return BlockingResponseHandler::new(Err(error));
45        }
46
47        let method_path = strfmt(self.config.get_path(), self.config.get_path_segments()).expect("failed to format path");
48        let full_path = format!("{}{}", self.client.path, method_path);
49        let url = format!("{}{}", self.client.url, full_path);
50
51        match self.client.client.lock() {
52            Ok(client) => {
53                let mut request_builder = match self.method {
54                    Method::GET => client.get(url.clone()),
55                    Method::POST => client.post(url.clone()),
56                    Method::PUT => client.put(url.clone()),
57                    Method::DELETE => client.delete(url.clone()),
58                    Method::HEAD => client.head(url.clone()),
59                    Method::PATCH => client.patch(url.clone()),
60                    _ => {
61                        let error_data = ClientixErrorData::builder().message(format!("invalid method: {:?}", self.method).as_str()).build();
62                        return BlockingResponseHandler::new(Err(ClientixError::InvalidRequest(error_data, None)));
63                    },
64                };
65
66                request_builder = request_builder
67                    .headers(self.config.get_headers().clone())
68                    .query(self.config.get_queries());
69
70                request_builder = match self.config.get_body() {
71                    Some(body) => request_builder.body::<String>(body.into()),
72                    None => request_builder,
73                };
74
75                request_builder = match self.config.get_timeout() {
76                    Some(timeout) => request_builder.timeout(timeout),
77                    None => request_builder,
78                };
79
80                match request_builder.send() {
81                    Ok(response) => BlockingResponseHandler::new(Ok(response)),
82                    Err(error) => BlockingResponseHandler::new(Err(ClientixError::Http(ClientixErrorData::new(), Some(error.into()))))
83                }
84            },
85            Err(error) => {
86                let error_data = ClientixErrorData::builder().message(format!("client locked: {:?}", error).as_str()).build();
87                BlockingResponseHandler::new(Err(ClientixError::Other(error_data, None)))
88            }
89        }
90    }
91
92}
clientix_core/client/blocking/request.rs

clientix_core/client/blocking/
request.rs
