yili-onemap/api/QM.KJGH.CGGL/QM.KJGH.CGGL.Repository/CgglScxmRepository.cs

using Microsoft.AspNetCore.Http;
using NPOI.OpenXmlFormats.Wordprocessing;
using NPOI.XWPF.UserModel;
using QM.KJGH.CGGL.IRepository;
using QM.KJGH.CGGL;
using QM.KJGH.CGGL.Model.Cggl;
using QM.KJGH.CGGL.Model.Enums;
using QM.KJGH.CGGL.Model.Ghxms;
using QM.KJGH.Model;
using QM.KJGH.Model.KJGH;
using QM.OrmSqlSugar;
using QM.OrmSqlSugar.Utility;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WS;
using WS.AutoMapper;
using WS.Helper;
using WS.IO;
using WS.IO.Upload;
using WS.Orm;
using QM.KJGH.CGGL.Model.CG;
using System.Threading;
using QM.KJGH.CGGL.NMCGHJ.QX;
using QM.KJGH.CGGL.Model.QxCghj;
using QM.KJGH.Model.Enums;
using QM.KJGH.CGGL.NMCGHJ;
using QM.KJGH.CGGL.Model.NMCghj;
using QM.KJGH.CGGL.NMCGHJ.ZZQ;
using QM.KJGH.Model.KJGH.CGHJ;
using QM.KJGH.Utility;
using QM.KJGH.CGGL.Model;

namespace QM.KJGH.CGGL.Repository
{
    public class CgglScxmRepository : SqlSugarRepository<CgglScxm>, ICgglScxmRepository
    {
        private readonly ICgzjZjrwRepository _ICgzjZjrwRepository;
        private readonly ICghjQxcgRepository _ICghjQxcgRepository;
        private readonly ICghjQxcgsbrwRepository _ICghjQxcgsbrwRepository;
        private readonly ICghjQxjczbRepository _ICghjQxjczbRepository;
        private readonly ICghjQxtjpgrwRepository _ICghjQxtjpgrwRepository;
        private readonly ICgzjSjbzRepository _ICgzjSjbzRepository;
        private readonly ICfgSettingRepository _ICfgSettingRepository;
        public CgglScxmRepository(
            ICgzjZjrwRepository ICgzjZjrwRepository
           , ICghjQxcgRepository ICghjQxcgRepository
            , ICghjQxcgsbrwRepository ICghjQxcgsbrwRepository
            , ICghjQxjczbRepository ICghjQxjczbRepository
            , ICghjQxtjpgrwRepository ICghjQxtjpgrwRepository
           , ICgzjSjbzRepository ICgzjSjbzRepository
           , ICfgSettingRepository ICfgSettingRepository
            )
        {
            _ICgzjZjrwRepository = ICgzjZjrwRepository;
            _ICghjQxcgRepository = ICghjQxcgRepository;
            _ICghjQxcgsbrwRepository = ICghjQxcgsbrwRepository;
            _ICghjQxjczbRepository = ICghjQxjczbRepository;
            _ICghjQxtjpgrwRepository = ICghjQxtjpgrwRepository;
            _ICgzjSjbzRepository = ICgzjSjbzRepository;
            _ICfgSettingRepository = ICfgSettingRepository;
        }

        /// <summary>
        /// 匹配花括号
        /// </summary>
        /// <param name="str">需要匹配的字符串</param>
        /// <returns></returns>
        private string GetTokens(string str)
        {
            Regex regex = new Regex(@"\{.*?\}", RegexOptions.IgnoreCase);

            MatchCollection matches = regex.Matches(str);

            var list = matches.Cast<Match>().Select(m => m.Value).Distinct().ToList();

            return string.Join("", list);
        }

        /// <summary>
        /// 测试使用
        /// </summary>
        /// <param name="xmbsm"></param>
        /// <param name="xzqdm"></param>
        /// <param name="xzqmc"></param>
        /// <param name="arrs"></param>
        /// <returns></returns>
        public List<string> FileCheck(string xmbsm, string xzqdm, string xzqmc, out List<CgglCgsj> arrs)
        {
            arrs = new List<CgglCgsj>();
            xzqdm = xzqdm.PadLeft(6, '0');
            var msgList = new List<string>();
            //上传文件并解压文件
            string path = FileManage.Instance.ToFullPath(@$"SCXM");
            //var file = FileUpload.SaveFile(formFile, path, "");
            //ZipFile.ExtractToDirectory($"{path}\\150600000鄂尔多斯市国土空间总体规划电子成果数据.zip", path, Encoding.GetEncoding("GBK"));

            //查询数据
            var db = DbClient();
            //查询所有目录
            var catalogRules = db.Queryable<CgglCgmlgz>().ToList();
            //所有目录标识码
            var list = catalogRules.Select(u => u.BSM).ToList();
            //取出根目录
            var rootDirectory = catalogRules.FirstOrDefault(u => SqlFunc.IsNullOrEmpty(u.SJML));
            if (rootDirectory == null)
                throw new UseArgumentException("查询根目录错误");

            //验证根目录
            //Regex reg = new Regex("{行政区代码:6}{行政区名称}");

            Regex reg = new Regex(GetTokens(rootDirectory.GZMC));
            string modified = reg.Replace(rootDirectory.GZMC, $"{xzqdm}{xzqmc}");

            //判断根目录是否存在
            if (FileSystem.IsExist($"{path}\\{modified}", true))
            {
                //验证根目录下得必要文件
                var rootDirectoryFile = db.Queryable<CgglWjgz>().Where(u => u.CGML_BSM == rootDirectory.BSM && u.YSTJ == "M").ToList();
                foreach (var item in rootDirectoryFile)
                {
                    //验证根目录文件
                    Regex regFile = new Regex(GetTokens(item.MMGZ));
                    string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}");
                    if (FileSystem.IsExist($"{path}\\{modified}\\{modifiedFile}", false))
                    {
                        arrs.Add(new CgglCgsj
                        {
                            BSM = Guid.NewGuid().ToString("N"),
                            XMBSM = xmbsm,
                            MLBSM = item.BSM,
                            MLMC = modified,
                            CGMC = modifiedFile,
                            CGLJ = $@"files\SCXM\{modified}\{modifiedFile}"
                        });
                        continue;
                    }
                    msgList.Add($"上传的文件不包含({modified}\\{modifiedFile})文件");
                }

                //取出所有子目录
                var subdirectory = catalogRules.Where(u => !SqlFunc.IsNullOrEmpty(u.SJML)).ToList();
                //取出子目录字典
                var dic = subdirectory.Where(u => !SqlFunc.IsNullOrEmpty(u.SJML)).ToDictionary(u => u.BSM);
                foreach (var item in subdirectory)
                {
                    //判断对应得子目录是否存在
                    if (FileSystem.IsExist($"{path}\\{modified}\\{item.MLMC}", true)) continue;
                    msgList.Add($"{item.MLMC}目录不存在");
                }
                //取出所有子目录所需必要文件规则不包含根目录（必填和条件必填）
                var subdirectoryFile = db.Queryable<CgglWjgz>().Where(u => list.Contains(u.CGML_BSM) && (u.YSTJ == "M" || u.YSTJ == "C") && !u.CGML_BSM.Contains("GTKJZTGHDZCGSJ")).ToList();
                foreach (var item in subdirectoryFile)
                {
                    if (item.YSTJ == "M")
                    {
                        //验证根子目录文件
                        Regex regFile = new Regex(GetTokens(item.MMGZ));
                        string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}");
                        if (dic.ContainsKey(item.CGML_BSM))
                        {
                            if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                            {
                                arrs.Add(new CgglCgsj
                                {
                                    BSM = Guid.NewGuid().ToString("N"),
                                    XMBSM = xmbsm,
                                    MLBSM = item.BSM,
                                    MLMC = dic[item.CGML_BSM].MLMC,
                                    CGMC = modifiedFile,
                                    CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                });
                                continue;
                            }
                            msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                        }
                        else
                        {
                            throw new UseArgumentException($"目录获取错误");
                        }

                    }
                    else
                    {
                        var dt = db.Ado.GetDataTable($"SELECT * FROM {item.BZ} WHERE YSTJ='M'");
                        foreach (DataRow dr in dt.Rows)
                        {
                            if (item.BZ == "t_cggl_ghwb")
                            {
                                Regex regFile = new Regex(GetTokens(item.MMGZ));
                                string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}{dr["WJMC"].ToString()}");
                                if (dic.ContainsKey(item.CGML_BSM))
                                {
                                    if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                                    {
                                        arrs.Add(new CgglCgsj
                                        {
                                            BSM = Guid.NewGuid().ToString("N"),
                                            XMBSM = xmbsm,
                                            MLBSM = item.BSM,
                                            MLMC = dic[item.CGML_BSM].MLMC,
                                            CGMC = modifiedFile,
                                            CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                        });
                                        continue;
                                    }
                                    msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                                }
                                else
                                {
                                    throw new UseArgumentException($"目录获取错误");
                                }
                            }
                            else
                            {
                                Regex regFile = new Regex(GetTokens(item.MMGZ));
                                string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}{dr["XH"]}{dr["TJMC"]}");
                                if (dic.ContainsKey(item.CGML_BSM))
                                {
                                    if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                                    {
                                        arrs.Add(new CgglCgsj
                                        {
                                            BSM = Guid.NewGuid().ToString("N"),
                                            XMBSM = xmbsm,
                                            MLBSM = item.BSM,
                                            MLMC = dic[item.CGML_BSM].MLMC,
                                            CGMC = modifiedFile,
                                            CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                        });
                                        continue;
                                    }
                                    msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                                }
                                else
                                {
                                    throw new UseArgumentException($"目录获取错误");
                                }
                            }
                        }
                    }
                }


            }
            else
            {
                msgList.Add($"{modified}目录不存在");
            }

            return msgList;
        }

        /// <summary>
        /// 文件检查文件合规检查
        /// </summary>
        /// <param name="formFile"></param>
        /// <param name="xzqdm"></param>
        /// <param name="xzqmc"></param>
        /// <returns></returns>
        private List<string> FileCheck(IFormFile formFile, string xmbsm, string xzqdm, string xzqmc, out List<CgglCgsj> arrs)
        {

            arrs = new List<CgglCgsj>();
            xzqdm = xzqdm.PadRight(9, '0');
            var msgList = new List<string>();
            //上传文件并解压文件
            string path = FileManage.Instance.ToFullPath(@$"SCXM");

            if (!formFile.FileName.Contains($"{xzqdm}{xzqmc}")) throw new UseArgumentException("上传的文件有误");

            var file = FileUpload.SaveFile(formFile, path);
            ZipFile.ExtractToDirectory($"{path}\\{file.Name}", path, Encoding.GetEncoding("GBK"));

            //查询数据
            var db = DbClient();
            //查询所有目录
            var catalogRules = db.Queryable<CgglCgmlgz>().ToList();
            //所有目录标识码
            var list = catalogRules.Select(u => u.BSM).ToList();
            //取出根目录
            var rootDirectory = catalogRules.FirstOrDefault(u => SqlFunc.IsNullOrEmpty(u.SJML));
            if (rootDirectory == null)
                throw new UseArgumentException("查询根目录错误");

            //验证根目录
            //Regex reg = new Regex("{行政区代码:6}{行政区名称}");

            Regex reg = new Regex(GetTokens(rootDirectory.GZMC));
            string modified = reg.Replace(rootDirectory.GZMC, $"{xzqdm}{xzqmc}");

            //判断根目录是否存在
            if (FileSystem.IsExist($"{path}\\{modified}", true))
            {
                //验证根目录下得必要文件
                var rootDirectoryFile = db.Queryable<CgglWjgz>().Where(u => u.CGML_BSM == rootDirectory.BSM && u.YSTJ == "M").ToList();
                foreach (var item in rootDirectoryFile)
                {
                    //验证根目录文件
                    Regex regFile = new Regex(GetTokens(item.MMGZ));
                    string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}");
                    if (FileSystem.IsExist($"{path}\\{modified}\\{modifiedFile}", false))
                    {
                        arrs.Add(new CgglCgsj
                        {
                            BSM = Guid.NewGuid().ToString("N"),
                            XMBSM = xmbsm,
                            MLBSM = item.BSM,
                            MLMC = modified,
                            CGMC = modifiedFile,
                            CGLJ = $@"files\SCXM\{modified}\{modifiedFile}"
                        });
                        continue;
                    }
                    msgList.Add($"上传的文件不包含({modified}\\{modifiedFile})文件");
                }

                //取出所有子目录
                var subdirectory = catalogRules.Where(u => !SqlFunc.IsNullOrEmpty(u.SJML)).ToList();
                //取出子目录字典
                var dic = subdirectory.Where(u => !SqlFunc.IsNullOrEmpty(u.SJML)).ToDictionary(u => u.BSM);
                foreach (var item in subdirectory)
                {
                    //判断对应得子目录是否存在
                    if (FileSystem.IsExist($"{path}\\{modified}\\{item.MLMC}", true)) continue;
                    msgList.Add($"{item.MLMC}目录不存在");
                }
                //取出所有子目录所需必要文件规则不包含根目录（必填和条件必填）
                var subdirectoryFile = db.Queryable<CgglWjgz>().Where(u => list.Contains(u.CGML_BSM) & (u.YSTJ == "M" || u.YSTJ == "C") & !u.CGML_BSM.Contains("GTKJZTGHDZCGSJ")).ToList();
                foreach (var item in subdirectoryFile)
                {
                    if (item.YSTJ == "M")
                    {
                        //验证根子目录文件
                        Regex regFile = new Regex(GetTokens(item.MMGZ));
                        string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}");
                        if (dic.ContainsKey(item.CGML_BSM))
                        {
                            if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                            {
                                arrs.Add(new CgglCgsj
                                {
                                    BSM = Guid.NewGuid().ToString("N"),
                                    XMBSM = xmbsm,
                                    MLBSM = item.BSM,
                                    MLMC = dic[item.CGML_BSM].MLMC,
                                    CGMC = modifiedFile,
                                    CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                });
                                continue;
                            }
                            msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                        }
                        else
                        {
                            throw new UseArgumentException($"目录获取错误");
                        }

                    }
                    else
                    {
                        var dt = db.Ado.GetDataTable($"SELECT * FROM {item.BZ} WHERE YSTJ='M'");
                        foreach (DataRow dr in dt.Rows)
                        {
                            if (item.BZ == "t_cggl_ghwb")
                            {
                                Regex regFile = new Regex(GetTokens(item.MMGZ));
                                string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}{dr["WJMC"].ToString()}");
                                if (dic.ContainsKey(item.CGML_BSM))
                                {
                                    if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                                    {
                                        arrs.Add(new CgglCgsj
                                        {
                                            BSM = Guid.NewGuid().ToString("N"),
                                            XMBSM = xmbsm,
                                            MLBSM = item.BSM,
                                            MLMC = dic[item.CGML_BSM].MLMC,
                                            CGMC = modifiedFile,
                                            CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                        });
                                        continue;
                                    }
                                    msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                                }
                                else
                                {
                                    throw new UseArgumentException($"目录获取错误");
                                }
                            }
                            else
                            {
                                Regex regFile = new Regex(GetTokens(item.MMGZ));
                                string modifiedFile = regFile.Replace(item.MMGZ, $"{xzqdm}{xzqmc}{dr["XH"]}{dr["TJMC"]}");
                                if (dic.ContainsKey(item.CGML_BSM))
                                {
                                    if (FileSystem.IsExist($"{path}\\{modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile}", false))
                                    {
                                        arrs.Add(new CgglCgsj
                                        {
                                            BSM = Guid.NewGuid().ToString("N"),
                                            XMBSM = xmbsm,
                                            MLBSM = item.BSM,
                                            MLMC = dic[item.CGML_BSM].MLMC,
                                            CGMC = modifiedFile,
                                            CGLJ = $@"files\SCXM\{modified}\{dic[item.CGML_BSM].MLMC}\{modifiedFile}"
                                        });
                                        continue;
                                    }
                                    msgList.Add($"上传的文件不包含({modified}\\{dic[item.CGML_BSM].MLMC}\\{modifiedFile})文件");
                                }
                                else
                                {
                                    throw new UseArgumentException($"目录获取错误");
                                }
                            }
                        }
                    }
                }


            }
            else
            {
                msgList.Add($"{modified}目录不存在");
            }
            return msgList;
        }

        /// <summary>
        /// 检查
        /// </summary>
        /// <param name="bsm">标识码</param>
        /// <returns></returns>
        public async Task<CgglScxm> CheckId(string bsm)
        {
            var model = await GetAsync(t => t.BSM == bsm);
            if (model == null)
                throw new UseArgumentException("数据不存在，请检查标识码是否正确");
            return model;
        }

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="cgglScxm"></param>
        /// <param name="files"></param>
        /// <returns></returns>
        public async Task<bool> Add(CgglScxm cgglScxm, IFormFileCollection files)
        {
            var db = DbClient();
            //如果集合不为空表示文件验证不通过
            List<string> passOrNot = null;
            List<CgglCgsj> arrs = null;
            if (files != null && files.Count > 0)
                passOrNot = FileCheck(files.FirstOrDefault(), cgglScxm.BSM, cgglScxm.XZQDM, cgglScxm.XZQMC, out arrs);
            //文件验证成功开始入库
            if (passOrNot == null)
            {
                try
                {

                    db.BeginTran();
                    await db.Insertable(cgglScxm).ExecuteCommandAsync();
                    if (files != null && files.Count > 0)
                        await db.Insertable(arrs).ExecuteCommandAsync();
                    db.CommitTran();
                }
                catch (Exception ex)
                {
                    db.RollbackTran();
                    WS.Log.RunLog.Error(ex);
                    throw new UseArgumentException("服务器错误");
                }
            }

            return passOrNot == null ? true : throw new UseArgumentException(string.Join(",", passOrNot)); ;
        }


        /// <summary>
        /// 添加数据（从质检转入）
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ZjToAdd(CgglScxmToRgDto input)
        {
            var zjrw = await _ICgzjZjrwRepository.GetAsync(t => t.BSM == input.JS_BSM);
            var cg = await Db.Queryable<CgglCg>().Where(t => t.BSM == zjrw.CG_BSM).FirstAsync();
            CgglScxm scxm = new CgglScxm()
            {
                BSM = Guid.NewGuid().ToStringN(),
                XMMC = zjrw.RWMC,
                GHLX = zjrw.GHLX,
                XZQDM = zjrw.XZQDM,
                XZQMC = zjrw.XZQMC,
                SCZT = "待审",
                GZL_BSM = input.GZL_BSM,
                QXCG_BSM = zjrw.QXCG_BSM,
                CG_BSM = zjrw.CG_BSM,
                ZJ_BSM = zjrw.BSM,
                CJRY = input.CJRY,
                CJSJ = DateTime.Now,
                SCSJ_KS = DateTime.Now,
            };
            var delList = new List<string>();
            //添加流程
            List<CgglGzlsp> splc = NextLc(input.GZL_BSM, scxm.BSM, null, null, ref delList);
            try
            {
                cg.ZT = KJGH.Model.Enums.EnumCgglCgZT.人工审查;
                cg.ZT_RGSC = KJGH.Model.Enums.EnumCgscZT.审查中;
                Db.BeginTran();
                await Db.Insertable(scxm).ExecuteCommandIdentityIntoEntityAsync();
                await Db.Updateable(cg).ExecuteCommandAsync();
                if (splc != null && splc.Count > 0)
                    await Db.Insertable(splc).ExecuteCommandIdentityIntoEntityAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 添加数据（从成果跳过）
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ZjToAddByTg(CgglScxmToRgDto input)
        {
            var cg = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.JS_BSM).FirstAsync();
            #region 检查目录
            //检查目录
            var cgpath = FileManage.Instance.ToFullPath(cg.CGML);
            var sjbz_bsm = cg.GHJB + cg.GHLX;
            if (cg.GHLX == EnumGHLX.村庄规划)
            {
                sjbz_bsm = cg.GHLX + cg.CGXS;
            }
            var errorFile = await _ICgzjSjbzRepository.FileCheck(sjbz_bsm, cg.XZQDM, cg.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);
            #endregion

            //var zjrw = await _ICgzjZjrwRepository.GetAsync(t => t.BSM == input.JS_BSM);
            CgglScxm scxm = new CgglScxm()
            {
                BSM = Guid.NewGuid().ToStringN(),
                XMMC = cg.XMMC,
                GHLX = cg.GHLX,
                XZQDM = cg.XZQDM,
                XZQMC = cg.XZQMC,
                SCZT = "待审",
                GZL_BSM = input.GZL_BSM,
                QXCG_BSM = cg.QXCG_BSM,
                CG_BSM = cg.BSM,
                ZJ_BSM = cg.BSM,
                CJRY = input.CJRY,
                CJSJ = DateTime.Now,
                SCSJ_KS = DateTime.Now,
            };
            var delList = new List<string>();
            //添加流程
            List<CgglGzlsp> splc = NextLc(input.GZL_BSM, scxm.BSM, null, null, ref delList);
            try
            {
                cg.ZT = KJGH.Model.Enums.EnumCgglCgZT.人工审查;
                cg.ZT_JQSC = KJGH.Model.Enums.EnumCgscZT.未提交;
                cg.ZT_RGSC = KJGH.Model.Enums.EnumCgscZT.审查中;
                Db.BeginTran();
                await Db.Insertable(scxm).ExecuteCommandIdentityIntoEntityAsync();
                await Db.Updateable(cg).ExecuteCommandAsync();
                if (splc != null && splc.Count > 0)
                    await Db.Insertable(splc).ExecuteCommandIdentityIntoEntityAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 添加数据（区县上报-跳过机检查）
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ZjToAddByCg(CgglScxmToRgDto input)
        {
            var cg = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.JS_BSM).FirstAsync();
            if (cg != null)
            {
                throw new UseArgumentException("成果管理中存在相同的成果数据");
            }
            //区县成果
            var model = await _ICghjQxcgRepository.GetAsync(t => t.BSM == input.JS_BSM);
            model.SCZT = "审查中";
            model.SCSJ_KS = DateTime.Now;
            //区县任务
            var qxrw = await Db.Queryable<CghjQxcgsbrw>().Where(t => t.BSM == model.BSM).FirstAsync();
            var cgml = FileManage.Instance.ToFullPath(model.CGLJ, false);
            var txtInfo = PathHelper.GetFiles(cgml).Where(t => t.EndsWith("基本信息.txt")).FirstOrDefault();
            var info = GhcgInfoHelper.ReadFile(txtInfo);
            var cgglCg = info.MapTo<CgglCg>();
            cgglCg.BSM = model.BSM;
            cgglCg.CGB = model.CGB;
            cgglCg.CGML = model.CGLJ;
            cgglCg.ZT = KJGH.Model.Enums.EnumCgglCgZT.人工审查;
            cgglCg.ZT_JQSC = KJGH.Model.Enums.EnumCgscZT.未提交;
            cgglCg.ZT_RGSC = KJGH.Model.Enums.EnumCgscZT.审查中;
            cgglCg.QXCG_BSM = model.BSM;
            cgglCg.CGFPS = qxrw.TOTAL;
            cgglCg.INSTID = model.INSTID;

            CgglScxm scxm = new CgglScxm()
            {
                BSM = Guid.NewGuid().ToStringN(),
                XMMC = cgglCg.XMMC,
                GHLX = cgglCg.GHLX,
                XZQDM = cgglCg.XZQDM,
                XZQMC = cgglCg.XZQMC,
                SCZT = "待审",
                GZL_BSM = input.GZL_BSM,
                QXCG_BSM = cgglCg.BSM,
                CG_BSM = cgglCg.BSM,
                ZJ_BSM = cgglCg.BSM,
                CJRY = input.CJRY,
                CJSJ = DateTime.Now,
                SCSJ_KS = DateTime.Now,
            };
            var delList = new List<string>();
            //添加流程
            List<CgglGzlsp> splc = NextLc(input.GZL_BSM, scxm.BSM, null, null, ref delList);
            try
            {
                Db.BeginTran();
                await Db.Insertable(cgglCg).ExecuteCommandIdentityIntoEntityAsync();
                await Db.Updateable(model).ExecuteCommandAsync();
                await Db.Insertable(scxm).ExecuteCommandIdentityIntoEntityAsync();
                if (splc != null && splc.Count > 0)
                    await Db.Insertable(splc).ExecuteCommandIdentityIntoEntityAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 成果审批
        /// </summary>
        public async Task<bool> SpLc(CgspInput sp)
        {
            List<CgglGzlsp> nextLcList = new List<CgglGzlsp>();
            bool endlc = false;
            if (string.IsNullOrWhiteSpace(sp.SPZT))
            {
                return await AuditStatus(sp);
            }
            //当前审批流程
            var splc = await Db.Queryable<CgglGzlsp>().Where(t => t.ID == sp.ID).FirstAsync();
            //当前审批节点
            var spjd = await Db.Queryable<CgglGzljd, CgglGzllc>((a, b) => new JoinQueryInfos(
                 JoinType.Inner, a.ID == b.DQJD))
                .Where((a, b) => b.ID == splc.LC_BSM)
                .FirstAsync();
            splc.SPSJ = DateTime.Now;
            splc.SPYJ = sp.SPYJ;
            splc.SPZT = sp.SPZT;
            var delList = new List<string>();
            CgglScxm scxm = null;
            CgglCg cgglCg = null;
            if (splc.SPZT == "通过")
            {
                nextLcList = NextLc(spjd.GZL_ID, splc.RW_BSM, spjd.ID, splc.SPR, ref delList);
                endlc = nextLcList == null;//报告
            }
            else if (splc.SPZT == "审查中")
            {
                scxm = Db.Queryable<CgglScxm>().Where(t => t.BSM == splc.RW_BSM).First();
                scxm.SCZT = splc.SPZT;
                if (scxm.SCSJ_KS == null)
                    scxm.SCSJ_KS = DateTime.Now;
            }
            else if (splc.SPZT == "退回")
            {
                scxm = Db.Queryable<CgglScxm>().Where(t => t.BSM == splc.RW_BSM).First();
                scxm.SCZT = splc.SPZT;
                scxm.SCJG = splc.ID;
                scxm.SCSJ_JS = DateTime.Now;
                cgglCg = Db.Queryable<CgglCg>().Where(t => t.BSM == scxm.CG_BSM).First();
                cgglCg.ZT_RGSC = EnumCgscZT.退回;
            }
            try
            {
                Db.BeginTran();
                await Db.Updateable(splc).ExecuteCommandAsync();
                if(nextLcList != null && nextLcList.Count > 0)
                    await Db.Insertable(nextLcList).ExecuteCommandIdentityIntoEntityAsync();
                if (delList != null && delList.Count > 0)
                    await Db.Deleteable<CgglGzlsp>().Where(t => delList.Contains(t.ID)).ExecuteCommandAsync();
                if (scxm != null)
                    await Db.Updateable(scxm).ExecuteCommandAsync();
                if (cgglCg != null)
                    await Db.Updateable(cgglCg).ExecuteCommandAsync();

                //结束
                if (endlc)
                {
                    await EndscLc(new CgspEndInput()
                    {
                        SCXM_BSM = splc.RW_BSM,
                        SCJG = string.Empty,
                        SCZT = "完结",
                    });
                }
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 获取下一流程
        /// </summary>
        /// <param name="lcid">流程编码</param>
        /// <param name="rwid">任务编码</param>
        /// <param name="jdid">当前完成节点</param>
        /// <param name="jdid">审批人</param>
        /// <returns>null结束  []没有下审批完  否则返回下一流程</returns>
        public List<CgglGzlsp> NextLc(string lcid, string rwid, string jdid, string user, ref List<string> delsp)
        {
            List<CgglGzlsp> splcList = new List<CgglGzlsp>();
            //1.获取下一流程
            var xylcs = Db.Queryable<CgglGzllc>().Where(t => t.GZL_ID == lcid)
                .WhereIF(string.IsNullOrWhiteSpace(jdid), t => string.IsNullOrWhiteSpace(t.SYJD))
                .WhereIF(!string.IsNullOrWhiteSpace(jdid),t => t.SYJD == jdid)
                .ToList();
            //2.获取所有审批流程
            var splc = Db.Queryable<CgglGzlsp>().Where(t => t.RW_BSM == rwid).ToList();
            //3.获取当前流程所涉及的所有审批人
            var sprs = Db.Queryable<CgglGzljdspyh, CgglGzllc>((a, b) => new JoinQueryInfos(
                 JoinType.Inner, a.JD_ID == b.DQJD))
                .Where((a, b) => b.GZL_ID == lcid)
                //.WhereIF(string.IsNullOrWhiteSpace(jdid),(a,b)=>string.IsNullOrWhiteSpace(b.SYJD))
                //.WhereIF(!string.IsNullOrWhiteSpace(jdid),(a,b)=> b.SYJD == jdid)
                .Select((a,b)=>a)
                .ToList();

            //第一次
            if (string.IsNullOrWhiteSpace(jdid))
            {
                if (xylcs == null || xylcs.Count < 1)
                    throw new UseMassageException("流程错误");
                splcList = new List<CgglGzlsp>();
                foreach (var item in xylcs)
                {
                    var jsapr = sprs.Where(t => t.JD_ID == item.DQJD).ToList();
                    foreach (var spr in jsapr)
                    {
                        CgglGzlsp lc = new CgglGzlsp()
                        {
                            SPZT = "待审",
                            ID = Guid.NewGuid().ToStringN(),
                            IS_DELETE = KJGH.Model.EnumDelete.Mormal,
                            RW_BSM = rwid,
                            RECEIVE_TIME = DateTime.Now,
                            LC_BSM = item.ID,
                            SPR = spr.SPR,
                            SPRMC = spr.SPRMC
                        };
                        splcList.Add(lc);
                    }
                }
            }
            else 
            {
                //1.获取当前流程
                var dqlcs = Db.Queryable<CgglGzllc>().Where(t => t.DQJD == jdid && t.GZL_ID == lcid).First();
                //获取当前节点
                var jd = Db.Queryable<CgglGzljd>().Where(t => t.ID == jdid && t.GZL_ID == lcid).First();

                //检查当前节点是否全部审批完成
                var wwcSP = splc.Where(t => t.LC_BSM == dqlcs.ID && t.SPZT == "待审" && t.SPR != user).ToList();
                if (jd.SFQB == EnumBool.Yes && wwcSP.Count > 0)
                {
                    //未完成所有审批，返回
                    return splcList;
                }
                else if(wwcSP.Count > 0)
                {
                    //不要求全部审批，删除没有审批的任务
                    delsp.AddRange(wwcSP.Select(t => t.ID));
                }

                //结束
                if(jd.JDLX == KJGH.Model.Enums.EnumGzljdLX.结束)
                {
                    return null;
                }

                ///子流程
                foreach (var item in xylcs)
                {
                    var jsapr = sprs.Where(t => t.JD_ID == item.DQJD).ToList();
                    foreach (var spr in jsapr)
                    {
                        CgglGzlsp lc = new CgglGzlsp()
                        {
                            SPZT = "待审",
                            ID = Guid.NewGuid().ToStringN(),
                            IS_DELETE = KJGH.Model.EnumDelete.Mormal,
                            RW_BSM = rwid,
                            RECEIVE_TIME = DateTime.Now,
                            LC_BSM = item.ID,
                            SPR = spr.SPR,
                            SPRMC = spr.SPRMC
                        };
                        splcList.Add(lc);
                    }
                }
            }
            return splcList;
        }


        /// <summary>
        /// 结束流程
        /// </summary>
        public async Task<bool> EndscLc(CgspEndInput input)
        {
            CgglScxm cgglScxm = await GetAsync(t => t.BSM == input.SCXM_BSM);
            cgglScxm.SCZT = input.SCZT;
            cgglScxm.SCSJ_JS = DateTime.Now;
            cgglScxm.SCJG = input.SCJG;
            //cgglScxm.SCBG = input.SCBG;//TODO：报告

            CgglCg cgglCg = Db.Queryable<CgglCg>().Where(t => t.BSM == cgglScxm.CG_BSM).First();
            cgglCg.ZT = KJGH.Model.Enums.EnumCgglCgZT.成果上报;
            cgglCg.ZT_RGSC = input.SCZT == "完结" ? KJGH.Model.Enums.EnumCgscZT.审查通过 : KJGH.Model.Enums.EnumCgscZT.退回; //TODO：不通过
            await Db.Updateable(cgglScxm).ExecuteCommandAsync();
            await Db.Updateable(cgglCg).ExecuteCommandAsync();

            #region 报告
            var filePath = await CreateReport(cgglScxm);
            #endregion
            return true;
        }

        /// <summary>
        /// 结束流程
        /// </summary>
        public async Task<bool> EndLc(CgspEndInput input)
        {
            try
            {
                Db.BeginTran();
                await EndscLc(input);
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("操作失败");
            }
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="list"></param>
        /// <param name="trees"></param>
        /// <param name="sjml"></param>
        private void ParseTree(List<CgglCgmlgz> list, List<Tree> trees, List<Tree> files, string sjml)
        {
            List<CgglCgmlgz> result = list.Where(a => a.SJML == sjml).ToList();

            foreach (var item in result)
            {
                var treeModel = new Tree();
                treeModel.label = item.MLMC;
                treeModel.value = item.BSM;
                treeModel.parent = item.SJML;
                treeModel.IsParent = true;
                treeModel.children = files.Where(u => u.parent == item.BSM).ToList();
                //递归
                ParseTree(list, treeModel.children, files, treeModel.value);
                trees.Add(treeModel);
            }
        }

        /// <summary>
        /// 根据标识码查看详细信息
        /// </summary>
        /// <param name="bsm"></param>
        /// <returns></returns>
        public async Task<CgglScxmView> QueryById(string bsm)
        {
            var model = (await CheckId(bsm)).MapTo<CgglScxmView>();
            var cgModel = Db.Queryable<CgglCg>().Where(t => t.BSM == model.CG_BSM).First();
            //查询审查意见列表
            var db = DbClient();

            var scyj = db.Queryable<CgglScyj, SysUser>((a, b) => new JoinQueryInfos(
               JoinType.Left, a.SCYH == b.ID && b.IS_DELETE ==  KJGH.Model.EnumBool.Yes)).Where((a, b) => a.CG_BSM == model.BSM).Select((a, b) => new CgglScyjDetailDto
               {
                   BSM = a.BSM,
                   CG_BSM = a.CG_BSM,
                   SCYH = b.NAME,
                   SCSJ = a.SCSJ,
                   SCYJ = a.SCYJ,
                   STATUS = a.STATUS
               }).ToList();


            //查询树结构
            var catalogRules = db.Queryable<CgglCgmlgz>().ToList();
            //递归解析数据
            var path = FileManage.Instance.ToFullPath(cgModel.CGB, false);
            var treeModels = FileHelp.FileCatalog(path.Substring(0,path.LastIndexOf('.')));

            //var files = db.Queryable<CgglWjgz, CgglCgsj>((a, b) => new JoinQueryInfos(
            //     JoinType.Inner, a.BSM == b.MLBSM && b.XMBSM == model.BSM))
            //    .Select((a, b) => new Tree { value = a.BSM, parent = a.CGML_BSM, label = b.CGMC, filepath = b.CGLJ, IsParent = false })
            //    .ToList();

            //ParseTree(catalogRules, treeModels, files, null);
            //审查报告
            if (!string.IsNullOrWhiteSpace(model.SCJG))
            {
                var filePath = FileManage.Instance.ToFullPath(model.SCJG, false);
                var pdfFile = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".pdf");
                if (!File.Exists(pdfFile))
                {
                    var pdfExe = ConfigHelper.Configuration["File:PdfExe"];
                    var exeFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, pdfExe);
                    var p = Process.Start(exeFile, $"\"{filePath}\" \"{pdfFile}\"");
                    p.WaitForExit();
                }
                treeModels.Add(new Tree()
                {
                    label = Path.GetFileName(pdfFile),
                    filepath = FileManage.Instance.ToRelativePath(pdfFile),
                    IsParent = false,
                    value = model.BSM + "SCBG"
                });
            }
            model.cgglScyj = scyj;
            model.Trees = treeModels;
            return model;
        }


        /// <summary>
        /// 成果标识码获取
        /// </summary>
        /// <param name="bsm">成果标识码</param>
        /// <returns></returns>
        public async Task<CgglGzlsp> QueryByCgbsm(string bsm)
        {
            var model = (await Db.Queryable<CgglScxm>().Where(t=>t.CG_BSM == bsm).FirstAsync()).MapTo<CgglScxmView>();
            var splc = await Db.Queryable<CgglGzlsp>().Where(t => t.ID == model.SCJG).FirstAsync();
            return splc;
        }

        /// <summary>
        /// 修改审核意见
        /// </summary>
        /// <param name="bsm"></param>
        /// <returns></returns>
        public async Task<bool> AuditStatus(CgspInput input)
        {
            return await Db.Updateable<CgglGzlsp>().SetColumns(u => new CgglGzlsp { SPYJ = input.SPYJ })
                .Where(u=>u.ID == input.ID).ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 分页查询审查数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageData> QueryList(CgglScxmPage input)
        {
            PageData page = null;
            if (input.SCZT == "完成")
            {
                var query = DbClient().Queryable<CgglScxm, CgglCg, CghjQxcg>((t, b, c) => new JoinQueryInfos(
                    JoinType.Inner, t.CG_BSM == b.BSM, JoinType.Left, b.BSM == c.BSM));
                if (!string.IsNullOrWhiteSpace(input.XZQDM))
                    query.Where((t, b, c) => t.XZQDM.StartsWith(input.XZQDM));
                if (!string.IsNullOrWhiteSpace(input.XMMC))
                    query.Where((t, b, c) => t.XMMC.Contains(input.XMMC));
                if (!string.IsNullOrWhiteSpace(input.GHLX))
                    query.Where((t, b, c) => t.GHLX == input.GHLX);
                query.WhereIF(input.SBZT != null, (t, b, c) => b.ZT_CGSB == (EnumCgsbZT)input.SBZT);
                query.WhereIF(input.INSTID == "0", (t, b, c) => string.IsNullOrEmpty(b.INSTID));
                query.WhereIF(input.INSTID == "1", (t, b, c) => b.INSTID != null);
                query.WhereIF(!string.IsNullOrWhiteSpace(input.GHJB), (t, b, c) => b.GHJB.Contains(input.GHJB));
                query.Where((t, b, c) => t.SCZT == "完结");
                query.OrderBy((t, b, c) => t.SCSJ_JS, OrderByType.Desc);
                page = await query.Select((t, b, c) =>
                    new CgglScxmView()
                    {
                        BSM = t.BSM,
                        CG_BSM = t.CG_BSM,
                        GHLX = t.GHLX,
                        GZL_BSM = t.GZL_BSM,
                        QXCG_BSM = t.QXCG_BSM,
                        SCBG = t.SCBG,
                        SCJG = t.SCJG,
                        SCSJ_JS = t.SCSJ_JS,
                        SCSJ_KS = t.SCSJ_KS,
                        SCZT = t.SCZT,
                        XMBH = t.XMBH,
                        XMMC = t.XMMC,
                        XZQDM = t.XZQDM,
                        XZQMC = t.XZQMC,
                        ZJ_BSM = t.ZJ_BSM,
                        CGB = b.CGB,
                        ZT = b.ZT,
                        ZT_CGSB = b.ZT_CGSB,
                        SBSJ_ZT = c.SBSJ_ZT,
                        SBSJ_JD = c.SBSJ_JD,
                        SBSJ_SBYY = c.SBSJ_SBYY,
                        SBSJ_SJ = c.SBSJ_SJ,
                        SBSJ_YH = c.SBSJ_YH,
                        SBSJ_YHM = c.SBSJ_YHM,
                        INSTID = b.INSTID,
                        GHJB = b.GHJB
                    }).ToPageAsync(input.page, input.limit);
            }
            else
            {
                var query = Db.Queryable<CgglGzlsp, CgglScxm, CgglCg>((t, b, c) => new JoinQueryInfos(
                    JoinType.Inner, t.RW_BSM == b.BSM, JoinType.Inner, b.CG_BSM == c.BSM))
                    .Where((t, b, c) => t.SPR == input.USER)
                    .WhereIF(!string.IsNullOrWhiteSpace(input.XZQDM), (t, b, c) => c.XZQDM.StartsWith(input.XZQDM))
                    .WhereIF(!string.IsNullOrWhiteSpace(input.XMMC), (t, b, c) => b.XMMC.Contains(input.XMMC))
                    .WhereIF(input.INSTID == "0", (t, b, c) => string.IsNullOrEmpty(c.INSTID))
                    .WhereIF(input.INSTID == "1", (t, b, c) => c.INSTID != null)
                    .WhereIF(!string.IsNullOrWhiteSpace(input.GHJB), (t, b, c) => c.GHJB.Contains(input.GHJB));

                if (input.SCZT == "通过" || input.SCZT == "已审查")
                    {
                        query.Where((t, b, c) => t.SPZT == "通过" || t.SPZT == "退回");
                    }
                    else
                    {
                        query.Where((t, b, c) => t.SPZT == input.SCZT);
                    }
                page = await query.OrderBy((t, b, c) => t.RECEIVE_TIME, OrderByType.Desc)
                    .Select((t, b, c) => new CgglGzlspView
                    {
                        IS_DELETE = t.IS_DELETE,
                        LC_BSM = t.LC_BSM,
                        ID = t.ID,
                        FJ = t.FJ,
                        RECEIVE_TIME = t.RECEIVE_TIME,
                        REMARKS = t.REMARKS,
                        RW_BSM = t.RW_BSM,
                        SPR = t.SPR,
                        SPRMC = t.SPRMC,
                        SPSJ = t.SPSJ,
                        SPYJ = t.SPYJ,
                        SPZT = t.SPZT,
                        CG_BSM = c.BSM,
                        CGB = c.CGB,
                        GHJB = c.GHJB,
                        GHLX = c.GHLX,
                        QXCG_BSM = c.QXCG_BSM,
                        XMMC = c.XMMC,
                        XZQDM = c.XZQDM,
                        XZQMC = c.XZQMC,
                        ZT = c.ZT,
                        ZT_RGSC = c.ZT_RGSC,
                        INSTID = c.INSTID,
                    })
                    .ToPageAsync(input.page, input.limit);
            }
            return page;
        }

        /// <summary>
        /// 根据审核状态查询总条数
        /// </summary>
        /// <returns></returns>
        public List<CgglScxmCount> QueryCount(string uid)
        {
            var list = Db.Queryable<CgglGzlsp, CgglScxm, CgglCg>((t, b, c) => new JoinQueryInfos(
                JoinType.Left, t.RW_BSM == b.BSM, JoinType.Left, b.CG_BSM == c.BSM))
                .Where((t, b, c) => t.SPR == uid)
                .GroupBy((t, b, c) => t.SPZT)
                .Select((t, b, c) => new CgglScxmCount
                {
                    ztmc = t.SPZT,
                    count = SqlFunc.AggregateCount(t.ID)
                }).ToList();
            return list;
        }

        /// <summary>
        /// 获取审查列表
        /// </summary>
        /// <param name="bsm"></param>
        /// <returns></returns>
        public async Task<List<CgglScyjView>> GetScyj(string bsm)
        {
            var list = await Db.Queryable<CgglGzlsp>().Where(t => t.RW_BSM == bsm).OrderBy(t => t.SPSJ).ToListAsync();
            return list.Select(t => new CgglScyjView()
            {
                BSM = t.ID,
                CG_BSM = t.RW_BSM,
                SCSJ = t.SPSJ,
                SCYH = t.SPR,
                SCYJ = t.SPYJ,
                SPZT = t.SPZT,
                SCYHMC=t.SPRMC,
            }).ToList();
        }

        #region 报告
        /// <summary>
        /// 审核完成
        /// </summary>
        /// <param name="bsm">标识码</param>
        /// <param name="sczt">审查状态</param>
        /// <returns></returns>
        public async Task<string> AuditCompleted(string bsm, string sczt = "通过")
        {
            var model = await GetAsync(t => t.BSM == bsm);
            if (model == null)
                throw new UseArgumentException("数据不存在，请检查标识码是否正确");
            var pdf = string.Empty;
            try
            {
             

                Db.BeginTran();
                var filePath = await CreateReport(model);
                var pdfFile = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".pdf");
                pdf = FileManage.Instance.ToRelativePath(pdfFile);
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseArgumentException("服务器错误");
            }
            return pdf;
        }

        /// <summary>
        /// 创建报告
        /// </summary>
        /// <param name="cgglScxm"></param>
        /// <returns></returns>
        private async Task<string> CreateReport(CgglScxm cgglScxm)
        {
            //查询审查意见列表
            var list = Db.Queryable<CgglGzlsp>()
                .Where(t => t.RW_BSM == cgglScxm.BSM)
                .Select(t => new CgglScyjView
                {
                    BSM = t.ID,
                    SCSJ = t.SPSJ,
                    SCYH = t.SPR,
                    SCYHMC = t.SPRMC,
                    SCYJ = t.SPYJ,
                    SPZT = t.SPZT,
                })
                .ToList();
            //创建word返回保存地址
            var filePath = Word($"{cgglScxm.XMMC}成果审查报告_{DateTime.Now:yyyyMMddHHmmss}", list);
            var pdf = string.Empty;
            var pdfExe = ConfigHelper.Configuration["File:PdfExe"];
            var pdfFile = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath) + ".pdf");
            var exeFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, pdfExe);
            var p = Process.Start(exeFile, $"\"{filePath}\" \"{pdfFile}\"");
            p.WaitForExit();
            pdf = FileManage.Instance.ToRelativePath(pdfFile);
            //PDF
            await UpdateAsync(u => new CgglScxm { SCZT = cgglScxm.SCZT, SCSJ_JS = DateTime.Now, SCBG = FileManage.Instance.ToRelativePath(filePath) }, t => t.BSM == cgglScxm.BSM);

            //更新区县
            if (!string.IsNullOrWhiteSpace(cgglScxm.QXCG_BSM))
            {
                await Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg()
                { SCZT = cgglScxm.SCZT == "完结"?"通过": cgglScxm.SCZT, SCJG = FileManage.Instance.ToRelativePath(pdf), SCSJ_JS = DateTime.Now })
                    .Where(it => it.BSM == cgglScxm.QXCG_BSM).ExecuteCommandAsync();
            }
            return filePath;
        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="title">标题</param>
        /// <param name="list">审查意见</param>
        private string Word(string title, List<CgglScyjView> list)
        {
            //创建生成word文档
            string path = $"{FileManage.Instance.ToFullPath(@$"成果审查")}\\{title}.docx";
            XWPFDocument doc = new XWPFDocument();

            // 添加段落
            XWPFParagraph gp = doc.CreateParagraph();
            gp.Alignment = ParagraphAlignment.CENTER;//水平居中
            XWPFRun gr = gp.CreateRun();
            gr.GetCTR().AddNewRPr().AddNewRFonts().ascii = "黑体";
            gr.GetCTR().AddNewRPr().AddNewRFonts().eastAsia = "黑体";
            gr.GetCTR().AddNewRPr().AddNewRFonts().hint = ST_Hint.eastAsia;
            gr.GetCTR().AddNewRPr().AddNewSz().val = (ulong)44;//2号字体
            gr.GetCTR().AddNewRPr().AddNewSzCs().val = (ulong)44;
            gr.GetCTR().AddNewRPr().AddNewB().val = true; //加粗
            //gr.GetCTR().AddNewRPr().AddNewColor().val = "red";//字体颜色
            gr.SetText(title);

            gp = doc.CreateParagraph();
            gp.Alignment = ParagraphAlignment.CENTER;//水平剧中
            gr = gp.CreateRun();
            CT_RPr rpr = gr.GetCTR().AddNewRPr();
            CT_Fonts rfonts = rpr.AddNewRFonts();
            rfonts.ascii = "宋体";
            rfonts.eastAsia = "宋体";
            rpr.AddNewSz().val = (ulong)35;//4号字体
            rpr.AddNewSzCs().val = (ulong)35;
            gr.SetText("成果审查报告");
            gp = doc.CreateParagraph();


            gp = doc.CreateParagraph();
            gr = gp.CreateRun();
            rfonts.ascii = "宋体";
            rfonts.eastAsia = "宋体";
            rpr.AddNewSz().val = (ulong)21;//5号字体
            rpr.AddNewSzCs().val = (ulong)21;
            gr.SetText($"{DateTime.Now.ToLongDateString()}完成对《{title}》的成果审查工作，审查意见如下：");
            gp = doc.CreateParagraph();

            var number = new string[] { "一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十", "二十一", "二十二", "二十三", "二十四", "二十五", "二十六", "二十七", "二十八", "二十九", "三十" };
            int i = 0;
            foreach (var item in list)
            {
                gp = doc.CreateParagraph();
                gr = gp.CreateRun();
                rfonts.ascii = "宋体";
                rfonts.eastAsia = "宋体";
                rpr.AddNewSz().val = (ulong)21;//5号字体
                rpr.AddNewSzCs().val = (ulong)21;
                gr.SetText($"意见{number[i]}({item.SCYHMC})：{item.SCYJ}");
                gp = doc.CreateParagraph();
                i++;
            }


            gp = doc.CreateParagraph();
            gp.Alignment = ParagraphAlignment.RIGHT;//靠左
            gr = gp.CreateRun();
            rfonts.ascii = "宋体";
            rfonts.eastAsia = "宋体";
            rpr.AddNewSz().val = (ulong)21;//5号字体
            rpr.AddNewSzCs().val = (ulong)21;
            gr.SetText(ConfigHelper.Configuration["Dwmc"]);
            gp = doc.CreateParagraph();


            gp = doc.CreateParagraph();
            gp.Alignment = ParagraphAlignment.RIGHT;//靠左
            gr = gp.CreateRun();
            rfonts.ascii = "宋体";
            rfonts.eastAsia = "宋体";
            rpr.AddNewSz().val = (ulong)21;//5号字体
            rpr.AddNewSzCs().val = (ulong)21;
            gr.SetText(DateTime.Now.ToLongDateString());
            gp = doc.CreateParagraph();

            using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
            {
                doc.Write(fs);
            }
            return path;
        }

        #endregion

        #region 成果包上报
        /// <summary>
        /// 成果上报(县 --> 市)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> Cgsb(CgsbIo input)
        {
            CgglCg cgglCg = await Db.Queryable<CgglCg>().Where(t=>t.BSM == input.ID).FirstAsync();
            if(cgglCg.ZT_CGSB != KJGH.Model.Enums.EnumCgsbZT.未提交 && cgglCg.ZT_CGSB != KJGH.Model.Enums.EnumCgsbZT.上报失败)
            {
                //throw new UseMassageException("当前成果已经上报，不能重复提交！");
            }

            cgglCg.ZT = KJGH.Model.Enums.EnumCgglCgZT.成果上报;
            cgglCg.ZT_CGSB = KJGH.Model.Enums.EnumCgsbZT.上报中;
            var path = FileManage.Instance.ToFullPath(Path.GetDirectoryName(cgglCg.CGB), false);
            var fileList = Directory.GetFiles(path).Where(t=> Path.GetFileName(t).StartsWith("_"))
                .ToDictionary(t => Path.GetFileName(t).Replace("_","").ToInt(), t => t).OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
            if(fileList.Count != cgglCg.CGFPS)
            {
                throw new UseMassageException("成果包有误，分包数据不全！");
            }
            var rk = await _ICghjQxcgRepository.IsExistAsync(t => t.BSM == cgglCg.BSM);

            CghjQxcg cghjQxcg = new CghjQxcg()
            {
                BSM = cgglCg.BSM,
                XMMC = cgglCg.XMMC,
                XZQDM = cgglCg.XZQDM,
                XZQMC = cgglCg.XZQMC,
                GHLX = cgglCg.GHLX,
                GHJB = cgglCg.GHJB,
                CGBB = cgglCg.CGBB,
                CGXS = cgglCg.CGXS,
                BZQK = cgglCg.BZQK,
                CGB = cgglCg.CGB,
                CGLJ = cgglCg.CGML,
                SJLY = "1",
                HJSJ = DateTime.Now,
                SCZT = EnumCghjQxcgsbSC.待审.Description(),
                SBSJ_SJ = DateTime.Now,
                SBSJ_YH = input.SBSJ_YH,
                SBSJ_YHM = input.SBSJ_YHM,
                SBSJ_JD = $"0/{cgglCg.CGFPS}",
                SBSJ_ZT = "上报中",
                INSTID = cgglCg.INSTID
            };

            var view = QXApi.Md5(new CghjQxcgsbrwIo()
            {
                MD5 = cgglCg.BSM,
                GHLX = cgglCg.GHLX,
                New = true,
                SIZE = cgglCg.CGFPS
            });
            try
            {
                Db.BeginTran();
                if (rk)
                {
                    await Db.Deleteable<CghjQxcg>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrw>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cgglCg.BSM).ExecuteCommandAsync();
                    Db.CommitTran();
                }
                Db.BeginTran();
                await _ICghjQxcgsbrwRepository.QXAddRw(view);
                await Db.Updateable(cgglCg).ExecuteCommandHasChangeAsync();
                await Db.Insertable(cghjQxcg).ExecuteCommandAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseMassageException("成果上报失败");
            }
            CghjQxcgsbrw rwModel = Db.Queryable<CghjQxcgsbrw>().Where(t=>t.BSM == cgglCg.BSM).First();
            Thread thread = new Thread(() =>
            {
                WS.Log.RunLog.Debug($"开始上传成果：{cgglCg.BSM} ，{rwModel == null}");

                try
                {
                    rwModel.CGLJ = cgglCg.CGML;
                    rwModel.CGWJ = cgglCg.CGB;
                    rwModel.XMMC = cgglCg.XMMC;
                    Db.Updateable(rwModel).ExecuteCommand();
                    WS.Log.RunLog.Debug($"开始上传rwModel：{rwModel.ToJson()}");

                    //分片上传
                    var index = 1;
                    foreach (var chunk in fileList.Keys)
                    {
                        CghjQxcgsbrwfp rwfp = new CghjQxcgsbrwfp()
                        {
                            BSM = Guid.NewGuid().ToString("N"),
                            MD5 = cgglCg.BSM,
                            CHUNK = chunk,
                            PATH = FileManage.Instance.ToRelativePath(fileList[chunk])
                        };
                        Db.Deleteable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cgglCg.BSM && t.CHUNK == chunk).ExecuteCommand();
                        Db.Insertable(rwfp).ExecuteCommand();

                        //更新主表
                        rwModel.RWZT = EnumCghjQxcgsbrw.NoHb;
                        rwModel.TIME = rwfp.SCSJ;
                        Db.Updateable(rwModel).ExecuteCommand();
                        WS.Log.RunLog.Debug($"更新主表11111111111");
                        QXApi.Upload(new CghjQxcgsbrwfpIo_QY()
                        {
                            token = view.token,
                            //MD5 = ApiHelper.GetMD5HashFromFile(fileList[chunk]),//乌兰察布 鄂尔多斯 不传分包MD5
                            MD5 = rwfp.MD5,
                            chunk = chunk,
                        }, fileList[chunk]);
                        WS.Log.RunLog.Debug($"更新主表22222222222");

                        //更新进度
                        Db.Updateable<CghjQxcg>().SetColumns(it => it.SBSJ_JD == $"{index}/{cgglCg.CGFPS}").Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                        index++;
                    }
                    //合包
                    var mst = QXApi.Complete(new CghjQxcgsbrwhbIo_QY()
                    {
                        fileName = Path.GetFileName(cghjQxcg.CGB),
                        MD5 = cgglCg.BSM,
                        token = view.token,
                        SPSJ = DateTime.Now,
                        type = "0",
                        INSTID = cghjQxcg.INSTID
                    });

                    cgglCg.ZT_CGSB = EnumCgsbZT.已上报;
                    rwModel.RWZT = EnumCghjQxcgsbrw.Complete;

                    Db.BeginTran();
                    Db.Updateable(cgglCg).ExecuteCommand();
                    Db.Updateable(rwModel).ExecuteCommand();
                    Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg() { SBSJ_JD = $"{cgglCg.CGFPS}/{cgglCg.CGFPS}", SBSJ_ZT = "上报完成" }).Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    try
                    {
                        _ICghjQxcgsbrwRepository.QXError(cgglCg.BSM, ex.Message);
                    }
                    catch (Exception ex2)
                    {
                        WS.Log.RunLog.Debug($"结束上传失败入库异常：{ex2.Message}");
                    }
                    WS.Log.RunLog.Error(ex);
                    return;
                    //throw new UseMassageException("操作失败");
                }
                WS.Log.RunLog.Debug($"结束上传成果：{cgglCg.XMMC}");
            });
            thread.Start();
            return true;
        }

        /// <summary>
        /// 成果上报(县 --> 巴彦淖尔市)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> CgsbBYNE(IFormFile formFile, CgsbByneIo input)
        {
            CgglCg cgglCg = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.ID).FirstAsync();
            if (cgglCg.ZT_CGSB != EnumCgsbZT.未提交 && cgglCg.ZT_CGSB != EnumCgsbZT.上报失败)
            {
                //throw new UseMassageException("当前成果已经上报，不能重复提交！");
            }
            cgglCg.ZT = EnumCgglCgZT.成果上报;
            cgglCg.ZT_CGSB = EnumCgsbZT.上报中;
            var path = FileManage.Instance.ToFullPath(Path.GetDirectoryName(cgglCg.CGB), false);
            //先保存质检报告
            var zjbgFile =FileUpload.SaveFile(formFile, path, null);
            if (zjbgFile.Size == 0)
                throw new UseMassageException("质检报上传失败（0kb），请重新上传");

            var fileList = Directory.GetFiles(path).Where(t => Path.GetFileName(t).StartsWith("_"))
                .ToDictionary(t => Path.GetFileName(t).Replace("_", "").ToInt(), t => t).OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
            if (fileList.Count != cgglCg.CGFPS)
            {
                throw new UseMassageException("成果包有误，分包数据不全！");
            }
            var rk = await _ICghjQxcgRepository.IsExistAsync(t => t.BSM == cgglCg.BSM);

            CghjQxcg cghjQxcg = new CghjQxcg()
            {
                BSM = cgglCg.BSM,
                XMMC = cgglCg.XMMC,
                XZQDM = cgglCg.XZQDM,
                XZQMC = cgglCg.XZQMC,
                GHLX = cgglCg.GHLX,
                GHJB = cgglCg.GHJB,
                CGBB = cgglCg.CGBB,
                CGXS = cgglCg.CGXS,
                BZQK = cgglCg.BZQK,
                CGB = cgglCg.CGB,
                CGLJ = cgglCg.CGML,
                SJLY = "1",
                HJSJ = DateTime.Now,
                SCZT = EnumCghjQxcgsbSC.待审.Description(),
                SBSJ_SJ = DateTime.Now,
                SBSJ_YH = input.SBSJ_YH,
                SBSJ_YHM = input.SBSJ_YHM,
                SBSJ_JD = $"0/{cgglCg.CGFPS}",
                SBSJ_ZT = "上报中",
                INSTID = cgglCg.INSTID
            };

            WS.Log.RunLog.Debug($"文件MD5检查，{cgglCg.BSM}，入库：{rk}");
            var view = BYNEApi.Md5(new BYNECghjMd5Io()
            {
                fileMd5 = cgglCg.BSM,
                fileName = Path.GetFileName(cghjQxcg.CGB)
            });
            try
            {
                Db.BeginTran();
                if (rk)
                {
                    await Db.Deleteable<CghjQxcg>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrw>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cgglCg.BSM).ExecuteCommandAsync();
                    Db.CommitTran();
                }
                Db.BeginTran();
                CghjQxcgsbrwView_QX cghjQxcgsbrw = new CghjQxcgsbrwView_QX()
                {
                    MD5 = cghjQxcg.BSM,
                    SIZE = cgglCg.CGFPS,
                    New = true,
                    token = view.token,
                    XZQDM = cghjQxcg.XZQDM,
                    XZQMC = cghjQxcg.XZQMC,
                    GHLX = cghjQxcg.GHLX,
                    TIME = DateTime.Now
                };
                await _ICghjQxcgsbrwRepository.QXAddRw(cghjQxcgsbrw);
                await Db.Updateable(cgglCg).ExecuteCommandHasChangeAsync();
                await Db.Insertable(cghjQxcg).ExecuteCommandAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseMassageException("成果上报失败");
            }
            CghjQxcgsbrw rwModel = Db.Queryable<CghjQxcgsbrw>().Where(t => t.BSM == cgglCg.BSM).First();
            Thread thread = new Thread(() =>
            {
                WS.Log.RunLog.Debug($"开始上传成果：{cgglCg.XMMC}");
                try
                {
                    rwModel.CGLJ = cgglCg.CGML;
                    rwModel.CGWJ = cgglCg.CGB;
                    rwModel.XMMC = cgglCg.XMMC;
                    Db.Updateable(rwModel).ExecuteCommand();

                    //分片上传
                    var index = 1;
                    var fileName = Path.GetFileName(cghjQxcg.CGB);
                    FileInfo cgFile = new FileInfo(FileManage.Instance.ToFullPath(cgglCg.CGB, false));
                    var fpFilePath = string.Empty;
                    foreach (var chunk in fileList.Keys)
                    {
                        WS.Log.RunLog.Debug($"分片上传：【{chunk}】{fileList[chunk]}");
                        CghjQxcgsbrwfp rwfp = new CghjQxcgsbrwfp()
                        {
                            BSM = Guid.NewGuid().ToString("N"),
                            MD5 = cgglCg.BSM,
                            CHUNK = chunk, // 当前文件块编号(分片索引)，从1开始
                            PATH = FileManage.Instance.ToRelativePath(fileList[chunk])
                        };
                        Db.Deleteable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cgglCg.BSM && t.CHUNK == chunk).ExecuteCommand();
                        Db.Insertable(rwfp).ExecuteCommand();

                        //更新主表
                        rwModel.RWZT = EnumCghjQxcgsbrw.NoHb;
                        rwModel.TIME = rwfp.SCSJ;
                        Db.Updateable(rwModel).ExecuteCommand();
                        FileInfo fileInfo = new FileInfo(fileList[chunk]);
                        fpFilePath = BYNEApi.Upload(new BYNECghjFpIo_QX()
                        {
                            token = view.token,
                            chunkFileMd5 = ApiHelper.GetMD5HashFromFile(fileList[chunk]),//巴彦淖尔-当前文件的MD5
                            chunkSize = 10 * 1024 * 1024,
                            currentChunk = rwfp.CHUNK,
                            currentChunkSize = (int)fileInfo.Length,
                            fileMd5 = rwfp.MD5,
                            fileName = fileName,
                            totalChunk = cgglCg.CGFPS,
                            totalSize = cgFile.Length
                        }, fileList[chunk]);

                        //更新进度
                        Db.Updateable<CghjQxcg>().SetColumns(it => it.SBSJ_JD == $"{index}/{cgglCg.CGFPS}").Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                        index++;
                    }
                    //合包
                    WS.Log.RunLog.Debug($"合包请求，{cgglCg.BSM}");
                    var fileInfoId = BYNEApi.Merge(new BYNECghjMergeIo()
                    {
                        fileName = Path.GetFileName(cghjQxcg.CGB),
                        fileMd5 = cgglCg.BSM,
                        filePath = fpFilePath,
                        fileSize = cgFile.Length
                    }, view.token);
                    //上报
                    var type = "0";
                    switch (cgglCg.GHLX)
                    {
                        case EnumGHLX.乡镇规划:
                            type = "1";
                            break;
                        case EnumGHLX.专项规划:
                            type = "2";
                            break;
                        case EnumGHLX.总体规划:
                        default:
                            type = "0";
                            break;
                    }
                    WS.Log.RunLog.Debug($"上报请求，{cgglCg.BSM}");
                    BYNEApi.Complete(new BYNECghjIo()
                    {
                        fileInfoId = fileInfoId,
                        name = cgglCg.XMMC,
                        phone = input.phone,
                        remark = input.remark,
                        type = type,
                        wdbh = input.wdbh,
                        year = input.year,
                        xzqdm = cgglCg.XZQDM,
                        xzqmc = cgglCg.XZQMC,
                        instid = cgglCg.INSTID,
                    }, zjbgFile.FullPath, view.token);
                    
                    cgglCg.ZT_CGSB = EnumCgsbZT.已上报;
                    rwModel.RWZT = EnumCghjQxcgsbrw.Complete;
                    Db.BeginTran();
                    Db.Updateable(cgglCg).ExecuteCommand();
                    Db.Updateable(rwModel).ExecuteCommand();
                    Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg() { SBSJ_JD = $"{cgglCg.CGFPS}/{cgglCg.CGFPS}", SBSJ_ZT = "上报完成" }).Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                    Db.CommitTran();
                    WS.Log.RunLog.Debug($"上报完成，{cgglCg.BSM}");
                    Thread.Sleep(1000);
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    try
                    {
                        _ICghjQxcgsbrwRepository.QXError(cgglCg.BSM, ex.Message);
                    }
                    catch (Exception ex2)
                    {
                        WS.Log.RunLog.Debug($"结束上传失败入库异常：{ex2.Message}");
                    }
                    WS.Log.RunLog.Error(ex);
                    return;
                }
                WS.Log.RunLog.Debug($"结束上传成果：{cgglCg.XMMC}");
            });
            thread.Start();
            return true;
        }


        /// <summary>
        /// 成果上报(市 --> 省/自治区)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> SCgsbByQxcgBSM(CgsbIo input)
        {
            CghjQxcg cghjQxcg = await Db.Queryable<CghjQxcg>().Where(t => t.BSM == input.ID).FirstAsync();
            if (cghjQxcg.SBSJ_ZT != "未上报" && cghjQxcg.SBSJ_ZT != "上报失败")
            {
                //throw new UseMassageException("当前成果已经上报，不能重复提交！");
            }
            CgglCg cgglCg = await Db.Queryable<CgglCg>().Where(t => t.QXCG_BSM == input.ID).FirstAsync();
            input.ID = cghjQxcg.BSM;
            return await SCgsb(input);
        }

        /// <summary>
        /// 成果上报(巴彦淖尔县 --> 省/自治区)
        /// </summary>
        public async Task<bool> SCgsbBYNE(CgsbIo input)
        {
            CgglCg cgglCg = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.ID).FirstAsync();
            if (cgglCg.ZT_CGSB != EnumCgsbZT.未提交 && cgglCg.ZT_CGSB != EnumCgsbZT.上报失败)
            {
                //throw new UseMassageException("当前成果已经上报，不能重复提交！");
            }
            cgglCg.ZT = EnumCgglCgZT.成果上报;
            cgglCg.ZT_CGSB = EnumCgsbZT.上报中;
            var path = FileManage.Instance.ToFullPath(Path.GetDirectoryName(cgglCg.CGB), false);
            var fileList = Directory.GetFiles(path).Where(t => Path.GetFileName(t).StartsWith("_"))
                .ToDictionary(t => Path.GetFileName(t).Replace("_", "").ToInt(), t => t).OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
            if (fileList.Count != cgglCg.CGFPS)
            {
                throw new UseMassageException("成果包有误，分包数据不全！");
            }
            var rk = await _ICghjQxcgRepository.IsExistAsync(t => t.BSM == cgglCg.BSM);

            CghjQxcg cghjQxcg = new CghjQxcg()
            {
                BSM = cgglCg.BSM,
                XMMC = cgglCg.XMMC,
                XZQDM = cgglCg.XZQDM,
                XZQMC = cgglCg.XZQMC,
                GHLX = cgglCg.GHLX,
                GHJB = cgglCg.GHJB,
                CGBB = cgglCg.CGBB,
                CGXS = cgglCg.CGXS,
                BZQK = cgglCg.BZQK,
                CGB = cgglCg.CGB,
                CGLJ = cgglCg.CGML,
                SJLY = "1",
                HJSJ = DateTime.Now,
                SCZT = EnumCghjQxcgsbSC.待审.Description(),
                SBSJ_SJ = DateTime.Now,
                SBSJ_YH = input.SBSJ_YH,
                SBSJ_YHM = input.SBSJ_YHM,
                SBSJ_JD = $"0/{cgglCg.CGFPS}",
                SBSJ_ZT = "上报中",
                INSTID = cgglCg.INSTID
            };

            //WS.Log.RunLog.Debug($"文件MD5检查，{cgglCg.BSM}，入库：{rk}");
            //var view = BYNEApi.Md5(new BYNECghjMd5Io()
            //{
            //    fileMd5 = cgglCg.BSM,
            //    fileName = Path.GetFileName(cghjQxcg.CGB)
            //});
            try
            {
                Db.BeginTran();
                if (rk)
                {
                    await Db.Deleteable<CghjQxcg>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrw>().Where(t => t.BSM == cgglCg.BSM).ExecuteCommandAsync();
                    await Db.Deleteable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cgglCg.BSM).ExecuteCommandAsync();
                    Db.CommitTran();
                }
                Db.BeginTran();
                CghjQxcgsbrwView_QX cghjQxcgsbrw = new CghjQxcgsbrwView_QX()
                {
                    MD5 = cghjQxcg.BSM,
                    SIZE = cgglCg.CGFPS,
                    New = true,
                    //token = view.token,
                    XZQDM = cghjQxcg.XZQDM,
                    XZQMC = cghjQxcg.XZQMC,
                    GHLX = cghjQxcg.GHLX,
                    TIME = DateTime.Now
                };
                await _ICghjQxcgsbrwRepository.QXAddRw(cghjQxcgsbrw);
                await Db.Updateable(cgglCg).ExecuteCommandHasChangeAsync();
                await Db.Insertable(cghjQxcg).ExecuteCommandAsync();
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                WS.Log.RunLog.Error(ex);
                throw new UseMassageException("成果上报失败");
            }
            CghjQxcgsbrw rwModel = Db.Queryable<CghjQxcgsbrw>().Where(t => t.BSM == cgglCg.BSM).First();

            Thread thread = new Thread(() =>
            {
                WS.Log.RunLog.Debug($"开始上传成果(县-->省/自治区)：{cgglCg.XMMC}");
                try
                {
                    var md5Data = ZZQApi.Md5(new NmCgMd5Io()
                    {
                        fileMd5 = cgglCg.BSM,
                        fileSize = 10 * 1024 * 1024,
                        fileName = Path.GetFileName(cgglCg.CGB),
                        totalSliceNum = cgglCg.CGFPS,
                        curSliceOrder = 0,
                        resetSliceOrder2Zero = !input.xc,
                        instId = cgglCg.INSTID
                    });

                    //分片上传
                    var index = 1;
                    var chazhi = fileList.Keys.First() == 0 ? 0 : 1;
                    foreach (var chunk in fileList.Keys)
                    {
                        var curOrder = chunk - chazhi;
                        if (input.xc && curOrder < md5Data.curSliceOrder)
                        {
                            continue;
                        }

                        WS.Log.RunLog.Debug($"分片上传：【{chunk}】{fileList[chunk]}");
                        FileInfo fileInfo = new FileInfo(fileList[chunk]);
                        NmCgUploadSplitIo inputU = new NmCgUploadSplitIo()
                        {
                            xmmc = cgglCg.XMMC,
                            XZQDM = cgglCg.XZQDM,
                            XZQMC = cgglCg.XZQMC,
                            token = md5Data.token,
                            ghlx = cgglCg.GHLX,
                            year = string.IsNullOrWhiteSpace(input.year) ? DateTime.Now.Year.ToString() : input.year,
                            name = Path.GetFileName(cgglCg.CGB),
                            zipMd5 = cgglCg.BSM,
                            totalSliceNum = cgglCg.CGFPS,
                            curSliceOrder = curOrder,
                            curSliceSize = 10 * 1024 * 1024,
                            resetSliceOrder2Zero = !input.xc,
                            instId = cgglCg.INSTID
                        };
                        WS.Log.RunLog.Debug($"分片上传参数：{inputU.ToJson()}");

                        bool res = false;
                        switch (inputU.ghlx)
                        {
                            case EnumGHLX.总体规划:
                            case EnumGHLX.专项规划:
                                res = ZZQApi.Upload(inputU, fileList[chunk]);
                                break;
                            case EnumGHLX.村庄规划:
                            case EnumGHLX.乡镇规划:
                                res = ZZQApi.TownUpload(inputU, fileList[chunk]);
                                break;
                            default:
                                throw new UseMassageException($"暂未实现{inputU.ghlx}成果数据的上传");
                        }
                        WS.Log.RunLog.Debug($"分片上传：【{chunk}】{res}");

                        //更新进度
                        Db.Updateable<CghjQxcg>().SetColumns(it => it.SBSJ_JD == $"{index}/{cgglCg.CGFPS}").Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                        index++;
                        Thread.Sleep(1000);
                    }
                    Db.BeginTran();
                    Db.Updateable<CgglCg>().SetColumns(it => new CgglCg() { ZT_CGSB = EnumCgsbZT.已上报 }).Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                    Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg() { SBSJ_JD = $"{cgglCg.CGFPS}/{cgglCg.CGFPS}", SBSJ_ZT = "上报完成" }).Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                    Db.CommitTran();
                    WS.Log.RunLog.Debug($"上传完成：{cgglCg.XMMC}");
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    try
                    {
                        _ICghjQxcgsbrwRepository.QXError(cgglCg.BSM, ex.Message);
                    }
                    catch (Exception ex2)
                    {
                        WS.Log.RunLog.Debug($"结束上传失败入库异常：{ex2.Message}");
                    }
                    WS.Log.RunLog.Error(ex);
                    return;
                }
                WS.Log.RunLog.Debug($"结束上传成果：{cgglCg.XMMC}");
            });
            thread.Start();
            return true;
        }
        #endregion

        #region 市平台
        public class xzqdm
        {
            public string BSM { set; get; }
            public string XZQDM { set; get; }
            public string XZQMC { set; get; }
            public string XMMC { set; get; }
            public int RW { set; get; }
        }
        /// <summary>
        /// 分页查询审查数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<PageData> QueryListCity(CgglScxmPage input)
        {
            PageData page = null;
            if (input.SCZT == "完成")
            {
                //用例1:连写
                var exp = Expressionable.Create<CgglScxmView>() //创建表达式
                    .And(t => t.SCZT == "完结")
                    .AndIF(!string.IsNullOrWhiteSpace(input.XZQDM), t => t.XZQDM.StartsWith(input.XZQDM))
                    .AndIF(!string.IsNullOrWhiteSpace(input.XMMC), t => t.XMMC.Contains(input.XMMC))
                    .AndIF(!string.IsNullOrWhiteSpace(input.GHLX), t => t.GHLX == input.GHLX)
                    .AndIF(!string.IsNullOrWhiteSpace(input.XMLY) && input.XMLY == "0", t => string.IsNullOrWhiteSpace(t.QXCG_BSM))
                    .AndIF(!string.IsNullOrWhiteSpace(input.XMLY) && input.XMLY == "1", t => t.QXCG_BSM != null)
                    .AndIF(input.SBZT != null, t => t.ZT_CGSB == (EnumCgsbZT)input.SBZT)
                    .AndIF(input.KSSJ != null, t => t.SBSJ_SJ >= input.KSSJ.Value)
                    .AndIF(input.JSSJ != null, t => t.SBSJ_SJ <= input.JSSJ.Value)
                    .AndIF(input.INSTID == "0", t => string.IsNullOrEmpty(t.INSTID))
                    .AndIF(input.INSTID == "1", t => t.INSTID != null)
                    .AndIF(!string.IsNullOrWhiteSpace(input.GHJB), t => t.GHJB.Contains(input.GHJB))
                    .ToExpression();//注意 这一句 不能少

                var query = DbClient().Queryable<CgglScxmView>().Where(exp);

                //只查重复
                if (input.SJCC == "0")
                {
                    //var query2 = Db.SqlQueryable<xzqdm>("select XZQDM from V_CGSCXM group by XZQDM having count(XZQDM) > 1");
                    //var query2 = Db.SqlQueryable<xzqdm>($"select {input.CCZD} from V_CGSCXM where group by {input.CCZD} having count(*) > 1");
                    var query2 = DbClient().Queryable<CgglScxmView>().Where(exp).Select(input.CCZD).GroupBy($"{input.CCZD} having count(*) > 1");
                    if (input.CCZD.Contains("XZQDM") && input.CCZD.Contains("XZQMC") && input.CCZD.Contains("XMMC"))
                        query = query.InnerJoin(query2, (t, d) => t.XZQDM == d.XZQDM && t.XZQMC == d.XZQMC && t.XMMC == d.XMMC).OrderBy(t => t.XZQDM);
                    else if (input.CCZD.Contains("XZQDM") && input.CCZD.Contains("XZQMC"))
                        query = query.InnerJoin(query2, (t, d) => t.XZQDM == d.XZQDM && t.XZQMC == d.XZQMC).OrderBy(t => t.XZQDM).OrderBy(t => t.XZQMC);
                    else if (input.CCZD.Contains("XZQDM") && input.CCZD.Contains("XMMC"))
                        query = query.InnerJoin(query2, (t, d) => t.XZQDM == d.XZQDM && t.XMMC == d.XMMC).OrderBy(t => t.XZQDM).OrderBy(t => t.XMMC);
                    else if (input.CCZD.Contains("XZQDM"))
                        query = query.InnerJoin(query2, (t, d) => t.XZQDM == d.XZQDM).OrderBy(t => t.XZQDM);
                    else if (input.CCZD.Contains("XZQMC"))
                        query = query.InnerJoin(query2, (t, d) => t.XZQMC == d.XZQMC).OrderBy(t => t.XZQMC);
                    else if (input.CCZD.Contains("XMMC"))
                        query = query.InnerJoin(query2, (t, d) => t.XMMC == d.XMMC).OrderBy(t => t.XMMC);
                }
                //去重查询
                else if (input.SJCC == "1")
                {
                    //var query2 = Db.SqlQueryable<xzqdm>($"SELECT A.BSM,ROW_NUMBER() OVER(PARTITION BY {input.CCZD} ORDER BY SCSJ_KS DESC) RW FROM V_CGSCXM A");
                    var query2 = DbClient().Queryable<CgglScxmView>().Where(exp).Select<xzqdm>($"BSM,ROW_NUMBER() OVER(PARTITION BY {input.CCZD} ORDER BY SCSJ_KS DESC) RW");
                    query = query.InnerJoin(query2, (t, d) => t.BSM == d.BSM && d.RW == 1);
                }
                page = await query.OrderBy(t => t.SCSJ_JS, OrderByType.Desc)
                    .ToPageAsync(input.page, input.limit);
                var sql = query.ToSqlString();
            }
            else
            {
                var query = Db.Queryable<CgglGzlsp, CgglScxm, CgglCg>((t, b, c) => new JoinQueryInfos(
                    JoinType.Inner, t.RW_BSM == b.BSM, JoinType.Inner, b.CG_BSM == c.BSM))
                    .Where((t, b, c) => t.SPR == input.USER)
                    .WhereIF(!string.IsNullOrWhiteSpace(input.XZQDM), (t, b, c) => c.XZQDM.StartsWith(input.XZQDM))
                    .WhereIF(!string.IsNullOrWhiteSpace(input.XMMC), (t, b, c) => b.XMMC.Contains(input.XMMC))
                    .WhereIF(input.INSTID == "0", (t, b, c) => string.IsNullOrEmpty(c.INSTID))
                    .WhereIF(input.INSTID == "1", (t, b, c) => c.INSTID != null)
                    .WhereIF(!string.IsNullOrWhiteSpace(input.GHJB), (t, b, c) => c.GHJB == input.GHJB)
                    .WhereIF(!string.IsNullOrWhiteSpace(input.GHLX), (t, b, c) => c.GHLX == input.GHLX);


                if (input.SCZT == "通过" || input.SCZT == "已审查")
                    {
                        query.Where((t, b, c) => t.SPZT == "通过" || t.SPZT == "退回");
                    }
                    else
                    {
                        query.Where((t, b, c) => t.SPZT == input.SCZT);
                    }
                page = await query.OrderBy((t, b, c) => t.RECEIVE_TIME, OrderByType.Desc)
                    .Select((t, b, c) => new CgglGzlspView
                    {
                        IS_DELETE = t.IS_DELETE,
                        LC_BSM = t.LC_BSM,
                        ID = t.ID,
                        FJ = t.FJ,
                        RECEIVE_TIME = t.RECEIVE_TIME,
                        REMARKS = t.REMARKS,
                        RW_BSM = t.RW_BSM,
                        SPR = t.SPR,
                        SPRMC = t.SPRMC,
                        SPSJ = t.SPSJ,
                        SPYJ = t.SPYJ,
                        SPZT = t.SPZT,
                        CG_BSM = c.BSM,
                        CGB = c.CGB,
                        GHJB = c.GHJB,
                        GHLX = c.GHLX,
                        QXCG_BSM = c.QXCG_BSM,
                        XMMC = c.XMMC,
                        XZQDM = c.XZQDM,
                        XZQMC = c.XZQMC,
                        ZT = c.ZT,
                        ZT_RGSC = c.ZT_RGSC,
                        INSTID = c.INSTID
                    })
                    .ToPageAsync(input.page, input.limit);
                var ssss = query.ToSqlString();
            }
            return page;
        }

        /// <summary>
        /// 成果上报(市 --> 省/自治区)
        /// </summary>
        /// <returns></returns>
        public async Task<bool> SCgsb(CgsbIo input)
        {
            //input.ID // T_CGHJ_QXCG.BSM
            CgglCg cgglCg = await Db.Queryable<CgglCg>().Where(t => t.BSM == input.ID).FirstAsync();
            if (cgglCg.ZT_CGSB != KJGH.Model.Enums.EnumCgsbZT.未提交 && cgglCg.ZT_CGSB != KJGH.Model.Enums.EnumCgsbZT.上报失败)
            {
                //throw new UseMassageException("当前成果已经上报，不能重复提交！");
            }
            //本地上传
            if (cgglCg.QXCG_BSM == null)
            {
                WS.Log.RunLog.Debug($"本地成果上传到自治区，{cgglCg.BSM}");
                cgglCg.ZT = KJGH.Model.Enums.EnumCgglCgZT.成果上报;
                cgglCg.ZT_CGSB = KJGH.Model.Enums.EnumCgsbZT.上报中;
                var path = FileManage.Instance.ToFullPath(Path.GetDirectoryName(cgglCg.CGB), false);
                var fileList = Directory.GetFiles(path).Where(t => Path.GetFileName(t).StartsWith("_"))
                    .ToDictionary(t => Path.GetFileName(t).Replace("_", "").ToInt(), t => t).OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
                if (fileList.Count != cgglCg.CGFPS)
                {
                    throw new UseMassageException("成果包有误，分包数据不全！");
                }
                //市本地上报记录
                var cityCghjCgsbrw = Db.Queryable<CityCghjCgsbrw>().Where(t => t.FILEMD5 == cgglCg.BSM).First();
                bool isNew = false;
                if (cityCghjCgsbrw == null)
                {
                    isNew = true;
                    cityCghjCgsbrw = new CityCghjCgsbrw()
                    {
                        ID = cgglCg.BSM,
                        XZQDM = cgglCg.XZQDM,
                        XZQMC = cgglCg.XZQMC,
                        GHLX = cgglCg.GHLX,
                        CGWJ = cgglCg.CGB,
                        CGLJ = cgglCg.CGML,
                        CREATETIME = DateTime.Now,
                        TOTALSLICENUM = cgglCg.CGFPS,
                        FILEMD5 = cgglCg.BSM,
                        FILENAME = cgglCg.XMMC,
                        CREATOR = input.SBSJ_YH,
                        CREATORMC = input.SBSJ_YHM,
                        SBNF = string.IsNullOrWhiteSpace(input.year) ? DateTime.Now.Year.ToString() : input.year,
                        RWZT = EnumCgsbrw.上报中,
                        SBJD = $"0/{cgglCg.CGFPS}",
                    };
                }
                else
                {
                    cityCghjCgsbrw.MODIFIER = input.SBSJ_YH;
                    cityCghjCgsbrw.MODIFIERMC = input.SBSJ_YHM;
                    cityCghjCgsbrw.MODIFYTIME = DateTime.Now;
                    cityCghjCgsbrw.SBJD = $"0/{cityCghjCgsbrw.TOTALSLICENUM}";
                    cityCghjCgsbrw.RWZT = EnumCgsbrw.上报中;
                }

                try
                {
                    Db.BeginTran();
                    if (isNew) await Db.Insertable(cityCghjCgsbrw).ExecuteCommandAsync();
                    else await Db.Updateable(cityCghjCgsbrw).ExecuteCommandHasChangeAsync();
                    await Db.Updateable(cgglCg).ExecuteCommandHasChangeAsync();
                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    WS.Log.RunLog.Error(ex);
                    throw new UseMassageException("成果上报失败");
                }
                Thread thread = new Thread(() =>
                {
                    WS.Log.RunLog.Debug($"开始上传成果(市-->省/自治区)：{cgglCg.XMMC}");
                    try
                    {
                        var md5Data = ZZQApi.Md5(new NmCgMd5Io()
                        {
                            fileMd5 = cgglCg.BSM,
                            fileSize = 10 * 1024 * 1024,
                            fileName = Path.GetFileName(cgglCg.CGB),
                            totalSliceNum = cgglCg.CGFPS,
                            curSliceOrder = 0,
                            resetSliceOrder2Zero = !input.xc,
                            instId = cgglCg.INSTID
                        });

                        //分片上传
                        var index = 1;
                        var chazhi = fileList.Keys.First() == 0 ? 0 : 1;
                        foreach (var chunk in fileList.Keys)
                        {
                            var curOrder = chunk - chazhi;
                            if (input.xc && curOrder < md5Data.curSliceOrder)
                            {
                                continue;
                            }

                            WS.Log.RunLog.Debug($"分片上传：【{chunk}】{fileList[chunk]}");
                            FileInfo fileInfo = new FileInfo(fileList[chunk]);
                            NmCgUploadSplitIo inputU = new NmCgUploadSplitIo()
                            {
                                xmmc = cgglCg.XMMC,
                                XZQDM = cityCghjCgsbrw.XZQDM,
                                XZQMC = cityCghjCgsbrw.XZQMC,
                                token = md5Data.token,
                                ghlx = cityCghjCgsbrw.GHLX,
                                year = cityCghjCgsbrw.SBNF,
                                name = Path.GetFileName(cgglCg.CGB),
                                zipMd5 = cgglCg.BSM,
                                totalSliceNum = cityCghjCgsbrw.TOTALSLICENUM,
                                curSliceOrder = curOrder,
                                curSliceSize = 10 * 1024 * 1024,
                                resetSliceOrder2Zero = !input.xc,
                                instId = cgglCg.INSTID
                            };
                            WS.Log.RunLog.Debug($"分片上传参数：{inputU.ToJson()}");

                            bool res = false;
                            switch (inputU.ghlx)
                            {
                                case EnumGHLX.总体规划:
                                case EnumGHLX.专项规划:
                                    res = ZZQApi.Upload(inputU, fileList[chunk]);
                                    break;
                                case EnumGHLX.村庄规划:
                                case EnumGHLX.乡镇规划:
                                    res = ZZQApi.TownUpload(inputU, fileList[chunk]);
                                    break;
                                default:
                                    throw new UseMassageException($"暂未实现{inputU.ghlx}成果数据的上传");
                            }
                            WS.Log.RunLog.Debug($"分片上传：【{chunk}】{res}");

                            //更新进度
                            Db.Updateable<CityCghjCgsbrw>().SetColumns(it => it.SBJD == $"{index}/{cityCghjCgsbrw.TOTALSLICENUM}").Where(it => it.ID == cgglCg.BSM).ExecuteCommand();
                            index++;
                            Thread.Sleep(1000);
                        }
                        Db.BeginTran();
                        Db.Updateable<CgglCg>().SetColumns(it => new CgglCg() { ZT_CGSB = EnumCgsbZT.已上报 }).Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                        Db.Updateable<CityCghjCgsbrw>().SetColumns(it => new CityCghjCgsbrw() { SBJD = $"{cityCghjCgsbrw.TOTALSLICENUM}/{cityCghjCgsbrw.TOTALSLICENUM}", RWZT = EnumCgsbrw.待审批 }).Where(it => it.ID == cgglCg.BSM).ExecuteCommand();
                        Db.CommitTran();
                        WS.Log.RunLog.Debug($"上传完成：{cgglCg.XMMC}");
                    }
                    catch (Exception ex)
                    {
                        Db.RollbackTran();
                        Db.Updateable<CgglCg>().SetColumns(it => new CgglCg() { ZT_CGSB = EnumCgsbZT.上报失败 }).Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                        try
                        {
                            Db.Updateable<CityCghjCgsbrw>().SetColumns(it => new CityCghjCgsbrw() { SBSBYY = ex.Message, RWZT = EnumCgsbrw.上报失败 }).Where(it => it.ID == cgglCg.BSM).ExecuteCommand();
                        }
                        catch (Exception ex2)
                        {
                            WS.Log.RunLog.Debug($"结束上传失败入库异常：{ex2.Message}");
                        }
                        WS.Log.RunLog.Error(ex);
                        return;
                    }
                    WS.Log.RunLog.Debug($"结束上传成果：{cgglCg.XMMC}");
                });
                thread.Start();
            }
            //旗县上报
            else
            {
                WS.Log.RunLog.Debug($"旗县上报成果上传到自治区，{cgglCg.BSM}");
                CghjQxcg cghjQxcg = await Db.Queryable<CghjQxcg>().Where(t => t.BSM == cgglCg.QXCG_BSM).FirstAsync();
                cgglCg.ZT = KJGH.Model.Enums.EnumCgglCgZT.成果上报;
                cgglCg.ZT_CGSB = KJGH.Model.Enums.EnumCgsbZT.上报中;
                cghjQxcg.SBSJ_ZT = "上报中";
                cghjQxcg.SBSJ_YH = input.SBSJ_YH;
                cghjQxcg.SBSJ_YHM = input.SBSJ_YHM;
                cghjQxcg.SBSJ_SJ = DateTime.Now;
                cghjQxcg.SBSJ_JD = $"0/{cgglCg.CGFPS}";

                var path = FileManage.Instance.ToFullPath(Path.GetDirectoryName(cgglCg.CGB), false);

                var fileList = Db.Queryable<CghjQxcgsbrwfp>().Where(t => t.MD5 == cghjQxcg.BSM).OrderBy(t => t.CHUNK).Select(t => new { t.CHUNK, t.PATH }).ToList()
                    .ToDictionary(t => t.CHUNK, t => FileManage.Instance.ToFullPath(t.PATH, false)).OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
                if (fileList.Count != cgglCg.CGFPS)
                {
                    throw new UseMassageException("成果包有误，分包数据不全！");
                }

                try
                {
                    Db.BeginTran();
                    await Db.Updateable(cgglCg).ExecuteCommandHasChangeAsync();
                    await Db.Updateable(cghjQxcg).ExecuteCommandAsync();
                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    WS.Log.RunLog.Error(ex);
                    throw new UseMassageException("成果上报失败");
                }
                Thread thread = new Thread(() =>
                {
                    WS.Log.RunLog.Debug($"开始上传成果(市-->省/自治区)：{cgglCg.XMMC}");
                    try
                    {
                        var md5Data = ZZQApi.Md5(new NmCgMd5Io()
                        {
                            fileMd5 = cghjQxcg.BSM,
                            fileSize = 10 * 1024 * 1024,
                            fileName = Path.GetFileName(cghjQxcg.CGB),
                            totalSliceNum = cgglCg.CGFPS,
                            curSliceOrder = 0,
                            resetSliceOrder2Zero = !input.xc,
                            instId = cghjQxcg.INSTID
                        });

                        //分片上传
                        var index = 1;
                        var chazhi = fileList.Keys.First() == 0 ? 0 : 1;
                        foreach (var chunk in fileList.Keys)
                        {
                            var curOrder = chunk - chazhi;
                            if (input.xc && curOrder < md5Data.curSliceOrder)
                            {
                                continue;
                            }

                            FileInfo fileInfo = new FileInfo(fileList[chunk]);
                            NmCgUploadSplitIo inputU = new NmCgUploadSplitIo()
                            {
                                xmmc = cghjQxcg.XMMC,
                                XZQDM = cghjQxcg.XZQDM,
                                XZQMC = cghjQxcg.XZQMC,
                                token = md5Data.token,
                                ghlx = cghjQxcg.GHLX,
                                year = string.IsNullOrWhiteSpace(input.year) ? DateTime.Now.Year.ToString() : input.year,
                                name = Path.GetFileName(cghjQxcg.CGB),
                                zipMd5 = cghjQxcg.BSM,
                                totalSliceNum = cgglCg.CGFPS,
                                curSliceOrder = curOrder,
                                curSliceSize = 10 * 1024 * 1024,
                                resetSliceOrder2Zero = !input.xc,
                                instId = cghjQxcg.INSTID
                            };

                            bool res = false;
                            switch (inputU.ghlx)
                            {
                                case EnumGHLX.总体规划:
                                case EnumGHLX.专项规划:
                                    res = ZZQApi.Upload(inputU, fileList[chunk]);
                                    break;
                                case EnumGHLX.村庄规划:
                                case EnumGHLX.乡镇规划:
                                    res = ZZQApi.TownUpload(inputU, fileList[chunk]);
                                    break;
                                default:
                                    throw new UseMassageException($"暂未实现{inputU.ghlx}成果数据的上传");
                            }

                            //更新进度
                            Db.Updateable<CghjQxcg>().SetColumns(it => it.SBSJ_JD == $"{index}/{cgglCg.CGFPS}").Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                            index++;
                            Thread.Sleep(1000);
                        }

                        Db.BeginTran();
                        Db.Updateable<CgglCg>().SetColumns(it => new CgglCg() { ZT_CGSB = EnumCgsbZT.已上报 }).Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                        Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg() { SBSJ_JD = $"{cgglCg.CGFPS}/{cgglCg.CGFPS}", SBSJ_ZT = "上报完成" }).Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                        Db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        Db.RollbackTran();
                        Db.Updateable<CgglCg>().SetColumns(it => new CgglCg() { ZT_CGSB = EnumCgsbZT.上报失败 }).Where(it => it.BSM == cgglCg.BSM).ExecuteCommand();
                        try
                        {
                            Db.Updateable<CghjQxcg>().SetColumns(it => new CghjQxcg() { SBSJ_SBYY = ex.Message, SBSJ_ZT = "上报失败" }).Where(it => it.BSM == cghjQxcg.BSM).ExecuteCommand();
                        }
                        catch (Exception ex2)
                        {
                            WS.Log.RunLog.Debug($"结束上传失败入库异常：{ex2.Message}");
                        }
                        WS.Log.RunLog.Error(ex);
                        return;
                    }
                    WS.Log.RunLog.Debug($"结束上传成果：{cgglCg.XMMC}");
                });
                thread.Start();
            }
            return true;
        }



        #endregion

        /// <summary>
        /// 厅结果更新ID
        /// </summary>
        /// <returns></returns>
        public async Task<bool> UpdateMd5Id()
        {
            List<CgglCg> cggls = Db.Queryable<CgglCg>().Where(t => t.TID == null).ToList();
            foreach (var item in cggls)
            {
                //item.TID = ZZQApi.GetToken
            }
            return true;
        }
    }
}