ECS / ECS_EquipmentMangaSystem_BingChengTaiGuang · Files

using HHECS.Application.Error;
using HHECS.Dal;
using HHECS.Dal.Repository;
using HHECS.BllModel;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Model.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using HHECS.Infrastructure.Json;
using FreeSql;

namespace HHECS.Application.Service
{
    /// <summary>
    /// 系统服务
    /// 字典、config等
    /// </summary>
    public class SystemService : BaseService
    {

        #region Config

        public BllResult<Config> GetConfigById(int id)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.Find(id));
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Config>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult DeleteConfigs(List<Config> configs)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.Delete(configs));
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }


        public BllResult<Config> SaveConfig(Config config)
        {
            try
            {
                ConfigRepository configRepository = new ConfigRepository();
                return BllResultFactory.Success(configRepository.InsertOrUpdate(config));
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Config>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public Dict GetDictById(int dictId)
        {
            using DictRepository dictRepository = new DictRepository();
            return dictRepository.Find(dictId);
        }

        /// <summary>
        /// 分页查询config
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="totalCount"></param>
        /// <returns></returns>
        public BllResult<List<Config>> GetConfigs(Expression<Func<Config, bool>> filter, int pageIndex, int pageSize, out long totalCount)
        {
            try
            {
                using var configRepository = new ConfigRepository();
                var query = configRepository.Where(filter);
                totalCount = query.Count();
                return BllResultFactory.Success(query.Page(pageIndex, pageSize).ToList());
            }
            catch (Exception ex)
            {
                totalCount = 0;
                return BllResultFactory.Error<List<Config>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        #endregion

        #region Dict

        public BllResult<Dict> GetDictWithDetails(Expression<Func<Dict, bool>> filter)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                var a = dictRepository.Where(filter).IncludeMany(t => t.DictDetails).First();
                if (a == null)
                {
                    return BllResultFactory.Error<Dict>("未查询到数据", ErrorCodeConst.QEZ0001.ToString());
                }
                else
                {
                    return BllResultFactory.Success(a);
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<Dict>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        /// <summary>
        /// 插入或更新字典主表
        /// </summary>
        /// <param name="currentDict"></param>
        /// <returns></returns>
        public BllResult SaveDict(Dict dict)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                dictRepository.InsertOrUpdate(dict);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<Dict>> GetDicts(Expression<Func<Dict, bool>> filter)
        {
            try
            {
                DictRepository dictRepository = new DictRepository();
                return BllResultFactory.Success(dictRepository.Where(filter).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<Dict>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<Dict>> GetDicts(Expression<Func<Dict, bool>> filter, int pageIndex, int pageSize, out long totalCount)
        {
            try
            {
                using var dictRepository = new DictRepository();
                var query = dictRepository.Where(filter);
                totalCount = query.Count();
                return BllResultFactory.Success(query.Page(pageIndex, pageSize).ToList());
            }
            catch (Exception ex)
            {
                totalCount = 0;
                return BllResultFactory.Error<List<Dict>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult DeleteDicts(List<Dict> dicts)
        {
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    DictRepository dictRepository = new DictRepository();
                    dictRepository.UnitOfWork = uw;
                    DictDetailRepository dictDetailRepository = new DictDetailRepository();
                    dictDetailRepository.UnitOfWork = uw;

                    var dictIds = dicts.Select(t => t.Id).ToList();
                    dictDetailRepository.Delete(t => dictIds.Contains(t.DictId));
                    dictRepository.Delete(dicts);
                    uw.Commit();
                    return BllResultFactory.Success();
                }
                catch (Exception ex)
                {
                    uw?.Rollback();
                    return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
                }
            }
        }

        /// <summary>
        /// 插入或更新字典明细
        /// </summary>
        /// <param name="currentDictDetial"></param>
        /// <returns></returns>
        public BllResult SaveDictDetail(DictDetail dictDetial)
        {
            try
            {
                DictDetailRepository dictDetailRepository = new DictDetailRepository();
                dictDetailRepository.InsertOrUpdate(dictDetial);
                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult<List<DictDetail>> GetDictDetails(Expression<Func<DictDetail, bool>> filter)
        {
            try
            {
                DictDetailRepository dictDetailRepository = new DictDetailRepository();
                return BllResultFactory.Success(dictDetailRepository.Where(filter).Include(t => t.Dict).ToList());
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error<List<DictDetail>>($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        public BllResult DeleteDictDetails(List<DictDetail> dictDetails)
        {
            try
            {
                DictDetailRepository dictDetailRepository = new DictDetailRepository();
                return BllResultFactory.Success(dictDetailRepository.Delete(dictDetails));
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"异常：{ex.Message}", ErrorCodeConst.DEZ0001.ToString());
            }
        }

        #endregion

        #region WEB

        #region 主表

        public string GetDicts(Dict entity, int page, int limit)
        {
            return Execute(() =>
            {
                using var dictRepository = new DictRepository();
                var query = dictRepository.Where(GetExpression(entity));
                var list = query.Page(page, limit).ToList();
                Response.Result = list;
                Response.Count = query.Count();
                return Response.ToJson();
            });
        }

        private Expression<Func<Dict, bool>> GetExpression(Dict entity)
        {
            Expression<Func<Dict, bool>> filter = t => true;
            if (!string.IsNullOrWhiteSpace(entity.Code))
            {
                filter = filter.And(t => t.Code.Contains(entity.Code));
            }
            if (!string.IsNullOrWhiteSpace(entity.Name))
            {
                filter = filter.And(t => t.Name.Contains(entity.Name));
            }
            return filter;
        }

        public string Insert(Dict entity, User user)
        {
            return Execute(() =>
            {
                entity.CreatedBy = user.UserCode;
                entity.Created = DateTime.Now;
                using DictRepository detailRepository = new DictRepository();
                detailRepository.Insert(entity);
                Response.ResponseSuccess();
                return Response.ToJson();
            });
        }

        public string Update(Dict entity, User user)
        {
            return Execute(() =>
            {

                try
                {
                    entity.UpdatedBy = user.UserCode;
                    entity.Updated = DateTime.Now;
                    using DictRepository detailRepository = new DictRepository();
                    detailRepository.Update(entity);
                    Response.ResponseSuccess();
                }
                catch (Exception ex)
                {
                    Response.ResponseError(ex.Message);
                }
                return Response.ToJson();
            });
        }

        public string DeleteByIds(int[] ids)
        {

            IRepositoryUnitOfWork uw = null;
            return Execute(() =>
            {
                uw = DALHelper.GetFreeSql().CreateUnitOfWork();
                DictRepository detailRepository = new DictRepository() { UnitOfWork = uw };
                DictDetailRepository dictDetailRepository = new DictDetailRepository() { UnitOfWork = uw };
                detailRepository.Delete(x => ids.Contains(x.Id));
                dictDetailRepository.Delete(x => ids.Contains(x.DictId));
                uw.Commit();
                return Response.ToJson();

            }, actionCatCh: () =>
            {
                uw?.Rollback();
            }, actionFinally: () =>
            {
                uw?.Dispose();
            });
        }
        #endregion

        #region 明细表

        public string GetDictDetails(DictDetail entity, int page, int limit, string mainCode, string mainName)
        {
            return Execute(() =>
            {

                try
                {
                    using var dictDetailRepository = new DictDetailRepository();
                    var query = dictDetailRepository.Where(GetExpression(entity));
                    var list = query.Page(page, limit).ToList();
                    Response.Result = list.Select(x => new
                    {
                        MainCode = mainCode,
                        MainName = mainName,
                        x.Id,
                        x.DictId,
                        x.Code,
                        x.Name,
                        x.Value,
                        x.Sort,
                        x.Remark,
                        x.Created,
                        x.CreatedBy,
                        x.Updated,
                        x.UpdatedBy
                    });
                    Response.Count = query.Count();
                    Response.ResponseSuccess();
                }
                catch (Exception ex)
                {
                    Response.ResponseError(ex.Message);
                }
                return Response.ToJson();
            });
        }

        private Expression<Func<DictDetail, bool>> GetExpression(DictDetail entity)
        {
            Expression<Func<DictDetail, bool>> filter = t => true;
            if (entity.DictId != 0)
            {
                filter = filter.And(x => x.DictId.Equals(entity.DictId));
            }
            if (!string.IsNullOrWhiteSpace(entity.Code))
            {
                filter = filter.And(t => t.Code.Contains(entity.Code));
            }
            if (!string.IsNullOrWhiteSpace(entity.Name))
            {
                filter = filter.And(t => t.Name.Contains(entity.Name));
            }
            return filter;
        }

        public string Insert(DictDetail entity, User user)
        {
            return Execute(() =>
            {

                try
                {
                    entity.CreatedBy = user.UserCode;
                    entity.Created = DateTime.Now;
                    using DictDetailRepository detailRepository = new DictDetailRepository();
                    detailRepository.Insert(entity);
                    Response.ResponseSuccess();
                }
                catch (Exception ex)
                {
                    Response.ResponseError(ex.Message);
                }
                return Response.ToJson();
            });
        }

        public string Update(DictDetail entity, User user)
        {
            return Execute(() =>
            {

                try
                {
                    entity.UpdatedBy = user.UserCode;
                    entity.Updated = DateTime.Now;
                    using DictDetailRepository detailRepository = new DictDetailRepository();
                    detailRepository.Update(entity);
                    Response.ResponseSuccess();
                }
                catch (Exception ex)
                {
                    Response.ResponseError(ex.Message);
                }
                return Response.ToJson();
            });
        }

        public string DeleteDetailById(int[] ids)
        {
            return Execute(() =>
            {

                try
                {
                    using DictDetailRepository detailRepository = new DictDetailRepository();
                    detailRepository.Delete(x => ids.Contains(x.Id));
                    Response.ResponseSuccess();
                }
                catch (Exception ex)
                {
                    Response.ResponseError(ex.Message);
                }
                return Response.ToJson();
            });
        }

        #endregion

        #endregion
    }
}