collaboflow_rs/client/document/
document_one.rs

1use crate::authorization::HEADER_KEY;
2use crate::client::document::RESOURCE_V1_DOCUMENTS;
3use crate::request::document::document_one::PutDocumentStatusRequest;
4use crate::response::document::document_one::{
5    DeleteDocumentResponse, GetDocumentResponse, GetDocumentResponseBody, PutDocumentStatusResponse,
6};
7use crate::response::error::{ErrorResponse, ErrorResponseBody};
8use crate::Query;
9use serde::Serialize;
10
11#[derive(Debug, Clone)]
12pub struct Document {
13    url: String,
14    authorization_header: String,
15}
16
17impl Document {
18    pub fn new(url: &str, authorization_header: &str) -> Self {
19        Self {
20            url: url.to_string() + RESOURCE_V1_DOCUMENTS,
21            authorization_header: authorization_header.to_string(),
22        }
23    }
24
25    pub async fn get(
26        &self,
27        document_id: i32,
28        query: Query,
29    ) -> Result<GetDocumentResponse, ErrorResponse> {
30        let request_url = format!("{}/{}", &self.url, document_id);
31
32        let http_client = reqwest::Client::new();
33        let result = http_client
34            .get(request_url)
35            .query(&query.to_queries())
36            .header(HEADER_KEY, &self.authorization_header)
37            .send()
38            .await;
39
40        match result {
41            Ok(resp) => {
42                let status = resp.status().as_u16();
43
44                if status == 200 {
45                    match resp.json::<GetDocumentResponseBody>().await {
46                        Ok(body) => Ok(GetDocumentResponse { status, body }),
47                        Err(err) => {
48                            let body = ErrorResponseBody {
49                                error: true,
50                                messages: vec![err.to_string()],
51                            };
52                            let error_response = ErrorResponse { status, body };
53                            Err(error_response)
54                        }
55                    }
56                } else {
57                    match resp.json::<ErrorResponseBody>().await {
58                        Ok(body) => {
59                            let error_response = ErrorResponse { status, body };
60                            Err(error_response)
61                        }
62                        Err(err) => {
63                            let body = ErrorResponseBody {
64                                error: true,
65                                messages: vec![err.to_string()],
66                            };
67                            let error_response = ErrorResponse { status, body };
68                            Err(error_response)
69                        }
70                    }
71                }
72            }
73            Err(err) => {
74                let body = ErrorResponseBody {
75                    error: true,
76                    messages: vec![err.to_string()],
77                };
78                let error_response = ErrorResponse { status: 500, body };
79                Err(error_response)
80            }
81        }
82    }
83
84    pub async fn put<T: Serialize>(
85        &self,
86        document_id: i32,
87        query: Query,
88        request: PutDocumentStatusRequest<T>,
89    ) -> Result<PutDocumentStatusResponse, ErrorResponse> {
90        let request_url = format!("{}/{}", &self.url, document_id);
91
92        let http_client = reqwest::Client::new();
93        let result = http_client
94            .put(request_url)
95            .query(&query.to_queries())
96            .json(&request.document)
97            .header(HEADER_KEY, &self.authorization_header)
98            .send()
99            .await;
100
101        match result {
102            Ok(resp) => {
103                let status = resp.status().as_u16();
104
105                if status == 200 {
106                    Ok(PutDocumentStatusResponse { status })
107                } else {
108                    match resp.json::<ErrorResponseBody>().await {
109                        Ok(body) => {
110                            let error_response = ErrorResponse { status, body };
111                            Err(error_response)
112                        }
113                        Err(err) => {
114                            let body = ErrorResponseBody {
115                                error: true,
116                                messages: vec![err.to_string()],
117                            };
118                            let error_response = ErrorResponse { status, body };
119                            Err(error_response)
120                        }
121                    }
122                }
123            }
124            Err(err) => {
125                let body = ErrorResponseBody {
126                    error: true,
127                    messages: vec![err.to_string()],
128                };
129                let error_response = ErrorResponse { status: 500, body };
130                Err(error_response)
131            }
132        }
133    }
134
135    pub async fn delete(
136        &self,
137        document_id: i32,
138        query: Query,
139    ) -> Result<DeleteDocumentResponse, ErrorResponse> {
140        let request_url = format!("{}/{}", &self.url, document_id);
141
142        let http_client = reqwest::Client::new();
143        let result = http_client
144            .delete(request_url)
145            .query(&query.to_queries())
146            .header(HEADER_KEY, &self.authorization_header)
147            .send()
148            .await;
149
150        match result {
151            Ok(resp) => {
152                let status = resp.status().as_u16();
153
154                if status == 200 {
155                    Ok(DeleteDocumentResponse { status })
156                } else {
157                    match resp.json::<ErrorResponseBody>().await {
158                        Ok(body) => {
159                            let error_response = ErrorResponse { status, body };
160                            Err(error_response)
161                        }
162                        Err(err) => {
163                            let body = ErrorResponseBody {
164                                error: true,
165                                messages: vec![err.to_string()],
166                            };
167                            let error_response = ErrorResponse { status, body };
168                            Err(error_response)
169                        }
170                    }
171                }
172            }
173            Err(err) => {
174                let body = ErrorResponseBody {
175                    error: true,
176                    messages: vec![err.to_string()],
177                };
178                let error_response = ErrorResponse { status: 500, body };
179                Err(error_response)
180            }
181        }
182    }
183}
collaboflow_rs/client/document/document_one.rs

collaboflow_rs/client/document/
document_one.rs
