protected virtual IQueryable <TResource> ApplyQueryLayer(QueryLayer layer)
        {
            _traceWriter.LogMethodStart(new { layer });
            if (layer == null)
            {
                throw new ArgumentNullException(nameof(layer));
            }

            IQueryable <TResource> source = GetAll();

            var queryableHandlers = _constraintProviders
                                    .SelectMany(p => p.GetConstraints())
                                    .Where(expressionInScope => expressionInScope.Scope == null)
                                    .Select(expressionInScope => expressionInScope.Expression)
                                    .OfType <QueryableHandlerExpression>()
                                    .ToArray();

            foreach (var queryableHandler in queryableHandlers)
            {
                source = queryableHandler.Apply(source);
            }

            var nameFactory = new LambdaParameterNameFactory();
            var builder     = new QueryableBuilder(source.Expression, source.ElementType, typeof(Queryable), nameFactory, _resourceFactory, _resourceGraph, _dbContext.Model);

            var expression = builder.ApplyQuery(layer);

            return(source.Provider.CreateQuery <TResource>(expression));
        }
        public void ThrowsWhenRootIsNull()
        {
            var builder = new QueryableBuilder();

            builder.Root(null);

            Assert.Throws <QueryableBuilderException>(() => builder.Build <EntityWithQueryableMember>());
        }
        public void ReturnsQueryable()
        {
            var builder   = new QueryableBuilder();
            var queryable = builder
                            .Root(RootStub)
                            .Build <EntityWithQueryableMember>();

            Assert.NotNull(queryable);
        }
        public void HttpClientCanBeConfigured()
        {
            var builder    = new QueryableBuilder();
            var httpClient = new MockHttpMessageHandler().ToHttpClient();
            var queryable  = builder
                             .HttpClient(httpClient)
                             .Root(RootStub)
                             .Build <EntityWithQueryableMember>();

            Assert.NotNull(queryable);
        }
        public void TestMethod13()
        {
            var str = QueryableBuilder.GetWhere <Page>(p => new { p.PageName, p.PageLink }, new List <string>()
            {
                "test",
                "test2"
            }, out var param);

            Assert.IsTrue(str == " WHERE [PageName] + ' ' + [PageLink] LIKE '%' + @Keyword__0 + '%' AND [PageName] + ' ' + [PageLink] LIKE '%' + @Keyword__1 + '%'");

            Assert.IsTrue(param.Count == 2);
        }
        public void TestMethod13()
        {
            var str = QueryableBuilder.GetWhere <Page>(p => new { p.PageName, p.PageLink }, new List <string>()
            {
                "test",
                "test2"
            }, out var param);

            Assert.IsTrue(str == " WHERE CONCAT(`PageName` , ' ' , `PageLink`) LIKE CONCAT('%', @Keyword__0, '%') AND CONCAT(`PageName` , ' ' , `PageLink`) LIKE CONCAT('%', @Keyword__1, '%')");

            Assert.IsTrue(param.Count == 2);
        }
        protected virtual IQueryable <TResource> ApplyQueryLayer(QueryLayer layer)
        {
            _traceWriter.LogMethodStart(new
            {
                layer
            });

            ArgumentGuard.NotNull(layer, nameof(layer));

            QueryLayer rewrittenLayer = layer;

            if (EntityFrameworkCoreSupport.Version.Major < 5)
            {
                var writer = new MemoryLeakDetectionBugRewriter();
                rewrittenLayer = writer.Rewrite(layer);
            }

            IQueryable <TResource> source = GetAll();

            // @formatter:wrap_chained_method_calls chop_always
            // @formatter:keep_existing_linebreaks true

            QueryableHandlerExpression[] queryableHandlers = _constraintProviders
                                                             .SelectMany(provider => provider.GetConstraints())
                                                             .Where(expressionInScope => expressionInScope.Scope == null)
                                                             .Select(expressionInScope => expressionInScope.Expression)
                                                             .OfType <QueryableHandlerExpression>()
                                                             .ToArray();

            // @formatter:keep_existing_linebreaks restore
            // @formatter:wrap_chained_method_calls restore

            foreach (QueryableHandlerExpression queryableHandler in queryableHandlers)
            {
                source = queryableHandler.Apply(source);
            }

            var nameFactory = new LambdaParameterNameFactory();

            var builder = new QueryableBuilder(source.Expression, source.ElementType, typeof(Queryable), nameFactory, _resourceFactory, _resourceGraph,
                                               _dbContext.Model);

            Expression expression = builder.ApplyQuery(rewrittenLayer);

            return(source.Provider.CreateQuery <TResource>(expression));
        }
        public void TestMethod11()
        {
            var str = QueryableBuilder.GetQueryColumn <Page>(p => new { p.PageId, p.PageName });

            if (QueryConfig.DialectServer == Dialect.SqlServer)
            {
                Assert.IsTrue(str == "[PageId] + ' ' + [PageName]");
            }
            else if (QueryConfig.DialectServer == Dialect.MySql)
            {
                Assert.IsTrue(str == "CONCAT(`PageId` , ' ' , `PageName`)");
            }
            else
            {
                Assert.IsTrue(false);
            }
        }
        public void ThrowsOnUnconfiguredRoot()
        {
            var builder = new QueryableBuilder();

            Assert.Throws <QueryableBuilderException>(() => builder.Build <EntityWithQueryableMember>());
        }
        public void TestMethod12()
        {
            var str = QueryableBuilder.GetQueryColumn <Page>(p => new { });

            Assert.IsTrue(str == "");
        }
        public void TestMethod11()
        {
            var str = QueryableBuilder.GetQueryColumn <Page>(p => new { p.PageId, p.PageName });

            Assert.IsTrue(str == "[PageId] + ' ' + [PageName]");
        }