Query filter

Author: ddidgdimitrov-infragistics

Filter/QueryFilterConverter.cs

@@ -0,0 +1,17 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Infragistics.QueryBuilder.Executor.Filter
+{
+    internal class QueryFilterConverter : System.Text.Json.Serialization.JsonConverter<QueryFilter>
+    {
+        public override QueryFilter Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            using var doc = JsonDocument.ParseValue(ref reader);
+            return System.Text.Json.JsonSerializer.Deserialize<QueryFilter>(doc.RootElement.GetRawText(), options)!;
+        }
+
+        public override void Write(Utf8JsonWriter writer, QueryFilter value, JsonSerializerOptions options)
+            => System.Text.Json.JsonSerializer.Serialize(writer, (object)value, value.GetType(), options);
+    }
+}

Infragistics.QueryBuilder.Executor.csproj

@@ -28,6 +28,7 @@
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="14.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.4" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="8.1.1" />
     <None Include="IgniteUI.png" Pack="true" PackagePath="" />
         <None Include="ReadMe.md">

Model/QueryFilter.cs

@@ -2,7 +2,7 @@
 
 namespace Infragistics.QueryBuilder.Executor
 {
-    public class QueryFilter
+    public abstract class QueryFilter
     {
         // Basic condition
         public string? FieldName { get; set; }
@@ -20,4 +20,8 @@ public class QueryFilter
 
         public QueryFilter[] FilteringOperands { get; set; }
     }
+
+    public class FilteringExpressionsTree : QueryFilter { }
+
+    public class FilteringExpression : QueryFilter { }
 }

QueryExecutorExtensions.cs

@@ -1,34 +1,158 @@
-using Microsoft.AspNetCore.Builder;
+using System;
+using System.IO;
+using System.Text.Json.Nodes; // for JsonValue
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace Infragistics.QueryBuilder.Executor
 {
     public static class QueryExecutorExtensions
     {
-        public static IServiceCollection AddQueryBuilder<TMyDbContext, TResults>(this IServiceCollection services) where TResults : class
+        public static IServiceCollection AddQueryBuilder<TMyDbContext, TResults>(this IServiceCollection services)
+            where TResults : class
         {
             services.AddScoped<QueryBuilderService<TMyDbContext, TResults>>();
             return services;
         }
 
-        public static IEndpointRouteBuilder UseQueryBuilder<TMyDbContext, TResults>(this IEndpointRouteBuilder endpoints, string path) where TMyDbContext : class where TResults : class
+        public static IEndpointRouteBuilder UseQueryBuilder<TMyDbContext, TResults>(
+            this IEndpointRouteBuilder endpoints, string path)
+            where TMyDbContext : class
+            where TResults : class
         {
-            endpoints.MapPost(path, ([FromBody] Query query, QueryBuilderService<TMyDbContext, TResults> queryBuilderService) =>
+            endpoints.MapPost(path, async (HttpContext ctx, QueryBuilderService<TMyDbContext, TResults> svc) =>
             {
-                if (query != null)
+                string json;
+                using (var sr = new StreamReader(ctx.Request.Body))
                 {
-                    var result = queryBuilderService.RunQuery(query);
-                    return Results.Ok(result);
+                    json = await sr.ReadToEndAsync();
                 }
-                else
+
+                var settings = new Newtonsoft.Json.JsonSerializerSettings
                 {
+                    DateParseHandling = Newtonsoft.Json.DateParseHandling.None,
+                    ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore,
+                };
+
+                // 1) Convert QueryFilter by shape (tree vs leaf)
+                settings.Converters.Add(new QueryFilterCreationConverter());
+                // 2) Let Newtonsoft write primitives (number/string/bool) into System.Text.Json.Nodes.JsonValue
+                settings.Converters.Add(new NewtonsoftJsonValueConverter());
+
+                var query = Newtonsoft.Json.JsonConvert.DeserializeObject<Query>(json, settings);
+                if (query is null)
                     return Results.BadRequest("Wrong or missing query");
-                }
-            }).WithTags(["QueryBuilder"]).Accepts<Query>("application/json").Produces<TResults>();
+
+                var result = svc.RunQuery(query);
+                return Results.Ok(result);
+            })
+            .WithTags(["QueryBuilder"])
+            .Accepts<Query>("application/json")
+            .Produces<TResults>();
+
             return endpoints;
         }
     }
-}
+
+    /// <summary>
+    /// Resolves QueryFilter to the only concrete types available:
+    /// - FilteringExpressionsTree (has "filteringOperands")
+    /// - FilteringExpression      (leaf)
+    /// </summary>
+    file sealed class QueryFilterCreationConverter : Newtonsoft.Json.JsonConverter
+    {
+        private static readonly Type BaseType = typeof(QueryFilter);
+        private static readonly Type TreeType = typeof(FilteringExpressionsTree);
+        private static readonly Type LeafType = typeof(FilteringExpression);
+
+        public override bool CanConvert(Type objectType) => objectType == BaseType;
+
+        public override object ReadJson(
+            Newtonsoft.Json.JsonReader reader,
+            Type objectType,
+            object? existingValue,
+            Newtonsoft.Json.JsonSerializer serializer)
+        {
+            var jo = JObject.Load(reader);
+
+            // Tree if it has an array "filteringOperands"; otherwise leaf
+            var isTree = jo["filteringOperands"] is JArray;
+            var target = isTree ? TreeType : LeafType;
+
+            return jo.ToObject(target, serializer)!;
+        }
+
+        public override void WriteJson(
+            Newtonsoft.Json.JsonWriter writer,
+            object? value,
+            Newtonsoft.Json.JsonSerializer serializer)
+        {
+            serializer.Serialize(writer, value);
+        }
+    }
+
+    /// <summary>
+    /// Newtonsoft -> System.Text.Json.Nodes.JsonValue bridge.
+    /// Handles primitives and null (which is all your payload needs for "searchVal": 10253).
+    /// </summary>
+    file sealed class NewtonsoftJsonValueConverter : Newtonsoft.Json.JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+            => objectType == typeof(JsonValue);
+
+        public override object? ReadJson(
+            Newtonsoft.Json.JsonReader reader,
+            Type objectType,
+            object? existingValue,
+            Newtonsoft.Json.JsonSerializer serializer)
+        {
+            if (reader.TokenType == Newtonsoft.Json.JsonToken.Null)
+                return null;
+
+            // Extract the raw .NET value from Newtonsoft token
+            var token = JToken.ReadFrom(reader);
+
+            // For numbers/bools/strings, token.ToObject<object>() is a primitive -> wrap it
+            // For safety, we only support primitives here since JsonValue is a primitive wrapper.
+            // (Your payload uses numbers/strings/null for searchVal.)
+            var primitive = token.Type switch
+            {
+                JTokenType.Integer => (object)token.ToObject<long>()!,
+                JTokenType.Float => token.ToObject<double>()!,
+                JTokenType.Boolean => token.ToObject<bool>()!,
+                JTokenType.String => token.ToObject<string>()!,
+                JTokenType.Null => null!,
+                _ => throw new NotSupportedException(
+                        $"JsonValue converter only supports primitives. Got {token.Type}.")
+            };
+
+            return primitive is null ? null : JsonValue.Create(primitive);
+        }
+
+        public override void WriteJson(
+            Newtonsoft.Json.JsonWriter writer,
+            object? value,
+            Newtonsoft.Json.JsonSerializer serializer)
+        {
+            if (value is null)
+            {
+                writer.WriteNull();
+                return;
+            }
+
+            var jv = (JsonValue)value;
+            // Extract the underlying primitive and write it as a native JSON value
+            if (jv.TryGetValue(out long l)) { writer.WriteValue(l); return; }
+            if (jv.TryGetValue(out double d)) { writer.WriteValue(d); return; }
+            if (jv.TryGetValue(out bool b)) { writer.WriteValue(b); return; }
+            if (jv.TryGetValue(out string s)) { writer.WriteValue(s); return; }
+
+            // Fallback: write as string representation
+            writer.WriteValue(jv.ToJsonString());
+        }
+    }
+}