Code polishing

Author: jcoitino

NorthwindCRUD/Program.cs

@@ -43,9 +43,6 @@ public static void Main(string[] args)
             {
                 options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
                 options.SerializerSettings.Converters.Add(new StringEnumConverter());
-                options.SerializerSettings.Converters.Add(new QueryConverter());
-                options.SerializerSettings.Converters.Add(new QueryFilterConverter());
-                options.SerializerSettings.Converters.Add(new QueryFilterConditionConverter());
             });
 
             builder.Services.AddEndpointsApiExplorer();

NorthwindCRUD/QueryBuilder/Model/FilterType.cs

@@ -0,0 +1,7 @@
+namespace QueryBuilder;
+
+public enum FilterType
+{
+    And = 0,
+    Or = 1,
+}

NorthwindCRUD/QueryBuilder/Model/Query.cs

@@ -0,0 +1,12 @@
+namespace QueryBuilder;
+
+public class Query
+{
+    public string Entity { get; set; }
+
+    public string[] ReturnFields { get; set; }
+
+    public FilterType Operator { get; set; }
+
+    public QueryFilter[] FilteringOperands { get; set; }
+}

NorthwindCRUD/QueryBuilder/Model/QueryFilter.cs

@@ -0,0 +1,20 @@
+namespace QueryBuilder;
+
+public class QueryFilter
+{
+    // Basic condition
+    public string? FieldName { get; set; }
+
+    public bool? IgnoreCase { get; set; }
+
+    public QueryFilterCondition? Condition { get; set; }
+
+    public object? SearchVal { get; set; }
+
+    public Query? SearchTree { get; set; }
+
+    // And/Or
+    public FilterType? Operator { get; set; }
+
+    public QueryFilter[] FilteringOperands { get; set; }
+}

NorthwindCRUD/QueryBuilder/Model/QueryFilterCondition.cs

@@ -0,0 +1,10 @@
+namespace QueryBuilder;
+
+public class QueryFilterCondition
+{
+    public string Name { get; set; }
+
+    public bool IsUnary { get; set; }
+
+    public string IconName { get; set; }
+}

…rthwindCRUD/Controllers/QueryExecutor.cs …thwindCRUD/QueryBuilder/QueryExecutor.csNorthwindCRUD/Controllers/QueryExecutor.cs renamed to NorthwindCRUD/QueryBuilder/QueryExecutor.cs NorthwindCRUD/Controllers/QueryExecutor.cs renamed to NorthwindCRUD/QueryBuilder/QueryExecutor.cs

@@ -7,125 +7,17 @@
 using AutoMapper.Internal;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
-using Newtonsoft.Json;
 using NorthwindCRUD;
 using Swashbuckle.AspNetCore.SwaggerGen;
 
-public enum FilterType
-{
-    And = 0,
-    Or = 1,
-}
-
-public interface IQuery
-{
-    public string Entity { get; set; }
-
-    public string[] ReturnFields { get; set; }
-
-    [SuppressMessage("Naming", "CA1716:Identifiers should not match keywords", Justification = "required name")]
-    public FilterType Operator { get; set; }
-
-    public IQueryFilter[] FilteringOperands { get; set; }
-}
-
-public interface IQueryFilter
-{
-    // Basic condition
-    public string? FieldName { get; set; }
-
-    public bool? IgnoreCase { get; set; }
-
-    public IQueryFilterCondition? Condition { get; set; }
-
-    public object? SearchVal { get; set; }
-
-    public IQuery? SearchTree { get; set; }
-
-    // And/Or
-    [SuppressMessage("Naming", "CA1716:Identifiers should not match keywords", Justification = "required name")]
-    public FilterType? Operator { get; set; }
-
-    public IQueryFilter[] FilteringOperands { get; set; }
-}
-
-public interface IQueryFilterCondition
-{
-    public string Name { get; set; }
-
-    public bool IsUnary { get; set; }
-
-    public string IconName { get; set; }
-}
-
-public class Query : IQuery
-{
-    public string Entity { get; set; }
-
-    public string[] ReturnFields { get; set; }
-
-    public FilterType Operator { get; set; }
-
-    public IQueryFilter[] FilteringOperands { get; set; }
-}
-
-public class QueryFilter : IQueryFilter
-{
-    // Basic condition
-    public string? FieldName { get; set; }
-
-    public bool? IgnoreCase { get; set; }
-
-    public IQueryFilterCondition? Condition { get; set; }
-
-    public object? SearchVal { get; set; }
-
-    public IQuery? SearchTree { get; set; }
-
-    // And/Or
-    public FilterType? Operator { get; set; }
-
-    public IQueryFilter[] FilteringOperands { get; set; }
-}
-
-public class QueryFilterCondition : IQueryFilterCondition
-{
-    public string Name { get; set; }
-
-    public bool IsUnary { get; set; }
-
-    public string IconName { get; set; }
-}
-
-public abstract class InterfaceToConcreteClassConverter<TI, TC> : JsonConverter
-{
-    public override bool CanConvert(Type objectType) => objectType == typeof(TI);
-
-    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer) => serializer.Deserialize<TC>(reader);
-
-    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer) => serializer.Serialize(writer, value);
-
-}
-
-public class QueryConverter : InterfaceToConcreteClassConverter<IQuery, Query>
-{
-}
-
-public class QueryFilterConverter : InterfaceToConcreteClassConverter<IQueryFilter, QueryFilter>
-{
-}
-
-public class QueryFilterConditionConverter : InterfaceToConcreteClassConverter<IQueryFilterCondition, QueryFilterCondition>
-{
-}
-
 /// <summary>
 /// A generic query executor that can be used to execute queries on IQueryable data sources.
 /// </summary>
 [SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1009:Closing parenthesis should be spaced correctly", Justification = "...")]
+[SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1025:Code should not contain multiple whitespace in a row", Justification = "...")]
 public static class QueryExecutor
 {
-    public static TEntity[] Run<TEntity>(this IQueryable<TEntity> source, IQuery? query)
+    public static TEntity[] Run<TEntity>(this IQueryable<TEntity> source, Query? query)
     {
         var infrastructure = source as IInfrastructure<IServiceProvider>;
         var serviceProvider = infrastructure!.Instance;
@@ -134,7 +26,7 @@ public static TEntity[] Run<TEntity>(this IQueryable<TEntity> source, IQuery? qu
         return db is not null ? BuildQuery(db, source, query).ToArray() : Array.Empty<TEntity>();
     }
 
-    private static IQueryable<TEntity> BuildQuery<TEntity>(DataContext db, IQueryable<TEntity> source, IQuery? query)
+    private static IQueryable<TEntity> BuildQuery<TEntity>(DataContext db, IQueryable<TEntity> source, Query? query)
     {
         if (query is null)
         {
@@ -154,7 +46,7 @@ private static IQueryable<TEntity> BuildQuery<TEntity>(DataContext db, IQueryabl
         }
     }
 
-    private static Expression<Func<TEntity, bool>> BuildExpression<TEntity>(DataContext db, IQueryable<TEntity> source, IQueryFilter[] filters, FilterType filterType)
+    private static Expression<Func<TEntity, bool>> BuildExpression<TEntity>(DataContext db, IQueryable<TEntity> source, QueryFilter[] filters, FilterType filterType)
     {
         var parameter = Expression.Parameter(typeof(TEntity), "entity");
         var finalExpression = null as Expression;
@@ -178,7 +70,7 @@ private static Expression<Func<TEntity, bool>> BuildExpression<TEntity>(DataCont
                 : (TEntity _) => true;
     }
 
-    private static Expression BuildConditionExpression<TEntity>(DataContext db, IQueryable<TEntity> source, IQueryFilter filter, ParameterExpression parameter)
+    private static Expression BuildConditionExpression<TEntity>(DataContext db, IQueryable<TEntity> source, QueryFilter filter, ParameterExpression parameter)
     {
         if (filter.FieldName is not null && filter.IgnoreCase is not null && filter.Condition is not null)
         {
@@ -190,26 +82,26 @@ private static Expression BuildConditionExpression<TEntity>(DataContext db, IQue
             var emptyValue = GetEmptyValue(targetType);
             Expression condition = filter.Condition.Name switch
             {
-                "null" => targetType.IsNullableType() ? Expression.Equal(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(false),
-                "notNull" => targetType.IsNullableType() ? Expression.NotEqual(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(true),
-                "empty" => Expression.Or(Expression.Equal(field, emptyValue), targetType.IsNullableType() ? Expression.Equal(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(false)),
-                "notEmpty" => Expression.And(Expression.NotEqual(field, emptyValue), targetType.IsNullableType() ? Expression.NotEqual(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(true)),
-                "equals" => Expression.Equal(field, searchValue),
-                "doesNotEqual" => Expression.NotEqual(field, searchValue),
-                "in" => BuildInExpression(db, filter.SearchTree, field),
-                "notIn" => Expression.Not(BuildInExpression(db, filter.SearchTree, field)),
-                "contains" => Expression.Call(field, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, searchValue),
-                "doesNotContain" => Expression.Not(Expression.Call(field, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, searchValue)),
-                "startsWith" => Expression.Call(field, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, searchValue),
-                "endsWith" => Expression.Call(field, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, searchValue),
-                "greaterThan" => Expression.GreaterThan(field, searchValue),
-                "lessThan" => Expression.LessThan(field, searchValue),
-                "greaterThanOrEqualTo" => Expression.GreaterThanOrEqual(field, searchValue),
-                "lessThanOrEqualTo" => Expression.LessThanOrEqual(field, searchValue),
-                "all" => throw new NotImplementedException("Not implemented"),
-                "true" => Expression.IsTrue(field),
-                "false" => Expression.IsFalse(field),
-                _ => throw new NotImplementedException("Not implemented"),
+                "null"                  => targetType.IsNullableType() ? Expression.Equal(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(false),
+                "notNull"               => targetType.IsNullableType() ? Expression.NotEqual(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(true),
+                "empty"                 => Expression.Or(Expression.Equal(field, emptyValue), targetType.IsNullableType() ? Expression.Equal(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(false)),
+                "notEmpty"              => Expression.And(Expression.NotEqual(field, emptyValue), targetType.IsNullableType() ? Expression.NotEqual(field, Expression.Constant(targetType.GetDefaultValue())) : Expression.Constant(true)),
+                "equals"                => Expression.Equal(field, searchValue),
+                "doesNotEqual"          => Expression.NotEqual(field, searchValue),
+                "in"                    => BuildInExpression(db, filter.SearchTree, field),
+                "notIn"                 => Expression.Not(BuildInExpression(db, filter.SearchTree, field)),
+                "contains"              => Expression.Call(field, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, searchValue),
+                "doesNotContain"        => Expression.Not(Expression.Call(field, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, searchValue)),
+                "startsWith"            => Expression.Call(field, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, searchValue),
+                "endsWith"              => Expression.Call(field, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, searchValue),
+                "greaterThan"           => Expression.GreaterThan(field, searchValue),
+                "lessThan"              => Expression.LessThan(field, searchValue),
+                "greaterThanOrEqualTo"  => Expression.GreaterThanOrEqual(field, searchValue),
+                "lessThanOrEqualTo"     => Expression.LessThanOrEqual(field, searchValue),
+                "all"                   => throw new NotImplementedException("Not implemented"),
+                "true"                  => Expression.IsTrue(field),
+                "false"                 => Expression.IsFalse(field),
+                _                       => throw new NotImplementedException("Not implemented"),
             };
             if (filter.IgnoreCase.Value && field.Type == typeof(string))
             {
@@ -232,7 +124,7 @@ private static Expression BuildConditionExpression<TEntity>(DataContext db, IQue
         }
     }
 
-    private static Expression BuildInExpression(DataContext db, IQuery? query, MemberExpression field)
+    private static Expression BuildInExpression(DataContext db, Query? query, MemberExpression field)
     {
         if (field.Type == typeof(string))
         {
@@ -270,40 +162,28 @@ private static Expression BuildInExpression(DataContext db, IQuery? query, Membe
         }
     }
 
-    private static IEnumerable<dynamic> RunSubquery(DataContext db, IQuery? query)
+    private static IEnumerable<dynamic> RunSubquery(DataContext db, Query? query)
     {
         // var t = query?.Entity.ToLower(CultureInfo.InvariantCulture);
         // var p = db.GetType().GetProperty(t, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) ?? throw new InvalidOperationException($"Property '{t}' not found on type '{db.GetType()}'");
         // var q = p.GetValue(db) as IQueryable<dynamic>;
         // return q is null ? Array.Empty<dynamic>() : q.Run(query).ToArray();
         var t = query?.Entity.ToLower(CultureInfo.InvariantCulture) ?? string.Empty;
-        switch (t)
-        {
-            case "addresses":
-                return db.Suppliers.Run(query).ToArray();
-            case "categories":
-                return db.Categories.Run(query).ToArray();
-            case "products":
-                return db.Products.Run(query).ToArray();
-            case "regions":
-                return db.Regions.Run(query).ToArray();
-            case "territories":
-                return db.Territories.Run(query).ToArray();
-            case "employees":
-                return db.Employees.Run(query).ToArray();
-            case "customers":
-                return db.Customers.Run(query).ToArray();
-            case "orders":
-                return db.Orders.Run(query).ToArray();
-            case "orderdetails":
-                return db.OrderDetails.Run(query).ToArray();
-            case "shippers":
-                return db.Shippers.Run(query).ToArray();
-            case "suppliers":
-                return db.Suppliers.Run(query).ToArray();
-            default:
-                return Array.Empty<dynamic>();
-        }
+        return t switch
+        {
+            "addresses"     => db.Suppliers.Run(query).ToArray(),
+            "categories"    => db.Categories.Run(query).ToArray(),
+            "products"      => db.Products.Run(query).ToArray(),
+            "regions"       => db.Regions.Run(query).ToArray(),
+            "territories"   => db.Territories.Run(query).ToArray(),
+            "employees"     => db.Employees.Run(query).ToArray(),
+            "customers"     => db.Customers.Run(query).ToArray(),
+            "orders"        => db.Orders.Run(query).ToArray(),
+            "orderdetails"  => db.OrderDetails.Run(query).ToArray(),
+            "shippers"      => db.Shippers.Run(query).ToArray(),
+            "suppliers"     => db.Suppliers.Run(query).ToArray(),
+            _               => Array.Empty<dynamic>(),
+        };
     }
 
     private static dynamic? ProjectField(dynamic? obj, string field)
@@ -343,65 +223,3 @@ private static Expression<Func<TEntity, dynamic>> BuildProjectionExpression<TEnt
         return Expression.Lambda<Func<TEntity, dynamic>>(body, parameter);
     }
 }
-
-[SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1025:Code should not contain multiple whitespace in a row", Justification = "...")]
-public static class SqlGenerator
-{
-    public static string GenerateSql(IQuery query)
-    {
-        var selectClause = BuildSelectClause(query);
-        var whereClause  = BuildWhereClause(query.FilteringOperands, query.Operator);
-        return $"{selectClause} {whereClause};";
-    }
-
-    private static string BuildSelectClause(IQuery query)
-    {
-        var fields = query.ReturnFields != null && query.ReturnFields.Any()
-            ? string.Join(", ", query.ReturnFields)
-            : "*";
-        return $"SELECT {fields} FROM {query.Entity}";
-    }
-
-    private static string BuildWhereClause(IQueryFilter[] filters, FilterType filterType)
-    {
-        if (filters == null || !filters.Any())
-        {
-            return string.Empty;
-        }
-
-        var conditions  = filters.Select(BuildCondition).ToArray();
-        var conjunction = filterType == FilterType.And ? " AND " : " OR ";
-        return $"WHERE {string.Join(conjunction, conditions)}";
-    }
-
-    private static string BuildCondition(IQueryFilter filter)
-    {
-        var field     = filter.FieldName;
-        var condition = filter.Condition?.Name;
-        var value     = filter.SearchVal != null ? $"'{filter.SearchVal}'" : "NULL";
-        var subquery  = filter.SearchTree != null ? $"({GenerateSql(filter.SearchTree)})" : string.Empty;
-        return condition switch
-        {
-            "null"                 => $"{field} IS NULL",
-            "notNull"              => $"{field} IS NOT NULL",
-            "empty"                => $"{field} = ''",
-            "notEmpty"             => $"{field} <> ''",
-            "equals"               => $"{field} = {value}",
-            "doesNotEqual"         => $"{field} <> {value}",
-            "in"                   => $"{field} IN ({subquery})",
-            "notIn"                => $"{field} NOT IN ({subquery})",
-            "contains"             => $"{field} LIKE '%{filter.SearchVal}%'",
-            "doesNotContain"       => $"{field} NOT LIKE '%{filter.SearchVal}%'",
-            "startsWith"           => $"{field} LIKE '{filter.SearchVal}%'",
-            "endsWith"             => $"{field} LIKE '%{filter.SearchVal}'",
-            "greaterThan"          => $"{field} > {value}",
-            "lessThan"             => $"{field} < {value}",
-            "greaterThanOrEqualTo" => $"{field} >= {value}",
-            "lessThanOrEqualTo"    => $"{field} <= {value}",
-            "all"                  => throw new NotImplementedException("Not implemented"),
-            "true"                 => $"{field} = TRUE",
-            "false"                => $"{field} = FALSE",
-            _                      => throw new NotImplementedException($"Condition '{condition}' is not implemented"),
-        };
-    }
-}