Merge pull request #14 from LithWang/master

checkNullForString

doc/ReleaseNotes.md

@@ -1,4 +1,9 @@
 # Vit.Linq ReleaseNotes
+
+-----------------------
+# 3.1.4
+- FilterService.checkNullForString = false;
+
 -----------------------
 # 3.1.0
 - [Vit.Linq] rename namespace ExpressionTree to ExpressionNodes , Filter to FilterRules

src/Versions.props

@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <Version>3.1.3</Version>
+        <Version>3.1.4</Version>
     </PropertyGroup>
 
     <PropertyGroup>

src/Vit.Linq/FilterRules/FilterConvertor/OperatorConvert/StringOperatorConvertor.cs

@@ -9,6 +9,11 @@ namespace Vit.Linq.FilterRules.FilterConvertor.OperatorConvert
         public int priority => 4000;
 
         public (bool success, Expression expression) ConvertToCode(OperatorConvertArgument arg)
+        {
+            return arg.filterService.checkNullForString ? ConvertToCode_CheckNull(arg) : ConvertToCode_Primitive(arg);
+        }
+
+        public (bool success, Expression expression) ConvertToCode_CheckNull(OperatorConvertArgument arg)
         {
             if (RuleOperator.Contains.Equals(arg.Operator, arg.comparison))
             {
@@ -71,5 +76,64 @@ namespace Vit.Linq.FilterRules.FilterConvertor.OperatorConvert
         }
 
 
+        public (bool success, Expression expression) ConvertToCode_Primitive(OperatorConvertArgument arg)
+        {
+            if (RuleOperator.Contains.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+                var leftValueType = arg.leftValueType;
+                var rightValueExpression = arg.filterService.GetRightValueExpression(arg.filter, arg.parameter, leftValueType);
+
+                var contains = Expression.Call(leftValueExpression, "Contains", null, rightValueExpression);
+
+                return (true, contains);
+            }
+            else if (RuleOperator.NotContain.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+                var leftValueType = arg.leftValueType;
+                var rightValueExpression = arg.filterService.GetRightValueExpression(arg.filter, arg.parameter, leftValueType);
+
+                var contains = Expression.Call(leftValueExpression, "Contains", null, rightValueExpression);
+
+                return (true, Expression.Not(contains));
+            }
+            else if (RuleOperator.StartsWith.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+                var leftValueType = arg.leftValueType;
+                var rightValueExpression = arg.filterService.GetRightValueExpression(arg.filter, arg.parameter, leftValueType);
+
+                var startsWith = Expression.Call(leftValueExpression, "StartsWith", null, rightValueExpression);
+
+                return (true, startsWith);
+            }
+            else if (RuleOperator.EndsWith.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+                var leftValueType = arg.leftValueType;
+                var rightValueExpression = arg.filterService.GetRightValueExpression(arg.filter, arg.parameter, leftValueType);
+
+                var endsWith = Expression.Call(leftValueExpression, "EndsWith", null, rightValueExpression);
+
+                return (true, endsWith);
+            }
+            else if (RuleOperator.IsNullOrEmpty.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+
+                return (true, Expression.Call(typeof(string), "IsNullOrEmpty", null, leftValueExpression));
+            }
+            else if (RuleOperator.IsNotNullOrEmpty.Equals(arg.Operator, arg.comparison))
+            {
+                var leftValueExpression = arg.leftValueExpression;
+
+                return (true, Expression.Not(Expression.Call(typeof(string), "IsNullOrEmpty", null, leftValueExpression)));
+            }
+
+            return default;
+        }
+
+
     }
 }

src/Vit.Linq/FilterRules/FilterService.cs

@@ -17,6 +17,7 @@ namespace Vit.Linq.FilterRules
 
 
         public bool operatorIsIgnoreCase = true;
+        public virtual bool checkNullForString { get; set; } = false;
 
         public virtual Expression ConvertToCode(ParameterExpression parameter, IFilterRule rule)
         {

test/Vit.Linq.MsTest/FilterRules/Filter_TestBase.cs

@@ -67,6 +67,15 @@ namespace Vit.Linq.MsTest.FilterRules
                 Assert.AreEqual(1, result.Count);
                 Assert.AreEqual(10, result[0].id);
             }
+
+            {
+                var query = GetQueryable();
+
+                var strRule = "{'field':'id',  'operator': 'IsNull'  }".Replace("'", "\"");
+                var rule = GetRule(strRule);
+                var result = Filter(ToQuery(query), rule);
+                Assert.AreEqual(0, result.Count);
+            }
             #endregion
 
             #region ##2 IsNotNull
@@ -93,6 +102,15 @@ namespace Vit.Linq.MsTest.FilterRules
                 var result = Filter(ToQuery(query), rule);
                 Assert.AreEqual(999, result.Count);
             }
+
+            {
+                var query = GetQueryable();
+
+                var strRule = "{'field':'id',  'operator': 'IsNotNull'  }".Replace("'", "\"");
+                var rule = GetRule(strRule);
+                var result = Filter(ToQuery(query), rule);
+                Assert.AreEqual(1000, result.Count);
+            }
             #endregion
 
             #endregion
@@ -332,14 +350,43 @@ namespace Vit.Linq.MsTest.FilterRules
 
             #region ##1 Contains
             {
-                var query = GetQueryable();
+                //###1 Contains
+                {
+                    var query = GetQueryable();
 
-                var strRule = "{'field':'name',  'operator': 'Contains',  'value': '987' }".Replace("'", "\"");
-                var rule = GetRule(strRule);
-                var result = Filter(ToQuery(query), rule);
+                    var strRule = "{'field':'name',  'operator': 'Contains',  'value': '987' }".Replace("'", "\"");
+                    var rule = GetRule(strRule);
+                    var result = Filter(ToQuery(query), rule);
 
-                Assert.AreEqual(1, result.Count);
-                Assert.AreEqual(987, result.First().id);
+                    Assert.AreEqual(1, result.Count);
+                    Assert.AreEqual(987, result.First().id);
+                }
+
+                //###2  "".Contains
+                {
+                    var query = GetQueryable();
+                    query.Skip(988).FirstOrDefault().name = "";
+
+                    var strRule = "{'field':'name',  'operator': 'Contains',  'value': '987' }".Replace("'", "\"");
+                    var rule = GetRule(strRule);
+                    var result = Filter(ToQuery(query), rule);
+
+                    Assert.AreEqual(1, result.Count);
+                    Assert.AreEqual(987, result.First().id);
+                }
+
+                //###3  null.Contains
+                {
+                    var query = GetQueryable();
+                    query.Skip(988).FirstOrDefault().name = null;
+
+                    var strRule = "{'condition':'And','rules':[ {'field':'name',  'operator': 'IsNotNull' }, {'field':'name',  'operator': 'Contains',  'value': '987' }    ]}".Replace("'", "\"");
+                    var rule = GetRule(strRule);
+                    var result = Filter(ToQuery(query), rule);
+
+                    Assert.AreEqual(1, result.Count);
+                    Assert.AreEqual(987, result.First().id);
+                }
             }
             #endregion
 
@@ -355,27 +402,26 @@ namespace Vit.Linq.MsTest.FilterRules
                     Assert.AreEqual(999, result.Count);
                 }
 
-
                 //###2
                 {
                     var query = GetQueryable();
-                    query.Skip(987).FirstOrDefault().name = null;
+                    query.Skip(988).FirstOrDefault().name = "";
 
                     var strRule = "{'field':'name',  'operator': 'NotContain',  'value': '987' }".Replace("'", "\"");
                     var rule = GetRule(strRule);
                     var result = Filter(ToQuery(query), rule);
-                    Assert.AreEqual(1000, result.Count);
+                    Assert.AreEqual(999, result.Count);
                 }
 
                 //###3
                 {
                     var query = GetQueryable();
-                    query.Skip(987).FirstOrDefault().name = "";
+                    query.Skip(988).FirstOrDefault().name = null;
 
-                    var strRule = "{'field':'name',  'operator': 'NotContain',  'value': '987' }".Replace("'", "\"");
+                    var strRule = "{'condition':'Or','rules':[ {'field':'name',  'operator': 'IsNull' }, {'field':'name',  'operator': 'NotContain',  'value': '987' }       ]}  ".Replace("'", "\"");
                     var rule = GetRule(strRule);
                     var result = Filter(ToQuery(query), rule);
-                    Assert.AreEqual(1000, result.Count);
+                    Assert.AreEqual(999, result.Count);
                 }
             }
             #endregion