Fix: Bug with file names

Cargo.lock

@@ -126,6 +126,7 @@ checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
 name = "awesm"
 version = "0.1.0"
 dependencies = [
+ "chrono",
  "clap",
  "env_logger",
  "lazy_static",
@@ -239,7 +240,10 @@ checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
+ "js-sys",
  "num-traits",
+ "serde",
+ "wasm-bindgen",
  "windows-targets 0.52.5",
 ]
 

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+chrono = { version = "0.4.38", features = ["serde"] }
 clap = { version = "4.5.4", features = ["derive"] }
 env_logger = "0.11.3"
 lazy_static = "1.4.0"

src/elastic_query.rs

@@ -45,8 +45,14 @@ impl ElasticQuery {
         let query = serde_json::to_string(self).unwrap();
 
         let client = reqwest::blocking::Client::new();
-        let response = client.get(url).body(query).send()?.text()?;
+        let response = client
+            .get(url)
+            .header("Content-Type", "application/json")
+            .body(query)
+            .send()?
+            .text()?;
         debug!("Elastic Response:\n  {:?}", response);
+
         Ok(serde_json::from_str(&response)?)
     }
 }

src/elastic_response.rs

@@ -23,5 +23,13 @@ pub struct Source {
 
 #[derive(Debug, Deserialize)]
 pub struct File {
-    pub file_name: String,
+    pub filename: String,
+    pub last_modified: String,
+    pub filesize: usize,
+}
+
+#[test]
+fn simple() {
+    let data = "{\"took\":20,\"timed_out\":false,\"_shards\":{\"total\":4,\"successful\":4,\"skipped\":0,\"failed\":0},\"hits\":{\"total\":{\"value\":402,\"relation\":\"eq\"},\"max_score\":7.386201,\"hits\":[{\"_index\":\"awesm\",\"_id\":\"english.md\",\"_score\":7.386201,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.951+00:00\",\"filesize\":16423,\"filename\":\"english.md\"}}},{\"_index\":\"awesm\",\"_id\":\"persian.md\",\"_score\":7.2951937,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:33.171+00:00\",\"filesize\":8665,\"filename\":\"persian.md\"}}},{\"_index\":\"awesm\",\"_id\":\"nologinwebapps.md\",\"_score\":6.871194,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:33.143+00:00\",\"filesize\":30453,\"filename\":\"nologinwebapps.md\"}}},{\"_index\":\"awesm\",\"_id\":\"research.md\",\"_score\":6.614027,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:33.231+00:00\",\"filesize\":41865,\"filename\":\"research.md\"}}},{\"_index\":\"awesm\",\"_id\":\"AutoHotkey.md\",\"_score\":6.309735,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.807+00:00\",\"filesize\":40670,\"filename\":\"AutoHotkey.md\"}}},{\"_index\":\"awesm\",\"_id\":\"devfun.md\",\"_score\":6.2060246,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.927+00:00\",\"filesize\":13573,\"filename\":\"devfun.md\"}}},{\"_index\":\"awesm\",\"_id\":\"arabic.md\",\"_score\":5.7819433,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.795+00:00\",\"filesize\":8660,\"filename\":\"arabic.md\"}}},{\"_index\":\"awesm\",\"_id\":\"i18n.md\",\"_score\":5.737568,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:33.027+00:00\",\"filesize\":16880,\"filename\":\"i18n.md\"}}},{\"_index\":\"awesm\",\"_id\":\"ethics.md\",\"_score\":5.4912834,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.959+00:00\",\"filesize\":71797,\"filename\":\"ethics.md\"}}},{\"_index\":\"awesm\",\"_id\":\"fantasy.md\",\"_score\":5.2991915,\"_source\":{\"file\":{\"last_modified\":\"2024-04-22T20:43:32.959+00:00\",\"filesize\":142570,\"filename\":\"fantasy.md\"}}}]}}";
+    let _: ElasticResponse = serde_json::from_str(data).unwrap();
 }

src/main.rs

@@ -1,11 +1,13 @@
 use clap::Parser;
 use log::info;
 use std::net::{IpAddr, TcpListener};
+
 mod options;
 mod server;
 
 mod elastic_query;
 mod elastic_response;
+mod search_result;
 
 #[derive(Parser, Debug)]
 struct Args {

src/options.rs

@@ -4,7 +4,11 @@ pub mod elastic_search {
     lazy_static! {
         pub static ref URL: Url =
             Url::parse("http://127.0.0.1:9200/_search?filter_path=hits.hits._source").unwrap();
-        pub static ref FIELDS: Vec<String> = vec!["file.filename".to_string()];
+        pub static ref FIELDS: Vec<String> = vec![
+            "file.filename".to_string(),
+            "file.filesize".to_string(),
+            "file.last_modified".to_string()
+        ];
     }
 }
 

src/search_result.rs

@@ -0,0 +1,38 @@
+use serde::Serialize;
+
+use crate::elastic_response::File;
+
+#[derive(Debug, Serialize)]
+pub struct SearchResult {
+    pub name: String,
+    pub modified: String,
+    pub size: usize,
+}
+
+impl SearchResult {
+    pub fn to_html(&self) -> String {
+        format!(
+            "<li><span><a href=\"/{name}\">{name}</a>({size} Bytes)</li>{modified}</span>",
+            name = self.name,
+            size = self.size,
+            modified = self.modified
+        )
+    }
+}
+impl From<&File> for SearchResult {
+    fn from(file: &File) -> Self {
+        let name = file
+            .filename
+            .split('.')
+            .next()
+            .ok_or(file.filename.clone())
+            .unwrap()
+            .to_string();
+
+        Self {
+            name,
+            modified: file.last_modified.clone(),
+            size: file.filesize,
+        }
+    }
+}

src/server.rs

@@ -1,3 +1,4 @@
+use log::warn;
 use log::{error, info};
 use rouille::router;
 use rouille::Request;
@@ -6,69 +7,135 @@ use std::error::Error;
 
 use crate::elastic_query::ElasticQuery;
 use crate::options;
+use crate::search_result::SearchResult;
 
 pub fn serve_request(req: &Request) -> Response {
     router!(req,
-    (GET) (/search) => { query(req) },
+    (GET) (/redirect) => { redirect(req) },
+    (GET) (/search) => { search(req) },
     _ => Response::empty_404()
         )
 }
 
-fn query(req: &Request) -> Response {
+fn get_query(req: &Request) -> Result<String, Response> {
-    info!("Handling request: {:?}", req);
     let Some(query) = req.get_param("q") else {
-        return Response::empty_400();
+        return Err(Response::text("Query Parameter q must be specified!").with_status_code(400));
     };
     match query.len() {
         0..=options::query::MIN_LENGTH => {
-            return Response::text(format!(
+            return Err(Response::text(format!(
                 "Min query length: {:?}",
                 options::query::MIN_LENGTH
             ))
-            .with_status_code(400);
+            .with_status_code(400));
         }
         options::query::MAX_LENGTH..=usize::MAX => {
-            return Response::text(format!(
+            return Err(Response::text(format!(
                 "Max query length: {:?}",
                 options::query::MAX_LENGTH
             ))
-            .with_status_code(400);
+            .with_status_code(400));
         }
-        _ => (),
+        _ => Ok(query),
     }
-
+}
-    let response = query_elastic_search(query);
+fn search(req: &Request) -> Response {
-    if let Err(e) = response {
+    info!("Searching request: {:?}", req);
-        error!("Error searching: {}", e);
+    let query = match get_query(req) {
-        return Response::empty_404();
+        Ok(v) => v,
-    }
+        Err(e) => {
-    let response = response.unwrap();
+            return e;
-
+        }
-    let Some(name) = response.split('.').next() else {
-        error!("Error getting name from response!");
-        return Response::empty_404();
     };
 
-    info!("Redirecting to: /{}", name);
+    let response = match query_elastic_search(query) {
-    Response::redirect_303(format!("/{}", name))
+        Ok(v) => v,
+        Err(e) => {
+            error!("Error searching: {}", e);
+            return Response::text("Could not find any awesome pages :(").with_status_code(404);
+        }
+    };
+
+    if let Some(_) = req.get_param("pretty") {
+        return Response::html(search_to_html(response)).with_status_code(200);
+    }
+    Response::json(&response).with_status_code(200)
 }
 
-fn query_elastic_search(query: String) -> Result<String, Box<dyn Error>> {
+fn search_to_html(results: Vec<SearchResult>) -> String {
+    let res_html = results
+        .iter()
+        .map(|res| res.to_html())
+        .collect::<Vec<String>>()
+        .join("      \n");
+    let body = format!(
+        "<div>Yay, found the following {} lists!</div><div><ul>{}</ul></div>",
+        results.len(),
+        res_html
+    );
+    HTML_TEMPLATE.replace("{body}", &body)
+}
+
+fn redirect(req: &Request) -> Response {
+    info!("Redirecting request: {:?}", req);
+
+    let query = match get_query(req) {
+        Ok(v) => v,
+        Err(e) => {
+            warn!("Error with request: {:?}", e);
+            return e;
+        }
+    };
+
+    let response = match query_elastic_search(query) {
+        Ok(v) => v,
+        Err(e) => {
+            error!("Error searching: {}", e);
+            return Response::text("Could not find any awesome page to redirect you to :(")
+                .with_status_code(404);
+        }
+    };
+
+    let Some(first) = response.get(0) else {
+        error!("No search results. Should not happen because we checked before!");
+        return Response::text("Could not find any awesome page to redirect you to :()")
+            .with_status_code(404);
+    };
+
+    info!("Redirecting to: /{}", first.name);
+    Response::redirect_303(format!("/{}", first.name))
+}
+
+fn query_elastic_search(query: String) -> Result<Vec<SearchResult>, Box<dyn Error>> {
     let query = ElasticQuery::new(options::elastic_search::FIELDS.clone(), query);
 
-    let res = query.send(options::elastic_search::URL.clone())?;
+    let query_res = query.send(options::elastic_search::URL.clone())?;
 
-    Ok(res.hits.hits[0].source.file.file_name.clone())
+    let search_res = query_res
+        .hits
+        .hits
+        .iter()
+        .map(|hit| SearchResult::from(&hit.source.file))
+        .collect();
+
+    Ok(search_res)
 }
 
 #[cfg(test)]
 mod test {
+    const REDIRECT_URL: &str = "/redirect";
     const SEARCH_URL: &str = "/search";
     use super::*;
     mod serve_request {
         use super::*;
         #[test]
-        fn test_query_route_exists() {
+        fn test_redirect_route_exists() {
+            let req = Request::fake_http("GET", REDIRECT_URL, vec![], vec![]);
+            let res = serve_request(&req);
+            assert_ne!(res.status_code, 404)
+        }
+        #[test]
+        fn test_search_route_exists() {
             let req = Request::fake_http("GET", SEARCH_URL, vec![], vec![]);
             let res = serve_request(&req);
             assert_ne!(res.status_code, 404)
@@ -80,12 +147,24 @@ mod test {
             assert_eq!(res.status_code, 404)
         }
     }
-    mod query {
+    mod get_query {
         use super::*;
         #[test]
+        fn simple() {
+            let q = "simple";
+            let req = Request::fake_http("GET", format!("/{}?q={}", SEARCH_URL, q), vec![], vec![]);
+            let Ok(res) = get_query(&req) else {
+                panic!("No Value")
+            };
+
+            assert_eq!(res, q);
+        }
+        #[test]
         fn no_query_parameter() {
             let req = Request::fake_http("GET", SEARCH_URL, vec![], vec![]);
-            let res = query(&req);
+            let Err(res) = get_query(&req) else {
+                panic!("No Error")
+            };
             assert_eq!(res.status_code, 400)
         }
         #[test]
@@ -94,7 +173,9 @@ mod test {
                 .take(options::query::MAX_LENGTH + 1)
                 .collect();
             let req = Request::fake_http("GET", format!("/{}?q={}", SEARCH_URL, q), vec![], vec![]);
-            let res = query(&req);
+            let Err(res) = get_query(&req) else {
+                panic!("No Error")
+            };
 
             let mut body = String::new();
             let _ = res.data.into_reader_and_size().0.read_to_string(&mut body);
@@ -104,7 +185,9 @@ mod test {
         #[test]
         fn query_too_short() {
             let req = Request::fake_http("GET", format!("/{}?q=", SEARCH_URL), vec![], vec![]);
-            let res = query(&req);
+            let Err(res) = get_query(&req) else {
+                panic!("No Error")
+            };
 
             assert_eq!(res.status_code, 400);
 
@@ -114,3 +197,19 @@ mod test {
         }
     }
 }
+
+static HTML_TEMPLATE: &'static str = r#"
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>AWESM Search Results</title>
+    <link rel="stylesheet" href="/style/search.css">
+  </head>
+  <body>
+    {body}
+  </body>
+</html>
+"#;