chore: add null checks (#1355)

A previous PR modified the conditions config to make the value 
field nullable. But the frontend is sometimes sending an empty 
string in case of null. This PR performs both the checks and rejects 
the request in case the operator is is null or is not null and the value 
is something other than null or an empty string.


Co-authored-by: Nikhil Sinha <[email protected]>

Author: parmesant

src/alerts/alerts_utils.rs

@@ -347,15 +347,21 @@ pub fn get_filter_string(where_clause: &Conditions) -> Result<String, String> {
             LogicalOperator::And => {
                 let mut exprs = vec![];
                 for condition in &where_clause.condition_config {
-                    if let Some(value) = &condition.value {
+                    if condition
+                        .value
+                        .as_ref()
+                        .is_some_and(|v| !v.trim().is_empty())
+                    {
                         // ad-hoc error check in case value is some and operator is either `is null` or `is not null`
                         if condition.operator.eq(&WhereConfigOperator::IsNull)
                             || condition.operator.eq(&WhereConfigOperator::IsNotNull)
                         {
                             return Err("value must be null when operator is either `is null` or `is not null`"
                                 .into());
                         }
-                        let value = NumberOrString::from_string(value.to_owned());
+                        let value = NumberOrString::from_string(
+                            condition.value.as_ref().unwrap().to_owned(),
+                        );
                         match value {
                             NumberOrString::Number(val) => exprs.push(format!(
                                 "\"{}\" {} {}",
@@ -387,7 +393,8 @@ fn match_alert_operator(expr: &ConditionConfig) -> Expr {
     // the form accepts value as a string
     // if it can be parsed as a number, then parse it
     // else keep it as a string
-    if let Some(value) = &expr.value {
+    if expr.value.as_ref().is_some_and(|v| !v.trim().is_empty()) {
+        let value = expr.value.as_ref().unwrap();
         let value = NumberOrString::from_string(value.clone());
 
         // for maintaining column case

src/alerts/mod.rs

@@ -343,14 +343,24 @@ impl Conditions {
                 LogicalOperator::And | LogicalOperator::Or => {
                     let expr1 = &self.condition_config[0];
                     let expr2 = &self.condition_config[1];
-                    let expr1_msg = if let Some(val) = &expr1.value {
-                        format!("{} {} {}", expr1.column, expr1.operator, val)
+                    let expr1_msg = if expr1.value.as_ref().is_some_and(|v| !v.trim().is_empty()) {
+                        format!(
+                            "{} {} {}",
+                            expr1.column,
+                            expr1.operator,
+                            expr1.value.as_ref().unwrap()
+                        )
                     } else {
                         format!("{} {}", expr1.column, expr1.operator)
                     };
 
-                    let expr2_msg = if let Some(val) = &expr2.value {
-                        format!("{} {} {}", expr2.column, expr2.operator, val)
+                    let expr2_msg = if expr2.value.as_ref().is_some_and(|v| !v.trim().is_empty()) {
+                        format!(
+                            "{} {} {}",
+                            expr2.column,
+                            expr2.operator,
+                            expr2.value.as_ref().unwrap()
+                        )
                     } else {
                         format!("{} {}", expr2.column, expr2.operator)
                     };
@@ -661,7 +671,12 @@ impl AlertConfig {
                     WhereConfigOperator::IsNull | WhereConfigOperator::IsNotNull
                 );
 
-                if needs_no_value && condition.value.is_some() {
+                if needs_no_value
+                    && condition
+                        .value
+                        .as_ref()
+                        .is_some_and(|v| !v.trim().is_empty())
+                {
                     return Err(AlertError::CustomError(
                         "value must be null when operator is either `is null` or `is not null`"
                             .into(),