Fixed enum filtering

Author: mcintyre321

Mvc.JQuery.Datatables/DataTablesFilter.cs

@@ -59,23 +59,25 @@ public IQueryable FilterPagingSortingSearch(DataTablesParam dtParameters, IQuery
             return data;
         }
 
-        public delegate string ReturnedFilteredQueryForType(string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
+        public delegate string ReturnedFilteredQueryForType(
+            string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
 
 
-
-        static readonly List<ReturnedFilteredQueryForType> Filters = new List<ReturnedFilteredQueryForType>()
+        private static readonly List<ReturnedFilteredQueryForType> Filters = new List<ReturnedFilteredQueryForType>()
         {
             Guard(IsBoolType, TypeFilters.BoolFilter),
             Guard(IsDateTimeType, TypeFilters.DateTimeFilter),
             Guard(IsDateTimeOffsetType, TypeFilters.DateTimeOffsetFilter),
             Guard(IsNumericType, TypeFilters.NumericFilter),
+            Guard(IsEnumType, TypeFilters.EnumFilter),
             Guard(arg => arg == typeof (string), TypeFilters.StringFilter),
         };
 
 
-        public delegate string GuardedFilter(string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
+        public delegate string GuardedFilter(
+            string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
 
-        static ReturnedFilteredQueryForType Guard(Func<Type, bool> guard, GuardedFilter filter)
+        private static ReturnedFilteredQueryForType Guard(Func<Type, bool> guard, GuardedFilter filter)
         {
             return (q, c, t, p) =>
             {
@@ -94,19 +96,20 @@ public static void RegisterFilter<T>(GuardedFilter filter)
 
         private static string GetFilterClause(string query, ColInfo column, List<object> parametersForLinqQuery)
         {
-            foreach (var filter in Filters)
+            Func<string, string> filterClause = (queryPart) =>
+                                                Filters.Select(
+                                                    f => f(queryPart, column.Name, column.Type, parametersForLinqQuery))
+                                                       .First(filterPart => filterPart != null);
+
+            var queryParts = query.Split('|').Select(filterClause).Where(fc => fc != "").ToArray();
+            if (queryParts.Any())
             {
-                var filteredQuery = filter(query, column.Name, column.Type, parametersForLinqQuery);
-                if (filteredQuery != null)
-                {
-                    return filteredQuery;
-                }
+                return "(" + string.Join(") OR (", queryParts) + ")";
             }
-            var parts = query.Split('~').SelectMany(s => s.Split('|'))
-                .Select(q => string.Format("({1} == null ? \"\" : {1}.ToString()).{0}", TypeFilters.FilterMethod(q, parametersForLinqQuery, column.Type), column.Name));
-            return "(" + string.Join(") OR (", parts) + ")";
+            return null;
         }
 
+
         public static bool IsNumericType(Type type)
         {
             if (type == null || type.IsEnum)
@@ -138,6 +141,11 @@ public static bool IsNumericType(Type type)
             return false;
 
         }
+        public static bool IsEnumType(Type type)
+        {
+            return type.IsEnum;
+        }
+
         public static bool IsBoolType(Type type)
         {
             return type == typeof(bool) || type == typeof(bool?);
@@ -148,7 +156,7 @@ public static bool IsDateTimeType(Type type)
         }
         public static bool IsDateTimeOffsetType(Type type)
         {
-            return  type == typeof(DateTimeOffset) ||   type == typeof(DateTimeOffset?);
+            return type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?);
         }
 
     }

Mvc.JQuery.Datatables/TypeFilters.cs

@@ -6,19 +6,24 @@ namespace Mvc.JQuery.Datatables
 {
     static class TypeFilters
     {
+        private static readonly Func<string, Type, object> ParseValue = 
+            (input, t) => t.IsEnum ? Enum.Parse(t, input) : Convert.ChangeType(input, t);
+        
         internal static string FilterMethod(string q, List<object> parametersForLinqQuery, Type type)
         {
-            Func<string, string, string> makeClause = ( method, query) =>
+
+
+            Func<string, string, string> makeClause = (method, query) =>
             {
-                parametersForLinqQuery.Add(Convert.ChangeType(query, type));
+                parametersForLinqQuery.Add(ParseValue(query, type));
                 var indexOfParameter = parametersForLinqQuery.Count - 1;
                 return string.Format("{0}(@{1})", method, indexOfParameter);
             };
             if (q.StartsWith("^"))
             {
                 if (q.EndsWith("$"))
                 {
-                    parametersForLinqQuery.Add(Convert.ChangeType(q.Substring(1, q.Length -2), type));
+                    parametersForLinqQuery.Add(ParseValue(q.Substring(1, q.Length - 2), type));
                     var indexOfParameter = parametersForLinqQuery.Count - 1;
                     return string.Format("Equals((object)@{0})", indexOfParameter);
                 }
@@ -158,5 +163,14 @@ public static string StringFilter(string q, string columnname, Type columntype,
                         columnname, parameterArg);
             }
         }
+
+        public static string EnumFilter(string q, string columnname, Type type, List<object> parametersForLinqQuery)
+        {
+            
+            if (q.StartsWith("^")) q = q.Substring(1);
+            if (q.EndsWith("$")) q = q.Substring(0, q.Length - 1);
+            parametersForLinqQuery.Add(ParseValue(q, type));
+            return columnname + " == @" + (parametersForLinqQuery.Count - 1);
+        }
     }
 }