Update `get_post_form_text` to allow for an array of keys to search

core/http/src/handling/request.rs

@@ -72,9 +72,9 @@ impl Request<'_> {
         }
     }
     // pub fn get_post_form_key<T: FromRequest>(&self, data: Data) -> T {}
-    pub fn get_get_form_keys(
-        &self,
-        keys: Vec<&str>,
+    pub fn get_get_form_keys<'a>(
+        &'a self,
+        keys: &'a [&str],
     ) -> Result<HashMap<&str, &str>, ParseFormError> {
         let data = if let Some(val) = self.uri.split_once("?") {
             val
@@ -111,7 +111,11 @@ impl Request<'_> {
         }
         Ok(response)
     }
-    pub fn get_post_text_form_key(&self, key: &str, data: &Data) -> Result<String, ()> {
+    pub fn get_post_text_form_key(
+        &self,
+        keys: &[&str],
+        data: &Data,
+    ) -> Result<Vec<String>, ParseFormError> {
         let mut post_type = self
             .headers
             .iter()
@@ -134,11 +138,18 @@ impl Request<'_> {
                     .split("&")
                     .map(|kvp| kvp.split_once("=").unwrap())
                     .collect::<HashMap<&str, &str>>();
-                if let Some(val) = kvps.get(key) {
-                    Ok(val.to_string())
-                } else {
-                    Err(())
+
+                let mut result: Vec<String> = Vec::with_capacity(keys.len());
+                for key in keys {
+                    if let Some(val) = kvps.get(key) {
+                        result.push(val.to_string());
+                    } else {
+                        return Err(ParseFormError {
+                            error: ParseErrors::NoData,
+                        });
+                    }
                 }
+                Ok(result)
             }
             Mime::MultipartFormData => {
                 let from_req = post_type[1..]
@@ -158,16 +169,17 @@ impl Request<'_> {
                     .collect::<Vec<&[u8]>>();
 
                 let mut boundary_found = false;
-                let mut key_found = false;
-                let mut value = vec![];
+                let mut current_key: Option<usize> = None;
+                let mut result: Vec<Vec<u8>> = vec!["".into(); keys.len()];
                 for part in parts {
                     if part == [] {
                         continue;
                     }
-                    if (key_found && part == boundary) || part == end_boundary {
+                    if part == end_boundary {
                         break;
                     }
                     if !boundary_found && part == boundary {
+                        current_key = None;
                         boundary_found = true;
                         continue;
                     }
@@ -188,18 +200,27 @@ impl Request<'_> {
                             .trim_end()
                             .trim_matches('"')
                             .to_owned();
-                        key_found = key == mkey;
-                    } else if key_found == true {
-                        value.extend_from_slice(part);
-                        value.extend_from_slice(&[b'\n']);
+                        let mut index = 0;
+                        for i in keys {
+                            if *i == mkey {
+                                current_key = Some(index);
+                            }
+                            index += 1;
+                        }
+                        boundary_found = false;
+                    } else if let Some(key) = current_key {
+                        result[key].extend_from_slice(part);
+                        result[key].extend_from_slice(&[b'\n']);
                     }
                 }
-                Ok(String::from_utf8_lossy(&value)
-                    .to_owned()
-                    .trim()
-                    .to_string())
+                Ok(result
+                    .iter()
+                    .map(|arr| String::from_utf8(arr.to_vec()).unwrap().trim().into())
+                    .collect())
             }
-            _ => Err(()),
+            _ => Err(ParseFormError {
+                error: ParseErrors::BadData,
+            }),
         }
     }
 }
@@ -232,11 +253,16 @@ value2\r
         };
         assert_eq!(
             "value1",
-            req.get_post_text_form_key("field1", &data).unwrap()
+            req.get_post_text_form_key(&["field1"], &data).unwrap()[0]
         );
         assert_eq!(
             "value2",
-            req.get_post_text_form_key("field2", &data).unwrap()
+            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()
+        )
     }
 }