yili-onemap/api/QM.KJGH.CGGL/QM.KJGH.CGGL.Repository/Cgzj/CgzjZjrwRepository.cs

using QM.KJGH.CGGL.IRepository;
using QM.KJGH.CGGL.Model;
using QM.KJGH.CGGL.Model.Cgzj;
using QM.KJGH.Model;
using QM.KJGH.Model.KJGH;
using QM.OrmSqlSugar;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WS;
using WS.AutoMapper;
using WS.Helper;
using WS.IO;
using WS.Orm;

namespace QM.KJGH.CGGL.Repository
{
    /// <summary>
    /// 
    /// </summary>
    public class CgzjZjrwRepository : SqlSugarRepository<CgzjZjrw>, ICgzjZjrwRepository
    {
        private readonly ICgzjSjbzRepository _ICgzjSjbzRepository;
        private readonly ICfgSettingRepository _ICfgSettingRepository;
        public CgzjZjrwRepository(
           ICgzjSjbzRepository ICgzjSjbzRepository
           , ICfgSettingRepository ICfgSettingRepository
            )
        {
            _ICgzjSjbzRepository = ICgzjSjbzRepository;
            _ICfgSettingRepository = ICfgSettingRepository;
        }

        /// <summary>
        /// 检查项
        /// </summary>
        /// <param name="rwbsm"></param>
        /// <returns></returns>
        public List<CgzjZjx> GetZjx(string rwbsm)
        {
            var list = Db.Queryable<CgzjZjx>().Where(t => t.RWBSM == rwbsm).ToList();
            return list;
        }

        #region 质检任务
        /// <summary>
        /// 添加数据审核
        /// </summary>
        /// <returns></returns>
        public async Task<bool> Add(CgzjZjrwInput input)
        {
            var model = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.CG_BSM).FirstAsync();
            if (IsExist(t => t.BSM == input.CG_BSM))
            {
                throw new UseArgumentException("不能重复提交");
            }
            //检查目录
            var cgpath = FileManage.Instance.ToFullPath(model.CGML);
            var errorFile = await _ICgzjSjbzRepository.FileCheck(input.SJBZ_BSM, model.XZQDM, model.XZQMC, cgpath);
            //检查文文件
            var errorStr = string.Empty;
            var config = await _ICfgSettingRepository.GetSetting<CgglConfig>("CGGL");
            if (config.CheckLack && errorFile.lack.Count > 0)
            {
                errorStr+=@$"成果数据缺少以下目录或文件：{"\n"}{errorFile.lack.Join("\n")}{"\n"}";
            }
            if (config.CheckMany && errorFile.many.Count > 0)
            {
                errorStr += @$"成果数据多出以下文件，多的文档可放到其他文件中：{"\n"}{errorFile.many.Join("\n")}";
            }
            if (!string.IsNullOrWhiteSpace(errorStr))
                throw new UseMassageException(errorStr);

            model.ZT = KJGH.Model.Enums.EnumCgglCgZT.机器审查;
            model.ZT_JQSC = KJGH.Model.Enums.EnumCgscZT.审查中;
            CgzjZjrw zjrw = new CgzjZjrw()
            {
                BSM = model.BSM,
                CJSJ = DateTime.Now,
                GHLX = model.GHLX,
                ZRW_BSM = model.BSM,
                RWMC = model.XMMC,
                XZQDM = model.XZQDM,
                XZQMC = model.XZQMC,
                RWZT = KJGH.Model.Enums.EnumRwzt.Create,
                ZJFA_BSM = input.ZJFA_BSM,
                //SJBZ_BSM = input.SJBZ_BSM,
                SJWZ = model.CGB,
                GZML = model.CGML,
                QXCG_BSM = model.QXCG_BSM,
                //ZJSJ = DateTime.Now,
                ZJRY = input.ZJRY,
                CG_BSM = input.CG_BSM
            };
            //检查项
            List<CgzjZjx> zjxlist = new List<CgzjZjx>();
            var zjbzList = await Db.Queryable<CgzjZjbz>().Where(t => input.JCXS.Contains(t.BSM)).ToListAsync();
            foreach (var item in input.JCXS)
            {
                zjxlist.Add(new CgzjZjx()
                {
                    BSM = Guid.NewGuid().ToStringN(),
                    RWBSM = model.BSM,
                    JCZT = KJGH.Model.Enums.EnumRwzt.Create,
                    ZJBSM = item,
                    JCLR = zjbzList.Where(t => t.BSM == item).FirstOrDefault().JCLR,
                });
            }
            try
            {
                Db.BeginTran();
                Db.Insertable(zjrw).ExecuteCommand();
                Db.Insertable(zjxlist).ExecuteCommand();
                Db.Updateable(model).ExecuteCommand();
                Db.CommitTran();
            }
            catch (System.Exception ex)
            {
                WS.Log.RunLog.Error(ex);
                Db.RollbackTran();
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 开始检查
        /// </summary>
        /// <returns></returns>
        public async Task<bool> Start(string bsm)
        {
            var model = await Db.Queryable<CgzjZjrw>().Where(t => t.BSM == bsm).FirstAsync();
            model.RWZT = KJGH.Model.Enums.EnumRwzt.Run;
            model.ZJSJ = DateTime.Now;
            //进行质检查
            return Db.Updateable(model).ExecuteCommand() == 1;
        }

        /// <summary>
        /// 回退
        /// </summary>
        /// <returns></returns>
        public async Task<bool> Back(string bsm)
        {
            var model = await Db.Queryable<CgzjZjrw>().Where(t => t.BSM == bsm).FirstAsync();
            model.RWZT = KJGH.Model.Enums.EnumRwzt.Back;
            model.ZJSJ = DateTime.Now;
            var cg = await Db.Queryable<CgglCg>().Where(t => t.BSM == model.CG_BSM).FirstAsync();
            cg.ZT_JQSC =  KJGH.Model.Enums.EnumCgscZT.退回;
            //进行质检查
            try
            {
                Db.BeginTran();
                Db.Updateable(model).ExecuteCommand();
                Db.Updateable(cg).ExecuteCommand();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                WS.Log.RunLog.Error(ex);
                Db.RollbackTran();
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="bsm">标识码</param>
        /// <returns></returns>
        public async Task<CgzjZjrw> QueryById(string bsm)
        {
            return (await Db.Queryable<CgzjZjrw>().Where(t => t.BSM == bsm).FirstAsync()).MapTo<CgzjZjrw, CgzjZjrwView>();
        }

        /// <summary>
        /// 分页查询审查数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageData> GetPage(CgzjZjrwPage input)
        {
            var query = DbClient().Queryable<CgzjZjrw, CgglCg>((t, b) => new JoinQueryInfos(
                 JoinType.Inner, t.CG_BSM == b.BSM));
            if (!string.IsNullOrWhiteSpace(input.XZQDM))
                query.Where((t, b) => t.XZQDM.StartsWith(input.XZQDM));
            if (!string.IsNullOrWhiteSpace(input.RWMC))
                query.Where((t, b) => t.RWMC.Contains(input.RWMC));
            if (!string.IsNullOrWhiteSpace(input.SJBZ_BSM))
                query.Where((t, b) => t.SJBZ_BSM == input.SJBZ_BSM);
            if (!string.IsNullOrWhiteSpace(input.ZJFA_BSM))
                query.Where((t, b) => t.ZJFA_BSM == input.ZJFA_BSM);
            if (!string.IsNullOrWhiteSpace(input.GHLX))
                query.Where((t, b) => t.GHLX == input.GHLX);
            if (input.RWZT != KJGH.Model.Enums.EnumRwzt.None)
                query.Where((t, b) => t.RWZT == input.RWZT);

            query.WhereIF(input.INSTID == "0", (t, b) => string.IsNullOrEmpty(b.INSTID));
            query.WhereIF(input.INSTID == "1", (t, b) => !string.IsNullOrEmpty(b.INSTID));
            query.WhereIF(!string.IsNullOrWhiteSpace(input.GHJB), (t, b) => b.GHJB.Contains(input.GHJB));

            var page = await query
                .OrderBy((t, b) => t.CJSJ, OrderByType.Desc)
                .Select((t, b) => new CgzjZjrwView()
                {
                    BSM = t.BSM,
                    CG_BSM = t.CG_BSM,
                    CJSJ = t.CJSJ,
                    GHLX = t.GHLX,
                    GZML = t.GZML,
                    QXCG_BSM = t.QXCG_BSM,
                    RWMC = t.RWMC,
                    RWZT = t.RWZT,
                    SJBZ_BSM = t.SJBZ_BSM,
                    SJWZ = t.SJWZ,
                    WCSJ = t.WCSJ,
                    XZQDM = t.XZQDM,
                    XZQMC = t.XZQMC,
                    ZJFA_BSM = t.ZJFA_BSM,
                    ZJBG = t.ZJBG,
                    ZJDF = t.ZJDF,
                    ZJQU = t.ZJQU,
                    ZJRY = t.ZJRY,
                    ZJSJ = t.ZJSJ,
                    ZRW_BSM = t.ZRW_BSM,
                    CG_ZT = b.ZT,
                    INSTID = b.INSTID,
                    GHJB = b.GHJB
                })
                .ToPageAsync(input.page, input.limit);

            return page;
        }

        /// <summary>
        /// 质检项记录
        /// </summary>
        /// <param name="rwbsm"></param>
        /// <returns></returns>
        public async Task<List<CgzjZjxTree>> GetZjxTree(string rwbsm)
        {
            var zjrw = await Db.Queryable<CgzjZjrw>().Where(t => t.BSM == rwbsm).FirstAsync();
            var list = await Db.Queryable<CgzjZjbzfl>().Where(t => t.ZJFA_BSM == zjrw.ZJFA_BSM).ToListAsync();
            var zjxList = await DbClient().Queryable<CgzjZjbz, CgzjZjx>((t, b) => new object[] {
                JoinType.Inner, t.BSM == b.ZJBSM})
                .Where((t, b) => t.ZJFA_BSM == zjrw.ZJFA_BSM && b.RWBSM == rwbsm)
                .Select((t, b) => new CgzjZjxTree()
                {
                    ZJBSM = t.BSM,
                    JCBM = t.JCBM,
                    FLBSM = t.FLBSM,
                    CWSL = b.CWSL,
                    JCLR = t.JCLR,
                    JCZT = b.JCZT,
                    ZJDF = b.ZJDF,
                    IsParent = false,
                    parent = t.FLBSM,
                    children = null
                }).ToListAsync();
             
            List<CgzjZjxTree> treeList = new List<CgzjZjxTree>();
            var plist = list.Where(t => string.IsNullOrWhiteSpace(t.FBSM));
            foreach (var item in plist)
            {
                var pItem = new CgzjZjxTree()
                {
                    JCLR = item.FLMC,
                    IsParent = true,
                    children = zjxList.Where(t => t.FLBSM == item.BSM).ToList()
                };
                treeList.Add(pItem);
            }
            return treeList;
        }

        /// <summary>
        /// 质检错误
        /// </summary>
        /// <param name="rwbsm">任务标识码</param>
        /// <param name="zjbsm">质检标识码</param>
        /// <returns></returns>
        public async Task<List<CgzjCwrz>> GetZjErrorLog(string rwbsm, string zjbsm)
        {
            var list = await DbClient().Queryable<CgzjCwrz, CgzjZjx>((t, b) => new object[] {
                JoinType.Inner, t.ZJXBSM == b.BSM})
                .Where((t, b) => b.ZJBSM == zjbsm && b.RWBSM == rwbsm)
                .Select((t, b) => t)
                .ToListAsync();
            return list;
        }
        #endregion

    }
}