GBRSGB/CZFW.Framework/Logic/Base/SlimLogicBase.cs

using CZFW.Framework.Interface;
using CZFW.Framework.Model.Entity;
using System;
using System.Collections.Generic;
using System.Text;
using CZFW.Framework.Model;
using CZFW.Framework.Model.ViewModel;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel;
using CZFW.Framework.Interface.Base;

namespace CZFW.Framework.Logic
{
    public class SlimLogicBase<TSlimEntity> : ISlimLogicBase<TSlimEntity>
        where TSlimEntity : SlimEntityBase, new()
    {
        public SlimLogicBase(CZDbContext db)
        {
            DbContext = db;
        }

        public SlimLogicBase()
        {
            DbContext = new CZDbContext();/* CZHttpContext.ServiceProvider.GetService(typeof(CZDbContext)) as CZDbContext;*/
        }
        private CZDbContext dbContext;

        public CZDbContext DbContext
        {
            get
            {
                if (dbContext == null)
                    dbContext = CZHttpContext.ServiceProvider.GetService(typeof(CZDbContext)) as CZDbContext;
                return dbContext;
            }
            set { dbContext = value; }
        }

        public IQueryable<TSlimEntity> Queryable
        {
            get { return DbContext.Set<TSlimEntity>(); }
        }

        public virtual ResultModel AddEntity(TSlimEntity entity, bool save = true)
        {
            var validator = this as IValidate<TSlimEntity>;
            if (validator != null)
            {
                var valiRes = validator.Validate(entity);
                if (!valiRes.result)
                    return new ResultModel(valiRes.message);
            }
            DbContext.Add<TSlimEntity>(entity);
            if (save)
            {
                var res = Commit();
                res.Data = entity.Id;
                return res;
            }
            else
                return new ResultModel();
        }
        public virtual ResultModel AddEntities(IList<TSlimEntity> entities, bool save = true, bool skipInvalid = true)
        {
            var validator = this as IValidate<TSlimEntity>;
            if (validator != null)
            {
                foreach (var item in entities)
                {
                    var valiRes = validator.Validate(item);
                    if (valiRes.result)
                        DbContext.Set<TSlimEntity>().Add(item);
                    else
                        if (!skipInvalid)
                        return new ResultModel(valiRes.message);
                }
            }
            else
                DbContext.Set<TSlimEntity>().AddRange(entities);
            if (save)
            {
                var res = Commit();
                if (res.Success)
                {
                    res.Data = entities.Select(x => x.Id).ToList();
                }
                return res;
            }
            else
                return new ResultModel();
        }
        public virtual ResultModel Commit()
        {
            var result = new ResultModel();
            try
            {
                var tp2 = DbContext.SaveChanges();
                result.Data = tp2;
                if (tp2 > 0)
                {
                    result.Success = true;
                }
                else
                {
                    result.Success = false;
                    result.Message = "没有保存任何数据";
                }
            }
            catch (DbUpdateException valiErr)
            {
                result.Success = false;
                result.Message = $"数据更新错误,{valiErr.Message}";
            }
            catch (Exception err)
            {
                result.Success = false;
                result.Message = err.Message;
                if (string.IsNullOrEmpty(result.Message))
                    result.Message = "未知错误，请联系系统管理员！";
            }
            return result;
        }
        public virtual ResultModel EditEntity(TSlimEntity entity, bool save = true)
        {
            var validator = this as IValidate<TSlimEntity>;
            if (validator != null)
            {
                var valiRes = validator.Validate(entity);
                if (!valiRes.result)
                    return new ResultModel(valiRes.message);
            }
            DbContext.Set<TSlimEntity>().Update(entity);
            if (save)
            {
                var res = Commit();
                return res;
            }
            else
                return new ResultModel();
        }
        public virtual ResultModel ExcuteSql(string sql)
        {
            var res = DbContext.Database.ExecuteSqlCommand(sql);
            return new ResultModel() { Success = true, Data = res };
        }

        public TSlimEntity GetEntity(int id)
        {
            return Queryable.FirstOrDefault(x => x.Id == id);
        }
        public TSlimEntity GetEntity(Expression<Func<TSlimEntity, bool>> condition)
        {
            return Queryable.FirstOrDefault(condition);
        }

        public IQueryable<TSlimEntity> GetQueryable()
        {
            return DbContext.Set<TSlimEntity>();
        }

        public virtual ResultModel RemoveEntities(Expression<Func<TSlimEntity, bool>> condition, bool save = true)
        {
            var remove = DbContext.Set<TSlimEntity>().Where(condition);
            DbContext.Set<TSlimEntity>().RemoveRange(remove);
            if (save)
            {
                var res = Commit();
                return res;
            }
            else
                return new ResultModel();
        }

        public virtual ResultModel RemoveEntity(int id, bool save = true)
        {
            var remove = DbContext.Set<TSlimEntity>().Where(x => x.Id == id);
            DbContext.Set<TSlimEntity>().RemoveRange(remove);
            if (save)
            {
                var res = Commit();
                return res;
            }
            else
                return new ResultModel();
        }

        public IList<TSlimEntity> GetEntities(Expression<Func<TSlimEntity, bool>> condition)
        {
            if (condition == null)
                return Queryable.ToList();
            var res = Queryable.Where(condition).ToList();
            return res;
        }
        public IList<TSlimEntity> GetEntities()
        {
            return Queryable.ToList();
        }

        public int GetCount(Expression<Func<TSlimEntity, bool>> condition = null)
        {
            if (condition != null)
                return Queryable.Count(condition);
            else
                return Queryable.Count();
        }

        public ResultModel AddOrEditEntity(TSlimEntity entity, bool save = true)
        {
            if (entity.Id == 0)
                return AddEntity(entity, save);
            else
                return EditEntity(entity, save);
        }

        public TVal GetValue<TVal>(Expression<Func<TSlimEntity, bool>> condition, Expression<Func<TSlimEntity, TVal>> selector)
        {
            var res = Queryable.Where(condition).Select(selector).FirstOrDefault();
            return res;
        }

        public IList<TVal> GetValues<TVal>(Expression<Func<TSlimEntity, bool>> condition, Expression<Func<TSlimEntity, TVal>> selector)
        {
            var res = Queryable.Where(condition).Select(selector).ToList();
            return res;
        }

        public IList<TSlimEntity> GetEntities<TVal>(
            Expression<Func<TSlimEntity, bool>> condition,
            Expression<Func<TSlimEntity, TVal>> orderBy,
            ListSortDirection direction)
        {
            IList<TSlimEntity> res = null;
            if (direction == ListSortDirection.Ascending)
            {
                res = Queryable.Where(condition).OrderBy(orderBy).ToList();
            }
            else
            {
                res = Queryable.Where(condition).OrderByDescending(orderBy).ToList();
            }
            return res;
        }

        public IList<TSlimEntity> GetEntities<TVal>(
             out int rows,
            Expression<Func<TSlimEntity, bool>> condition = null,
            int pageIndex = 1,
            int pageSize = 20,
            Expression<Func<TSlimEntity, TVal>> orderBy = null,
            ListSortDirection direction = ListSortDirection.Descending
            )
        {
            var queryable = Queryable;
            if (condition != null)
                queryable = queryable.Where(condition);
            rows = queryable.Count();
            if (orderBy != null)
            {
                if (direction == ListSortDirection.Descending)
                    queryable = queryable.OrderByDescending(orderBy);
                else
                    queryable = queryable.OrderBy(orderBy);
            }
            else
            {
                if (direction == ListSortDirection.Descending)
                    queryable = queryable.OrderByDescending(x => x.Id);
                else
                    queryable = queryable.OrderBy(x => x.Id);
            }
            queryable = queryable.Skip((pageIndex - 1) * pageSize).Take(pageSize);
            var res = queryable.ToList();
            return res;
        }

        public IList<TSlimEntity> GetEntities(int pageSize, int pageIndex, out int rows)
        {
            var res = GetEntities<int>(rows: out rows, condition: null, pageIndex: pageIndex, pageSize: pageSize, orderBy: x =>x.Id, direction: ListSortDirection.Descending);
            return res;
        }


    }
}