Merge pull request #71 from trenoncourt/develop

add wrap total-count & fix disallowed/allowed clauses

sample/AutoQueryable.Sample.EfCore/Controllers/ProductController.cs

@@ -38,6 +38,13 @@ public IQueryable Get([FromServices] AutoQueryableDbContext context)
             return context.Product;
         }
 
+        [AutoQueryable(DisAllowedClauses = ClauseType.Select)]
+        [HttpGet("with_disallow")]
+        public IQueryable GetWithDisallow([FromServices] AutoQueryableDbContext context)
+        {
+            return context.Product;
+        }
+
 
         [AutoQueryable(DefaultToSelect = "name")]
         [HttpGet("with_default")]

src/AutoQueryable.AspNet.Filter/AutoQueryable.AspNet.Filter.csproj

@@ -2,8 +2,7 @@
   <PropertyGroup>
     <Description>AutoQueryable.AspNetCore.Filter add filterAttribute for AutoQueryable to Asp.Net &gt;=4.6.</Description>
     <AssemblyTitle>AutoQueryable.AspNetCore.Filter add filterAttribute for AutoQueryable to Asp.Net &gt;=4.6.</AssemblyTitle>
-    <VersionPrefix>1.7.0</VersionPrefix>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <Authors>Thibaut Renoncourt</Authors>
     <TargetFramework>net46</TargetFramework>
     <AssemblyName>AutoQueryable.AspNet.Filter</AssemblyName>

src/AutoQueryable.AspNet/AutoQueryable.AspNet.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net46</TargetFramework>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <PackageLicenseUrl>https://raw.githubusercontent.com/trenoncourt/AutoQueryable/master/LICENSE</PackageLicenseUrl>
     <Authors>Thibaut Renoncourt</Authors>
     <Product>AutoQueryable</Product>

src/AutoQueryable.AspNetCore.Filter/AutoQueryable.AspNetCore.Filter.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>AutoQueryable.AspNetCore.Filter add filterAttribute for AutoQueryable to Asp.Net Core.</Description>
     <AssemblyTitle>AutoQueryable.AspNetCore.Filter add filterAttribute for AutoQueryable to Asp.Net Core.</AssemblyTitle>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <Authors>Thibaut Renoncourt</Authors>
     <TargetFramework>netstandard2.0</TargetFramework>
     <AssemblyName>AutoQueryable.AspNetCore.Filter</AssemblyName>

src/AutoQueryable.AspNetCore.Filter/FilterAttributes/AutoQueryableFilter.cs

@@ -93,31 +93,31 @@ public void OnActionExecuted(ActionExecutedContext context)
             _autoQueryableProfile.UnSortableProperties = UnSortableProperties;
             _autoQueryableProfile.GroupableProperties = GroupableProperties;
             _autoQueryableProfile.UnGroupableProperties = UnGroupableProperties;
-            if (_autoQueryableProfile.AllowedClauses.HasValue)
+            if (AllowedClauses != ClauseType.None)
             {
                 _autoQueryableProfile.AllowedClauses = AllowedClauses;
             }
-            if (_autoQueryableProfile.DisAllowedClauses.HasValue)
+            if (DisAllowedClauses != ClauseType.None)
             {
                 _autoQueryableProfile.DisAllowedClauses = DisAllowedClauses;
             }
-            if (_autoQueryableProfile.AllowedConditions.HasValue)
+            if (AllowedConditions != ConditionType.None)
             {
                 _autoQueryableProfile.AllowedConditions = AllowedConditions;
             }
-            if (_autoQueryableProfile.DisAllowedConditions.HasValue)
+            if (DisAllowedConditions != ConditionType.None)
             {
                 _autoQueryableProfile.DisAllowedConditions = DisAllowedConditions;
             }
-            if (_autoQueryableProfile.AllowedWrapperPartType.HasValue)
+            if (AllowedWrapperPartType != WrapperPartType.None)
             {
                 _autoQueryableProfile.AllowedWrapperPartType = AllowedWrapperPartType;
             }
-            if (_autoQueryableProfile.DisAllowedWrapperPartType.HasValue)
+            if (DisAllowedWrapperPartType != WrapperPartType.None)
             {
                 _autoQueryableProfile.DisAllowedWrapperPartType = DisAllowedWrapperPartType;
             }
-            if (_autoQueryableProfile.MaxToTake.HasValue)
+            if (MaxToTake != 0)
             {
                 _autoQueryableProfile.MaxToTake = MaxToTake;
             }

src/AutoQueryable.AspNetCore.Swagger/AutoQueryable.AspNetCore.Swagger.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>AutoQueryable.AspNetCore.Swagger add Swagger parameters for AutoQueryable to Asp.Net Core.</Description>
     <AssemblyTitle>AutoQueryable.AspNetCore.Swagger add Swagger parameters for AutoQueryable to Asp.Net Core.</AssemblyTitle>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <Authors>Thibaut Renoncourt</Authors>
     <TargetFramework>netstandard2.0</TargetFramework>
     <AssemblyName>AutoQueryable.AspNetCore.Swagger</AssemblyName>

src/AutoQueryable.Extensions.Autofac/AutoQueryable.Extensions.Autofac.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net46</TargetFramework>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <Authors>Thibaut Renoncourt</Authors>
     <Company>-</Company>
     <Product>AutoQueryable</Product>

src/AutoQueryable.Extensions.DependencyInjection/AutoQueryable.Extensions.DependencyInjection.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <TargetFramework>netstandard2.0</TargetFramework>
     <LangVersion>7.1</LangVersion>
     <Product>AutoQueryable</Product>

src/AutoQueryable/AutoQueryable.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>AutoQueryable add auto querying functionality like OData with best url practices to Asp.Net Core.</Description>
     <AssemblyTitle>AutoQueryable add auto querying functionality like OData with best url practices to Asp.Net Core.</AssemblyTitle>
-    <Version>2.0.4-beta</Version>
+    <Version>2.0.5-beta</Version>
     <Authors>Thibaut Renoncourt, Nils Goovaerts</Authors>
     <TargetFramework>netstandard1.3</TargetFramework>
     <AssemblyName>AutoQueryable</AssemblyName>

src/AutoQueryable/Core/Clauses/ClauseHandlers/DefaultOrderByClauseHandler.cs

@@ -1,13 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using AutoQueryable.Core.Models;
 
-namespace AutoQueryable.Core.Clauses
+namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {
     public class DefaultOrderByClauseHandler : IOrderByClauseHandler
     {
-        public Dictionary<string, bool> Handle(string orderByQueryStringPart, Type type = default(Type), IAutoQueryableProfile profile = null)
+        public Dictionary<string, bool> Handle(string orderByQueryStringPart, Type type = default, IAutoQueryableProfile profile = null)
         {
             var orderByValues = new Dictionary<string, bool>();
             foreach(var q in orderByQueryStringPart.Split(','))

src/AutoQueryable/Core/Clauses/ClauseHandlers/SelectClauseHandler.cs → src/AutoQueryable/Core/Clauses/ClauseHandlers/DefaultSelectClauseHandler.cs

@@ -5,7 +5,7 @@
 using AutoQueryable.Core.Extensions;
 using AutoQueryable.Core.Models;
 
-namespace AutoQueryable.Core.Clauses
+namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {
     public class DefaultSelectClauseHandler : ISelectClauseHandler
     {
@@ -236,7 +236,8 @@ private void AddBaseColumns(IEnumerable<string> selection)
             }
         }
     }
-
+
+
     public interface IAutoQueryableBaseType 
     {
         Type BaseType { get; set; }

src/AutoQueryable/Core/Clauses/ClauseHandlers/DefaultWrapWithClauseHandler.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using AutoQueryable.Core.Models;
 
 namespace AutoQueryable.Core.Clauses.ClauseHandlers
@@ -10,7 +9,7 @@ public class DefaultWrapWithClauseHandler : IWrapWithClauseHandler
     {
         public IEnumerable<string> Handle(string wrapWithQueryStringPart, Type type = default, IAutoQueryableProfile profile = null)
         {
-            return wrapWithQueryStringPart.Split(new []{';'}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.ToLowerInvariant());
+            return wrapWithQueryStringPart.Split(new []{','}, StringSplitOptions.RemoveEmptyEntries).Select(s => s.ToLowerInvariant());
         }
     }
 }

src/AutoQueryable/Core/Clauses/ClauseHandlers/IClauseHandler.cs

@@ -1,7 +1,7 @@
 using System;
 using AutoQueryable.Core.Models;
 
-namespace AutoQueryable.Core.Clauses
+namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {
     public interface IClauseHandler<T> where T : class 
     {

src/AutoQueryable/Core/Clauses/ClauseHandlers/IOrderByClauseHandler.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
-using AutoQueryable.Core.Models;
 
-namespace AutoQueryable.Core.Clauses
+namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {
     public interface IOrderByClauseHandler : IClauseHandler<Dictionary<string, bool>>
     {

src/AutoQueryable/Core/Clauses/ClauseHandlers/ISelectClauseHandler.cs

@@ -1,8 +1,7 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using AutoQueryable.Core.Models;
 
-namespace AutoQueryable.Core.Clauses
+namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {
     public interface ISelectClauseHandler : IClauseHandler<ICollection<SelectColumn>>
     {

src/AutoQueryable/Core/Clauses/ClauseHandlers/IWrapWithClauseHandler.cs

@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Collections.Generic;
 
 namespace AutoQueryable.Core.Clauses.ClauseHandlers
 {

src/AutoQueryable/Core/Clauses/ClauseMapManager.cs

@@ -1,25 +1,75 @@
-using System.Text.RegularExpressions;
+using System.Collections.Generic;
+using System.Linq;
+using AutoQueryable.Core.Aliases;
 using AutoQueryable.Core.Clauses.ClauseHandlers;
 using AutoQueryable.Core.Enums;
+using AutoQueryable.Core.Models;
 
 namespace AutoQueryable.Core.Clauses
 {
     public class ClauseMapManager : IClauseMapManager
     {
-        private readonly IClauseQueryFilterMap _clauseQueryFilterMap;
+        private readonly ISelectClauseHandler _selectClauseHandler;
+        private readonly IOrderByClauseHandler _orderByClauseHandler;
+        private readonly IWrapWithClauseHandler _wrapWithClauseHandler;
+        private readonly IAutoQueryableProfile _autoQueryableProfile;
+        private readonly ICollection<IClauseQueryFilter> _queryFilters = new List<IClauseQueryFilter>();
 
-        public ClauseMapManager(ISelectClauseHandler selectClauseHandler, IOrderByClauseHandler orderByClauseHandler, IWrapWithClauseHandler wrapWithClauseHandler)
+        public ClauseMapManager(ISelectClauseHandler selectClauseHandler, IOrderByClauseHandler orderByClauseHandler, IWrapWithClauseHandler wrapWithClauseHandler, IAutoQueryableProfile autoQueryableProfile)
         {
-            _clauseQueryFilterMap = new DefaultClauseQueryFilterMap(selectClauseHandler, orderByClauseHandler, wrapWithClauseHandler);
+            _selectClauseHandler = selectClauseHandler;
+            _orderByClauseHandler = orderByClauseHandler;
+            _wrapWithClauseHandler = wrapWithClauseHandler;
+            _autoQueryableProfile = autoQueryableProfile;
         }
 
-        public IClauseQueryFilter GetClauseQueryFilter(string alias)
-            => _clauseQueryFilterMap.GetClauseQueryFilter(alias);
+        public void Init()
+        {
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.Select))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Select, ClauseType.Select, _selectClauseHandler.Handle));    
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.Top))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Top, ClauseType.Top, (value, type, profile) => int.Parse(value)));
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Take, ClauseType.Top, (value, type, profile) => int.Parse(value)));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.Skip))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Skip, ClauseType.Skip, (value, type, profile) => int.Parse(value)));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.First))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.First, ClauseType.First));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.Last))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Last, ClauseType.Last));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.OrderBy))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.OrderBy, ClauseType.OrderBy, _orderByClauseHandler.Handle));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.GroupBy))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.GroupBy, ClauseType.GroupBy));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.Page))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.Page, ClauseType.Page, (value, type, profile) => int.Parse(value)));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.PageSize))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.PageSize, ClauseType.PageSize, (value, type, profile) => int.Parse(value)));
+            }
+            if (_autoQueryableProfile.IsClauseAllowed(ClauseType.WrapWith))
+            {
+                _queryFilters.Add(new DefaultClauseQueryFilter(ClauseAlias.WrapWith, ClauseType.WrapWith, _wrapWithClauseHandler.Handle));
+            }
+        }
 
-        public IClauseQueryFilter GetClauseQueryFilter(ClauseType clauseType) => _clauseQueryFilterMap.GetClauseQueryFilter(clauseType);
+        public IClauseQueryFilter GetClauseQueryFilter(ClauseType clauseType) => _queryFilters.FirstOrDefault(f => f.ClauseType == clauseType);
 
-        public IClauseQueryFilter FindClauseQueryFilter(string queryParameterKey)
-            => _clauseQueryFilterMap.FindClauseQueryFilter(queryParameterKey);
-        private string GetOperandValue(string q, string clauseAlias) => Regex.Split(q, clauseAlias, RegexOptions.IgnoreCase)[1];
+        public IClauseQueryFilter FindClauseQueryFilter(string queryParameterKey) => _queryFilters.FirstOrDefault(clause => queryParameterKey.Contains(clause.Alias.ToLowerInvariant()));
     }
 }

src/AutoQueryable/Core/Clauses/IClauseMapManager.cs

@@ -1,12 +1,11 @@
 using AutoQueryable.Core.Enums;
-using AutoQueryable.Core.Models;
 
 namespace AutoQueryable.Core.Clauses
 {
     public interface IClauseMapManager
     {
+        void Init();
         IClauseQueryFilter FindClauseQueryFilter(string queryParameterKey);
-        IClauseQueryFilter GetClauseQueryFilter(string alias);
         IClauseQueryFilter GetClauseQueryFilter(ClauseType clauseType);
     }
 }

src/AutoQueryable/Core/CriteriaFilters/FilterMaps/StringFilterMapFactory.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Reflection;
 using AutoQueryable.Core.Aliases;