#503 - Grid filters - DoesNotContain support added. (#709)

vikramlearning · May 4, 2024 · 15541be · 15541be
1 parent f1c3f22
commit 15541be
Show file tree

Hide file tree

Showing 5 changed files with 30 additions and 15 deletions.
diff --git a/blazorbootstrap/Components/Form/AutoComplete/AutoComplete.razor.cs b/blazorbootstrap/Components/Form/AutoComplete/AutoComplete.razor.cs
@@ -172,6 +172,7 @@ private FilterOperator GetFilterOperator() =>
         {
             StringFilterOperator.Equals => FilterOperator.Equals,
             StringFilterOperator.Contains => FilterOperator.Contains,
+            StringFilterOperator.DoesNotContain => FilterOperator.DoesNotContain,
             StringFilterOperator.StartsWith => FilterOperator.StartsWith,
             StringFilterOperator.EndsWith => FilterOperator.EndsWith,
             _ => FilterOperator.Contains

diff --git a/blazorbootstrap/Enums/StringFilterOperator.cs b/blazorbootstrap/Enums/StringFilterOperator.cs
@@ -12,6 +12,11 @@ public enum StringFilterOperator
     /// </summary>
     Contains,
 
+    /// <summary>
+    /// Satisfied if the current value does not contain the specified value.
+    /// </summary>
+    DoesNotContain,
+
     /// <summary>
     /// Satisfied if the current value starts with the specified value.
     /// </summary>

diff --git a/blazorbootstrap/Extensions/ExpressionExtensions.cs b/blazorbootstrap/Extensions/ExpressionExtensions.cs
@@ -392,6 +392,7 @@ or StringConstants.PropertyTypeNameDecimal
             return filterItem.Operator switch
             {
                 FilterOperator.Contains => GetStringContainsExpressionDelegate<TItem>(parameterExpression, filterItem),
+                FilterOperator.DoesNotContain => GetStringDoesNotContainExpressionDelegate<TItem>(parameterExpression, filterItem),
                 FilterOperator.StartsWith => GetStringStartsWithExpressionDelegate<TItem>(parameterExpression, filterItem),
                 FilterOperator.EndsWith => GetStringEndsWithExpressionDelegate<TItem>(parameterExpression, filterItem),
                 FilterOperator.Equals => GetStringEqualsExpressionDelegate<TItem>(parameterExpression, filterItem),
@@ -675,6 +676,28 @@ public static Expression<Func<TItem, bool>> GetStringContainsExpressionDelegate<
         return Expression.Lambda<Func<TItem, bool>>(finalExpression, parameterExpression);
     }
 
+    public static Expression<Func<TItem, bool>> GetStringDoesNotContainExpressionDelegate<TItem>(ParameterExpression parameterExpression, FilterItem filterItem)
+    {
+        var propertyExp = Expression.Property(parameterExpression, filterItem.PropertyName);
+        var someValue = Expression.Constant(filterItem.Value, typeof(string));
+        var comparisonExpression = Expression.Constant(filterItem.StringComparison);
+
+        // Handle null check
+        var nullCheckExpression = Expression.NotEqual(propertyExp, Expression.Constant(null, typeof(string)));
+
+        // Create method call expression for Contains method
+        var methodInfo = typeof(string).GetMethod(nameof(string.Contains), new[] { typeof(string), typeof(StringComparison) });
+        var containsExpression = Expression.Call(propertyExp, methodInfo!, someValue, comparisonExpression);
+
+        // "not contains" expression
+        var notContainsExpression = Expression.Not(containsExpression);
+
+        // Combine null check and contains expression using AndAlso
+        var finalExpression = Expression.AndAlso(nullCheckExpression, notContainsExpression);
+
+        return Expression.Lambda<Func<TItem, bool>>(finalExpression, parameterExpression);
+    }
+
     public static Expression<Func<TItem, bool>> GetStringEndsWithExpressionDelegate<TItem>(ParameterExpression parameterExpression, FilterItem filterItem)
     {
         var propertyExp = Expression.Property(parameterExpression, filterItem.PropertyName);

diff --git a/blazorbootstrap/Extensions/TypeExtensions.cs b/blazorbootstrap/Extensions/TypeExtensions.cs
@@ -23,20 +23,6 @@ public static string GetPropertyTypeName(this Type type, string propertyName)
             return string.Empty;
 
         var propertyTypeName = propertyType?.ToString();
-
-        //if(propertyTypeName is null) // Nullable type scenario
-        //{
-        //    var props = type.GetProperties();
-        //    if(props.Length > 0)
-        //    {
-        //        var propertyInfo = props?.FirstOrDefault(x=>x.Name == propertyName);
-        //        if (propertyInfo is null)
-        //            throw new InvalidDataException($"PropertyName `{propertyName}` is invalid.");
-
-        //        propertyTypeName = Nullable.GetUnderlyingType(propertyInfo.PropertyType)?.FullName;
-        //    }
-        //}
-
         if (string.IsNullOrWhiteSpace(propertyTypeName))
             return string.Empty;
 

diff --git a/blazorbootstrap/Utilities/FilterOperatorHelper.cs b/blazorbootstrap/Utilities/FilterOperatorHelper.cs
@@ -120,7 +120,7 @@ public static IEnumerable<FilterOperatorInfo> GetStringFilterOperators()
         List<FilterOperatorInfo> result = new()
                                           {
                                               new FilterOperatorInfo("*a*", "Contains", FilterOperator.Contains),
-                                              //result.Add(new("!*a*", "Does not contain", FilterOperator.DoesNotContain));
+                                              new FilterOperatorInfo("!*a*", "Does not contain", FilterOperator.DoesNotContain),
                                               new FilterOperatorInfo("a**", "Starts with", FilterOperator.StartsWith),
                                               new FilterOperatorInfo("**a", "Ends with", FilterOperator.EndsWith),
                                               //result.Add(new("=''", "Is empty", FilterOperator.IsEmpty));