(B) Add specification pattern

Clinics.Backend/Persistence/Repositories/Base/Repositroy.cs

@@ -19,6 +19,12 @@ public class Repositroy<TEntity> : IRepository<TEntity> where TEntity : Entity
 
     #endregion
 
+    #region Apply specification
+
+    #endregion
+
+    #region CRUD
+
     #region Create operation
 
     public async Task<TEntity> CreateAsync(TEntity entity)
@@ -66,6 +72,11 @@ public class Repositroy<TEntity> : IRepository<TEntity> where TEntity : Entity
 
     #endregion
 
+    #endregion
+
+
+
+
 
 
 

Clinics.Backend/Persistence/Specifications/Base/Specification.cs

+using Domain.Primitives;
+using System.Linq.Expressions;
+
+namespace Persistence.Specifications.Base;
+
+public abstract class Specification<TEntity> where TEntity : Entity
+{
+    protected Specification(Expression<Func<TEntity, bool>>? criteria)
+    {
+        Criteria = criteria;
+    }
+
+    public Expression<Func<TEntity, bool>>? Criteria { get; }
+
+    public List<Expression<Func<TEntity, object>>> IncludeExpressions { get; } = new();
+
+    public Expression<Func<TEntity, object>>? OrderByExpression { get; private set; }
+    public Expression<Func<TEntity, object>>? OrderByDescendingExpression { get; private set; }
+
+    protected void AddInclude(Expression<Func<TEntity, object>> includeExpression)
+    {
+        IncludeExpressions.Add(includeExpression);
+    }
+
+    protected void AddOrderBy(Expression<Func<TEntity, object>> orderByExpression)
+    {
+        OrderByExpression = orderByExpression;
+    }
+
+    protected void AddOrderByDescending(Expression<Func<TEntity, object>> orderByDescendingExpression)
+    {
+        OrderByDescendingExpression = orderByDescendingExpression;
+    }
+
+
+}

Clinics.Backend/Persistence/Specifications/Evaluator/SpecificationEvaluator.cs

+using Domain.Primitives;
+using Microsoft.EntityFrameworkCore;
+using Persistence.Specifications.Base;
+
+namespace Persistence.Specifications.Evaluator;
+
+public static class SpecificationEvaluator
+{
+    public static IQueryable<TEntity> GetQuery<TEntity>(
+        IQueryable<TEntity> inputQueryable,
+        Specification<TEntity> specification)
+        where TEntity : Entity
+    {
+        IQueryable<TEntity> queryable = inputQueryable;
+
+        if (specification.Criteria is not null)
+        {
+            queryable = queryable.Where(specification.Criteria);
+        }
+
+        specification.IncludeExpressions.Aggregate(
+            queryable,
+            (current, includeExpression) =>
+                current.Include(includeExpression)
+            );
+
+        if (specification.OrderByExpression is not null)
+        {
+            queryable = queryable.OrderBy(specification.OrderByExpression);
+        }
+
+        if (specification.OrderByDescendingExpression is not null)
+        {
+            queryable = queryable.OrderByDescending(specification.OrderByDescendingExpression);
+        }
+
+        return queryable;
+    }
+}