apimock_server/response/
file_response.rs

1use console::style;
2use hyper::HeaderMap;
3use serde_json::{Map, Value};
4use tokio::task;
5
6use std::{collections::HashMap, fs};
7
8use crate::{
9    constant::CSV_RECORDS_DEFAULT_KEY,
10    json_path_util::resolve_with_json_compatible_extensions,
11    response::{error_response::not_found_response, json_response::json_response},
12    response_handler::ResponseHandler,
13    types::BoxBody,
14};
15
16use super::{
17    error_response::internal_server_error_response,
18    text_response::text_response,
19    util::{
20        binary_content_type, file_extension, json_value_with_jsonpath_key, text_file_content_type,
21    },
22};
23
24pub struct FileResponse {
25    file_path: String,
26    csv_records_key: Option<String>,
27    text_content: Option<String>,
28    binary_content: Option<Vec<u8>>,
29    custom_headers: Option<HashMap<String, Option<String>>>,
30    request_headers: HeaderMap,
31}
32
33impl FileResponse {
34    /// create instance
35    pub fn new(
36        file_path: &str,
37        custom_headers: Option<&HashMap<String, Option<String>>>,
38        request_headers: &HeaderMap,
39    ) -> Self {
40        FileResponse {
41            file_path: file_path.to_owned(),
42            csv_records_key: None,
43            text_content: None,
44            binary_content: None,
45            custom_headers: custom_headers.cloned(),
46            request_headers: request_headers.clone(),
47        }
48    }
49
50    /// create instance
51    pub fn new_with_csv_records_jsonpath(
52        file_path: &str,
53        custom_headers: Option<&HashMap<String, Option<String>>>,
54        csv_records_key: Option<String>,
55        request_headers: &HeaderMap,
56    ) -> Self {
57        let mut ret = FileResponse::new(file_path, custom_headers, request_headers);
58        ret.csv_records_key = csv_records_key;
59        ret
60    }
61
62    /// response from file path
63    pub async fn file_content_response(
64        &mut self,
65    ) -> Result<hyper::Response<BoxBody>, hyper::http::Error> {
66        let file_path = match resolve_with_json_compatible_extensions(self.file_path.as_str()) {
67            Some(x) => x,
68            None => {
69                log::warn!(
70                    "{}:\n{} (missing or a directory)",
71                    style("file not found").red(),
72                    self.file_path
73                );
74                return not_found_response(&self.request_headers);
75            }
76        };
77        self.file_path = file_path.clone();
78
79        // read file as text file in non-blocking task
80        let file_path_to_read_text_file = file_path.clone();
81        let content =
82            task::spawn_blocking(move || fs::read_to_string(file_path_to_read_text_file)).await;
83
84        match content {
85            Ok(Ok(content)) => {
86                self.text_content = Some(content);
87                self.text_file_content_response()
88            }
89            Ok(Err(_)) => {
90                // read file as binary in non-blocking task
91                let file_path_to_read_binary = file_path.clone();
92                let content =
93                    task::spawn_blocking(move || fs::read(file_path_to_read_binary)).await;
94                match content {
95                    Ok(Ok(content)) => {
96                        self.binary_content = Some(content);
97                        self.binary_content_type_response()
98                    }
99                    Ok(Err(err)) => internal_server_error_response(
100                        &format!("{}: failed to read file - {}", self.file_path, err),
101                        &self.request_headers,
102                    ),
103                    Err(err) => internal_server_error_response(
104                        &format!("{}: async task failed - {}", self.file_path, err),
105                        &self.request_headers,
106                    ),
107                }
108            }
109            Err(err) => internal_server_error_response(
110                &format!("{}: async task failed - {}", self.file_path, err),
111                &self.request_headers,
112            ),
113        }
114    }
115
116    /// text file response
117    fn text_file_content_response(&self) -> Result<hyper::Response<BoxBody>, hyper::http::Error> {
118        match file_extension(self.file_path.as_str()) {
119            Some(ext) => match ext.as_str() {
120                "json" | "json5" => self.json_file_content_response(),
121                "csv" => self.csv_file_content_response(),
122                _ => text_response(
123                    self.text_content.clone().unwrap_or_default().as_str(),
124                    Some(text_file_content_type(ext).as_str()),
125                    None,
126                    &self.request_headers,
127                ),
128            },
129            None => text_response(
130                self.text_content.clone().unwrap_or_default().as_str(),
131                None,
132                None,
133                &self.request_headers,
134            ),
135        }
136    }
137
138    /// json file response
139    fn json_file_content_response(&self) -> Result<hyper::Response<BoxBody>, hyper::http::Error> {
140        let json_str = self.text_content.clone().unwrap_or_default();
141        json_response(
142            json_str.as_str(),
143            self.custom_headers.as_ref(),
144            &self.request_headers,
145            self.file_path.as_str(),
146        )
147    }
148
149    /// csv file response
150    fn csv_file_content_response(&self) -> Result<hyper::Response<BoxBody>, hyper::http::Error> {
151        let text_content = self.text_content.clone().unwrap_or_default();
152        let mut rdr = csv::ReaderBuilder::new()
153            .has_headers(true)
154            .from_reader(text_content.as_bytes());
155
156        let csv_headers = if let Ok(csv_headers) = rdr.headers() {
157            csv_headers.clone()
158        } else {
159            return internal_server_error_response(
160                &format!("{}: failed to analyze csv headers", self.file_path.as_str()),
161                &self.request_headers,
162            );
163        };
164
165        let rows = rdr
166            .records()
167            .map(|result| {
168                let record = result?;
169                let obj = csv_headers
170                    .iter()
171                    .zip(record.iter())
172                    .map(|(k, v)| (k.to_string(), Value::String(v.to_string())))
173                    .collect::<Map<_, _>>();
174                Ok(Value::Object(obj))
175            })
176            .collect::<Result<Vec<Value>, csv::Error>>();
177
178        match rows {
179            Ok(rows) => {
180                let jsonpath_key = if let Some(csv_records_key) = self.csv_records_key.as_ref() {
181                    csv_records_key.as_str()
182                } else {
183                    CSV_RECORDS_DEFAULT_KEY
184                };
185                let json_value = json_value_with_jsonpath_key(jsonpath_key, Value::from(rows));
186
187                let body = serde_json::to_string(&json_value);
188                match body {
189                    Ok(body) => json_response(
190                        body.as_str(),
191                        self.custom_headers.as_ref(),
192                        &self.request_headers,
193                        self.file_path.as_str(),
194                    ),
195                    Err(err) => internal_server_error_response(
196                        &format!(
197                            "{}: failed to convert csv records to json response - {}",
198                            self.file_path.as_str(),
199                            err
200                        ),
201                        &self.request_headers,
202                    ),
203                }
204            }
205            Err(err) => internal_server_error_response(
206                &format!(
207                    "{}: failed to analyze csv records - {}",
208                    self.file_path.as_str(),
209                    err
210                ),
211                &self.request_headers,
212            ),
213        }
214    }
215
216    /// binary file response
217    fn binary_content_type_response(&self) -> Result<hyper::Response<BoxBody>, hyper::http::Error> {
218        let mut response_handler = ResponseHandler::default();
219
220        if let Some(custom_headers) = self.custom_headers.clone() {
221            response_handler = response_handler.with_headers(custom_headers);
222        }
223
224        let content = self.binary_content.clone().unwrap_or_default().to_owned();
225        let content_type = binary_content_type(self.file_path.as_str());
226        response_handler
227            .with_binary_body(content, Some(content_type))
228            .into_response(&self.request_headers)
229    }
230}
apimock_server/response/file_response.rs

apimock_server/response/
file_response.rs
