luticate2-api/Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Luticate2.Utils.Dbo.Basic;
using Luticate2.Utils.Dbo.Filter;
using Luticate2.Utils.Dbo.OrderBy;
using Luticate2.Utils.Dbo.Result;
using Luticate2.Utils.Interfaces;
using Luticate2.Utils.Utils;
using Microsoft.EntityFrameworkCore;

namespace Luticate2.Utils.DataAccess
{
    public abstract class LuEfCrudDataAccess<TModel, TDboCreate, TDboRead, TDboUpdate, TDbContext, TId> :
            LuEfDataAccess<TModel, TDbContext>,
            ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
        where TModel : class
        where TDboCreate : class
        where TDboRead : class
        where TDboUpdate : class
        where TDbContext : DbContext
    {
        protected LuEfCrudDataAccess(IServiceProvider serviceProvider) : base(serviceProvider)
        {
        }

        protected abstract TModel GetModelFromTCreate(TDboCreate obj);

        protected abstract void EditModelFromTUpdate(TDboUpdate obj, TModel model);

        protected abstract TDboRead GetDboFromModel(TModel model);

        protected virtual Expression<Func<TModel, object>> GetOrderByFieldExpression(string fieldName)
        {
            fieldName = fieldName.ToSnakeCase();
            if (!typeof(TModel).HasProperty(fieldName))
            {
                return null;
            }
            var param = Expression.Parameter(typeof(TModel), "x");
            var prop = Expression.Property(param, fieldName);
            var converted = Expression.Convert(prop, typeof(object));
            var exp = Expression.Lambda<Func<TModel, object>>(converted, param);
            return exp;
        }

        protected virtual Expression<Func<TModel, bool>> GetFilterExpression(LuFilterDbo filter)
        {
            return model => true;
        }

        protected virtual object GetId(TId id)
        {
            var s = id as string;
            if (s != null)
            {
                Guid guid;
                if (Guid.TryParse(s, out guid))
                {
                    return guid;
                }
                return null;

            }
            return id;
        }

        protected virtual object GetModelId(object id)
        {
            var g = id as Guid?;
            if (g != null)
            {
                return g.ToString();
            }
            return id;
        }

        protected virtual IQueryable<TModel> GetGetQueryable(TDbContext db, DbSet<TModel> table)
        {
            return table;
        }

        protected virtual IQueryable<TModel> GetEditQueryable(TDbContext db, DbSet<TModel> table)
        {
            return table;
        }

        protected virtual IQueryable<TModel> GetDeleteQueryable(TDbContext db, DbSet<TModel> table)
        {
            return table;
        }

        protected virtual Func<TDboRead, T> GetIdFunc<T>()
        {
            return x => ((dynamic) x).Id;
        }

        protected virtual TModel GetModelFromTUpdate(TDboUpdate obj, TModel model)
        {
            EditModelFromTUpdate(obj, model);
            return model;
        }

        protected virtual LuResult<T> GetNotFoundResult<T>()
        {
            return LuResult<T>.Error(LuStatus.NotFound, typeof(TModel).Name + ": Value not found", "");
        }

        protected virtual IQueryable<TModel> GetFilterQuery(LuFilterDbo filter, TDbContext db, DbSet<TModel> table)
        {
            return GetGetQueryable(db, table).Where(GetFilterExpression(filter));
        }



        protected virtual LuResult<bool> _Add(TModel model, TDboCreate dbo, TDbContext db, DbSet<TModel> table)
        {
            return LuResult<bool>.Ok(true);
        }

        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
        {
            var models = new List<TModel>();
            var addRes = Execute((db, table) =>
            {
                var transact = BeginTransaction(db);
                foreach (var dbo in objs)
                {
                    var model = GetModelFromTCreate(dbo);
                    table.Add(model);
                    models.Add(model);
                    var res = _Add(model, dbo, db, table);
                    if (!res)
                    {
                        RollbackTransaction(transact);
                        return res.To<T>();
                    }
                }
                db.SaveChanges();
                CommitTransaction(transact);
                return LuResult<T>.Ok(default(T));
            });
            if (!addRes)
            {
                return addRes;
            }
            return GetMultiple(models, returnFunc);
        }

        public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
        {
            return Add(new List<TDboCreate> {obj}, list => returnFunc(list.First()));
        }


        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
        {
            var func = GetIdFunc<TId>();
            return Add(objs, list => list.Select(func));
        }

        public virtual LuResult<TId> AddId(TDboCreate obj)
        {
            return AddId(new List<TDboCreate> {obj}).To(list => list.First());
        }


        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
        {
            return Add(obj, read => read);
        }

        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
        {
            return AddDbo(new List<TDboCreate> {obj}).To(list => list.First());
        }




        public virtual LuResult<TDboRead> GetSingle(Expression<Func<TModel, bool>> predicate)
        {
            return Execute((db, table) =>
            {
                var model = GetGetQueryable(db, table).FirstOrDefault(predicate);
                if (model == default(TModel))
                {
                    return GetNotFoundResult<TDboRead>();
                }
                var dbo = GetDboFromModel(model);
                return LuResult<TDboRead>.Ok(dbo);
            });
        }

        public virtual LuResult<TDboRead> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
        {
            return GetSingle(GetExpression(keys));
        }

        public virtual LuResult<TDboRead> GetSingleById(TId id)
        {
            var guid = GetId(id);
            if (guid == null)
            {
                return GetNotFoundResult<TDboRead>();
            }
            return GetSingleByKeys(new KeyValuePair<string, object>("id", guid));
        }

        protected virtual LuResult<T> GetMultiple<T>(IList<TModel> models, Func<IEnumerable<TDboRead>, T> returnFunc)
        {
            var dbos = new List<TDboRead>();
            foreach (var model in models)
            {
                var getRes = GetSingleById((TId) GetModelId(((dynamic)model).id));
                if (!getRes)
                {
                    return getRes.To<T>();
                }
                dbos.Add(getRes.Data);
            }
            var res = returnFunc(dbos);
            return LuResult<T>.Ok(res);
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
            Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
            params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
        {
            return Execute((db, table) =>
            {
                var queryable = GetGetQueryable(db, table);
                var count = queryable.Count(predicate);
                var ordered = orderBy(queryable);
                foreach (var func in otherOrderBy)
                {
                    ordered = func(ordered);
                }
                var data = ordered.Where(predicate).Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
                var result = new LuPaginatedDbo<TDboRead>
                {
                    Count = count,
                    Data = data
                };
                return LuResult<LuPaginatedDbo<TDboRead>>.Ok(result);
            });
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
            Expression<Func<TModel, bool>> predicate, int page = 0, int perPage = int.MaxValue,
            params Expression<Func<TModel, object>>[] otherOrderBy)
        {
            return GetMultiple(table => table.OrderBy(orderBy), predicate, page, perPage,
                otherOrderBy.Select<Expression<Func<TModel, object>>, Func<IOrderedQueryable<TModel>,
                    IOrderedQueryable<TModel>>>(expression => (t => t.ThenBy(expression))).ToArray());
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Func<IQueryable<TModel>, IOrderedQueryable<TModel>> orderBy,
            int page = 0, int perPage = int.MaxValue, params Func<IOrderedQueryable<TModel>, IOrderedQueryable<TModel>>[] otherOrderBy)
        {
            return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(Expression<Func<TModel, object>> orderBy,
            int page = 0, int perPage = int.MaxValue, params Expression<Func<TModel, object>>[] otherOrderBy)
        {
            return GetMultiple(orderBy, x => true, page, perPage, otherOrderBy);
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, Func<TDbContext, DbSet<TModel>, IQueryable<TModel>> getQueryable,
            int page = 0, int perPage = int.MaxValue)
        {
            return Execute((db, table) =>
            {
                var queryable = getQueryable(db, table);
                var count = queryable.Count();
                IOrderedQueryable<TModel> ordered = null;
                foreach (var field in orderBy.Fields)
                {
                    var exp = GetOrderByFieldExpression(field.Name);
                    if (exp == null)
                    {
                        return LuResult<LuPaginatedDbo<TDboRead>>.Error(LuStatus.InputError,
                            $"LuEfCrudDataAccess: {field.Name}", "Invalid order by field");
                    }
                    if (ordered != null)
                    {
                        ordered = field.Asc ? ordered.ThenBy(exp) : ordered.ThenByDescending(exp);
                    }
                    else
                    {
                        ordered = field.Asc ? queryable.OrderBy(exp) : queryable.OrderByDescending(exp);
                    }
                }

                var data = ordered.Skip(page * perPage).Take(perPage).Select(GetDboFromModel).ToList();
                var result = new LuPaginatedDbo<TDboRead>
                {
                    Count = count,
                    Data = data
                };
                return LuResult<LuPaginatedDbo<TDboRead>>.Ok(result);
            });
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
            int page = 0, int perPage = int.MaxValue)
        {
            return GetMultiple(orderBy, (db, table) => GetFilterQuery(filter, db, table), page, perPage);
        }

        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
        {
            return GetMultiple(orderBy, GetGetQueryable, page, perPage);
        }




//        public virtual LuResult<T> Edit<T>(Expression<Func<TModel, bool>> predicate, Action<TModel> update,
//            Func<IEnumerable<TDboRead>, T> returnFunc)
//        {
//            IList<TModel> models = null;
//            var editRes = Execute((db, table) =>
//            {
//                models = GetEditQueryable(db, table).Where(predicate).ToList();
//                foreach (var model in models)
//                {
//                    update(model);
//                }
//                db.SaveChanges();
//                return LuResult<T>.Ok(default(T));
//            });
//            if (!editRes)
//            {
//                return editRes;
//            }
//            return GetMultiple(models, returnFunc);
//        }
//
//        public virtual LuResult<IEnumerable<TId>> EditId(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
//        {
//            var func = GetIdFunc<TId>();
//            return Edit(predicate, update, reads => reads.Select(func));
//        }
//
//        public virtual LuResult<IEnumerable<TDboRead>> EditDbo(Expression<Func<TModel, bool>> predicate, Action<TModel> update)
//        {
//            return Edit(predicate, update, read => read);
//        }


//        public virtual LuResult<T> EditSingleById<T>(TId id, Action<TModel> update, Func<TDboRead, T> returnFunc)
//        {
//            var guid = GetId(id);
//            if (guid == null)
//            {
//                return GetNotFoundResult<T>();
//            }
//            return Edit(GetExpression(new KeyValuePair<string, object>("id", guid)), update,
//                list => returnFunc(list.FirstOrDefault()));
//        }
//
//        public virtual LuResult<TId> EditSingleByIdId(TId id, Action<TModel> update)
//        {
//            return EditSingleById(id, update, GetIdFunc<TId>());
//        }
//
//        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, Action<TModel> update)
//        {
//            return EditSingleById(id, update, read => read);
//        }

        protected void SyncManyToMany<T>(IList<TId> ids, IList<T> verbs, Func<TId, T> newVerb, Func<T, TId> getVerbFk)
        {
            foreach (var added in ids.Where(id => verbs.FirstOrDefault(o => Equals(getVerbFk(o), id)) == null))
            {
                verbs.Add(newVerb(added));
            }
            foreach (var removed in verbs.Where(v => ids.FirstOrDefault(id => Equals(getVerbFk(v), id)) == null).ToList())
            {
                verbs.Remove(removed);
            }
        }

        protected virtual LuResult<bool> _EditSingleById(TModel model, TDboUpdate update, TDbContext db, DbSet<TModel> table)
        {
            return LuResult<bool>.Ok(true);
        }

        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
        {
            var guid = GetId(id);
            if (guid == null)
            {
                return GetNotFoundResult<T>();
            }
            var transact = BeginTransaction(null);
            var editRes = Execute((db, table) =>
            {
                var model = GetEditQueryable(db, table).FirstOrDefault(GetExpression(new KeyValuePair<string, object>("id", guid)));
                EditModelFromTUpdate(update, model);
                db.SaveChanges();
                var res = _EditSingleById(model, update, db, table);
                if (!res)
                {
                    RollbackTransaction(transact);
                    return res.To<T>();
                }
                db.SaveChanges();
                return LuResult<T>.Ok(default(T));
            });
            if (!editRes)
            {
                RollbackTransaction(transact);
                return editRes;
            }
            var getRes = GetSingleById(id).To(returnFunc);
            CommitTransaction(transact);
            return getRes;
        }

        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
        {
            return EditSingleById(id, update, GetIdFunc<TId>());
        }

        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
        {
            return EditSingleById(id, update, read => read);
        }




        public virtual LuResult<T> Delete<T>(Expression<Func<TModel, bool>> predicate,
            Func<IEnumerable<TDboRead>, T> returnFunc)
        {
            return Execute((db, table) =>
            {
                var transact = BeginTransaction(db);
                var models = GetDeleteQueryable(db, table).Where(predicate).ToList();
                var getRes = GetMultiple(models, returnFunc);
                if (!getRes)
                {
                    RollbackTransaction(transact);
                    return getRes;
                }
                table.RemoveRange(models);
                db.SaveChanges();
                CommitTransaction(transact);
                return getRes;
            });
        }

        public virtual LuResult<IEnumerable<TId>> DeleteId(Expression<Func<TModel, bool>> predicate)
        {
            var func = GetIdFunc<TId>();
            return Delete(predicate, reads => reads.Select(func));
        }

        public virtual LuResult<IEnumerable<TDboRead>> DeleteDbo(Expression<Func<TModel, bool>> predicate)
        {
            return Delete(predicate, read => read);
        }


        public virtual LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
        {
            var guid = GetId(id);
            if (guid == null)
            {
                return GetNotFoundResult<T>();
            }
            return Delete(GetExpression(new KeyValuePair<string, object>("id", guid)),
                reads => returnFunc(reads.FirstOrDefault()));
        }

        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
        {
            var func = GetIdFunc<TId>();
            return DeleteSingleById(id, func);
        }

        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
        {
            return DeleteSingleById(id, read => read);
        }
    }
}