luticate2-api/Luticate2.Auth/Business/Crud/LuEfCrudBusiness.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Luticate2.Auth.Dbo;
using Luticate2.Auth.Dbo.Fields;
using Luticate2.Auth.Dbo.Pagination;
using Luticate2.Auth.Dbo.PartialObjectCopier;
using Luticate2.Auth.Dbo.Result;
using Luticate2.Auth.Interfaces;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace Luticate2.Auth.Business.Crud
{
    public class LuEfCrudBusiness<TDbo, TModel, TDbContext> : ILuCrud<TDbo>
        where TModel : class
        where TDbContext : DbContext
        where TDbo : new()
    {
        protected IServiceProvider ServiceProvider { get; }

        public LuEfCrudBusiness(IServiceProvider serviceProvider)
        {
            ServiceProvider = serviceProvider;
        }

        protected virtual LuResult<TModel> ConvertDboToModel(LuPartialFieldsDbo partialInput, TDbo dbo, TModel model)
        {
            var copier = ServiceProvider.GetService<ILuPartialObjectCopier<TDbo, TModel>>();
            if (copier == null)
            {
                return LuResult<TModel>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuPartialObjectCopier<{typeof(TDbo).Name}, {typeof(TModel).Name}>");
            }
            var result = copier.Copy(partialInput, dbo, model, new LuPartialObjectCopierOptions());
            return result;
        }

        protected virtual LuResult<TDbo> ConvertModelToDbo(LuPartialFieldsDbo partialResponse, TModel model, TDbo dbo)
        {
            var copier = ServiceProvider.GetService<ILuPartialObjectCopier<TModel, TDbo>>();
            if (copier == null)
            {
                return LuResult<TDbo>.Error(LuStatus.InternalError.ToInt(), $"Could not get service: ILuPartialObjectCopier<{typeof(TModel).Name}, {typeof(TDbo).Name}>");
            }
            var result = copier.Copy(partialResponse, model, dbo, new LuPartialObjectCopierOptions());
            return result;
        }

        protected virtual LuResult<T> HandleError<T>(Exception e)
        {
            return LuResult<T>.Error(LuStatus.DbError.ToInt(), e);
        }

        protected LuResult<T> Execute<T>(Func<TDbContext, DbSet<TModel>, LuResult<T>> action)
        {
            try
            {
                using (var db = ServiceProvider.GetService<TDbContext>())
                {
                    return action(db, db.Set<TModel>());
                }
            }
            catch (Exception e)
            {
                var result = HandleError<T>(e);
                return result;
            }
        }

        protected virtual LuResult<IQueryable<TModel>> Include(LuPartialFieldsDbo partialResponse, IQueryable<TModel> queryable)
        {
            return LuResult<IQueryable<TModel>>.Ok(queryable);
        }

        protected virtual LuResult<IQueryable<TModel>> Filter(LuFilterDbo filter, IQueryable<TModel> queryable)
        {
            return LuResult<IQueryable<TModel>>.Ok(queryable.Where((Expression<Func<TModel, bool>>) filter.Expression));
        }

        protected IQueryable<TModel> ConvertAndOrderByQueryable<T>(Expression<Func<TModel, object>> exp,
            LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable, Expression expressionNoConvert)
        {
            var ordered = queryable as IOrderedQueryable<TModel>;
            var expType = expressionNoConvert.Type;
            var type = typeof(T);
            if (type.IsAssignableFrom(expType))
            {
                var expLambda = Expression.Lambda<Func<TModel, T>>(expressionNoConvert, exp.Parameters);
                if (ordered != null)
                {
                    ordered = orderByfield.Asc ? ordered.ThenBy(expLambda) : ordered.ThenByDescending(expLambda);
                }
                else
                {
                    ordered = orderByfield.Asc ? queryable.OrderBy(expLambda) : queryable.OrderByDescending(expLambda);
                }
            }

            return ordered ?? queryable;
        }

        protected virtual LuResult<IQueryable<TModel>> OrderByField(LuOrderByFieldDbo orderByfield, IQueryable<TModel> queryable)
        {
            var expressionBuilder = ServiceProvider.GetService<ILuFieldsExpressions<TDbo, TModel>>();
            var expressionResult = expressionBuilder.GetExpression<TModel>(x => x, orderByfield.Field);
            if (!expressionResult)
            {
                return expressionResult.To<IQueryable<TModel>>();
            }

            var expression = expressionResult.Data;
            var expressionNoConvert = LuExpressionUtils.GetFromConvert(expression);

            var ordered = ConvertAndOrderByQueryable<bool>(expression, orderByfield, queryable, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<byte>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<DateTime>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<DateTimeOffset>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<decimal>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<double>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<float>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<Guid>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<short>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<int>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<long>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<char>(expression, orderByfield, ordered, expressionNoConvert);
            ordered = ConvertAndOrderByQueryable<string>(expression, orderByfield, ordered, expressionNoConvert);
            
            return LuResult<IQueryable<TModel>>.Ok(ordered);
        }

        protected virtual LuResult<IQueryable<TModel>> OrderBy(LuOrderByDbo orderBy, IQueryable<TModel> queryable)
        {
            var ordered = queryable;
            foreach (var field in orderBy.OrderByFields)
            {
                var orderedResult = OrderByField(field, ordered);
                if (!orderedResult)
                {
                    return orderedResult.To<IQueryable<TModel>>();
                }

                ordered = orderedResult.Data;
            }

            return LuResult<IQueryable<TModel>>.Ok(ordered ?? queryable);
        }

        protected virtual LuResult<IQueryable<TModel>> Paginate(int page, int perPage, IQueryable<TModel> queryable)
        {
            var paginated = queryable.Skip(page * perPage).Take(perPage);
            return LuResult<IQueryable<TModel>>.Ok(paginated);
        }

        public virtual LuResult<IList<TDbo>> Create(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }

        public virtual LuResult<LuPaginatedDbo<TDbo>> Read(LuPartialFieldsDbo partialResponse, LuPaginatedParamsDbo paginationParams)
        {
            var result = Execute((context, set) =>
            {
                var includeResult = Include(partialResponse, set);
                if (!includeResult)
                {
                    return includeResult.To<LuPaginatedDbo<TDbo>>();
                }

                var included = includeResult.Data;

                var orderByResult = OrderBy(paginationParams.OrderBy, included);
                if (!orderByResult)
                {
                    return orderByResult.To<LuPaginatedDbo<TDbo>>();
                }

                var ordered = orderByResult.Data;
                
                var filteredResult = Filter(paginationParams.Filter, ordered);
                if (!filteredResult)
                {
                    return filteredResult.To<LuPaginatedDbo<TDbo>>();
                }

                var filtered = filteredResult.Data;
                var count = filtered.Count();

                var paginatedResult = Paginate(paginationParams.Page, paginationParams.PerPage, filtered);
                if (!paginatedResult)
                {
                    return paginatedResult.To<LuPaginatedDbo<TDbo>>();
                }

                var paginated = paginatedResult.Data;

                var data = paginated.AsEnumerable().Select(model =>
                    {
                        var dbo = new TDbo();
                        ConvertModelToDbo(partialResponse, model, dbo);
                        return dbo;
                    }).ToList();

                return LuResult<LuPaginatedDbo<TDbo>>.Ok(new LuPaginatedDbo<TDbo>
                {
                    Count = count,
                    Data = data
                });
            });
            return result;
        }

        public virtual LuResult<IList<TDbo>> Update(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }

        public virtual LuResult<IList<TDbo>> Delete(LuPartialFieldsDbo partialResponse, LuPartialFieldsDbo partialInput, IEnumerable<TDbo> dbos)
        {
            throw new NotImplementedException();
        }
    }
}