chore: fix error handling

racoonframework · Jun 11, 2024 · 7f25e95 · 7f25e95
1 parent 4a304ca
commit 7f25e95
Showing 1 changed file with 67 additions and 8 deletions.
diff --git a/src/forms/mod.rs b/src/forms/mod.rs
@@ -2,14 +2,19 @@ pub mod fields;
 
 use std::collections::HashMap;
 use std::future::Future;
+use std::vec;
 
+use crate::core::forms::FormFieldError;
 use crate::core::request::Request;
 
 use crate::forms::fields::AbstractFields;
 
 pub type FormFields = Vec<Box<dyn AbstractFields + Sync + Send>>;
 
-pub type ValidationError = HashMap<String, Vec<String>>;
+pub struct ValidationError {
+    pub field_errors: HashMap<String, Vec<String>>,
+    pub others: Vec<String>,
+}
 
 pub trait FormValidator: Sized + Send {
     fn new() -> Self;
@@ -19,14 +24,63 @@ pub trait FormValidator: Sized + Send {
         request: &'a Request,
     ) -> Box<dyn Future<Output = Result<Self, ValidationError>> + Sync + Send + Unpin + 'a>
     where
-        Self: 'a, Self: Sync,
+        Self: 'a,
+        Self: Sync,
     {
         let request = request.clone();
 
         Box::new(Box::pin(async move {
-            let (mut form_data, mut files) = request.parse().await;
+            let mut field_errors: HashMap<String, Vec<String>> = HashMap::new();
+            let mut other_errors = vec![];
+
+            let (mut form_data, mut files) = match request
+                .parse_body(request.form_constraints.clone())
+                .await
+            {
+                Ok((form_data, files)) => (form_data, files),
+                Err(error) => {
+                    match error {
+                        FormFieldError::MaxBodySizeExceed => {
+                            other_errors.push("Max body size exceed.");
+                        }
 
-            let mut errors = HashMap::new();
+                        FormFieldError::MaxHeaderSizeExceed => {
+                            other_errors.push("Max header size exceed.");
+                        }
+
+                        FormFieldError::MaxFileSizeExceed(field_name) => {
+                            let file_size_exceed_error = vec!["Max file size exceed.".to_string()];
+                            if let Some(errors) = field_errors.get_mut(&field_name) {
+                                errors.extend_from_slice(&file_size_exceed_error);
+                            } else {
+                                field_errors.insert(field_name, file_size_exceed_error);
+                            }
+                        }
+
+                        FormFieldError::MaxValueSizeExceed(field_name) => {
+                            let value_length_exceed_error = vec!["Max value length exceed.".to_string()];
+                            if let Some(errors) = field_errors.get_mut(&field_name) {
+                                errors.extend_from_slice(&value_length_exceed_error);
+                            } else {
+                                field_errors.insert(field_name, value_length_exceed_error);
+                            }
+                        }
+
+                        FormFieldError::Others(field_name, error)=> {
+                            if let Some(field_name) = field_name {
+                                field_errors.insert(field_name, vec![error]);
+                            } else {
+                                other_errors.push(&error);
+                            }
+                        }
+                    }
+                    let validation_error = ValidationError {
+                        field_errors: HashMap::new(),
+                        others: vec![],
+                    };
+                    return Err(validation_error);
+                }
+            };
 
             for mut field in self.form_fields() {
                 let field_name = field.field_name().await;
@@ -43,13 +97,17 @@ pub trait FormValidator: Sized + Send {
                 match result {
                     Ok(()) => {}
                     Err(error) => {
-                        errors.insert(field_name, error);
+                        field_errors.insert(field_name, error);
                     }
                 }
             }
 
-            if errors.len() > 0 {
-                return Err(errors);
+            if field_errors.len() > 0 {
+                let validation_error = ValidationError {
+                    field_errors,
+                    others: vec![],
+                };
+                return Err(validation_error);
             }
 
             Ok(self)
@@ -61,7 +119,8 @@ pub trait FormValidator: Sized + Send {
         _: &Request,
         _: &String,
         _: &Box<dyn AbstractFields + Sync + Send>,
-    ) -> Box<dyn Future<Output = Option<Result<(), Vec<String>>>> + Sync + Send + Unpin + 'static> {
+    ) -> Box<dyn Future<Output = Option<Result<(), Vec<String>>>> + Sync + Send + Unpin + 'static>
+    {
         Box::new(Box::pin(async move { None }))
     }
 }