using log4net;
using Microsoft.Extensions.Caching.Memory;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Http;
using UFIDA.U8.Framework.Api.Common.Entity;
using UFIDA.U8.Framework.Api.ControlObject.Common;
using UFIDA.U8.Framework.Api.ControlObject.Entity;
using UFIDA.U8.Framework.Api.ControlObject.Json;
using UFIDA.U8.Framework.Api.ControlObject.ST;
using UFIDA.U8.Framework.Api.ControlObject.U8M;
using UFIDA.U8.Framework.Api.Entity;
using UFIDA.U8.Framework.Api.Models;
using UFIDA.U8.Framework.Api.Unit;
// ReSharper disable StringLiteralTypo
// ReSharper disable IdentifierTypo
// ReSharper disable InconsistentNaming

namespace UFIDA.U8.Framework.Api.Controllers.U8
{
    /// <summary>
    /// 库存管理
    /// </summary>
    public class STController : ApiController
    {
        /// <summary>
        /// 日志组件
        /// </summary>
        private readonly ILog _logInfo = LogManager.GetLogger("logInfo");

        private static readonly MemoryCache _cache = new MemoryCache(new MemoryCacheOptions { ExpirationScanFrequency = TimeSpan.FromMinutes(10) });

        /// <summary>
        /// 新增单据
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">报文</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bIsRedVouch">是否红字单据</param>
        /// <param name="sAddedState">传空字符串</param>
        /// <param name="bReMote">是否远程</param>
        /// <param name="bVerify">是否生成时审核</param>
        /// <returns></returns>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/Insert")]
        public async Task<BaseResult<string>> Insert(string cAccId ,string cCardNum,[FromBody] Dictionary<string, object> input, bool bCheck = true,bool bBeforCheckStock=true,bool bIsRedVouch=false,string sAddedState="",bool bReMote=false,bool? bVerify=null)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:新增,对接账套:{cAccId},数据:{input.ToJson()}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var defs = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "H" && s.bEnable==true).ToListAsync();  //查询表头字段配置,供后续设置字段值

                var dateKey = "";
                var exchKey = "";
                if (defs.Any(a => a.bDate == true && a.cPosition == "H"))
                    dateKey = defs.Where(a => a.bDate == true && a.cPosition == "H").Select(a => a.FieldName).First();

                if (defs.Any(a => a.bPrice == true && a.cPosition == "H"))
                    exchKey = defs.Where(a => a.bPrice == true && a.cPosition == "H").Select(a => a.FieldName).First();

                var dDate = DateTime.Today;
                if (!string.IsNullOrWhiteSpace(dateKey))
                {
                    if (!DateTime.TryParse($"{input[dateKey]}", out dDate))
                    {
                        dDate = DateTime.Today;
                    }
                }

                Exch exch;

                if (!string.IsNullOrWhiteSpace(exchKey) && input.TryGetValue(exchKey, out var value))
                {
                    exch = CommonHelper.GetExch(dDate, cAccId, $"{value}", baseLogin.Connection);
                }
                else
                {
                    exch = null;
                }


                var newNumber = "";
                var bGetCode = false;
                var codeKey = "";

                if (defs.Any(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" && a.bEnable==true))
                {
                    bGetCode = true;
                    codeKey = defs
                        .Where(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" &&
                                    a.bEnable == true).Select(a => a.FieldName).First();

                    _logInfo.Debug($"作业Id:{workId}-----配置获取单号");
                }
                else
                {
                    _logInfo.Debug($"作业Id:{workId}-----没有单号需要自动指定");
                }

                #region 调整日期,去掉时间部分

                if (input.ContainsKey("ddate"))
                {
                    _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
                    input["ddate"] = $"{Convert.ToDateTime(input["ddate"]):yyyy-MM-dd}";
                }

                if (input.ContainsKey("dtvdate"))
                {
                    _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
                    input["dtvdate"] = $"{Convert.ToDateTime(input["dtvdate"]):yyyy-MM-dd}";
                }

                #endregion
                _logInfo.Debug($"作业Id:{workId}-----设置表头数据");
                input.SetDictionaryData(defs, baseLogin.Connection, newNumber, 1, exch);

                _logInfo.Debug($"作业Id:{workId}-----读取表体数据");
                var bodyData = input[voucherInfo.BodyName].ToJson().ToList<Dictionary<string, object>>(); //读取表体的数据

                if (bodyData == null || bodyData.Count <= 0)
                    throw new Exception("无表体数据!");

                _logInfo.Debug($"作业Id:{workId}-----获取表体字段配置");
                var defsBody = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "B" && s.bEnable==true).ToListAsync();   //获取表体的字段配置

                var rowNo = 1;

                foreach (var body in bodyData)
                {
                    _logInfo.Debug($"作业Id:{workId}-----设置第{rowNo}行单据数据");
                    body.SetDictionaryData(defsBody, baseLogin.Connection, newNumber, rowNo, exch);

                    rowNo++;

                    // 根据存货档案是否批次管理调整批次号
                    if (body.ContainsKey("binvbatch") && body.ContainsKey("cbatch"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号");
                        if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
                        {
                            body["cbatch"] = "";
                        }
                    }

                    // 根据存货档案是否批次管理调整批次号(调拨单)
                    if (body.ContainsKey("binvbatch") && body.ContainsKey("ctvbatch"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号(调拨单)");
                        if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
                        {
                            body["ctvbatch"] = "";
                        }
                    }

                    // 根据存货档案是否保质期管理调整生产日期和失效日期
                    if (body.ContainsKey("binvquality") && body.ContainsKey("dmadedate"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否保质期管理调整生产日期和失效日期");

                        if (body["binvquality"] == null || body["binvquality"] == DBNull.Value || !body["binvquality"].ToBoolean())
                        {
                            if (cCardNum == "0304")
                            {
                                body["dmadedate"] = "";
                            }
                            else
                            {
                                body["dmadedate"] = "";
                            }
                        }
                        else
                        {
                            if (body.ContainsKey("cmassunit") && body.ContainsKey("imassdate"))
                            {
                                switch ($"{body["cmassunit"]}")
                                {
                                    case "1" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "1" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "2" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "2" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "3" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "3" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                }
                            }
                        }
                    }
                }

                input[voucherInfo.BodyName] = bodyData;

                var co = new USERPCO();

                var res = await co.Insert(baseLogin, input, cCardNum, voucherInfo.VoucherType, bGetCode, codeKey, bCheck, bBeforCheckStock, bIsRedVouch, sAddedState, bReMote, bVerify??voucherInfo.bVerify,voucherInfo.bPrintDom);

                return res;
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = ex.Message, result = ex.StackTrace };
            }
        }


        /// <summary>
        /// 新增单据
        /// </summary>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">报文</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bIsRedVouch">是否红字单据</param>
        /// <param name="sAddedState">传空字符串</param>
        /// <param name="bReMote">是否远程</param>
        /// <param name="bVerify">是否生成时审核</param>
        /// <returns></returns>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/Insert/Token")]
        public async Task<BaseResult<string>> InsertToken(string cCardNum, [FromBody] Dictionary<string, object> input, bool bCheck = true, bool bBeforCheckStock = true, bool bIsRedVouch = false, string sAddedState = "", bool bReMote = false, bool? bVerify = null)
        {
            try
            {
                var userToken = Request.Headers.GetValues("userToken").First();

                _logInfo.Debug($"当前接口:api/U8/ST/{cCardNum}/Insert/{userToken},参数:{input.ToJson()}");

                var output = CommUnit.GetDecrypt(userToken).ToObject<LoginOutput>();

                var token = CommUnit.GetDecrypt(output.userToken);

                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:新增,对接账套:{output.cAccId},数据:{input.ToJson()}");

                //LoginParamter param;



                if (!_cache.TryGetValue($"U8_{userToken}_{output.cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    baseLogin.Init(token, false, 5);

                    _cache.Clear();

                    _cache.Set($"U8_{userToken}_{output.cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var defs = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "H" && s.bEnable == true).ToListAsync();  //查询表头字段配置,供后续设置字段值

                var dateKey = "";
                var exchKey = "";
                if (defs.Any(a => a.bDate == true && a.cPosition == "H"))
                    dateKey = defs.Where(a => a.bDate == true && a.cPosition == "H").Select(a => a.FieldName).First();

                if (defs.Any(a => a.bPrice == true && a.cPosition == "H"))
                    exchKey = defs.Where(a => a.bPrice == true && a.cPosition == "H").Select(a => a.FieldName).First();

                var dDate = DateTime.Today;
                if (!string.IsNullOrWhiteSpace(dateKey))
                {
                    if (!DateTime.TryParse($"{input[dateKey]}", out dDate))
                    {
                        dDate = DateTime.Today;
                    }
                }

                Exch exch;

                if (!string.IsNullOrWhiteSpace(exchKey) && input.TryGetValue(exchKey, out var value))
                {
                    exch = CommonHelper.GetExch(dDate, output.cAccId, $"{value}", baseLogin.Connection);
                }
                else
                {
                    exch = null;
                }


                var newNumber = "";
                var bGetCode = false;
                var codeKey = "";

                if (defs.Any(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" && a.bEnable == true))
                {
                    bGetCode = true;
                    codeKey = defs
                        .Where(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" &&
                                    a.bEnable == true).Select(a => a.FieldName).First();

                    _logInfo.Debug($"作业Id:{workId}-----配置获取单号");
                }
                else
                {
                    _logInfo.Debug($"作业Id:{workId}-----没有单号需要自动指定");
                }

                #region 调整日期,去掉时间部分

                if (input.ContainsKey("ddate"))
                {
                    _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
                    input["ddate"] = $"{Convert.ToDateTime(input["ddate"]):yyyy-MM-dd}";
                }

                if (input.ContainsKey("dtvdate"))
                {
                    _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
                    input["dtvdate"] = $"{Convert.ToDateTime(input["dtvdate"]):yyyy-MM-dd}";
                }

                #endregion
                _logInfo.Debug($"作业Id:{workId}-----设置表头数据");
                input.SetDictionaryData(defs, baseLogin.Connection, newNumber, 1, exch);

                _logInfo.Debug($"作业Id:{workId}-----读取表体数据");
                var bodyData = input[voucherInfo.BodyName].ToJson().ToList<Dictionary<string, object>>(); //读取表体的数据

                if (bodyData == null || bodyData.Count <= 0)
                    throw new Exception("无表体数据!");

                _logInfo.Debug($"作业Id:{workId}-----获取表体字段配置");
                var defsBody = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "B" && s.bEnable == true).ToListAsync();   //获取表体的字段配置

                var rowNo = 1;

                foreach (var body in bodyData)
                {
                    _logInfo.Debug($"作业Id:{workId}-----设置第{rowNo}行单据数据");
                    body.SetDictionaryData(defsBody, baseLogin.Connection, newNumber, rowNo, exch);

                    rowNo++;

                    // 根据存货档案是否批次管理调整批次号
                    if (body.ContainsKey("binvbatch") && body.ContainsKey("cbatch"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号");
                        if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
                        {
                            body["cbatch"] = "";
                        }
                    }

                    // 根据存货档案是否批次管理调整批次号(调拨单)
                    if (body.ContainsKey("binvbatch") && body.ContainsKey("ctvbatch"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号(调拨单)");
                        if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
                        {
                            body["ctvbatch"] = "";
                        }
                    }

                    // 根据存货档案是否保质期管理调整生产日期和失效日期
                    if (body.ContainsKey("binvquality") && body.ContainsKey("dmadedate"))
                    {
                        _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否保质期管理调整生产日期和失效日期");

                        if (body["binvquality"] == null || body["binvquality"] == DBNull.Value || !body["binvquality"].ToBoolean())
                        {
                            if (cCardNum == "0304")
                            {
                                body["dmadedate"] = "";
                            }
                            else
                            {
                                body["dmadedate"] = "";
                            }
                        }
                        else
                        {
                            if (body.ContainsKey("cmassunit") && body.ContainsKey("imassdate"))
                            {
                                switch ($"{body["cmassunit"]}")
                                {
                                    case "1" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "1" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "2" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "2" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "3" when cCardNum != "0304":
                                        body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                    case "3" when cCardNum == "0304":
                                        body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
                                        break;
                                }
                            }
                        }
                    }
                }

                input[voucherInfo.BodyName] = bodyData;

                var co = new USERPCO();

                var res = await co.Insert(baseLogin, input, cCardNum, voucherInfo.VoucherType, bGetCode, codeKey, bCheck, bBeforCheckStock, bIsRedVouch, sAddedState, bReMote, bVerify??voucherInfo.bVerify, voucherInfo.bPrintDom);

                return res;
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = ex.Message, result = ex.StackTrace };
            }
        }

        ///// <summary>
        ///// 修改单据
        ///// </summary>
        ///// <param name="cAccId">系统号</param>
        ///// <param name="cCardNum">单据类型编码</param>
        ///// <param name="input">报文</param>
        ///// <param name="bCheck">是否控制可用量</param>
        ///// <param name="bBeforCheckStock">是否检查可用量</param>
        ///// <param name="bIsRedVouch">是否红字单据</param>
        ///// <param name="sAddedState">传空字符串</param>
        ///// <param name="bReMote">是否远程</param>
        ///// <returns></returns>
        //[HttpPost]
        //[Route("api/U8/ST/{cCardNum}/Update")]
        //public async Task<BaseResult<string>> Update(string cAccId, string cCardNum, [FromBody] Dictionary<string, object> input, bool bCheck = true, bool bBeforCheckStock = true, bool bIsRedVouch = false, string sAddedState = "", bool bReMote = false)
        //{
        //    try
        //    {
        //        var db = CommUnit.GetDbClient();

        //        var workId = SnowFlakeSingle.Instance.NextId();

        //        _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:修改,对接账套:{cAccId},数据:{input.ToJson()}");

        //        //LoginParamter param;

        //        if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
        //        {
        //            _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

        //            baseLogin = new BaseLogin();

        //            var param = await CommUnit.GetLoginParamter(cAccId);

        //            if (param == null)
        //            {
        //                throw new Exception("未能加载指定系统号的登录信息");
        //            }

        //            baseLogin.Init(param, false);

        //            _cache.Clear();

        //            _cache.Set($"U8_{cAccId}", baseLogin);
        //        }
        //        //else
        //        //{
        //        //    param = await CommUnit.GetLoginParamter(cAccId);
        //        //}

        //        _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

        //        var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

        //        var defs = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "H" && s.bEnable == true).ToListAsync();  //查询表头字段配置,供后续设置字段值

        //        var dateKey = "";
        //        var exchKey = "";
        //        if (defs.Any(a => a.bDate == true && a.cPosition == "H"))
        //            dateKey = defs.Where(a => a.bDate == true && a.cPosition == "H").Select(a => a.FieldName).First();

        //        if (defs.Any(a => a.bPrice == true && a.cPosition == "H"))
        //            exchKey = defs.Where(a => a.bPrice == true && a.cPosition == "H").Select(a => a.FieldName).First();

        //        var dDate = DateTime.Today;
        //        if (!string.IsNullOrWhiteSpace(dateKey))
        //        {
        //            if (!DateTime.TryParse($"{input[dateKey]}", out dDate))
        //            {
        //                dDate = DateTime.Today;
        //            }
        //        }

        //        Exch exch;

        //        if (!string.IsNullOrWhiteSpace(exchKey) && input.TryGetValue(exchKey, out var value))
        //        {
        //            exch = CommonHelper.GetExch(dDate, cAccId, $"{value}", baseLogin.Connection);
        //        }
        //        else
        //        {
        //            exch = null;
        //        }


        //        var newNumber = "";
        //        var bGetCode = false;
        //        var codeKey = "";

        //        if (defs.Any(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" && a.bEnable == true))
        //        {
        //            bGetCode = true;
        //            codeKey = defs
        //                .Where(a => a.bDefault == true && a.cPosition == "H" && a.DefaultValue == "单号" &&
        //                            a.bEnable == true).Select(a => a.FieldName).First();

        //            _logInfo.Debug($"作业Id:{workId}-----配置获取单号");
        //        }
        //        else
        //        {
        //            _logInfo.Debug($"作业Id:{workId}-----没有单号需要自动指定");
        //        }

        //        #region 调整日期,去掉时间部分

        //        if (input.ContainsKey("ddate"))
        //        {
        //            _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
        //            input["ddate"] = $"{Convert.ToDateTime(input["ddate"]):yyyy-MM-dd}";
        //        }

        //        if (input.ContainsKey("dtvdate"))
        //        {
        //            _logInfo.Debug($"作业Id:{workId}-----调整日期,去掉时间部分");
        //            input["dtvdate"] = $"{Convert.ToDateTime(input["dtvdate"]):yyyy-MM-dd}";
        //        }

        //        #endregion
        //        _logInfo.Debug($"作业Id:{workId}-----设置表头数据");
        //        input.SetDictionaryData(defs, baseLogin.Connection, newNumber, 1, exch);

        //        _logInfo.Debug($"作业Id:{workId}-----读取表体数据");
        //        var bodyData = input[voucherInfo.BodyName].ToJson().ToList<Dictionary<string, object>>(); //读取表体的数据

        //        if (bodyData == null || bodyData.Count <= 0)
        //            throw new Exception("无表体数据!");

        //        _logInfo.Debug($"作业Id:{workId}-----获取表体字段配置");
        //        var defsBody = await db.Queryable<SysU8FieldDefine>().Where(s => s.CardNumber == cCardNum && s.cPosition == "B" && s.bEnable == true).ToListAsync();   //获取表体的字段配置

        //        var rowNo = 1;

        //        foreach (var body in bodyData)
        //        {
        //            _logInfo.Debug($"作业Id:{workId}-----设置第{rowNo}行单据数据");
        //            body.SetDictionaryData(defsBody, baseLogin.Connection, newNumber, rowNo, exch);

        //            rowNo++;

        //            // 根据存货档案是否批次管理调整批次号
        //            if (body.ContainsKey("binvbatch") && body.ContainsKey("cbatch"))
        //            {
        //                _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号");
        //                if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
        //                {
        //                    body["cbatch"] = "";
        //                }
        //            }

        //            // 根据存货档案是否批次管理调整批次号(调拨单)
        //            if (body.ContainsKey("binvbatch") && body.ContainsKey("ctvbatch"))
        //            {
        //                _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否批次管理调整批次号(调拨单)");
        //                if (body["binvbatch"] == null || body["binvbatch"] == DBNull.Value || !body["binvbatch"].ToBoolean())
        //                {
        //                    body["ctvbatch"] = "";
        //                }
        //            }

        //            // 根据存货档案是否保质期管理调整生产日期和失效日期
        //            if (body.ContainsKey("binvquality") && body.ContainsKey("dmadedate"))
        //            {
        //                _logInfo.Debug($"作业Id:{workId}-----第{rowNo}行根据存货档案是否保质期管理调整生产日期和失效日期");

        //                if (body["binvquality"] == null || body["binvquality"] == DBNull.Value || !body["binvquality"].ToBoolean())
        //                {
        //                    if (cCardNum == "0304")
        //                    {
        //                        body["dmadedate"] = "";
        //                    }
        //                    else
        //                    {
        //                        body["dmadedate"] = "";
        //                    }
        //                }
        //                else
        //                {
        //                    if (body.ContainsKey("cmassunit") && body.ContainsKey("imassdate"))
        //                    {
        //                        switch ($"{body["cmassunit"]}")
        //                        {
        //                            case "1" when cCardNum != "0304":
        //                                body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                            case "1" when cCardNum == "0304":
        //                                body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddYears(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                            case "2" when cCardNum != "0304":
        //                                body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                            case "2" when cCardNum == "0304":
        //                                body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddMonths(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                            case "3" when cCardNum != "0304":
        //                                body["dvdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                            case "3" when cCardNum == "0304":
        //                                body["ddisdate"] = $"{Convert.ToDateTime(body["dmadedate"]).AddDays(Convert.ToInt32(body["imassdate"])):yyyy-MM-dd HH:MM:ss}";
        //                                break;
        //                        }
        //                    }
        //                }
        //            }
        //        }

        //        input[voucherInfo.BodyName] = bodyData;

        //        var co = new USERPCO();

        //        var res = await co.Update(baseLogin, input, cCardNum, voucherInfo.VoucherType,   bCheck, bBeforCheckStock, bIsRedVouch, sAddedState, bReMote, voucherInfo.bVerify, voucherInfo.bPrintDom);

        //        return res;
        //    }
        //    catch (Exception ex)
        //    {
        //        _logInfo.Error(ex.Message, ex);

        //        return new BaseResult<string> { bSuccess = false, message = ex.Message, result = ex.StackTrace };
        //    }
        //}

        /// <summary>
        /// 审核单据(单号)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="cCode">单据编号</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/Verify/Code")]
        public async Task<BaseResult<string>> Verify(string cAccId, string cCardNum,string cCode, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:审核,对接账套:{cAccId},单号:{cCode}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin) || baseLogin ==null)
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, cCode, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "审核失败", result = ex.Message };
            }
        }

        /// <summary>
        /// 审核单据(ID)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="voucherId">单据ID</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/Verify/ID")]
        public async Task<BaseResult<string>> Verify(string cAccId, string cCardNum, long voucherId, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:审核,对接账套:{cAccId},ID:{voucherId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, voucherId, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "审核失败", result = ex.Message };
            }
        }

        /// <summary>
        /// 审核单据(批量)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">报文</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/Verify")]
        public async Task<BaseResult<List<BaseResult<string>>>> Verify(string cAccId, string cCardNum, [FromBody] STInput input, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                if (input == null)
                {
                    throw new Exception("参数不能为空");
                }

                var cCodes = input.cCode;

                var voucherIds = input.voucherId;

                if ((cCodes == null || cCodes.Count<=0) && (voucherIds == null || voucherIds.Count <= 0))
                {
                    throw new Exception("没有数据需要审核");
                }

                var strCode = "";
                var strId = "";

                var apiType = cCodes == null || cCodes.Count <= 0 ? 1 : 0;

                if (cCodes != null && cCodes.Count > 0)
                {
                    strCode = string.Join(",", cCodes);
                }

                if (voucherIds != null && voucherIds.Count > 0)
                {
                    strId = string.Join(",", voucherIds);
                }

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:审核,对接账套:{cAccId},单号:{strCode},ID:{strId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                var result = apiType == 0
                    ? await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, cCodes, bCheck, bBeforCheckStock, bList)
                    : await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, voucherIds, bCheck, bBeforCheckStock, bList);

                var res = new BaseResult<List<BaseResult<string>>>()
                {
                    bSuccess = true,
                    message = "审核完成",
                    result = result
                };

                return res;
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<List<BaseResult<string>>> { bSuccess = false, message = ex.Message, result = null };
            }
        }

        /// <summary>
        /// 弃审单据(单号)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="cCode">单据编号</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/UnVerify/Code")]
        public async Task<BaseResult<string>> UnVerify(string cAccId, string cCardNum,string cCode, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:弃审,对接账套:{cAccId},单号:{cCode}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.UnVerify(baseLogin, cCardNum, voucherInfo.VoucherType, cCode, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "弃审失败", result = ex.Message };
            }
        }


        /// <summary>
        /// 弃审单据(ID)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="voucherId">单据ID</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/UnVerify/ID")]
        public async Task<BaseResult<string>> UnVerify(string cAccId, string cCardNum, long voucherId, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:弃审,对接账套:{cAccId},ID:{voucherId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.UnVerify(baseLogin, cCardNum, voucherInfo.VoucherType, voucherId, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "弃审失败", result = ex.Message };
            }
        }

        /// <summary>
        /// 弃审单据(批量)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">报文</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/UnVerify")]
        public async Task<BaseResult<List<BaseResult<string>>>> UnVerify(string cAccId, string cCardNum, [FromBody] STInput input, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                if (input == null)
                {
                    throw new Exception("参数不能为空");
                }

                var cCodes = input.cCode;

                var voucherIds = input.voucherId;

                if ((cCodes == null || cCodes.Count<=0) && (voucherIds == null || voucherIds.Count <= 0))
                {
                    throw new Exception("没有数据需要弃审");
                }

                var strCode = "";
                var strId = "";

                var apiType = cCodes == null || cCodes.Count <= 0 ? 1 : 0;

                if (cCodes != null && cCodes.Count > 0)
                {
                    strCode = string.Join(",", cCodes);
                }

                if (voucherIds != null && voucherIds.Count > 0)
                {
                    strId = string.Join(",", voucherIds);
                }

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:弃审,对接账套:{cAccId},单号:{strCode},ID:{strId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                var result = apiType == 0
                    ? await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, cCodes, bCheck, bBeforCheckStock, bList)
                    : await co.Verify(baseLogin, cCardNum, voucherInfo.VoucherType, voucherIds, bCheck, bBeforCheckStock, bList);

                var res = new BaseResult<List<BaseResult<string>>>()
                {
                    bSuccess = true,
                    message = "弃审完成",
                    result = result
                };

                return res;
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<List<BaseResult<string>>> { bSuccess = false, message = ex.Message, result = null };
            }
        }

        /// <summary>
        /// 删除单据(单号)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="cCode">单据编号</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/Delete/Code")]
        public async Task<BaseResult<string>> Delete(string cAccId, string cCardNum,string cCode, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:删除,对接账套:{cAccId},单号:{cCode}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.Delete(baseLogin, cCardNum, voucherInfo.VoucherType, cCode, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "删除失败", result = ex.Message };
            }
        }


        /// <summary>
        /// 删除单据(ID)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="voucherId">单据ID</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpGet]
        [Route("api/U8/ST/{cCardNum}/Delete/ID")]
        public async Task<BaseResult<string>> Delete(string cAccId, string cCardNum, long voucherId, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:删除,对接账套:{cAccId},ID:{voucherId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                return await co.UnVerify(baseLogin, cCardNum, voucherInfo.VoucherType, voucherId, bCheck, bBeforCheckStock, bList);
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<string> { bSuccess = false, message = "删除失败", result = ex.Message };
            }
        }

        /// <summary>
        /// 删除单据(批量)
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">报文</param>
        /// <param name="bCheck">是否控制可用量</param>
        /// <param name="bBeforCheckStock">是否检查可用量</param>
        /// <param name="bList">是否列表</param>
        /// <returns></returns>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/Delete")]
        public async Task<BaseResult<List<BaseResult<string>>>> Delete(string cAccId, string cCardNum, [FromBody] STInput input, bool bCheck = true, bool bBeforCheckStock = true, bool bList = false)
        {
            try
            {
                var db = CommUnit.GetDbClient();

                var workId = SnowFlakeSingle.Instance.NextId();

                if (input == null)
                {
                    throw new Exception("参数不能为空");
                }

                var cCodes = input.cCode;

                var voucherIds = input.voucherId;

                if ((cCodes == null || cCodes.Count<=0) && (voucherIds == null || voucherIds.Count <= 0))
                {
                    throw new Exception("没有数据需要删除");
                }

                var strCode = "";
                var strId = "";

                var apiType = cCodes == null || cCodes.Count <= 0 ? 1 : 0;

                if (cCodes != null && cCodes.Count > 0)
                {
                    strCode = string.Join(",", cCodes);
                }

                if (voucherIds != null && voucherIds.Count > 0)
                {
                    strId = string.Join(",", voucherIds);
                }

                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:删除,对接账套:{cAccId},单号:{strCode},ID:{strId}");

                //LoginParamter param;

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }
                //else
                //{
                //    param = await CommUnit.GetLoginParamter(cAccId);
                //}

                _logInfo.Debug($"作业Id:{workId}-----登录信息获取完成,缓存设置完成,开始加载单据配置信息");

                var voucherInfo = await db.Queryable<SysU8VoucherDefine>().FirstAsync(s => s.CardNumber == cCardNum);

                var co = new USERPCO();

                var result = apiType == 0
                    ? await co.Delete(baseLogin, cCardNum, voucherInfo.VoucherType, cCodes, bCheck, bBeforCheckStock, bList)
                    : await co.Delete(baseLogin, cCardNum, voucherInfo.VoucherType, voucherIds, bCheck, bBeforCheckStock, bList);

                var res = new BaseResult<List<BaseResult<string>>>()
                {
                    bSuccess = true,
                    message = "删除完成",
                    result = result
                };

                return res;
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<List<BaseResult<string>>> { bSuccess = false, message = ex.Message, result = null };
            }
        }

        /// <summary>
        /// 查询特定单据部分
        /// </summary>
        /// <param name="cAccId">系统号</param>
        /// <param name="cCardNum">单据类型编码</param>
        /// <param name="input">查询条件</param>
        /// <param name="cCardPostion">查询所属区域 H:表头，B:表体, L:列表</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Route("api/U8/ST/{cCardNum}/Load")]
        [Route("api/U8/ST/{cCardNum}/Load/{cCardPostion}")]
        public async Task<BaseResult<dynamic>> Load(string cAccId, string cCardNum, [FromBody] Dictionary<string, object> input, string cCardPostion = "H")
        {
            var workId = SnowFlakeSingle.Instance.NextId();

            try
            {
                _logInfo.Debug($"作业Id:{workId}-----单据:{cCardNum},操作:查询,对接账套:{cAccId},条件:{input.ToJson()}");

                if (!_cache.TryGetValue($"U8_{cAccId}", out BaseLogin baseLogin))
                {
                    _logInfo.Debug($"作业Id:{workId}-----未获取到缓存的登录信息,正在重新构建");

                    baseLogin = new BaseLogin();

                    var param = await CommUnit.GetLoginParamter(cAccId);

                    if (param == null)
                    {
                        throw new Exception("未能加载指定系统号的登录信息");
                    }

                    baseLogin.Init(param, false);

                    _cache.Clear();

                    _cache.Set($"U8_{cAccId}", baseLogin);
                }

                var vouchers = CommonHelper.GetVouchers(baseLogin.Connection, cCardNum);

                if (vouchers == null)
                {
                    throw new Exception("未能获取到单据配置信息");
                }

                var db = new SqlSugarClient(new ConnectionConfig()
                {
                    DbType = DbType.SqlServer,
                    ConfigId = cAccId,
                    ConnectionString = baseLogin.UFDataConnstringForNet,
                    IsAutoCloseConnection = true,
                    MoreSettings = new ConnMoreSettings()
                    {
                        IsWithNoLockQuery = true
                    }
                });

                var cBTQName = vouchers.cBTQName;
                var cBWQName = vouchers.cBWQName;

                var cBTTblExtName = $"{vouchers.cBTTblName}_extradefine";
                var cBWTblExtName = $"{vouchers.cBWTblName}_extradefine";

                var voucherIdFieldName = vouchers.voucherIdFieldName;
                var vouchersIdFieldName = "";

                var bExtHead = false;
                var bExtBody = false;

                var colList = new Dictionary<string, string>();
                var colListHead = new Dictionary<string, string>();
                var colListBody = new Dictionary<string, string>();

                var cols = db.DbMaintenance.GetColumnInfosByTableName(cBTQName);

                if (cols != null && cols.Count > 0)
                {
                    foreach (var col in cols.Where(col => !colList.ContainsKey(col.DbColumnName.ToLower())))
                    {
                        if (cCardPostion == "H" || cCardPostion == "L")
                            colList.Add(col.DbColumnName.ToLower(), $"{cBTQName}.[{col.DbColumnName}]");

                        colListHead.Add(col.DbColumnName.ToLower(), $"{cBTQName}.[{col.DbColumnName}]");
                    }
                }

                if (db.DbMaintenance.IsAnyTable($"{cBTTblExtName}"))
                {
                    bExtHead = true;

                    var extcols = db.DbMaintenance.GetColumnInfosByTableName($"{cBTTblExtName}");

                    if (extcols != null && extcols.Count > 0)
                    {
                        foreach (var col in extcols.Where(col => !colList.ContainsKey(col.DbColumnName.ToLower())))
                        {
                            if (cCardPostion == "H" || cCardPostion == "L")
                                colList.Add(col.DbColumnName.ToLower(), $"{cBTTblExtName}.[{col.DbColumnName}]");

                            colListHead.Add(col.DbColumnName.ToLower(), $"{cBTTblExtName}.[{col.DbColumnName}]");
                        }
                    }
                }

                cols = db.DbMaintenance.GetColumnInfosByTableName(cBWQName);

                if (cols != null && cols.Count > 0)
                {
                    foreach (var col in cols.Where(col => !colList.ContainsKey(col.DbColumnName.ToLower())))
                    {
                        if (cCardPostion == "B" || cCardPostion == "L")
                            colList.Add(col.DbColumnName.ToLower(), $"{cBWQName}.[{col.DbColumnName}]");

                        colListBody.Add(col.DbColumnName.ToLower(), $"{cBWQName}.[{col.DbColumnName}]");
                    }
                }

                if (db.DbMaintenance.IsAnyTable(cBWTblExtName))
                {
                    bExtBody = true;

                    var extcols = db.DbMaintenance.GetColumnInfosByTableName($"{cBWTblExtName}");

                    if (extcols != null && extcols.Count > 0)
                    {
                        foreach (var col in extcols)
                        {
                            if (colList.ContainsKey(col.DbColumnName.ToLower()))
                            {
                                vouchersIdFieldName = col.DbColumnName.ToLower();
                            }
                            else
                            {
                                if (cCardPostion == "B" || cCardPostion == "L")
                                    colList.Add(col.DbColumnName.ToLower(), $"{cBWTblExtName}.[{col.DbColumnName}]");

                                colListBody.Add(col.DbColumnName.ToLower(), $"{cBWTblExtName}.[{col.DbColumnName}]");
                            }
                        }
                    }
                }

                var cDefWhere = vouchers.cDefWhere;

                var query = db.Queryable<dynamic>().AS(cBTQName, cBTQName);

                if (bExtHead)
                {
                    query.AddJoinInfo(cBTTblExtName, cBTTblExtName, $"{cBTQName}.[{voucherIdFieldName}]={cBTTblExtName}.[{voucherIdFieldName}]");
                }

                query.AddJoinInfo(cBWQName, cBWQName, $"{cBTQName}.[{voucherIdFieldName}]={cBWQName}.[{voucherIdFieldName}]");

                if (bExtBody)
                {
                    query.AddJoinInfo(cBWTblExtName, cBWTblExtName, $"{cBWQName}.[{vouchersIdFieldName}]={cBWTblExtName}.[{vouchersIdFieldName}]");
                }

                if (input != null)
                {
                    var conModels = new List<IConditionalModel>();

                    foreach (var o in input)
                    {
                        if (o.Key == "dModifyDate")
                        {
                            if (colListHead.Any(a => string.Equals(a.Key, "dnverifytime", StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, "dnverifytime", StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListHead.First(a => string.Equals(a.Key, "dnverifytime", StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, "dnverifytime", StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.GreaterThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }


                        }
                        else if (o.Key == "dModifyDate__2")
                        {
                            if (colListHead.Any(a => string.Equals(a.Key, "dnverifytime", StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, "dnverifytime", StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListHead.First(a => string.Equals(a.Key, "dnverifytime", StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, "dnverifytime", StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.LessThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }
                        }
                        else if ($"{o.Value}".EndsWith("%") || $"{o.Value}".StartsWith("%"))
                        {
                            if (colListHead.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListHead.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.Like,
                                    FieldValue = $"{o.Value}"
                                });
                            }

                            if (colListBody.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListBody.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.Like,
                                    FieldValue = $"{o.Value}"
                                });
                            }
                        }
                        else if (o.Key.EndsWith("__2"))
                        {
                            if (colListHead.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListHead.First(a => string.Equals(a.Key, o.Key.Replace("__2", ""), StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key.Replace("__2", ""), StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.LessThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }

                            if (colListBody.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListBody.First(a => string.Equals(a.Key, o.Key.Replace("__2", ""), StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key.Replace("__2", ""), StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.LessThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }
                        }
                        else if (input.ContainsKey($"{o.Key}__2"))
                        {
                            if (colListHead.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListHead.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.GreaterThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }

                            if (colListBody.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                            {
                                var col = colListBody.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                                conModels.Add(new ConditionalModel
                                {
                                    FieldName = $"{col.Value}",
                                    ConditionalType = ConditionalType.GreaterThanOrEqual,
                                    FieldValue = $"{o.Value}"
                                });
                            }
                        }
                        else if (colListHead.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                        {
                            var col = colListHead.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                            conModels.Add(new ConditionalModel
                            {
                                FieldName = col.Value,
                                ConditionalType = ConditionalType.Equal,
                                FieldValue = $"{o.Value}"
                            });
                        }
                        else if (colListBody.Any(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase)))
                        {
                            var col = colListBody.First(a => string.Equals(a.Key, o.Key, StringComparison.OrdinalIgnoreCase) || string.Equals(a.Value, o.Key, StringComparison.OrdinalIgnoreCase));

                            conModels.Add(new ConditionalModel
                            {
                                FieldName = col.Value,
                                ConditionalType = ConditionalType.Equal,
                                FieldValue = $"{o.Value}"
                            });
                        }
                    }

                    query.Where(conModels);
                }

                query.Where(cDefWhere);


                var selector = colList.Select(col => new SelectModel { FieldName = $"{col.Value}", AsName = col.Key }).ToList();

                query.Select(selector).Distinct();

                _logInfo.Debug(query.ToSqlString());

                return new BaseResult<dynamic>() { bSuccess = true, message = "查询成功", result = await query.ToListAsync() };
            }
            catch (Exception ex)
            {
                _logInfo.Error(ex.Message, ex);

                return new BaseResult<dynamic> { bSuccess = false, message = ex.Message, result = ex.StackTrace };
            }
        }
    }
}