Exemple #1
0
        public void Create_ShortGreaterThan_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("barShort_gt",
                                    new IntValueNode(12)));

            var fooType = CreateType(new FooFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType, typeof(Foo), TypeConversion.Default, true);

            filter.Visit(value, null);
            Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();

            // assert
            var a = new Foo {
                BarShort = 11
            };

            Assert.False(func(a));

            var b = new Foo {
                BarShort = 12
            };

            Assert.False(func(b));

            var c = new Foo {
                BarShort = 13
            };

            Assert.True(func(c));
        }
        public void Create_StringNotEqual_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("bar_not",
                                    new StringValueNode("a")));

            FooFilterType fooType = CreateType(new FooFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(Foo),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();

            // assert
            var a = new Foo {
                Bar = "a"
            };

            Assert.False(func(a));

            var b = new Foo {
                Bar = "b"
            };

            Assert.True(func(b));
        }
Exemple #3
0
        public void Create_NullableBooleanEqual_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("bar",
                                    new BooleanValueNode(true)));

            var fooNullableType = CreateType(new FooNullableFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooNullableType, typeof(FooNullable), TypeConversion.Default, true);

            filter.Visit(value, null);
            Func <FooNullable, bool> func = filter.CreateFilter <FooNullable>().Compile();

            // assert
            var a = new FooNullable {
                Bar = true
            };

            Assert.True(func(a));

            var b = new FooNullable {
                Bar = false
            };

            Assert.False(func(b));

            var c = new FooNullable {
                Bar = null
            };

            Assert.False(func(c));
        }
Exemple #4
0
        public void Create_ArraySomeObjectStringEqualWithNull_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("fooNested_some",
                                    new ObjectValueNode(
                                        new ObjectFieldNode("bar",
                                                            new StringValueNode("a")
                                                            )
                                        )
                                    )
                );

            FooFilterType fooType = CreateType(new FooFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(Foo),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();

            // assert
            var a = new Foo
            {
                FooNested = new[]
                {
                    new FooNested {
                        Bar = "c"
                    },
                    null,
                    new FooNested {
                        Bar = "a"
                    }
                }
            };

            Assert.True(func(a));

            var b = new Foo
            {
                FooNested = new[]
                {
                    new FooNested {
                        Bar = "c"
                    },
                    null,
                    new FooNested {
                        Bar = "b"
                    }
                }
            };

            Assert.False(func(b));
        }
Exemple #5
0
        public void Create_ArrayAnyObjectStringEqual_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("fooNested_any",
                                    new BooleanValueNode(true)
                                    )
                );

            FooFilterType fooType = CreateType(new FooFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(Foo),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();

            // assert
            var a = new Foo
            {
                FooNested = new[]
                {
                    new FooNested {
                        Bar = "c"
                    },
                    new FooNested {
                        Bar = "d"
                    },
                    new FooNested {
                        Bar = "a"
                    }
                }
            };

            Assert.True(func(a));

            var b = new Foo {
                FooNested = new FooNested[] { }
            };

            Assert.False(func(b));
            var c = new Foo {
                FooNested = null
            };

            Assert.False(func(c));
            var d = new Foo {
                FooNested = new FooNested[] { null }
            };

            Assert.True(func(d));
        }
        public async Task InvokeAsync(IMiddlewareContext context)
        {
            await _next(context).ConfigureAwait(false);

            IValueNode filter = context.Argument <IValueNode>(_contextData.ArgumentName);

            if (filter is null || filter is NullValueNode)
            {
                return;
            }

            IQueryable <T> source = null;

            if (context.Result is PageableData <T> p)
            {
                source = p.Source;
            }
            else
            {
                p = null;
            }

            if (context.Result is IQueryable <T> q)
            {
                source = q;
            }
            else if (context.Result is IEnumerable <T> e)
            {
                source = e.AsQueryable();
            }

            if (source != null &&
                context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot &&
                iot is IFilterInputType fit)
            {
                if (source is EnumerableQuery)
                {
                    var visitor = new QueryableFilterVisitor(iot, fit.EntityType, _converter, true);
                    visitor.Visit(filter, null);
                    source = source.Where(visitor.CreateFilter <T>());
                }
                else
                {
                    var visitor = new QueryableFilterVisitor(iot, fit.EntityType, _converter, false);
                    visitor.Visit(filter, null);
                    source = source.Where(visitor.CreateFilter <T>());
                }

                context.Result = p is null
                    ? (object)source
                    : new PageableData <T>(source, p.Properties);
            }
        }
        public void Create_ObjectStringEqualDeep_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("foo",
                                    new ObjectValueNode(
                                        new ObjectFieldNode("fooNested",
                                                            new ObjectValueNode(
                                                                new ObjectFieldNode("bar",
                                                                                    new StringValueNode("a")
                                                                                    )
                                                                )
                                                            )
                                        )
                                    )
                );

            var fooType = CreateType(new EvenDeeperFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(EvenDeeper),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <EvenDeeper, bool> func = filter.CreateFilter <EvenDeeper>().Compile();

            // assert
            var a = new EvenDeeper {
                Foo = new Foo {
                    FooNested = new FooNested {
                        Bar = "a"
                    }
                }
            };

            Assert.True(func(a));

            var b = new EvenDeeper {
                Foo = new Foo {
                    FooNested = new FooNested {
                        Bar = "b"
                    }
                }
            };

            Assert.False(func(b));
        }
        public void Create_ObjectStringEqualRecursive_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("nested",
                                    new ObjectValueNode(
                                        new ObjectFieldNode("nested",
                                                            new ObjectValueNode(
                                                                new ObjectFieldNode("bar",
                                                                                    new StringValueNode("a")
                                                                                    )
                                                                )
                                                            )
                                        )
                                    )
                );

            var fooType = CreateType(new FilterInputType <Recursive>());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(Recursive),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <Recursive, bool> func = filter.CreateFilter <Recursive>().Compile();


            var a = new Recursive {
                Nested = new Recursive {
                    Nested = new Recursive {
                        Bar = "a"
                    }
                }
            };

            Assert.True(func(a));

            var b = new Recursive {
                Nested = new Recursive {
                    Nested = new Recursive {
                        Bar = "b"
                    }
                }
            };

            Assert.False(func(b));
        }
Exemple #9
0
        public void Create_ArraySomeStringEqualWithNull_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("bar_some",
                                    new ObjectValueNode(
                                        new ObjectFieldNode("element",
                                                            new StringValueNode("a")
                                                            )
                                        )
                                    )
                );

            FooSimpleFilterType fooType = CreateType(new FooSimpleFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooType,
                typeof(FooSimple),
                TypeConversion.Default,
                true);

            filter.Visit(value, null);
            Func <FooSimple, bool> func = filter.CreateFilter <FooSimple>().Compile();

            // assert
            var a = new FooSimple {
                Bar = new[] { "c", null, "a" }
            };

            Assert.True(func(a));

            var b = new FooSimple {
                Bar = new[] { "c", null, "b" }
            };

            Assert.False(func(b));

            var c = new FooSimple {
                Bar = null
            };

            Assert.False(func(c));
        }
Exemple #10
0
        public void Create_NullableShortNotLowerThanOrEquals_Expression()
        {
            // arrange
            var value = new ObjectValueNode(
                new ObjectFieldNode("barShort_not_lte",
                                    new IntValueNode(12)));

            var fooNullableType = CreateType(new FooNullableFilterType());

            // act
            var filter = new QueryableFilterVisitor(
                fooNullableType, typeof(FooNullable), TypeConversion.Default, true);

            filter.Visit(value, null);
            Func <FooNullable, bool> func = filter.CreateFilter <FooNullable>().Compile();

            // assert
            var a = new FooNullable {
                BarShort = 11
            };

            Assert.False(func(a));

            var b = new FooNullable {
                BarShort = 12
            };

            Assert.False(func(b));

            var c = new FooNullable {
                BarShort = 13
            };

            Assert.True(func(c));

            var d = new FooNullable {
                BarShort = null
            };

            Assert.True(func(d));
        }