luticate2-api/Luticate2.Utils/Business/LuCrudBusiness.cs

using System;
using System.Collections.Generic;
using Luticate2.Utils.Dbo.Basic;
using Luticate2.Utils.Dbo.Filter;
using Luticate2.Utils.Dbo.OrderBy;
using Luticate2.Utils.Dbo.Result;
using Luticate2.Utils.Interfaces;

namespace Luticate2.Utils.Business
{
    public abstract class LuCrudBusiness<TDataAccess, TDboCreate, TDboRead, TDboUpdate, TId> :
            LuBusiness,
            ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
        where TDataAccess : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
        where TDboCreate : class
        where TDboRead : class
        where TDboUpdate : class
    {
        protected readonly TDataAccess DataAccess;

        protected LuCrudBusiness(TDataAccess dataAccess)
        {
            DataAccess = dataAccess;
        }

        protected virtual LuResult<TDboCreate> CheckAdd(TDboCreate obj)
        {
            return LuResult<TDboCreate>.Ok(obj);
        }

        protected virtual LuResult<IEnumerable<TDboCreate>> CheckAdd(IEnumerable<TDboCreate> objs)
        {
            var list = new List<TDboCreate>();
            foreach (var obj in objs)
            {
                var res = CheckAdd(obj);
                if (!res)
                {
                    return res.To<IEnumerable<TDboCreate>>();
                }
                list.Add(res.Data);
            }
            return LuResult<IEnumerable<TDboCreate>>.Ok(list);
        }

        protected virtual LuResult<TDboUpdate> CheckEdit(TDboRead dbo, TDboUpdate update)
        {
            return LuResult<TDboUpdate>.Ok(update);
        }

        protected LuResult<TDboUpdate> GetAndCheckEdit(TId id, TDboUpdate update)
        {
            var res = GetSingleById(id);
            if (!res)
            {
                return res.To<TDboUpdate>();
            }
            return CheckEdit(res.Data, update);
        }




        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
        {
            var res = CheckAdd(objs);
            if (!res)
            {
                return res.To<T>();
            }
            return DataAccess.Add(res.Data, returnFunc);
        }

        public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
        {
            var res = CheckAdd(obj);
            if (!res)
            {
                return res.To<T>();
            }
            return DataAccess.Add(res.Data, returnFunc);
        }

        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
        {
            var res = CheckAdd(objs);
            if (!res)
            {
                return res.To<IEnumerable<TId>>();
            }
            return DataAccess.AddId(res.Data);
        }

        public virtual LuResult<TId> AddId(TDboCreate obj)
        {
            var res = CheckAdd(obj);
            if (!res)
            {
                return res.To<TId>();
            }
            return DataAccess.AddId(res.Data);
        }

        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
        {
            var res = CheckAdd(obj);
            if (!res)
            {
                return res.To<IEnumerable<TDboRead>>();
            }
            return DataAccess.AddDbo(res.Data);
        }

        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
        {
            var res = CheckAdd(obj);
            if (!res)
            {
                return res.To<TDboRead>();
            }
            return DataAccess.AddDbo(res.Data);
        }




        public virtual LuResult<TDboRead> GetSingleById(TId id)
        {
            return DataAccess.GetSingleById(id);
        }


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

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




        public virtual LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc)
        {
            var obj = GetAndCheckEdit(id, update);
            if (!obj)
            {
                return obj.To<T>();
            }
            return DataAccess.EditSingleById(id, obj.Data, returnFunc);
        }

        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
        {
            var obj = GetAndCheckEdit(id, update);
            if (!obj)
            {
                return obj.To<TId>();
            }
            return EditSingleById(id, obj.Data, read => (TId)((dynamic)read).Id);
        }

        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
        {
            var obj = GetAndCheckEdit(id, update);
            if (!obj)
            {
                return obj.To<TDboRead>();
            }
            return EditSingleById(id, obj.Data, read => read);
        }




        public virtual LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc)
        {
            return DataAccess.DeleteSingleById(id, returnFunc);
        }

        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
        {
            return DeleteSingleById(id, read => (TId)((dynamic)read).Id);
        }

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