working on post

core/http/src/handling/request.rs

@@ -30,13 +30,13 @@ pub enum MediaType {
     Html,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ParseErrors {
     NoData,
     BadData,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ParseFormError {
     pub error: ParseErrors,
 }
@@ -111,18 +111,18 @@ impl Request<'_> {
         Ok(response)
     }
 
-    pub fn get_post_data(
-        &self,
-        keys: &[&str],
+    pub fn get_post_data<'a>(
+        &'a self,
+        keys: &[&'a str],
         data: &Data,
     ) -> Result<HashMap<&str, Result<Vec<u8>, ParseFormError>>, ParseFormError> {
-        let mut post_type = if let Some(val) = self
+        let post_type = if let Some(val) = self
             .headers
             .iter()
             .find(|header| header.contains("Content-Type: "))
         {
-            if let Ok(Type) = val.strip_prefix("Content-Type: ").unwrap().trim().parse() {
-                Type
+            if let Ok(mime_type) = val.strip_prefix("Content-Type: ").unwrap().trim().parse() {
+                mime_type
             } else {
                 return Err(ParseFormError {
                     error: ParseErrors::NoData,
@@ -135,17 +135,52 @@ impl Request<'_> {
         };
 
         let data = data.buffer.as_slice();
-        let mut keymap: HashMap<&str, Option<&[u8]>> = HashMap::with_capacity(keys.len());
-        for i in keys {
-            keymap.entry(i).or_default();
+        let mut keymap: HashMap<&str, Result<Vec<u8>, ParseFormError>> =
+            HashMap::with_capacity(keys.len());
+        for key in keys {
+            keymap.entry(key).or_insert(Err(ParseFormError {
+                error: ParseErrors::NoData,
+            }));
         }
         match post_type {
-            Mime::ApplicationXWwwFormUrlencoded => Ok(()),
-            _ => Err(ParseFormError {
-                error: ParseErrors::BadData,
-            }),
+            Mime::ApplicationXWwwFormUrlencoded => {
+                for kvp in data.split(|byte| *byte == b'&') {
+                    let kvp = kvp.split(|byte| *byte == b'=').collect::<Vec<&[u8]>>();
+                    let key = if let Some(kv) = kvp.get(0) {
+                        kv
+                    } else {
+                        return Err(ParseFormError {
+                            error: ParseErrors::BadData,
+                        });
+                    };
+                    let key = if let Ok(kv) = String::from_utf8(key.to_vec()) {
+                        kv
+                    } else {
+                        return Err(ParseFormError {
+                            error: ParseErrors::BadData,
+                        });
+                    };
+                    let value = kvp.get(1).ok_or(ParseFormError {
+                        error: ParseErrors::NoData,
+                    });
+                    let thing = if let Some(val) = keymap.get_mut(key.as_str()) {
+                        val
+                    } else {
+                        continue;
+                    };
+                    *thing = match value {
+                        Ok(val) => Ok(val.to_vec()),
+                        Err(err) => Err(err),
+                    }
+                }
+            }
+            _ => {
+                return Err(ParseFormError {
+                    error: ParseErrors::BadData,
+                })
+            }
         };
-        todo!()
+        Ok(keymap)
     }
 
     // pub fn get_post_text_form_key(
@@ -288,38 +323,23 @@ mod test {
 
     use super::Request;
 
-    //     #[test]
-    //     fn try_post_text() {
-    //         let req = Request {
-    //             uri: "",
-    //             headers: vec!["Content-Type: multipart/form-data;boundary=\"boundary\"".to_string()],
-    //             method: crate::handling::methods::Method::Post,
-    //         };
-    //         let data = Data {
-    //             buffer: b"--boundary\r
-    // Content-Disposition: form-data; name=\"field1\"\r
-    // \r
-    // value1\r
-    // --boundary\r
-    // Content-Disposition: form-data; name=\"field2\"; filename=\"example.txt\"\n\r
-    // \r
-    // value2\r
-    // --boundary--"
-    //                 .to_vec(),
-    //             is_complete: true,
-    //         };
-    //         assert_eq!(
-    //             "value1",
-    //             req.get_post_text_form_key(&["field1"], &data).unwrap()[0]
-    //         );
-    //         assert_eq!(
-    //             "value2",
-    //             req.get_post_text_form_key(&["field2"], &data).unwrap()[0]
-    //         );
-    //         assert_eq!(
-    //             vec!["value1", "value2"],
-    //             req.get_post_text_form_key(&["field1", "field2"], &data)
-    //                 .unwrap()
-    //         )
-    //     }
+    #[test]
+    fn try_post_text() {
+        let req = Request {
+            uri: "",
+            headers: vec!["Content-Type: application/x-www-form-urlencoded".to_string()],
+            method: crate::handling::methods::Method::Post,
+        };
+        let data = Data {
+            buffer: b"message=23&message1=24".to_vec(),
+            is_complete: true,
+        };
+        assert_eq!(
+            vec![&Ok(b"23".to_vec()), &Ok(b"24".to_vec())],
+            req.get_post_data(&["message", "message1"], &data)
+                .unwrap()
+                .values()
+                .collect::<Vec<_>>()
+        );
+    }
 }

core/http/src/setup.rs

@@ -96,7 +96,7 @@ pub async fn build(ip: &str) -> Config {
     let ip = ip[0];
     let workers = available_parallelism().unwrap().get();
     println!(
-        "\x1b[34m⚙ Configuration\x1b[0m
+"\x1b[34m⚙ Configuration\x1b[0m
   >> \x1b[34mIp\x1b[0m: {ip}
   >> \x1b[34mPort\x1b[0m: {port}
   >> \x1b[34mWorkers\x1b[0m: {workers}