mega cleanup :D

Svrnty.CQRS.DynamicQuery/Discover/DynamicQueryMeta.cs

@@ -4,14 +4,10 @@ using Svrnty.CQRS.Abstractions.Discovery;
 
 namespace Svrnty.CQRS.DynamicQuery.Discover;
 
-public class DynamicQueryMeta : QueryMeta
+public class DynamicQueryMeta(Type queryType, Type serviceType, Type queryResultType)
+  : QueryMeta(queryType, serviceType, queryResultType)
 {
-    public DynamicQueryMeta(Type queryType, Type serviceType, Type queryResultType) : base(queryType, serviceType, queryResultType)
-    {
-
-    }
-
-    public Type SourceType => QueryType.GetGenericArguments()[0];
+  public Type SourceType => QueryType.GetGenericArguments()[0];
     public Type DestinationType => QueryType.GetGenericArguments()[1];
     public override string Category => "DynamicQuery";
     public override string Name

Svrnty.CQRS.DynamicQuery/DynamicQuery.cs

@@ -0,0 +1,68 @@
+using System.Collections.Generic;
+using System.Linq;
+using Svrnty.CQRS.DynamicQuery.Abstractions;
+using PoweredSoft.DynamicQuery;
+using PoweredSoft.DynamicQuery.Core;
+
+namespace Svrnty.CQRS.DynamicQuery;
+
+public class DynamicQuery<TSource, TDestination> : DynamicQuery, IDynamicQuery<TSource, TDestination>
+        where TSource : class
+        where TDestination : class
+{
+
+}
+
+public class DynamicQuery<TSource, TDestination, TParams> : DynamicQuery, IDynamicQuery<TSource, TDestination, TParams>
+    where TSource : class
+    where TDestination : class
+    where TParams : class
+{
+    public TParams Params { get; set; }
+
+    public TParams GetParams()
+    {
+        return Params;
+    }
+}
+
+public class DynamicQuery : IDynamicQuery
+{
+    public int? Page { get; set; }
+    public int? PageSize { get; set; }
+    public List<Sort> Sorts { get; set; }
+    public List<DynamicQueryAggregate> Aggregates { get; set; }
+    public List<Group> Groups { get; set; }
+    public List<DynamicQueryFilter> Filters { get; set; }
+
+
+    public List<IAggregate> GetAggregates()
+    {
+        return Aggregates?.Select(t => t.ToAggregate())?.ToList();//.AsEnumerable<IAggregate>()?.ToList();
+    }
+
+    public List<IFilter> GetFilters()
+    {
+        return Filters?.Select(t => t.ToFilter())?.ToList();
+    }
+
+    public List<IGroup> GetGroups()
+    {
+        return this.Groups?.AsEnumerable<IGroup>()?.ToList();
+    }
+
+    public int? GetPage()
+    {
+        return this.Page;
+    }
+
+    public int? GetPageSize()
+    {
+        return this.PageSize;
+    }
+
+    public List<ISort> GetSorts()
+    {
+        return this.Sorts?.AsEnumerable<ISort>()?.ToList();
+    }
+}

Svrnty.CQRS.DynamicQuery/DynamicQueryAggregate.cs

@@ -0,0 +1,21 @@
+using PoweredSoft.DynamicQuery;
+using PoweredSoft.DynamicQuery.Core;
+using System;
+
+namespace Svrnty.CQRS.DynamicQuery;
+
+public class DynamicQueryAggregate
+{
+    public string Path { get; set; }
+    public string Type { get; set; }
+
+    public IAggregate ToAggregate()
+    {
+        return new Aggregate
+        {
+            Type = Enum.Parse<AggregateType>(Type),
+            Path = Path
+        };
+    }
+
+}

Svrnty.CQRS.DynamicQuery/DynamicQueryFilter.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using PoweredSoft.DynamicQuery;
+using PoweredSoft.DynamicQuery.Core;
+
+namespace Svrnty.CQRS.DynamicQuery;
+
+public class DynamicQueryFilter
+{
+    public List<DynamicQueryFilter> Filters { get; set; }
+    public bool? And { get; set; }
+    public string Type { get; set; }
+    public bool? Not { get; set; }
+    public string Path { get; set; }
+    public object Value { get; set; }
+
+    public string QueryValue
+    {
+        get
+        {
+            return null;
+        }
+        set
+        {
+            Value = value;
+        }
+    }
+
+    public bool? CaseInsensitive { get; set; }
+
+    public IFilter ToFilter()
+    {
+        var type = Enum.Parse<FilterType>(Type);
+        if (type == FilterType.Composite)
+        {
+            var compositeFilter = new CompositeFilter
+            {
+                And = And,
+                Type = FilterType.Composite,
+                Filters = Filters?.Select(t => t.ToFilter())?.ToList() ?? new List<IFilter>()
+            };
+            return compositeFilter;
+        }
+
+        object value = Value;
+        if (Value is JsonElement jsonElement)
+        {
+            switch (jsonElement.ValueKind)
+            {
+                case JsonValueKind.String:
+                    value = jsonElement.ToString();
+                    break;
+                case JsonValueKind.Number:
+                    if (jsonElement.ToString().Contains('.'))
+                        value = jsonElement.GetDecimal();
+                    else if (jsonElement.TryGetInt64(out var convertedValue))
+                        value = convertedValue;
+                    break;
+                case JsonValueKind.True:
+                    value = true;
+                    break;
+                case JsonValueKind.False:
+                    value = false;
+                    break;
+                // TODO: Array support
+                default:
+                    value = null;
+                    break;
+            }
+
+        }
+
+        var simpleFilter = new SimpleFilter
+        {
+            And = And,
+            Type = type,
+            Not = Not,
+            Path = Path,
+            Value = value,
+            CaseInsensitive = CaseInsensitive,
+        };
+        return simpleFilter;
+    }
+}