End date is now inclusive (i.e. return results < endDate.Date.AddDays(1))

mcintyre321 · mcintyre321 · commit 8b98c7db65af · 2014-05-20T16:43:01.000+01:00
diff --git a/Mvc.JQuery.Datatables/DataTablesFilter.cs b/Mvc.JQuery.Datatables/DataTablesFilter.cs
@@ -68,7 +68,7 @@ public IQueryable<T> FilterPagingSortingSearch<T>(DataTablesParam dtParameters,
         }
 
         public delegate string ReturnedFilteredQueryForType(
-            string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
+            string query, string columnName, ColInfo columnType, List<object> parametersForLinqQuery);
 
 
         private static readonly List<ReturnedFilteredQueryForType> Filters = new List<ReturnedFilteredQueryForType>()
@@ -78,14 +78,14 @@ public delegate string ReturnedFilteredQueryForType(
             Guard(IsDateTimeOffsetType, TypeFilters.DateTimeOffsetFilter),
             Guard(IsNumericType, TypeFilters.NumericFilter),
             Guard(IsEnumType, TypeFilters.EnumFilter),
-            Guard(arg => arg == typeof (string), TypeFilters.StringFilter),
+            Guard(arg => arg.Type == typeof (string), TypeFilters.StringFilter),
         };
 
 
         public delegate string GuardedFilter(
-            string query, string columnName, Type columnType, List<object> parametersForLinqQuery);
+            string query, string columnName, ColInfo columnType, List<object> parametersForLinqQuery);
 
-        private static ReturnedFilteredQueryForType Guard(Func<Type, bool> guard, GuardedFilter filter)
+        private static ReturnedFilteredQueryForType Guard(Func<ColInfo, bool> guard, GuardedFilter filter)
         {
             return (q, c, t, p) =>
             {
@@ -106,7 +106,7 @@ private static string GetFilterClause(string query, ColInfo column, List<object>
         {
             Func<string, string> filterClause = (queryPart) =>
                                                 Filters.Select(
-                                                    f => f(queryPart, column.Name, column.Type, parametersForLinqQuery))
+                                                    f => f(queryPart, column.Name, column, parametersForLinqQuery))
                                                        .FirstOrDefault(filterPart => filterPart != null) ?? "";
 
             var queryParts = query.Split('|').Select(filterClause).Where(fc => fc != "").ToArray();
@@ -118,7 +118,13 @@ private static string GetFilterClause(string query, ColInfo column, List<object>
         }
 
 
-        public static bool IsNumericType(Type type)
+        public static bool IsNumericType(ColInfo colInfo)
+        {
+            var type = colInfo.Type;
+            return IsNumericType(type);
+        }
+
+        private static bool IsNumericType(Type type)
         {
             if (type == null || type.IsEnum)
             {
@@ -140,31 +146,31 @@ public static bool IsNumericType(Type type)
                 case TypeCode.UInt64:
                     return true;
                 case TypeCode.Object:
-                    if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
+                    if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>))
                     {
                         return IsNumericType(Nullable.GetUnderlyingType(type));
                     }
                     return false;
             }
             return false;
-
         }
-        public static bool IsEnumType(Type type)
+
+        public static bool IsEnumType(ColInfo colInfo)
         {
-            return type.IsEnum;
+            return colInfo.Type.IsEnum;
         }
 
-        public static bool IsBoolType(Type type)
+        public static bool IsBoolType(ColInfo colInfo)
         {
-            return type == typeof(bool) || type == typeof(bool?);
+            return colInfo.Type == typeof(bool) || colInfo.Type == typeof(bool?);
         }
-        public static bool IsDateTimeType(Type type)
+        public static bool IsDateTimeType(ColInfo colInfo)
         {
-            return type == typeof(DateTime) || type == typeof(DateTime?);
+            return colInfo.Type == typeof(DateTime) || colInfo.Type == typeof(DateTime?);
         }
-        public static bool IsDateTimeOffsetType(Type type)
+        public static bool IsDateTimeOffsetType(ColInfo colInfo)
         {
-            return type == typeof(DateTimeOffset) || type == typeof(DateTimeOffset?);
+            return colInfo.Type == typeof(DateTimeOffset) || colInfo.Type == typeof(DateTimeOffset?);
         }
 
     }
diff --git a/Mvc.JQuery.Datatables/TypeFilters.cs b/Mvc.JQuery.Datatables/TypeFilters.cs
@@ -38,7 +38,7 @@ internal static string FilterMethod(string q, List<object> parametersForLinqQuer
                 return makeClause("Contains", q);
             }
         }
-        public static string NumericFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)
+        public static string NumericFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)
         {
             if (query.StartsWith("^")) query = query.TrimStart('^');
             if (query.EndsWith("$")) query = query.TrimEnd('$');
@@ -51,7 +51,7 @@ public static string NumericFilter(string query, string columnname, Type columnT
                 var clause = null as string;
                 try
                 {
-                    parametersForLinqQuery.Add(Convert.ChangeType(parts[0], columnType));
+                    parametersForLinqQuery.Add(Convert.ChangeType(parts[0], colInfo.Type));
                     clause = string.Format("{0} >= @{1}", columnname, parametersForLinqQuery.Count - 1);
                 }
                 catch (FormatException)
@@ -60,7 +60,7 @@ public static string NumericFilter(string query, string columnname, Type columnT
 
                 try
                 {
-                    parametersForLinqQuery.Add(Convert.ChangeType(parts[1], columnType));
+                    parametersForLinqQuery.Add(Convert.ChangeType(parts[1], colInfo.Type));
                     if (clause != null) clause += " and ";
                     clause += string.Format("{0} <= @{1}", columnname, parametersForLinqQuery.Count - 1);
                 }
@@ -74,7 +74,7 @@ public static string NumericFilter(string query, string columnname, Type columnT
             {
                 try
                 {
-                    parametersForLinqQuery.Add(Convert.ChangeType(query, columnType));
+                    parametersForLinqQuery.Add(Convert.ChangeType(query, colInfo.Type));
                     return string.Format("{0} == @{1}", columnname, parametersForLinqQuery.Count - 1);
                 }
                 catch (FormatException)
@@ -84,7 +84,7 @@ public static string NumericFilter(string query, string columnname, Type columnT
             }
         }
 
-        public static string DateTimeOffsetFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)
+        public static string DateTimeOffsetFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)
         {
             if (query == "~") return string.Empty;
 
@@ -93,37 +93,51 @@ public static string DateTimeOffsetFilter(string query, string columnname, Type
                 var parts = query.Split('~');
                 DateTimeOffset start, end;
                 DateTimeOffset.TryParse(parts[0] ?? "", out start);
-                if (!DateTimeOffset.TryParse(parts[1] ?? "", out end)) end = DateTimeOffset.MaxValue;
+                if (!DateTimeOffset.TryParse(parts[1] ?? "", out end))
+                {
+                    end = DateTimeOffset.MaxValue;
+                }
+                else
+                {
+                    end = end.Date.AddDays(1);
+                }
 
                 parametersForLinqQuery.Add(start);
-                parametersForLinqQuery.Add(end);
-                return string.Format("{0} >= @{1} and {0} <= @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);
+                parametersForLinqQuery.Add(end.AddDays(1).AddSeconds(-1));
+                return string.Format("{0} >= @{1} and {0} < @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);
             }
             else
             {
-                return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, columnType), columnname);
+                return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, colInfo.Type), columnname);
             }
         }
-        public static string DateTimeFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)
+        public static string DateTimeFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)
         {
             if (query == "~") return string.Empty;
             if (query.Contains("~"))
             {
                 var parts = query.Split('~');
                 DateTime start, end;
                 DateTime.TryParse(parts[0] ?? "", out start);
-                if (!DateTime.TryParse(parts[1] ?? "", out end)) end = DateTime.MaxValue;
+                if (!DateTime.TryParse(parts[1] ?? "", out end))
+                {
+                    end = DateTime.MaxValue;
+                }
+                else
+                {
+                    end = end.Date.AddDays(1);
+                }
 
                 parametersForLinqQuery.Add(start);
                 parametersForLinqQuery.Add(end);
-                return string.Format("{0} >= @{1} and {0} <= @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);
+                return string.Format("{0} >= @{1} and {0} < @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);
             }
             else
             {
-                return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, columnType), columnname);
+                return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, colInfo.Type), columnname);
             }
         }
-        public static string BoolFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)
+        public static string BoolFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)
         {
             if (query != null)
                 query = query.TrimStart('^').TrimEnd('$');
@@ -133,15 +147,15 @@ public static string BoolFilter(string query, string columnname, Type columnType
                 if (query.ToLower() == "true") return columnname + " == true";
                 return columnname + " == false";
             }
-            if (columnType == typeof (bool?))
+            if (colInfo.Type == typeof(bool?))
             {
                 if (lowerCaseQuery == "null") return columnname + " == null";
             }
             return null;
 
         }
 
-        public static string StringFilter(string q, string columnname, Type columntype, List<object> parametersforlinqquery)
+        public static string StringFilter(string q, string columnname, ColInfo columntype, List<object> parametersforlinqquery)
         {
             if (q == ".*") return "";
             if (q.StartsWith("^"))
@@ -172,12 +186,12 @@ public static string StringFilter(string q, string columnname, Type columntype,
             }
         }
 
-        public static string EnumFilter(string q, string columnname, Type type, List<object> parametersForLinqQuery)
+        public static string EnumFilter(string q, string columnname, ColInfo colInfo, 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));
+            parametersForLinqQuery.Add(ParseValue(q, colInfo.Type));
             return columnname + " == @" + (parametersForLinqQuery.Count - 1);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public IQueryable<T> FilterPagingSortingSearch<T>(DataTablesParam dtParameters,`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`public delegate string ReturnedFilteredQueryForType(`
`71`		`- string query, string columnName, Type columnType, List<object> parametersForLinqQuery);`
	`71`	`+ string query, string columnName, ColInfo columnType, List<object> parametersForLinqQuery);`
`72`	`72`
`73`	`73`
`74`	`74`	`private static readonly List<ReturnedFilteredQueryForType> Filters = new List<ReturnedFilteredQueryForType>()`
`@@ -78,14 +78,14 @@ public delegate string ReturnedFilteredQueryForType(`
`78`	`78`	`Guard(IsDateTimeOffsetType, TypeFilters.DateTimeOffsetFilter),`
`79`	`79`	`Guard(IsNumericType, TypeFilters.NumericFilter),`
`80`	`80`	`Guard(IsEnumType, TypeFilters.EnumFilter),`
`81`		`- Guard(arg => arg == typeof (string), TypeFilters.StringFilter),`
	`81`	`+ Guard(arg => arg.Type == typeof (string), TypeFilters.StringFilter),`
`82`	`82`	`};`
`83`	`83`
`84`	`84`
`85`	`85`	`public delegate string GuardedFilter(`
`86`		`- string query, string columnName, Type columnType, List<object> parametersForLinqQuery);`
	`86`	`+ string query, string columnName, ColInfo columnType, List<object> parametersForLinqQuery);`
`87`	`87`
`88`		`- private static ReturnedFilteredQueryForType Guard(Func<Type, bool> guard, GuardedFilter filter)`
	`88`	`+ private static ReturnedFilteredQueryForType Guard(Func<ColInfo, bool> guard, GuardedFilter filter)`
`89`	`89`	`{`
`90`	`90`	`return (q, c, t, p) =>`
`91`	`91`	`{`
`@@ -106,7 +106,7 @@ private static string GetFilterClause(string query, ColInfo column, List<object>`
`106`	`106`	`{`
`107`	`107`	`Func<string, string> filterClause = (queryPart) =>`
`108`	`108`	`Filters.Select(`
`109`		`- f => f(queryPart, column.Name, column.Type, parametersForLinqQuery))`
	`109`	`+ f => f(queryPart, column.Name, column, parametersForLinqQuery))`
`110`	`110`	`.FirstOrDefault(filterPart => filterPart != null) ?? "";`
`111`	`111`
`112`	`112`	`var queryParts = query.Split('\|').Select(filterClause).Where(fc => fc != "").ToArray();`
`@@ -118,7 +118,13 @@ private static string GetFilterClause(string query, ColInfo column, List<object>`
`118`	`118`	`}`
`119`	`119`
`120`	`120`
`121`		`- public static bool IsNumericType(Type type)`
	`121`	`+ public static bool IsNumericType(ColInfo colInfo)`
	`122`	`+ {`
	`123`	`+ var type = colInfo.Type;`
	`124`	`+ return IsNumericType(type);`
	`125`	`+ }`
	`126`	`+`
	`127`	`+ private static bool IsNumericType(Type type)`
`122`	`128`	`{`
`123`	`129`	`if (type == null \|\| type.IsEnum)`
`124`	`130`	`{`
`@@ -140,31 +146,31 @@ public static bool IsNumericType(Type type)`
`140`	`146`	`case TypeCode.UInt64:`
`141`	`147`	`return true;`
`142`	`148`	`case TypeCode.Object:`
`143`		`- if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))`
	`149`	`+ if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Nullable<>))`
`144`	`150`	`{`
`145`	`151`	`return IsNumericType(Nullable.GetUnderlyingType(type));`
`146`	`152`	`}`
`147`	`153`	`return false;`
`148`	`154`	`}`
`149`	`155`	`return false;`
`150`		`-`
`151`	`156`	`}`
`152`		`- public static bool IsEnumType(Type type)`
	`157`	`+`
	`158`	`+ public static bool IsEnumType(ColInfo colInfo)`
`153`	`159`	`{`
`154`		`- return type.IsEnum;`
	`160`	`+ return colInfo.Type.IsEnum;`
`155`	`161`	`}`
`156`	`162`
`157`		`- public static bool IsBoolType(Type type)`
	`163`	`+ public static bool IsBoolType(ColInfo colInfo)`
`158`	`164`	`{`
`159`		`- return type == typeof(bool) \|\| type == typeof(bool?);`
	`165`	`+ return colInfo.Type == typeof(bool) \|\| colInfo.Type == typeof(bool?);`
`160`	`166`	`}`
`161`		`- public static bool IsDateTimeType(Type type)`
	`167`	`+ public static bool IsDateTimeType(ColInfo colInfo)`
`162`	`168`	`{`
`163`		`- return type == typeof(DateTime) \|\| type == typeof(DateTime?);`
	`169`	`+ return colInfo.Type == typeof(DateTime) \|\| colInfo.Type == typeof(DateTime?);`
`164`	`170`	`}`
`165`		`- public static bool IsDateTimeOffsetType(Type type)`
	`171`	`+ public static bool IsDateTimeOffsetType(ColInfo colInfo)`
`166`	`172`	`{`
`167`		`- return type == typeof(DateTimeOffset) \|\| type == typeof(DateTimeOffset?);`
	`173`	`+ return colInfo.Type == typeof(DateTimeOffset) \|\| colInfo.Type == typeof(DateTimeOffset?);`
`168`	`174`	`}`
`169`	`175`
`170`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ internal static string FilterMethod(string q, List<object> parametersForLinqQuer`
`38`	`38`	`return makeClause("Contains", q);`
`39`	`39`	`}`
`40`	`40`	`}`
`41`		`- public static string NumericFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)`
	`41`	`+ public static string NumericFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)`
`42`	`42`	`{`
`43`	`43`	`if (query.StartsWith("^")) query = query.TrimStart('^');`
`44`	`44`	`if (query.EndsWith("$")) query = query.TrimEnd('$');`
`@@ -51,7 +51,7 @@ public static string NumericFilter(string query, string columnname, Type columnT`
`51`	`51`	`var clause = null as string;`
`52`	`52`	`try`
`53`	`53`	`{`
`54`		`- parametersForLinqQuery.Add(Convert.ChangeType(parts[0], columnType));`
	`54`	`+ parametersForLinqQuery.Add(Convert.ChangeType(parts[0], colInfo.Type));`
`55`	`55`	`clause = string.Format("{0} >= @{1}", columnname, parametersForLinqQuery.Count - 1);`
`56`	`56`	`}`
`57`	`57`	`catch (FormatException)`
`@@ -60,7 +60,7 @@ public static string NumericFilter(string query, string columnname, Type columnT`
`60`	`60`
`61`	`61`	`try`
`62`	`62`	`{`
`63`		`- parametersForLinqQuery.Add(Convert.ChangeType(parts[1], columnType));`
	`63`	`+ parametersForLinqQuery.Add(Convert.ChangeType(parts[1], colInfo.Type));`
`64`	`64`	`if (clause != null) clause += " and ";`
`65`	`65`	`clause += string.Format("{0} <= @{1}", columnname, parametersForLinqQuery.Count - 1);`
`66`	`66`	`}`
`@@ -74,7 +74,7 @@ public static string NumericFilter(string query, string columnname, Type columnT`
`74`	`74`	`{`
`75`	`75`	`try`
`76`	`76`	`{`
`77`		`- parametersForLinqQuery.Add(Convert.ChangeType(query, columnType));`
	`77`	`+ parametersForLinqQuery.Add(Convert.ChangeType(query, colInfo.Type));`
`78`	`78`	`return string.Format("{0} == @{1}", columnname, parametersForLinqQuery.Count - 1);`
`79`	`79`	`}`
`80`	`80`	`catch (FormatException)`
`@@ -84,7 +84,7 @@ public static string NumericFilter(string query, string columnname, Type columnT`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`- public static string DateTimeOffsetFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)`
	`87`	`+ public static string DateTimeOffsetFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)`
`88`	`88`	`{`
`89`	`89`	`if (query == "~") return string.Empty;`
`90`	`90`
`@@ -93,37 +93,51 @@ public static string DateTimeOffsetFilter(string query, string columnname, Type`
`93`	`93`	`var parts = query.Split('~');`
`94`	`94`	`DateTimeOffset start, end;`
`95`	`95`	`DateTimeOffset.TryParse(parts[0] ?? "", out start);`
`96`		`- if (!DateTimeOffset.TryParse(parts[1] ?? "", out end)) end = DateTimeOffset.MaxValue;`
	`96`	`+ if (!DateTimeOffset.TryParse(parts[1] ?? "", out end))`
	`97`	`+ {`
	`98`	`+ end = DateTimeOffset.MaxValue;`
	`99`	`+ }`
	`100`	`+ else`
	`101`	`+ {`
	`102`	`+ end = end.Date.AddDays(1);`
	`103`	`+ }`
`97`	`104`
`98`	`105`	`parametersForLinqQuery.Add(start);`
`99`		`- parametersForLinqQuery.Add(end);`
`100`		`- return string.Format("{0} >= @{1} and {0} <= @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);`
	`106`	`+ parametersForLinqQuery.Add(end.AddDays(1).AddSeconds(-1));`
	`107`	`+ return string.Format("{0} >= @{1} and {0} < @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);`
`101`	`108`	`}`
`102`	`109`	`else`
`103`	`110`	`{`
`104`		`- return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, columnType), columnname);`
	`111`	`+ return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, colInfo.Type), columnname);`
`105`	`112`	`}`
`106`	`113`	`}`
`107`		`- public static string DateTimeFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)`
	`114`	`+ public static string DateTimeFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)`
`108`	`115`	`{`
`109`	`116`	`if (query == "~") return string.Empty;`
`110`	`117`	`if (query.Contains("~"))`
`111`	`118`	`{`
`112`	`119`	`var parts = query.Split('~');`
`113`	`120`	`DateTime start, end;`
`114`	`121`	`DateTime.TryParse(parts[0] ?? "", out start);`
`115`		`- if (!DateTime.TryParse(parts[1] ?? "", out end)) end = DateTime.MaxValue;`
	`122`	`+ if (!DateTime.TryParse(parts[1] ?? "", out end))`
	`123`	`+ {`
	`124`	`+ end = DateTime.MaxValue;`
	`125`	`+ }`
	`126`	`+ else`
	`127`	`+ {`
	`128`	`+ end = end.Date.AddDays(1);`
	`129`	`+ }`
`116`	`130`
`117`	`131`	`parametersForLinqQuery.Add(start);`
`118`	`132`	`parametersForLinqQuery.Add(end);`
`119`		`- return string.Format("{0} >= @{1} and {0} <= @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);`
	`133`	`+ return string.Format("{0} >= @{1} and {0} < @{2}", columnname, parametersForLinqQuery.Count - 2, parametersForLinqQuery.Count - 1);`
`120`	`134`	`}`
`121`	`135`	`else`
`122`	`136`	`{`
`123`		`- return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, columnType), columnname);`
	`137`	`+ return string.Format("{1}.ToLocalTime().ToString(\"g\").{0}", FilterMethod(query, parametersForLinqQuery, colInfo.Type), columnname);`
`124`	`138`	`}`
`125`	`139`	`}`
`126`		`- public static string BoolFilter(string query, string columnname, Type columnType, List<object> parametersForLinqQuery)`
	`140`	`+ public static string BoolFilter(string query, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)`
`127`	`141`	`{`
`128`	`142`	`if (query != null)`
`129`	`143`	`query = query.TrimStart('^').TrimEnd('$');`
`@@ -133,15 +147,15 @@ public static string BoolFilter(string query, string columnname, Type columnType`
`133`	`147`	`if (query.ToLower() == "true") return columnname + " == true";`
`134`	`148`	`return columnname + " == false";`
`135`	`149`	`}`
`136`		`- if (columnType == typeof (bool?))`
	`150`	`+ if (colInfo.Type == typeof(bool?))`
`137`	`151`	`{`
`138`	`152`	`if (lowerCaseQuery == "null") return columnname + " == null";`
`139`	`153`	`}`
`140`	`154`	`return null;`
`141`	`155`
`142`	`156`	`}`
`143`	`157`
`144`		`- public static string StringFilter(string q, string columnname, Type columntype, List<object> parametersforlinqquery)`
	`158`	`+ public static string StringFilter(string q, string columnname, ColInfo columntype, List<object> parametersforlinqquery)`
`145`	`159`	`{`
`146`	`160`	`if (q == ".*") return "";`
`147`	`161`	`if (q.StartsWith("^"))`
`@@ -172,12 +186,12 @@ public static string StringFilter(string q, string columnname, Type columntype,`
`172`	`186`	`}`
`173`	`187`	`}`
`174`	`188`
`175`		`- public static string EnumFilter(string q, string columnname, Type type, List<object> parametersForLinqQuery)`
	`189`	`+ public static string EnumFilter(string q, string columnname, ColInfo colInfo, List<object> parametersForLinqQuery)`
`176`	`190`	`{`
`177`	`191`
`178`	`192`	`if (q.StartsWith("^")) q = q.Substring(1);`
`179`	`193`	`if (q.EndsWith("$")) q = q.Substring(0, q.Length - 1);`
`180`		`- parametersForLinqQuery.Add(ParseValue(q, type));`
	`194`	`+ parametersForLinqQuery.Add(ParseValue(q, colInfo.Type));`
`181`	`195`	`return columnname + " == @" + (parametersForLinqQuery.Count - 1);`
`182`	`196`	`}`
`183`	`197`	`}`