Exemple #1
0
        public void ReferenceTypeIsInCondition()
        {
            var referenceTypeIsInCondition = new ReferenceTypeIsInCondition <string>();

            var expr1 = referenceTypeIsInCondition.For <TestSource>(x => x.Name);

            Assert.IsNull(expr1);

            referenceTypeIsInCondition.Value = new FilterValue <string>
            {
                Values = new List <string> {
                    "1", "2", "3"
                }
            };

            var expr2     = referenceTypeIsInCondition.For <TestSource>(x => x.Name);
            var expr2Func = expr2.Compile();

            Assert.IsTrue(expr2Func(new TestSource {
                Name = "1"
            }));
            Assert.IsFalse(expr2Func(new TestSource {
                Name = "100"
            }));

            referenceTypeIsInCondition.Value = new FilterValue <string>
            {
                Values = new List <string> {
                    "1", "2", "3", null
                }
            };

            var expr3 = referenceTypeIsInCondition.For <TestSource>(x => x.Name);

            Assert.IsNotNull(expr3);
        }
        public void ReferenceTypeConditionBuilder()
        {
            var filter = new ReferenceTypeFilter <User, string>();

            filter.For(x => x.Guid);

            filter.Conditions(conditions =>
            {
                conditions["none"]      = new ReferenceTypeNoneCondition <string>();
                conditions["equal"]     = new ReferenceTypeEqualCondition <string>();
                conditions["isin"]      = new ReferenceTypeIsInCondition <string>();
                conditions["isnull"]    = new ReferenceTypeIsNullCondition <string>();
                conditions["isnotnull"] = new ReferenceTypeIsNotNullCondition <string>();
            });

            filter.ConditionBuilder((filterValue, condition, conditionKey) =>
            {
                var expression = condition(filterValue);
                if (expression == null)
                {
                    return(null);
                }

                switch (conditionKey)
                {
                case "isnotnull":
                    {
                        return(Linq.Expr <Task, bool>(x => x.Users.AsQueryable().Any()));
                    }

                case "isnull":
                    {
                        return(Linq.Expr <Task, bool>(x => !x.Users.AsQueryable().Any()));
                    }

                default:    //for equal,isin
                    {
                        return(Linq.Expr <Task, bool>(x => x.Users.AsQueryable().Any(expression)));
                    }
                }
            });

            filter.Init(new FilterValue <string>
            {
                LeftValue    = "1",
                ConditionKey = "equal"
            });

            var expr1 = filter.BuildExpression <User>();

            Assert.IsNull(expr1);

            var epxr2 = filter.BuildExpression <Task>();

            Assert.IsNotNull(epxr2);

            var tasksAnyUserId1 = filter.ApplyFilter(Source);

            Assert.IsTrue(tasksAnyUserId1.Count() == 1);


            filter.Init(new FilterValue <string>
            {
                ConditionKey = "isnotnull"
            });


            var tasksAnyUsers = filter.ApplyFilter(Source);

            Assert.IsTrue(tasksAnyUsers.Count() == 3);

            filter.Init(new FilterValue <string>
            {
                ConditionKey = "isnull"
            });

            var tasksNotAnyUsers = filter.ApplyFilter(Source);

            Assert.IsTrue(tasksNotAnyUsers.Count() == 1);


            filter.Init(new FilterValue <string>
            {
                ConditionKey = "isin",
                Values       = new List <string> {
                    "1", "5"
                }
            });

            var tasksIsInUser1User5 = filter.ApplyFilter(Source);

            Assert.IsTrue(tasksIsInUser1User5.Count() == 2);
        }