public static void MultipleValueConditions <TProperty>(IDictionary <string, IValueTypeCondition <TProperty> > conditions) where TProperty : struct, IComparable, IComparable <TProperty>, IEquatable <TProperty>
 {
     conditions["none"]      = new ValueTypeNoneCondition <TProperty>("None");
     conditions["isin"]      = new ValueTypeIsInCondition <TProperty>("IsIn");
     conditions["inotsin"]   = new ValueTypeIsNotInCondition <TProperty>("IsNotIn");
     conditions["isnull"]    = new ValueTypeIsNullCondition <TProperty>("IsNull");
     conditions["isnotnull"] = new ValueTypeIsNotNullCondition <TProperty>("IsNotNull");
 }
示例#2
0
        public ProductFilter()
        {
            Add("CategoryId", new ValueTypeFilter <Product, int>())
            .For(x => x.CategoryId)
            .Conditions(conditions => conditions["isin"] = new ValueTypeIsInCondition <int>("IsIn"))
            .SetTitle("Categories:")
            .SetTemplate("FastFilterWithListBox");

            Add("UnitPrice", new ValueTypeFilter <Product, decimal>())
            .For(x => x.UnitPrice)
            .Conditions(conditions => conditions["between"] = new BetweenCondition <decimal>("Between"))
            .SetTitle("UnitPrice:")
            .SetValueFormat("{0:G29}")
            .SetTemplate("FastNumberFilter");

            Add("Name", new ReferenceTypeFilter <Product, string>())
            .For(x => x.Name)
            .Conditions(conditions => conditions["contains"] = new ContainsCondition("Contains"))
            .SetTitle("Name:")
            .SetTemplate("FastStringFilter");
        }
        public SimpleProductFilter(NorthwindDataContext dc)
        {
            if (dc == null)
            {
                throw new ArgumentNullException("dc");
            }

            var categories = dc.Categories.OrderBy(x => x.Name).Select(x =>
                                                                       new SelectListItem
            {
                Value = SqlFunctions.StringConvert((double)x.ID).Trim(),
                Text  = x.Name
            });

            Add("CategoryId", new ValueTypeFilter <Product, int>())
            .For(x => x.CategoryID)
            .Conditions(conditions => conditions["isin"] = new ValueTypeIsInCondition <int>("IsIn"))
            .SetDictionary(categories)
            .SetTitle("Categories:")
            .SetTemplate("FastFilterWithListBox");

            Add("UnitPrice", new ValueTypeFilter <Product, decimal>())
            .For(x => x.UnitPrice)
            .Conditions(conditions => conditions["between"] = new BetweenCondition <decimal>("Between"))
            .SetTitle("UnitPrice:")
            .SetValueFormat("{0:G29}")
            .SetTemplate("FastNumberFilter");

            Add("Name", new ReferenceTypeFilter <Product, string>())
            .For(x => x.Name)
            .Conditions(conditions => conditions["contains"] = new ContainsCondition("Contains"))
            .SetTitle("Name:")
            .SetTemplate("FastStringFilter");

            Action = "Grid";

            UpdateTargetId = "products";
        }
        public void ValueTypeIsInCondition()
        {
            var isInCondition = new ValueTypeIsInCondition <int>();

            var expr1 = isInCondition.For <TestSource>(x => x.Id);

            Assert.IsNull(expr1);

            isInCondition.Value = new FilterValue <int?>
            {
                Values = new List <int?> {
                    1, 2, 3
                }
            };

            var expr2     = isInCondition.For <TestSource>(x => x.Id);
            var expr2Func = expr2.Compile();

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

            isInCondition.Value = new FilterValue <int?>
            {
                Values = new List <int?> {
                    1, 2, 3, null
                }
            };

            var expr3 = isInCondition.For <TestSource>(x => x.Id);

            Assert.IsNotNull(expr3);
        }
        public void ValueTypeConditionBuilder()
        {
            var filter = new ValueTypeFilter <User, int>();

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

            filter.Conditions(conditions =>
            {
                conditions["none"]      = new ValueTypeNoneCondition <int>();
                conditions["equal"]     = new ValueTypeEqualCondition <int>();
                conditions["isin"]      = new ValueTypeIsInCondition <int>();
                conditions["isnull"]    = new ValueTypeIsNullCondition <int>();
                conditions["isnotnull"] = new ValueTypeIsNullCondition <int>();
            });

            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 <int?>
            {
                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 <int?>
            {
                ConditionKey = "isnotnull"
            });


            var tasksAnyUsers = filter.ApplyFilter(Source);

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

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

            var tasksNotAnyUsers = filter.ApplyFilter(Source);

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


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

            var tasksIsInUser1User5 = filter.ApplyFilter(Source);

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