Merge remote-tracking branch 'origin/development' into development

Author: HaikAsatryan

Readme.md

@@ -35,7 +35,7 @@ builder.AddGridify(params Assembly[] assemblies);
 
 ## Usage
 **Creating Mappings for Your Entities:**
-To efficiently filter and query your Book entity using Gridify, you need to create a mapping class that extends GridifyMapper<T>.
+To efficiently filter and query your Book entity using Gridify, you need to create a mapping class that extends FilterMapper<T>.
 This class will define how each property in your Book entity should be mapped.
 
 Here’s an example of how to set up the Book entity and its corresponding mapping class:
@@ -52,7 +52,7 @@ public class Book
     public Book OtherBook { get; set; }
 }
 
-public class BookMapper : GridifyMapper<Book>
+public class BookMapper : FilterMapper<Book>
 {
     public BookMapper()
     {

src/GridifyExtensions/Abstractions/IOrderThenBy.cs

@@ -0,0 +1,7 @@
+namespace GridifyExtensions.Abstractions;
+
+public interface IOrderThenBy
+{
+    IOrderThenBy ThenBy(string column);
+    IOrderThenBy ThenByDescending(string column);
+}

src/GridifyExtensions/Extensions/QueryableExtensions.cs

@@ -2,6 +2,7 @@
 using GridifyExtensions.Enums;
 using GridifyExtensions.Models;
 using Microsoft.EntityFrameworkCore;
+using System.Collections;
 using System.Linq.Expressions;
 
 namespace GridifyExtensions.Extensions;
@@ -15,7 +16,9 @@ public static async Task<PagedResponse<TDto>> FilterOrderAndGetPagedAsync<TEntit
         Expression<Func<TEntity, TDto>> selectExpression, CancellationToken cancellationToken = default)
         where TEntity : class
     {
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
+        
+        model.OrderBy ??= mapper!.GetDefaultOrderExpression();
 
         query = query.ApplyFilteringAndOrdering(model, mapper);
 
@@ -37,15 +40,17 @@ public static Task<PagedResponse<TEntity>> FilterOrderAndGetPagedAsync<TEntity>(
     public static IQueryable<TEntity> ApplyFilter<TEntity>(this IQueryable<TEntity> query, GridifyQueryModel model)
         where TEntity : class
     {
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
 
         return query.AsNoTracking().ApplyFiltering(model, mapper);
     }
 
     public static IQueryable<TEntity> ApplyOrder<TEntity>(this IQueryable<TEntity> query, GridifyQueryModel model)
         where TEntity : class
     {
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
+
+        model.OrderBy ??= mapper!.GetDefaultOrderExpression();
 
         return query.AsNoTracking().ApplyOrdering(model, mapper);
     }
@@ -66,10 +71,25 @@ public static async Task<PagedResponse<object>> ColumnDistinctValuesAsync<TEntit
         ColumnDistinctValueQueryModel model, Func<byte[], string>? decryptor = default,
         CancellationToken cancellationToken = default)
     {
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
 
-        if (!model.Encrypted)
+        if (!mapper!.IsEncrypted(model.PropertyName))
         {
+            if (mapper!.IsArray(model.PropertyName))
+            {
+
+                var data = await query.ApplyFiltering(model, mapper)
+                                      .ApplySelect(model.PropertyName, mapper)
+                                      .ToArrayAsync(cancellationToken);
+
+                var result = data.SelectMany(item => ((IList)item).Cast<object>())
+                                 .Distinct()
+                                 .OrderBy(x => x)
+                                 .ToList();
+
+                return new PagedResponse<object>(result, model.Page, model.PageSize, result.Count);
+            }
+
             return await query
                 .ApplyFiltering(model, mapper)
                 .ApplySelect(model.PropertyName, mapper)
@@ -92,40 +112,31 @@ public static async Task<PagedResponse<object>> ColumnDistinctValuesAsync<TEntit
         return new PagedResponse<object>([decryptedItem], 1, 1, 1);
     }
 
-    private static Expression<Func<T, object>> CreateSelector<T>(string propertyName)
-    {
-        var parameter = Expression.Parameter(typeof(T), "x");
-        var property = Expression.Property(parameter, propertyName);
-        var converted = Expression.Convert(property, typeof(object));
-
-        return Expression.Lambda<Func<T, object>>(converted, parameter);
-    }
-
     public static async Task<object> AggregateAsync<TEntity>(this IQueryable<TEntity> query,
-        AggregateQueryModel model,
-        CancellationToken cancellationToken = default)
-        where TEntity : class
+      AggregateQueryModel model,
+      CancellationToken cancellationToken = default)
+      where TEntity : class
     {
         var aggregateProperty = model.PropertyName;
 
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
 
-        var query2 = query.ApplyFiltering(model, mapper).ApplySelect(aggregateProperty, mapper);
+        var filteredQuery = query.ApplyFiltering(model, mapper).ApplySelect(aggregateProperty, mapper);
 
         return model.AggregateType switch
         {
-            AggregateType.UniqueCount => await query2.Distinct().CountAsync(cancellationToken),
-            AggregateType.Sum => await query2.SumAsync(x => (decimal)x, cancellationToken),
-            AggregateType.Average => await query2.AverageAsync(x => (decimal)x, cancellationToken),
-            AggregateType.Min => await query2.MinAsync(cancellationToken),
-            AggregateType.Max => await query2.MaxAsync(cancellationToken),
+            AggregateType.UniqueCount => await filteredQuery.Distinct().CountAsync(cancellationToken),
+            AggregateType.Sum => await filteredQuery.SumAsync(x => (decimal)x, cancellationToken),
+            AggregateType.Average => await filteredQuery.AverageAsync(x => (decimal)x, cancellationToken),
+            AggregateType.Min => await filteredQuery.MinAsync(cancellationToken),
+            AggregateType.Max => await filteredQuery.MaxAsync(cancellationToken),
             _ => throw new NotImplementedException(),
         };
     }
 
     public static IEnumerable<MappingModel> GetMappings<TEntity>()
     {
-        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as GridifyMapper<TEntity>;
+        var mapper = EntityGridifyMapperByType[typeof(TEntity)] as FilterMapper<TEntity>;
 
         return mapper!.GetCurrentMaps().Select(x => new MappingModel
         {
@@ -138,4 +149,13 @@ public static IEnumerable<MappingModel> GetMappings<TEntity>()
                     : x.To.Body.Type.Name,
         });
     }
+
+    private static Expression<Func<T, object>> CreateSelector<T>(string propertyName)
+    {
+        var parameter = Expression.Parameter(typeof(T), "x");
+        var property = Expression.Property(parameter, propertyName);
+        var converted = Expression.Convert(property, typeof(object));
+
+        return Expression.Lambda<Func<T, object>>(converted, parameter);
+    }
 }

src/GridifyExtensions/Extensions/WebApplicationBuilderExtensions.cs

@@ -1,4 +1,5 @@
 using Gridify;
+using GridifyExtensions.Models;
 using Microsoft.AspNetCore.Builder;
 using System.Reflection;
 
@@ -22,7 +23,7 @@ public static WebApplicationBuilder AddGridify(this WebApplicationBuilder builde
                                                            && !t.IsAbstract
                                                             && t.BaseType != null
                                                             && t.BaseType.IsGenericType
-                                                            && t.BaseType.GetGenericTypeDefinition() == typeof(GridifyMapper<>))
+                                                            && t.BaseType.GetGenericTypeDefinition() == typeof(FilterMapper<>))
                                                    .Select(x => new KeyValuePair<Type, object>(x.BaseType!.GetGenericArguments()[0], Activator.CreateInstance(x)!)))
                                                    .ToDictionary(x => x.Key, x => x.Value);
 

src/GridifyExtensions/GridifyExtensions.csproj

@@ -8,13 +8,13 @@
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
         <Authors>Pandatech</Authors>
         <Copyright>MIT</Copyright>
-        <Version>1.1.0</Version>
+        <Version>1.3.0</Version>
         <PackageId>Pandatech.GridifyExtensions</PackageId>
         <Title>Pandatech.Gridify.Extensions</Title>
         <PackageTags>Pandatech, library, Gridify, Pagination, Filters</PackageTags>
         <Description>Pandatech.Gridify.Extensions simplifies and extends the functionality of the Gridify NuGet package. It provides additional extension methods and functionality to streamline data filtering and pagination, making it more intuitive and powerful to use in .NET applications. Our enhancements ensure more flexibility, reduce boilerplate code, and improve overall developer productivity when working with Gridify.</Description>
         <RepositoryUrl>https://github.com/PandaTechAM/be-lib-gridify-extensions</RepositoryUrl>
-        <PackageReleaseNotes>Stable release</PackageReleaseNotes>
+        <PackageReleaseNotes>Ability to set default ordering using fluent API.</PackageReleaseNotes>
     </PropertyGroup>
 
     <ItemGroup>

src/GridifyExtensions/Models/ColumnDistinctValueQueryModel.cs

@@ -3,5 +3,4 @@
 public class ColumnDistinctValueQueryModel : GridifyQueryModel
 {
     public required string PropertyName { get; set; }
-    public bool Encrypted { get; set; } = false;
 }

src/GridifyExtensions/Models/FilterMapper.cs

@@ -0,0 +1,87 @@
+using Gridify;
+using GridifyExtensions.Abstractions;
+using System.Linq.Expressions;
+
+namespace GridifyExtensions.Models;
+
+
+public class FilterMapper<T> : GridifyMapper<T>, IOrderThenBy
+{
+    internal const string Desc = " desc";
+    internal const string Separator = ", ";
+
+    private string _defaultOrderExpression = string.Empty;
+    private readonly HashSet<string> _encryptedColumns = [];
+    private readonly HashSet<string> _arrayColumns = [];
+
+    internal bool IsArray(string column) => _arrayColumns.Contains(column);
+    internal bool IsEncrypted(string column) => _encryptedColumns.Contains(column);
+
+    internal string GetDefaultOrderExpression() => _defaultOrderExpression;
+
+    public IOrderThenBy AddDefaultOrderBy(string column)
+    {
+        _defaultOrderExpression = column;
+        return this;
+    }
+
+    public IOrderThenBy AddDefaultOrderByDescending(string column)
+    {
+        _defaultOrderExpression = column + Desc;
+        return this;
+    }
+
+    IOrderThenBy IOrderThenBy.ThenBy(string column)
+    {
+        _defaultOrderExpression += Separator + column;
+
+        return this;
+    }
+
+    IOrderThenBy IOrderThenBy.ThenByDescending(string column)
+    {
+        _defaultOrderExpression += Separator + column + Desc;
+
+        return this;
+    }
+
+    public IGridifyMapper<T> AddMap(string from,
+                                        Expression<Func<T, object?>> to,
+                                        Func<string, object>? convertor = null,
+                                        bool overrideIfExists = true,
+                                        bool isEncrypted = false,
+                                        bool isArray = false)
+    {
+        if (isEncrypted)
+        {
+            _encryptedColumns.Add(from);
+        }
+
+        if (isArray)
+        {
+            _arrayColumns.Add(from);
+        }
+
+        return base.AddMap(from, to, convertor, overrideIfExists);
+    }
+
+    public IGridifyMapper<T> AddMap(string from,
+        Expression<Func<T, int, object?>> to,
+        Func<string, object>? convertor = null,
+        bool overrideIfExists = true,
+        bool isEncrypted = false,
+        bool isArray = false)
+    {
+        if (isEncrypted)
+        {
+            _encryptedColumns.Add(from);
+        }
+
+        if (isArray)
+        {
+            _arrayColumns.Add(from);
+        }
+
+        return base.AddMap(from, to, convertor, overrideIfExists);
+    }
+}