stuff happened

backend/task/src/utils/request.rs

@@ -0,0 +1,85 @@
+use reqwest::StatusCode;
+use std::env;
+use std::time::Duration;
+
+#[derive(Debug)]
+pub struct Request<'a> {
+    pub client: reqwest::Client,
+    pub base_url: Box<str>,
+    pub full_url: Option<&'a str>,
+}
+
+#[derive(Debug)]
+pub enum Response<T> {
+    Json(T),
+    Xml(String),
+    Text(String),
+    Bytes(Vec<u8>),
+}
+
+impl<'a> Request<'a> {
+    pub fn new() -> Self {
+        Request {
+            client: reqwest::ClientBuilder::new()
+                .use_rustls_tls()
+                .timeout(Duration::from_secs(30))
+                .build()
+                .unwrap(),
+            base_url: env::var("BASE_URI_API")
+                .expect("Environment variable BASE_URI_API is not found")
+                .into_boxed_str(),
+            full_url: None,
+        }
+    }
+
+    pub async fn request_url<T>(
+        &self,
+        url: &String,
+    ) -> Result<Response<T>, Box<dyn std::error::Error>>
+    where
+        T: for<'de> serde::Deserialize<'de>,
+    {
+        println!("{}", url);
+        let api_result = match self.client.get(url).send().await {
+            Ok(r) => r,
+            Err(e) => return Err(Box::new(e)),
+        };
+
+        match api_result.status() {
+            StatusCode::OK => {
+                // TODO: handle errors here
+                let content_type = api_result
+                    .headers()
+                    .get("content-type")
+                    .and_then(|v| v.to_str().ok())
+                    .unwrap();
+
+                if content_type.contains("application/json") {
+                    match api_result.json::<T>().await {
+                        Ok(j) => Ok(Response::Json(j)),
+                        Err(e) => return Err(Box::new(e)),
+                    }
+                } else if content_type.contains("application/xml") {
+                    match api_result.text().await {
+                        Ok(x) => Ok(Response::Xml(x)),
+                        Err(e) => return Err(Box::new(e)),
+                    }
+                } else if content_type.starts_with("text/") {
+                    match api_result.text().await {
+                        Ok(t) => Ok(Response::Text(t)),
+                        Err(e) => return Err(Box::new(e)),
+                    }
+                } else {
+                    match api_result.bytes().await {
+                        Ok(b) => Ok(Response::Bytes(b.to_vec())),
+                        Err(e) => Err(Box::new(e)),
+                    }
+                }
+            }
+            status => Err(Box::new(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                format!("Unexpected status code: {}", status),
+            ))),
+        }
+    }
+}