using Rhea.Common;
using Tiger.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Newtonsoft.Json;
using Rhea.Common.Authorization;
using Newtonsoft.Json.Linq;
using Tiger.Model.Minsun;
using System.Globalization;
using System.Data;
using System.Text.RegularExpressions;
using System.Text;
using Dm;
using System.Reflection;
using Apache.NMS.ActiveMQ.Commands;
using Apache.NMS;
using System.Configuration;
using System.Reflection.PortableExecutable;
using Tiger.Business.WMS.Transaction;
using System.Threading;
using System.Drawing.Drawing2D;
using System.Collections;
using Tiger.IBusiness;
using Autofac;

namespace Tiger.Business.WMS
{
    public partial class iWMS
    {
        /// <summary>
        ///
        /// </summary>

        /// <summary>
        /// 物料包装管理	物料包装层级:小包归属于哪个中包、中包归属于哪个外包  wms_barcode 有
        /// </summary>
        /// <param name="sn"></param>
        /// <returns></returns>
        public List<iPackageInfo> GetPackageInfo(string sn)
        {
            var query = new List<iPackageInfo>();
            return query;
        }

        /// <summary>
        /// 物料入库信息	物料名称、物料代码、物料供应商、数量、库位、储位、批次、入库时间
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<iInStoreInfo> GetInStoreInfo(iParams param)
        {
            var query = Biz.Db.Queryable<WMS_STORAGELOTINFO, WMS_BARCODE, WMS_BARCODE_LOG, WMS_MesMaterial>((t, b, l, m) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.BARCODE == b.BARCODE,
                                    JoinType.Left, t.BARCODE == l.BARCODE,
                                    JoinType.Left, t.MATERIALCODE == m.MCode
                                    ))
            .Where((t, b, l, m) => l.INOUTTYPE == 10)
            .WhereIF(!string.IsNullOrEmpty(param.sn), (t, b, l, m) => t.BARCODE == param.sn)
            .WhereIF(!string.IsNullOrEmpty(param.startDate), (t, b, l, m) => l.CreationTime >= Convert.ToDateTime(param.startDate))
            .WhereIF(!string.IsNullOrEmpty(param.endDate), (t, b, l, m) => l.CreationTime < Convert.ToDateTime(param.endDate))
            .Select((t, b, l, m) => new iInStoreInfo
            {
                sn = t.BARCODE,
                MaterialCode = t.MATERIALCODE,
                MaterialName = m.MDesc,
                VendorCode = b.SUPPLIERCODE,
                WarehouseCode = t.WAREHOUSECODE,
                LocationCode = t.LOCATIONCODE,
                LotNo = b.LOTNO,
                SourceCode = b.SOURCEBARCODE,
                QTY = t.QTY,
                CreateDate = l.CreationTime,
                UpdateDate = l.LastModificationTime
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 物料出库信息	领料单号、领料料号、数量、库位、储位、出库时间   
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<iOutStoreInfo> GetOutStoreInfo(iParams param)
        {
            var query = Biz.Db.Queryable<WMS_BARCODE_LOG, WMS_MesMaterial>((t, m) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.MATERIALCODE == m.MCode
                                    ))
            .Where((t, m) => t.INOUTTYPE == 20 && !SqlFunc.IsNullOrEmpty(t.BILLCODE))
            .WhereIF(!string.IsNullOrEmpty(param.sn), (t, m) => t.BARCODE == param.sn)
            .WhereIF(!string.IsNullOrEmpty(param.startDate), (t, m) => t.CreationTime >= Convert.ToDateTime(param.startDate))
            .WhereIF(!string.IsNullOrEmpty(param.endDate), (t, m) => t.CreationTime < Convert.ToDateTime(param.endDate))
            .Select((t, m) => new iOutStoreInfo
            {
                sn = t.BARCODE,
                MaterialCode = t.MATERIALCODE,
                MaterialName = m.MDesc,
                WarehouseCode = t.WAREHOUSECODE,
                LocationCode = t.LOCATIONCODE,
                BillCode = t.BILLCODE,
                QTY = t.QTY,
                CreateDate = t.CreationTime,
                UpdateDate = t.LastModificationTime
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 物料退料信息	退料料号、退料时间、退料条码、退料库位、称重清点结果  
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<iReturnInfo> GetReturnInfo(iParamsBase param)
        {
            var query = Biz.Db.Queryable<WMS_BARCODE_LOG, WMS_MesMaterial>((t, m) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.MATERIALCODE == m.MCode
                                    ))
                .Where(t => t.SOURCEBILLTYPE == 25)
                .WhereIF(!string.IsNullOrEmpty(param.startDate), (t, m) => t.CreationTime >= Convert.ToDateTime(param.startDate))
                .WhereIF(!string.IsNullOrEmpty(param.endDate), (t, m) => t.CreationTime < Convert.ToDateTime(param.endDate))
                .Select((t, m) => new iReturnInfo
                {
                    sn = t.BARCODE,
                    MaterialCode = t.MATERIALCODE,
                    MaterialName = m.MDesc,
                    WarehouseCode = t.WAREHOUSECODE,
                    CreateDate = t.CreationTime
                })
                .ToList();
            return query;
        }

        /// <summary>
        /// 物料库存信息
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<iStorageInfo> GetStorageInfo(iParamsBase param)
        {
            var query = Biz.Db.Queryable<WMS_STORAGELOTINFO, WMS_BARCODE, WMS_MesMaterial, MesVender>((t, b, m, v) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.BARCODE == b.BARCODE,
                                    JoinType.Left, t.MATERIALCODE == m.MCode,
                                    JoinType.Left, b.SUPPLIERCODE == v.VenderCode
                                    ))
            .WhereIF(!string.IsNullOrEmpty(param.startDate), (t, b, m, v) => t.CreationTime >= Convert.ToDateTime(param.startDate))
            .WhereIF(!string.IsNullOrEmpty(param.endDate), (t, b, m, v) => t.CreationTime < Convert.ToDateTime(param.endDate))
            .Select((t, b, m, v) => new iStorageInfo
            {
                MaterialCode = t.MATERIALCODE,
                MaterialName = m.MDesc,
                VenderCode = b.SUPPLIERCODE,
                VenderName = v.VenderName,
                Unit = m.MUom,
                QTY = t.QTY,
                UpdateDate = t.LastModificationTime ?? t.CreationTime
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 备料分包装信息	拆包备料，重新组包的包装号关系：拆包编号、组包后编号、组包后数量、备领料单号、料号
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public List<iSplitInfo> GetSplitInfo(iParams param)
        {
            var query = Biz.Db.Queryable<WMS_BARCODE, WMS_MesMaterial>((t, m) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.MATERIALCODE == m.MCode
                                    ))
            .WhereIF(!string.IsNullOrEmpty(param.sn), (t, m) => t.BARCODE.Contains(param.sn))
            .WhereIF(!string.IsNullOrEmpty(param.startDate), (t, m) => t.CreationTime >= Convert.ToDateTime(param.startDate))
            .WhereIF(!string.IsNullOrEmpty(param.endDate), (t, m) => t.CreationTime < Convert.ToDateTime(param.endDate))
            .Select((t, m) => new iSplitInfo
            {
                sn = t.BARCODE,
                MaterialCode = t.MATERIALCODE,
                MaterialName = m.MDesc,
                ParentBoxBarcode = t.PARENTBOXBARCODE,
                SourceCode = t.SOURCECODE,
                QTY = t.PACKQTY,
                UpdateDate = t.LastModificationTime
            })
            .ToList();
            return query;
        }

        private static readonly IReceiptInfo _IReceiptInfo = BizContext.Container.Resolve<IReceiptInfo>();
        /// <summary>
        /// 到货单生成接口	清点系统 --> wms,  接口需wms定义
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public ApiAction GenerateReceipt(iReceiptInput input)
        {
            var action = new ApiAction();
            bool isIQCOk = true;
            try
            {
                string msg = "";
                if (!input.iReceipts.Any())
                {
                    action.IsSuccessed = false;
                    msg += $"{msg.IsNullOrEmpty("", "；")}没有可以提交的清点数据";
                    action.Message = msg;
                    return action;
                }

                var judian = BizConfig.Configuration["JuDian"];
                var requestJson = JsonConvert.SerializeObject(input);
                var response = HttpHelper.PostAsync("http://172.18.8.56:9631/api/WMS/GenerateReceiptNew/", requestJson).Result;
                action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                return action;
                //if (input.StrongHold != judian)
                //{
                //    var requestJson = JsonConvert.SerializeObject(input);
                //    //if (input.StrongHold == "AHXC")
                //    //{
                //    //    var response = HttpHelper.PostAsync("http://172.18.8.56:9529/api/WMS/GenerateReceipt", requestJson).Result;
                //    //    action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                //    //    return action;
                //    //}
                //    if (input.StrongHold == "DGXC" || input.StrongHold == "AHXC")
                //    {
                //        //return _IReceiptInfo.GenerateReceipt(input); 

                //        var response = HttpHelper.PostAsync("http://172.18.8.56:9631/api/WMS/GenerateReceiptNew/", requestJson).Result;
                //        action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                //        return action;
                //    }
                //    if (input.StrongHold == "XCSJ")
                //    {
                //        var response = HttpHelper.PostAsync("http://172.18.8.56:9527/api/WMS/GenerateReceipt/", requestJson).Result;
                //        action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                //        return action;
                //    }
                //}
                var usercode = "00000";
                switch (input.CompanyCode)
                {
                    case "XCQX":
                        usercode = "LX0001";
                        break;
                    case "XCHF":
                        usercode = "AA0001";
                        break;
                    case "XCTH":
                        //usercode = "AA0001";
                        break;
                    case "XCTX":
                        usercode = "TA0001";
                        break;
                }
                //待提交数据按来源单号分组（ASN/PO）
                var srcBills = input.iReceipts
                        .Select(p => new { BillCode = p.DeliveryNo })
                        .GroupBy(p => p.BillCode)
                        .ToList();
                List<WMS_RECEIPT_H> receiptHeaders = new List<WMS_RECEIPT_H>();
                List<WMS_RECEIPT_D> receiptDetails = new List<WMS_RECEIPT_D>();
                List<WMS_RECEIPT_SCAN> receiptScans = new List<WMS_RECEIPT_SCAN>();
                List<Detail> details = new List<Detail>();
                List<WMS_IQC_H> iqcHeaders = new List<WMS_IQC_H>();
                List<WMS_PO_D> poDetails = new List<WMS_PO_D>();
                int billid = 1;
                foreach (var srcBill in srcBills)
                {
                    var asnHeader = Biz.Db.Queryable<WMS_SRM_ASN>().Where(x => x.DeliveryNo == srcBill.Key).First();
                    if (asnHeader == null)
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}SRM中查不到数据";
                        action.Message = msg;
                        return action;
                    }
                    //获取ASN行明细
                    var asnLines = Biz.Db.Queryable<WMS_SRM_ASN_LINES>().Where(x => x.DeliveryNo == srcBill.Key).ToList();
                    if (asnLines == null)
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}SRM中查不到ASN行明细";
                        action.Message = msg;
                        return action;
                    }
                    var asnBarcodeList = Biz.Db.Queryable<WMS_SRMSNList>().Where(x => x.DeliveryNo == srcBill.Key).ToList();
                    if (asnBarcodeList == null)
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}SRM中查不到ASN行明细";
                        action.Message = msg;
                        return action;
                    }

                    if (asnBarcodeList.Count > input.iReceipts.Where(x => x.DeliveryNo == srcBill.Key).ToList().Count)
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}送货单[{srcBill.Key}]还有条码未扫描清点，不能生成到货单";
                        action.Message = msg;
                        return action;
                    }
                    if (Biz.Db.Queryable<WMS_RECEIPT_SCAN>().Where(x => x.BILLCODE == srcBill.Key).Any())
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}送货单[{srcBill.Key}]已经扫描过不能再扫描";
                        action.Message = msg;
                        return action;
                    }
                    List<string> asnLinesNum = new List<string>();
                    asnLinesNum = asnLines.Select(x => x.productCode).Distinct().ToList();

                    List<string> tempBarcodesNum = new List<string>();
                    tempBarcodesNum = input.iReceipts.Where(x => x.DeliveryNo == srcBill.Key).ToList().Select(x => x.MaterialCode).Distinct().ToList();

                    if (asnLinesNum.Count > tempBarcodesNum.Count)
                    {
                        action.IsSuccessed = false;
                        msg += $"{msg.IsNullOrEmpty("", "；")}送货单[{srcBill.Key}]还有料号未扫描清点，不能生成到货单";
                        return action;
                    }

                    msg += $"{msg.IsNullOrEmpty("", "；")}送货单[{srcBill.Key}]总数[{asnBarcodeList.Count}]，扫描总数[{input.iReceipts.Where(x => x.DeliveryNo == srcBill.Key).ToList().Count}]";

                    // 生成收料单
                    // 新建一个 Header 
                    var nReceiptHeader = new WMS_RECEIPT_H
                    {
                        BILLCODE = GetBillNoByType("RECEIPT"),
                        BILLDATE = DateTime.Now,
                        STATUS = (int)WMS_RECEIPT_H.ReceiptStatus.Add,
                        BIZTYPE = (int)WMS_RECEIPT_H.ReceiptBizType.PO,
                        SUPPLIERCODE = asnHeader.innerVendorCode,
                        CreationTime = DateTime.Now,
                        CreatorUserId = 1
                    };
                    var nHeaderId = Biz.Db.Insertable(nReceiptHeader).ExecuteReturnBigIdentity();
                    nReceiptHeader.Id = nHeaderId;

                    // 生成收料单行明细
                    var nLineSeq = 1;
                    foreach (var asnLine in asnLines)
                    {
                        //订单物料行(唯一)
                        int poline = Convert.ToInt32(asnLine.poLineNo.Split('-')[0]);
                        var nOrderDetail = Biz.Db.Queryable<WMS_PO_D>().Where(x => x.BILLCODE.ToUpper() == asnLine.poErpNo.ToUpper() && x.BILLLINE == poline).First();
                        if (asnBarcodeList == null)
                        {
                            action.IsSuccessed = false;
                            msg += $"{msg.IsNullOrEmpty("", "；")}订单中查不到数据";
                            return action;
                        }
                        nOrderDetail.ARRIVALQTY = (nOrderDetail.ARRIVALQTY ?? 0) + asnLine.deliveryQty;
                        poDetails.Add(nOrderDetail);

                        //插入收料单行
                        var nReceiptDetail = new WMS_RECEIPT_D
                        {
                            BILLCODE = nReceiptHeader.BILLCODE,
                            BILLLINE = nLineSeq++,
                            BILLID = nHeaderId,
                            LINESTATUS = (int)WMS_RECEIPT_H.ReceiptLineStatus.Add,
                            MATERIALCODE = asnLine.productCode,
                            UNITCODE = "",
                            QTY = asnLine.deliveryQty,
                            QTYPASS = 0,
                            INSTOCKQTY = 0,
                            RETURNQTY = 0,
                            PRINTQTY = 0,
                            ISGIVEAWAY = false,
                            SOURCETYPE = (int)WMS_RECEIPT_H.SourceType.Asn,
                            SOURCECODE = asnLine.DeliveryNo,
                            SOURCELINE = string.IsNullOrEmpty(asnLine.extendN01) ? asnLine.lineNo : Convert.ToInt32(asnLine.extendN01 ?? "0"), //asnLine.lineNo,
                            PONO = asnLine.poErpNo,
                            POLINE = poline,
                            LastModificationTime = DateTime.Now,
                            CreationTime = DateTime.Now,
                            CreatorUserId = 1
                        };
                        receiptDetails.Add(nReceiptDetail);
                        details.Add(new Detail
                        {
                            pmdtseq = nLineSeq.ToString(),
                            pmdt001 = string.IsNullOrEmpty(nReceiptDetail.PONO) ? asnLine.DeliveryNo : asnLine.poErpNo,
                            pmdt002 = asnLine.lineNo.ToString(), //string.IsNullOrEmpty(nReceiptDetail.PONO) ? asnLine.lineNo.ToString() : poline.ToString(), 采购项次
                            pmdt003 = "1",
                            pmdt004 = asnLine.poLineNo.Split('-').Length > 2 ? asnLine.poLineNo.Split('-')[2] : (asnLine.poLineNo ?? "1"), //采购分批序
                            pmdt006 = asnLine.productCode, //"K7015AA016141",
                                                           //pmdt018 = "创米科技",
                            pmdt020 = asnLine.deliveryQty.ToString(),  //"100.00000",
                            pmdtud011 = "0"
                        });

                        //创建送检单
                        Result<WMS_IQC_H> result = CreateIqcHeader(nReceiptDetail, "Y", Biz.Db);
                        if (result.Flag != Result.Flags.Success)
                        {
                            action.IsSuccessed = false;
                            action.Message = result.Message;
                            return action;
                        }
                        iqcHeaders.Add(result.Data);
                        billid++;
                    }

                    //var asnScanTemp = await _tempRepository.GetAll().Where(x => x.CreatorUserId == (AbpSession.UserId ?? 0) && x.BillCode.ToUpper() == srcBill.Key.ToUpper()).ToListAsync();
                    foreach (var scanTemp in input.iReceipts.Where(x => x.DeliveryNo == srcBill.Key).ToList())
                    {
                        WMS_RECEIPT_SCAN scanObj = new WMS_RECEIPT_SCAN
                        {
                            Id = Guid.NewGuid().ToString(),
                            BILLCODE = scanTemp.DeliveryNo,
                            BILLLINE = 0,
                            SOURCETYPE = (int)WMS_RECEIPT_H.SourceType.Asn,
                            MATERIALCODE = scanTemp.MaterialCode,
                            BARCODE = scanTemp.SmallBarcode,
                            SCAN_BARCODE = scanTemp.SCAN_BARCODE,
                            CARTON = scanTemp.BigBarcode,
                            PALLET = scanTemp.OuterBarcode,
                            SUPPLIERCODE = scanTemp.innerVendorCode,
                            DATECODE = DateTime.Now,
                            //LOTNO = scanTemp.LotNo,
                            SCANQTY = scanTemp.SCANQTY,
                            //UNIT = scanTemp.Unit,
                            //ISGIVEAWAY = scanTemp.IsGiveAway,
                            RECEIPTNO = nReceiptHeader.BILLCODE,
                            RECEIPTLINE = 0,
                            STATEFLAG = WMS_RECEIPT_H.ReceiptLineStatus.PreInstock.ToString(),
                            LastModificationTime = DateTime.Now,
                            CreationTime = DateTime.Now,
                            CreatorUserId = 1
                        };
                        receiptScans.Add(scanObj);
                    }

                    //调用T100接口生成到货单
                    var ret = ErpT100.GenerateCustReceipt(new CustReceiptInputParameter
                    {
                        parameter = new Parameter<Detail>
                        {
                            pmds000 = "1",
                            pmdsdocno = "3438",
                            pmdsdocdt = DateTime.Now.ToString("yyyy-MM-dd"), //"2023-04-26", //当天时间
                            pmds002 = usercode, // "00000", //UserCode == "admin" ? "00000" : UserCode, //"L36783", //用户ID
                            pmds003 = "",
                            pmds007 = nReceiptHeader.SUPPLIERCODE, //"C0006", //供应商代码
                            pmds010 = srcBill.Key, //"测试客供料无采购收货", //送货单号
                                                   //pmdsud001 = SecondVenderCode, //"CM017", //二级供应编号
                            detail = details
                        },
                        datakey = new Datakey
                        {
                            EntId = ApiConfig.IsTestServer ? "108" : "88",
                            CompanyId = input.StrongHold
                        }
                    });
                    if (ret.payload.std_data.execution.code == "0") //成功
                    {
                        nReceiptHeader.ERP_BILL_CODE = ret.payload.std_data.parameter.docno;
                        nReceiptHeader.STATUS = 3;
                        receiptHeaders.Add(nReceiptHeader);
                        action.Message += $"{action.Message.IsNullOrEmpty("", "；")}{ret.payload.std_data.execution.description}，返回的收货单号：[{ret.payload.std_data.parameter.docno}]";

                        #region 生成送检单
                        foreach (var item in iqcHeaders)
                        {
                            var retIns = ErpT100.GenerateInspection(new InsInputParameter
                            {
                                parameter = new InsParameter
                                {
                                    pmdsdocno = ret.payload.std_data.parameter.docno,
                                    pmdsdocdt = DateTime.Now.ToString("yyyy-MM-dd"),
                                    pmdtseq = item.SOURCELINE.ToString(),
                                    pmdt020 = item.QCQTY.ToString(),
                                    qcbadocno = "3701",
                                },
                                datakey = new Datakey
                                {
                                    EntId = ApiConfig.IsTestServer ? "108" : "88",
                                    CompanyId = input.StrongHold
                                }
                            });
                            if (retIns.payload.std_data.execution.code != "0")
                            {
                                isIQCOk = false;
                                action.IsSuccessed = false;
                                action.Message = $"到货单[{ret.payload.std_data.parameter.docno}]，当前用户[{usercode}]，供应商编号[{nReceiptHeader.SUPPLIERCODE}]，返回的信息:{retIns.payload.std_data.execution.description}"; ;
                                //return action;
                            }
                            else
                            {
                                action.Message += $"到货单[{ret.payload.std_data.parameter.docno}]，当前用户[{usercode}]，供应商编号[{nReceiptHeader.SUPPLIERCODE}]，返回的信息:{retIns.payload.std_data.execution.description}";
                                item.ERP_BILL_CODE = retIns.payload.std_data.parameter.docno;
                            }
                        }
                        #endregion
                    }
                    else //失败
                    {
                        action.IsSuccessed = false;
                        action.Message = $"当前用户[{usercode}]，供应商编号[{nReceiptHeader.SUPPLIERCODE}]，返回的信息:{ret.payload.std_data.execution.description}";
                        return action;
                    }
                }
                var db = Business.Biz.Db;
                //保存到数据库
                var dbTran = db.UseTran(() =>
                {
                    if (receiptHeaders.Any())
                    {
                        db.Updateable(receiptHeaders, "system").ExecuteCommand();
                    }
                    if (poDetails.Any())
                    {
                        db.Updateable(poDetails, "system").ExecuteCommand();
                    }
                    if (receiptDetails.Any())
                    {
                        db.Insertable(receiptDetails, "system").ExecuteCommand();
                    }
                    if (receiptScans.Any())
                    {
                        db.Insertable(receiptScans, "system").ExecuteCommand();
                    }
                    if (action.IsSuccessed && isIQCOk)
                    {
                        db.Insertable(iqcHeaders).ExecuteCommand();
                    }
                });
                if (!dbTran.IsSuccess)
                {
                    if (receiptHeaders.Any())
                    {
                        db.Deleteable(receiptHeaders).ExecuteCommand();
                    }
                    action.GetResponse().CatchExceptionWithLog(dbTran.ErrorException, $"到货单生成异常");
                }
                action.Message += $"{msg.IsNullOrEmpty("", "；")}到货单和送检单生成成功！";
                return action;
            }
            catch (Exception ex)
            {
                return action.GetResponse().CatchExceptionWithLog(ex, $"到货单生成异常");
            }
        }

        private static readonly IProdMaterialReq _IProdMaterialReq = BizContext.Container.Resolve<IProdMaterialReq>();
        /// <summary>
        /// 获取T100领料单数据
        /// </summary>
        /// <param name="prd_hs"></param>
        /// <returns></returns>
        public ApiAction GetMaterialReq(List<WMS_PRDPICK_H> prd_hs)
        {
            var action = new ApiAction();
            try
            {
                if (prd_hs.Count > 0)
                {
                    Work.DoAsync(() =>
                    {
                        Logger.Interface.Info($"开始异步推送到新数据库");
                        _IProdMaterialReq.GetMaterialReq(prd_hs);
                    });
                    return action;
                    //var judian = BizConfig.Configuration["JuDian"];
                    //foreach (var group in prd_hs.Select(q => q.ENTERPRISECODE).Distinct())
                    //{
                    //    List<WMS_PRDPICK_H> entity_h = new();
                    //    List<WMS_PRDPICK_D> entity_d = new();
                    //    //查询出来的列表
                    //    List<WMS_PRDPICK_D> list_d = new();
                    //    DbClient db;
                    //    List<WMS_PRDPICK_H> dtls=new();
                    //    if (group == 88)
                    //    {
                    //        dtls = prd_hs.Where(q=>q.STRONGHOID== judian && q.ENTERPRISECODE==group).ToList();
                    //        db = Business.Biz.Db;
                    //        foreach (var ju in prd_hs.Where(q=>q.STRONGHOID!=judian).Select(q => q.STRONGHOID).Distinct())
                    //        {
                    //            if (ju == "AHXC")
                    //            {
                    //                var requestJson = JsonConvert.SerializeObject(prd_hs.Where(q => q.STRONGHOID == ju && q.ENTERPRISECODE == group).ToList());
                    //                var response = HttpHelper.PostAsync("http://172.18.8.56:9529/api/WMS/GetMaterialReq", requestJson).Result;
                    //                action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                    //            }
                    //            if (ju == "DGXC")
                    //            {
                    //                //var requestJson = JsonConvert.SerializeObject(prd_hs.Where(q => q.STRONGHOID == ju && q.ENTERPRISECODE == group).ToList());
                    //                //var response = HttpHelper.PostAsync("http://172.18.8.56:9528/api/WMS/GetMaterialReq/", requestJson).Result;
                    //                //action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                    //            }
                    //            if (ju == "XCSJ")
                    //            {
                    //                var requestJson = JsonConvert.SerializeObject(prd_hs.Where(q => q.STRONGHOID == ju && q.ENTERPRISECODE == group).ToList());
                    //                var response = HttpHelper.PostAsync("http://172.18.8.56:9527/api/WMS/GetMaterialReq/", requestJson).Result;
                    //                action = JsonConvert.DeserializeObject<ApiAction>(response.Message);
                    //            }

                    //        }
                    //    }
                    //    else
                    //    {
                    //        //dtls = prd_hs.Where(q =>  q.ENTERPRISECODE !=88 ).ToList();
                    //        db = Biz.DataSource["Test"].Client;
                    //    }
                    //    foreach (var item_h in dtls)
                    //    {
                    //        var prd_h = Biz.Db.Queryable<WMS_PRDPICK_H>().Where(s => s.BILLCODE == item_h.BILLCODE).Single();
                    //        if (prd_h?.STATUS != "COMPLETE")
                    //        {
                    //            prd_h = prd_h ?? new WMS_PRDPICK_H()
                    //            {
                    //                STATUS = "INIT",
                    //                BIZTYPE = "1",
                    //                CreationTime = DateTime.Now,
                    //                CreatorUserId = 1,
                    //            };
                    //            prd_h.BILLCODE = item_h.BILLCODE;
                    //            prd_h.BILLDATE = item_h.BILLDATE;
                    //            prd_h.SOURCETYPE = item_h.SOURCETYPE;
                    //            prd_h.STATUS = prd_h.STATUS == "DELETE"? "INIT": prd_h.STATUS;
                    //            prd_h.REMARK = item_h.REMARK;
                    //            prd_h.SOURCECODE = item_h.SOURCECODE;
                    //            prd_h.LastModificationTime = DateTime.Now;
                    //            //prd_h.ENTERPRISECODE = item_h.ENTERPRISECODE;
                    //            //prd_h.STRONGHOID = item_h.STRONGHOID;

                    //            entity_h.Add(prd_h);
                    //        }
                    //    }

                    //    //保存到数据库
                    //    var dbTran = db.UseTran(() =>
                    //    {
                    //        db.Storageable(entity_h, "system").ExecuteCommand();

                    //    });
                    //    if (!dbTran.IsSuccess)
                    //    {
                    //        action.CatchExceptionWithLog(dbTran.ErrorException, $"数据保存失败");
                    //    }

                    //    //异步拉取单身列表
                    //    Work.DoAsync(() =>
                    //    {
                    //        GenerateReqDetail(dtls,db);
                    //    });
                    //    action.Message += $"拉取领料单单头完成，调用异步拉单身。";
                    //}

                }

                return action;
            }
            catch (Exception ex)
            {
                return action.GetResponse().CatchExceptionWithLog(ex, $"领料单生成异常");
            }
        }

        /// <summary>
        /// 根据领料单头拉单身
        /// </summary>
        /// <param name="dtls"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        private static ApiAction GenerateReqDetail(List<WMS_PRDPICK_H> dtls, DbClient db)
        {
            Thread.Sleep(5000);
            var action = new ApiAction();
            try
            {
                var judian = BizConfig.Configuration["JuDian"];
                List<WMS_PRDPICK_H> entity_h = new();
                List<WMS_PRDPICK_D> entity_d = new();
                List<WMS_TRANSFER_H> transferH = new();
                List<WMS_SCTRWO_TRANSFER> sctrwos = new();
                //查询出来的列表
                List<WMS_PRDPICK_D> list_dOld = new();
                foreach (var item_h in dtls)
                {
                    var prd_h = Biz.Db.Queryable<WMS_PRDPICK_H>().Where(s => s.BILLCODE == item_h.BILLCODE).Single();
                    if (prd_h?.STATUS != "COMPLETE")
                    {
                        var list_d = Biz.Db.Queryable<WMS_PRDPICK_D>().Where(s => s.BILLCODE == item_h.BILLCODE).ToList();

                        var item_h_list = new List<WMS_PRDPICK_D>();
                        var ret = DI.Resolve<IErpT100>().GetMaterialReqDetail(new ReqInputParameter
                        {
                            parameter = new reqParameter { sfdcdocno = item_h.BILLCODE },
                            datakey = new Datakey
                            {
                                EntId = item_h.ENTERPRISECODE.ToString(),
                                CompanyId = judian
                            }
                        });
                        List<reqParameterReturn> ret_list = new List<reqParameterReturn>();
                        if (ret.payload.std_data.execution.code != "0")
                        {
                            action.IsSuccessed = false;
                            action.Message = $"错误信息：[{ret.payload.std_data.execution.description}]";
                            Logger.Default.Info(action.Message);
                            var dt = DateTime.Now;
                            while ((dt - DateTime.Now).TotalSeconds < 10)
                            {

                            }
                            var ret1 = DI.Resolve<IErpT100>().GetMaterialReqDetail(new ReqInputParameter
                            {
                                parameter = new reqParameter { sfdcdocno = item_h.BILLCODE },
                                datakey = new Datakey
                                {
                                    EntId = item_h.ENTERPRISECODE.ToString(),
                                    CompanyId = judian
                                }
                            });
                            if (ret1.payload.std_data.execution.code != "0")
                            {
                                action.IsSuccessed = false;
                                action.Message = $"错误信息：[{ret1.payload.std_data.execution.description}]";
                                Logger.Default.Info(action.Message);
                                return action;
                            }
                            else
                            {
                                ret_list = ret1.payload.std_data.parameter.@return;
                            }
                        }
                        else
                        {
                            ret_list = ret.payload.std_data.parameter.@return;
                        }
                        foreach (var item in ret_list)
                        {
                            WMS_PRDPICK_D d = new WMS_PRDPICK_D
                            {
                                BILLCODE = item.sfdcdocno,
                                BILLLINE = Convert.ToInt32(item.sfdcseq),
                                UNITCODE = item.sfdc006,
                                MATERIALCODE = item.sfdc004,
                                PRQTY = Convert.ToDecimal(item.sfdc007),
                                DELIVERYDATE = Convert.ToDateTime(item.sfdareqdt),
                                WAREHOUSECODE = item.sfdc012,
                                SOURCETYPE = Convert.ToInt32(item.sfdc003),
                                SOURCECODE = item.sfdc001,
                                SOURCELINE = Convert.ToInt32(item.sfdc002),
                            };
                            item_h_list.Add(d);
                        }

                        //保存委外工单号对应关系
                        WMS_SCTRWO_TRANSFER sctr = new WMS_SCTRWO_TRANSFER
                        {
                            ID = Guid.NewGuid().ToString("N"),
                            ORIGINAL_WORKORDER = ret_list[0]?.sfdc001,
                            TARGET_WORKORDER = ret_list[0]?.sfdc001_1
                        };
                        sctrwos.Add(sctr);
                        action.Message += $"，领料单明细获取成功，[{string.Join(",", item_h_list.Select(x => x.BILLCODE + ";" + x.MATERIALCODE).ToList())},获取总数[{item_h_list.Count}]，数据库中总数[{list_d.Count}]";
                        action.Message += $"，委外工单，[{string.Join(",", sctrwos.Select(x => x.ORIGINAL_WORKORDER + ";" + x.TARGET_WORKORDER).ToList())}";
                        if (list_d.Count != item_h_list.Count)
                        {
                            foreach (var d in list_d) { d.PRQTY = 0; } //需求数量都弄成0
                        }
                        int n = 0;
                        List<WMS_PRDPICK_D> prdDList = new List<WMS_PRDPICK_D>();
                        foreach (var item_d in item_h_list)
                        {
                            //根据单据重新到数据查找相应的单据明细
                            var prd_d = list_d.Where(s => s.BILLCODE == item_d.BILLCODE && s.BILLLINE == item_d.BILLLINE).FirstOrDefault();
                            prd_d = prd_d ?? new WMS_PRDPICK_D()
                            {
                                LINESTATUS = "INIT",
                                QTY = Convert.ToDecimal(0),
                                CreationTime = DateTime.Now,
                                CreatorUserId = 1,
                            };
                            prd_d.BILLCODE = item_d.BILLCODE;
                            prd_d.BILLLINE = item_d.BILLLINE;
                            prd_d.UNITCODE = item_d.UNITCODE;
                            prd_d.MATERIALCODE = item_d.MATERIALCODE;
                            prd_d.PRQTY = Convert.ToDecimal(item_d.PRQTY);
                            prd_d.DELIVERYDATE = Convert.ToDateTime(item_d.DELIVERYDATE);
                            prd_d.WAREHOUSECODE = item_d.WAREHOUSECODE;
                            prd_d.LINESTATUS = prd_d.PRQTY == prd_d.QTY ? "COMPLETE" : Convert.ToDecimal(item_d.PRQTY) == 0 ? "COMPLETE" : prd_d.LINESTATUS == "DELETE" ? "INIT" : prd_d.LINESTATUS;
                            prd_d.SOURCETYPE = item_d.SOURCETYPE;
                            prd_d.SOURCECODE = item_d.SOURCECODE;
                            prd_d.SOURCELINE = item_d.SOURCELINE;
                            prd_d.LastModificationTime = item_d.LastModificationTime;
                            list_d.RemoveAll(q => q.BILLCODE == item_d.BILLCODE && q.BILLLINE == item_d.BILLLINE);
                            if (prd_d.LINESTATUS == "COMPLETE") { n++; }
                            prdDList.Add(prd_d);
                            entity_d.Add(prd_d);
                        }
                        if (prdDList.Count == n) { prd_h.STATUS = "COMPLETE"; }
                        entity_h.Add(prd_h);
                        list_dOld.AddRange(list_d);
                        //检查有没有调拨单，有就更新状态为完成
                        var transferList = Biz.Db.Queryable<WMS_TRANSFER_H>().Where(s => s.SOURCECODE == prd_h.BILLCODE).ToList();
                        if (transferList.Any())
                        {
                            foreach (var item in transferList)
                            {
                                item.STATUS = "COMPLETE2";
                                item.LastModificationTime = DateTime.Now;
                                item.SOURCECODE = prd_h.BILLCODE;
                                transferH.Add(item);
                                action.Message += $"，领料单[{prd_h.BILLCODE}]对应调拨单[{item.BILLCODE}]完成";
                            }
                        }
                    }
                }
                //保存到数据库
                var dbTran = db.UseTran(() =>
                {
                    db.Storageable(entity_h, "system").ExecuteCommand();
                    db.Storageable(entity_d, "system").ExecuteCommand();
                    if (transferH.Any())
                    {
                        db.Updateable(transferH).ExecuteCommand();
                    }
                    if (sctrwos.Any())
                    {
                        //db.Insertable(sctrwos).ExecuteCommand();
                        var y = db.Storageable(sctrwos)
                        .WhereColumns(t => new { t.ORIGINAL_WORKORDER, t.TARGET_WORKORDER })
                        .ToStorage();
                        y.AsInsertable.ExecuteCommand();
                        y.AsUpdateable.IgnoreColumns(t => t.ID).ExecuteCommand();
                    }
                    if (list_dOld.Any())
                    {
                        db.Deleteable(list_dOld).ExecuteCommand();
                    }
                });
                if (!dbTran.IsSuccess)
                {
                    action.CatchExceptionWithLog(dbTran.ErrorException, $"数据保存失败");
                }
                Logger.Default.Info(action.Message);
                return action;
            }
            catch (System.Exception ex)
            {
                return action.GetResponse().CatchExceptionWithLog(ex, $"领料单生成异常");
            }
        }

        /// <summary>
        /// 拆解条码
        /// </summary>
        /// <param name="nFullBarcode"></param>
        /// <param name="nPackageBarcode"></param>
        /// <returns></returns>
        public static Result<InputBarcodeDto> SplitFullBarcode(string nFullBarcode, bool nPackageBarcode = false)
        {
            Result<InputBarcodeDto> result = new(Result.Flags.Success, $"解析条码[{nFullBarcode}]成功");
            //识别新的识别二维码规则，以V开头，否则按旧识别模式
            if (nFullBarcode.Substring(0, 1).ToUpper() == "V")
            {
                return SplitFullBarcodeNew(nFullBarcode, nPackageBarcode);
            }

            // 旧格式条码，都是最小批次标签，非包装标签
            nPackageBarcode = false;

            //新条码解析
            var nSplitArray = nFullBarcode.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            if (nSplitArray.Length == 1) //一维码
            {
                result.Data = new InputBarcodeDto
                {
                    Barcode = nFullBarcode
                };
                return result;
            }

            var nOrderNo = "";
            var nMaterialCode = "";
            var nBarcodeLotNo = "";
            var nLotQty = "";
            var nLotDate = "";
            var nStateFlag = "";
            bool isBox = false;
            var nLotNo = "";


            foreach (string item in nSplitArray)
            {
                string itemKey = item.Substring(0, 1).ToUpper();
                string itemValue = item.Substring(1);
                if (itemKey == "V")
                { //采购订单号
                    nOrderNo = itemValue;
                }
                else if (itemKey == "P")
                { //条码料号
                    nMaterialCode = itemValue;
                }
                else if (itemKey == "S")
                { //来料外包条码   
                    nBarcodeLotNo = itemValue;
                    //nBarcodeLotNo = item;//PAG ID 解析出来的数据前缀“S”不用去掉
                    //if (itemValue.StartsWith("C") || itemValue.StartsWith("P")) //中箱（C）和栈板（P），需要再次去掉一位
                    //    nBarcodeLotNo = itemValue.Substring(1);
                }
                else if (itemKey == "Q")
                { //条码数量
                    nLotQty = itemValue;
                }
                else if (itemKey == "D")
                { //生产日期(去掉-，兼容带-的时间格式，后面统一时间解析)
                    nLotDate = itemValue;
                    //nLotDate = itemValue.Replace("-", "");
                }
                else if (itemKey == "L")
                { //批号
                    nLotNo = itemValue;
                }

            }


            if (nMaterialCode == "" || nLotQty == "" || nBarcodeLotNo == "")
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码数据有误";
                return result;
            }


            // 判断标签数量是否合法
            if (!decimal.TryParse(nLotQty, out decimal nBarcodeQty))
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码格式错误：未取到正确的条码数量";
                return result;
            }

            // 解析DateCode
            DateTime nDateCode = DateTime.MinValue;
            if (nLotDate != "")
            {
                //string dateTimeStr = nLotDate.Substring(0, 4) + "-" + nLotDate.Substring(4, 2) + "-" + nLotDate.Substring(6, 2);

                //if (!DateTime.TryParse(dateTimeStr, out nDateCode))
                ////if (!DateTime.TryParse(nLotDate, out DateTime nDateCode))
                //{
                //    throw new UserFriendlyException("条码格式错误：未取到正确的批次日期");
                //}

                /// 原始DateCode 为日期
                if (nLotDate.Length > 6)
                {
                    var sDate = nLotDate;
                    if (nLotDate.Length == 7) { sDate = $"{nLotDate.Substring(0, 4)}0{nLotDate.Substring(4)}"; }
                    IFormatProvider ifp = new CultureInfo("zh-CN", true);
                    DateTime.TryParseExact(sDate, "yyyyMMdd", ifp, DateTimeStyles.None, out nDateCode);
                }

                /// 原始DateCode 为年、周次（YYYYWW / YYWW）
                int yw = 0;
                if (nLotDate.Length <= 6 && int.TryParse(nLotDate, out yw))
                {
                    nDateCode = GetWeekStartTime(nLotDate);
                }

                if (nDateCode == DateTime.MinValue)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"条码格式错误：未取到正确的批次日期";
                    return result;
                }

            }

            // 判断物料代码是否合法
            var nMaterial = Biz.Db.Queryable<WMS_MesMaterial>().Where(q => q.MCode.ToUpper() == nMaterialCode.ToUpper() || q.MCode.ToUpper() == "K" + nMaterialCode.ToUpper()).First();
            if (nMaterial == null)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码对应的物料不存在";
                return result;
            }

            // 判断包装条码格式是否合法
            if (nPackageBarcode && nBarcodeLotNo.Length != 12)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"来料外包条码格式错误，应包含12位字符的批次号";
                return result;
            }

            if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_semimanufacture" && nBarcodeLotNo.Length < 16) //5位供应商+8位日期+3位流水码
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"半成品条码的批次格式错误，应至少包含16位字符";
                return result;
            }

            if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_finishedproduct" && nBarcodeLotNo.Length < 17) //5位供应商+8位日期+4位流水码
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"成品箱号批次格式错误，应至少包含17位字符";
                return result;
            }

            if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_rawmaterial" && nBarcodeLotNo.Length < 15)//4位供应商+8位日期+4位流水码
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"物料条码批次格式错误，应至少包含15位字符";
                return result;
            }
            result.Data = new InputBarcodeDto
            {
                OrderNo = nOrderNo,
                Barcode = nBarcodeLotNo,
                MaterialCode = nMaterial?.MCode,
                MaterialName = nMaterial?.MName,
                MaterialStandard = nMaterial?.MDesc,
                MGroupCode = nMaterial?.MGroupCode,
                Unit = nMaterial?.MUom,
                LotQty = nBarcodeQty,
                LotDate = nDateCode,
                LotDateString = nLotDate,
                PeriodDays = nMaterial.PERIODDAYS,
                FIFO = nMaterial.FIFO,
                SafeStorageQty = nMaterial.SAFEQTY,
                StateFlag = nStateFlag,
                IsBox = isBox,
                //SnList = snList,
                LotNo = nBarcodeLotNo,
            };
            return result;
        }

        /// <summary>
        /// 最新解码规则,SRM 标签
        /// 拆解条码
        ///        依次是：
        ///V：PO（MO）
        ///P：C P/N：料号
        ///N：Name（物料名称）
        ///Q：QTY（数量）
        ///U：Unit（单位）
        ///M：Mfr P/N（供应商内部管控的物料的料号）
        ///D：Date Code（生产日期，物料的生产日期）
        ///L：Lot Code（生产的批次）
        ///S：PAG ID（小包批次代码，也就是来料外包条码）
        /// </summary>
        /// <param name="nFullBarcode"></param>
        /// <param name="nPackageBarcode"></param>
        /// <returns></returns>
        public static Result<InputBarcodeDto> SplitFullBarcodeNew(string nFullBarcode, bool nPackageBarcode = false)
        {
            Result<InputBarcodeDto> result = new(Result.Flags.Success, $"解析条码[{nFullBarcode}]成功");
            var nSplitArray = nFullBarcode.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

            var nOrderNo = "";
            var nMaterialCode = "";
            var nBarcodeLotNo = "";
            var nLotQty = "";
            var nLotDate = "";
            var nStateFlag = "";
            bool isBox = false;
            var nLotNo = "";

            List<Tuple<string, decimal>> snList = new List<Tuple<string, decimal>>();


            foreach (string item in nSplitArray)
            {
                string itemKey = item.Substring(0, 1).ToUpper();
                string itemValue = item.Substring(1);
                if (itemKey == "V")
                { //采购订单号
                    nOrderNo = itemValue;
                }
                else if (itemKey == "P")
                { //条码料号
                    nMaterialCode = itemValue;
                }
                else if (itemKey == "S")
                { //来料外包条码   
                    nBarcodeLotNo = itemValue;
                }
                else if (itemKey == "Q")
                { //条码数量
                    nLotQty = itemValue;
                }
                else if (itemKey == "D")
                {
                    //生产日期(去掉-，兼容带-的时间格式，后面统一时间解析)
                    nLotDate = Regex.Replace(itemValue, @"[^0-9]+", "");
                }
                else if (itemKey == "L")
                { //批号
                    nLotNo = itemValue;
                }

            }

            //判断条码是否拆分过，拆分过的不判断是否为ASN 2022/12/17 Ben Lin
            //if (!nBarcodeLotNo.Contains("-1") && !nBarcodeLotNo.Contains("-2"))
            if (nBarcodeLotNo.Substring(nBarcodeLotNo.Length - 3, 2) != "-1" && nBarcodeLotNo.Substring(nBarcodeLotNo.Length - 3, 2) != "-2") //调整判断拆包标签的标准2023-1-2，weikaiyong
            {
                // 判断单据编号是否为ASN, 如果是ASN，调用ASN标签解析
                if (BillIsAsn(nOrderNo))
                {
                    return SplitFullBarcodeAsn(nSplitArray, nPackageBarcode);
                }
            }

            if (nMaterialCode == "" || nLotQty == "" || nBarcodeLotNo == "")
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码数据有误";
                return result;
            }

            var nInputSnDto = Biz.Db.Queryable<WMS_SRMSNList>().Where(q => q.OuterBarcode == nBarcodeLotNo || q.BigBarcode == nBarcodeLotNo).ToList();
            if (nInputSnDto.Any())
            {
                isBox = true;
                snList = nInputSnDto.Select(t => new Tuple<string, decimal>(t.SmallBarcode, t.IncludeQty)).ToList();
            }


            if (!decimal.TryParse(nLotQty, out decimal nBarcodeQty))
            {
                //throw new UserFriendlyException("条码格式错误：未取到正确的条码数量");
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码数据有误";
                return result;
            }
            DateTime nDateCode = DateTime.Now;
            if (nLotDate != "")
            {
                // 原始DateCode 为日期
                if (nLotDate.Length > 6)
                {
                    IFormatProvider ifp = new CultureInfo("zh-CN", true);
                    DateTime.TryParseExact(nLotDate, "yyyyMMdd", ifp, DateTimeStyles.None, out nDateCode);
                }

                // 原始DateCode 为年、周次（YYYYWW / YYWW）
                int yw = 0;
                if (nLotDate.Length <= 6 && int.TryParse(nLotDate, out yw))
                {
                    nDateCode = GetWeekStartTime(nLotDate);
                }

                if (nDateCode == DateTime.MinValue)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"条码[{nFullBarcode}]格式错误：未取到正确的批次日期";
                    return result;
                }
            }


            var nMaterial = Biz.Db.Queryable<WMS_MesMaterial>().Where(q => q.MCode.ToUpper() == nMaterialCode.ToUpper()).First();
            if (nMaterial == null)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码对应的物料不存在";
                return result;
            }
            if (!nPackageBarcode)
            {
                if (nPackageBarcode && nBarcodeLotNo.Length != 12)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"来料外包条码格式错误，应包含12位字符的批次号";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_semimanufacture" && nBarcodeLotNo.Length < 16) //5位供应商+8位日期+3位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"半成品条码的批次格式错误，应至少包含16位字符";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_finishedproduct" && nBarcodeLotNo.Length < 17) //5位供应商+8位日期+4位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"成品箱号批次格式错误，应至少包含17位字符";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_rawmaterial" && nBarcodeLotNo.Length < 15)//4位供应商+8位日期+4位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"物料条码批次格式错误，应至少包含15位字符";
                    return result;
                }
            }

            result.Data = new InputBarcodeDto
            {
                OrderNo = nOrderNo,
                Barcode = nBarcodeLotNo,
                MaterialCode = nMaterialCode,
                MaterialName = nMaterial?.MName,
                MaterialStandard = nMaterial?.MDesc,
                MGroupCode = nMaterial?.MGroupCode,
                Unit = nMaterial?.MUom,
                LotQty = nBarcodeQty,
                LotDateString = nLotDate,
                LotDate = nDateCode,
                PeriodDays = nMaterial.PERIODDAYS,
                FIFO = nMaterial.FIFO,
                SafeStorageQty = nMaterial.SAFEQTY,
                StateFlag = nStateFlag,
                IsBox = isBox,
                SnList = snList,
                LotNo = nBarcodeLotNo,
            };
            return result;
        }

        /// <summary>
        /// ASN标签条码解析
        /// 拆解条码，依次是：
        /// V：PO（MO）
        /// P：C P/N：料号
        /// N：Name（物料名称）
        /// Q：QTY（数量）
        /// U：Unit（单位）
        /// M：Mfr P/N（供应商内部管控的物料的料号）
        /// D：Date Code（生产日期，物料的生产日期）
        /// L：Lot Code（生产的批次）
        /// S：PAG ID（小包批次代码，也就是来料外包条码）
        /// </summary>
        /// <param name="nFullBarcode"></param>
        /// <param name="nBarcodeType"></param>
        /// <returns></returns>
        public static Result<InputBarcodeDto> SplitFullBarcodeAsn(string[] nSplitArray, bool nPackageBarcode = false)
        {
            Result<InputBarcodeDto> result = new(Result.Flags.Success, $"解析Asn条码成功");
            #region 方法变量
            // 条码变量
            var nAsnNo = "";
            var nVendorCode = "";
            var nMaterialCode = "";
            var nBarcodeLotNo = "";
            var nLotQty = "";
            var nLotDate = "";
            var nStateFlag = "";
            bool isBox = false;
            var nLotNo = "";

            // 最小包装条码列表
            List<Tuple<string, decimal>> snList = new List<Tuple<string, decimal>>();
            // 送货单行明细
            List<InputAsnLineDto> asnLineList = new List<InputAsnLineDto>();
            // 最小包装条码明细
            List<WMS_SRMSNList> snBarcodeList = new List<WMS_SRMSNList>();
            var nCartonNo = "";
            var nPalletNo = "";

            // 变量赋值
            foreach (string item in nSplitArray)
            {
                string itemKey = item.Substring(0, 1).ToUpper();
                string itemValue = item.Substring(1);
                if (itemKey == "V")
                { //送货单号
                    nAsnNo = itemValue;
                }
                else if (itemKey == "P")
                { //条码料号
                    nMaterialCode = itemValue;
                }
                else if (itemKey == "S")
                { //来料外包条码   
                    nBarcodeLotNo = itemValue;
                    //nBarcodeLotNo = item;//PAG ID 解析出来的数据前缀“S”不用去掉
                    //if(itemValue.StartsWith("C")|| itemValue.StartsWith("P")) //中箱（C）和栈板（P），需要再次去掉一位
                    //    nBarcodeLotNo = itemValue.Substring(1);
                }
                else if (itemKey == "Q")
                { //条码数量
                    nLotQty = itemValue;
                }
                else if (itemKey == "D")
                { //生产日期(去掉-，兼容带-的时间格式，后面统一时间解析)
                  //nLotDate = itemValue.Replace("-", "");
                    nLotDate = Regex.Replace(itemValue, @"[^0-9]+", "");
                }
                else if (itemKey == "L")
                { //批号
                    nLotNo = itemValue;
                }

            }
            #endregion

            #region 条码数据校验
            if (nMaterialCode == "" || nLotQty == "" || nBarcodeLotNo == "")
            {
                //throw new UserFriendlyException("条码数据有误");
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码数据有误";
                return result;
            }

            // 获取条码列表 snBarcodeList
            snBarcodeList = GetSrmBarcodeList(nBarcodeLotNo);

            // 如果最小包装标签记录数大于1，则为包装标签，否则为最小包装标签
            if (BarcodeIsBox(nBarcodeLotNo))
            {
                isBox = true;
            }

            if (snBarcodeList.Any())
            {
                snList = snBarcodeList.Select(t => new Tuple<string, decimal>(t.SmallBarcode, t.IncludeQty)).ToList();
                snBarcodeList = snBarcodeList.Select(t => new WMS_SRMSNList
                {
                    BILLCODE = t.BILLCODE,
                    MATERIALCODE = t.MATERIALCODE,
                    SmallBarcode = t.SmallBarcode,
                    BigBarcode = t.BigBarcode,
                    OuterBarcode = t.OuterBarcode,
                    IncludeQty = t.IncludeQty
                }).ToList();

                // 判断标签条码类型
                // 是最小包装条码
                var smallBarcode = snBarcodeList.Where(t => t.SmallBarcode == nBarcodeLotNo).FirstOrDefault();
                if (smallBarcode != null && !smallBarcode.SmallBarcode.IsNullOrEmpty())
                {
                    isBox = false;
                    nCartonNo = smallBarcode.BigBarcode;
                    nPalletNo = smallBarcode.OuterBarcode;
                }

                // 是外箱条码
                var bigBarcode = snBarcodeList.Where(t => t.BigBarcode == nBarcodeLotNo).FirstOrDefault();
                if (bigBarcode != null && !bigBarcode.BigBarcode.IsNullOrEmpty())
                {
                    isBox = true;
                    nCartonNo = bigBarcode.BigBarcode;
                    nPalletNo = bigBarcode.OuterBarcode;
                }

                // 是栈板条码
                var outerBarcode = snBarcodeList.Where(t => t.OuterBarcode == nBarcodeLotNo).FirstOrDefault();
                if (outerBarcode != null && !outerBarcode.OuterBarcode.IsNullOrEmpty())
                {
                    isBox = true;
                    nCartonNo = outerBarcode.BigBarcode;
                    nPalletNo = outerBarcode.OuterBarcode;
                }
            }

            // 验证条码标签数量格式是否正确
            if (!decimal.TryParse(nLotQty, out decimal nBarcodeQty))
            {
                //throw new UserFriendlyException("条码格式错误：未取到正确的条码数量");
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码格式错误：未取到正确的条码数量";
                return result;
            }

            // 验证条码标签数量与SRM 最小包装数量合计是否一致
            decimal snQtyTotal = snBarcodeList.Sum(t => t.IncludeQty);
            if (nBarcodeQty != snQtyTotal)
            {
                //throw new UserFriendlyException("标签数量与SRM最小包装总数量不一致");
                result.Flag = Result.Flags.Failed;
                result.Message = $"标签数量与SRM最小包装总数量不一致";
                return result;
            }


            DateTime nDateCode = DateTime.Now;
            if (nLotDate != "")
            {
                //增加判断日期的抛错提示 2022/07/27 Ben Lin, 2022/07/29 Ben Lin 再次更新
                try
                {
                    string dateTimeStr = nLotDate.Substring(0, 4) + "-" + nLotDate.Substring(4, 2) + "-" + nLotDate.Substring(6, 2);
                    if (nLotDate.Length < 7)
                    {
                        if (nLotDate.StartsWith("2") && nLotDate.Length == 6)
                        {
                            dateTimeStr = $"20{nLotDate.Substring(0, 2)}-{nLotDate.Substring(2, 2)}-{nLotDate.Substring(4, 2)}";
                        }
                        else
                        {
                            result.Flag = Result.Flags.Failed;
                            result.Message = $"条码[{nBarcodeLotNo}]格式错误：未取到正确的批次日期";
                            return result;
                        }
                    }

                    if (!DateTime.TryParse(dateTimeStr, out nDateCode))
                    //if (!DateTime.TryParse(nLotDate, out DateTime nDateCode))
                    {
                        result.Flag = Result.Flags.Failed;
                        result.Message = $"条码[{nBarcodeLotNo}]格式错误：未取到正确的批次日期";
                        return result;
                    }
                }
                catch (System.Exception ex)
                {
                    //Logger.Info($"ASN标签条码解析 =>条码[{nBarcodeLotNo}]格式错误：未取到正确的批次日期，{ex.Message}");
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"条条码[{nBarcodeLotNo}]格式错误：未取到正确的批次日期，{ex.Message}";
                    return result;
                }
            }

            var nMaterial = Biz.Db.Queryable<WMS_MesMaterial>().Where(t => t.MCode.ToUpper() == nMaterialCode.ToUpper()).First();
            if (nMaterial == null)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"条码对应的物料[{nMaterialCode}]不存在";
                return result;
            }
            if (!nPackageBarcode)
            {
                if (nPackageBarcode && nBarcodeLotNo.Length != 12)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"来料外包条码格式错误，应包含12位字符的批次号";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_semimanufacture" && nBarcodeLotNo.Length < 16) //5位供应商+8位日期+3位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"半成品条码的批次格式错误，应至少包含16位字符";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_finishedproduct" && nBarcodeLotNo.Length < 17) //5位供应商+8位日期+4位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"成品箱号批次格式错误，应至少包含17位字符";
                    return result;
                }
                else if (!nPackageBarcode && nMaterial.MtypeCode == "itemtype_rawmaterial" && nBarcodeLotNo.Length < 15)//4位供应商+8位日期+4位流水码
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"物料条码批次格式错误，应至少包含15位字符";
                    return result;
                }
            }
            #endregion

            #region 获取送货单数据
            // 如果标签没有送货单号，根据标签条码获取送货单号
            if (nAsnNo.IsNullOrEmpty())
            {
                var asnList = GetSrmAsn(nBarcodeLotNo);
                var asn = asnList.FirstOrDefault();
                if (asn != null)
                {
                    nAsnNo = asn.DeliveryNo;
                    nVendorCode = asn.VendorCode;
                }
            }

            // 获取送货单行明细 poLineList
            List<InputAsnLineDto> asnLines = GetSrmAsnLines(nAsnNo, nMaterialCode);

            if (asnLines != null && asnLines.Count > 0)
            {
                foreach (var line in asnLines)
                {
                    // 分割poLineNo（1-1-1），用-分割，取第一段，获取 PoErpLine
                    string[] splitLineNo = line.PoLineNo.Split('-');

                    if (splitLineNo != null && splitLineNo.Count() > 0)
                    {
                        int erpPoLine = 0;
                        int.TryParse(splitLineNo[0], out erpPoLine);
                        line.PoErpLine = erpPoLine;
                    }
                }
            }

            #endregion
            result.Data = new InputBarcodeDto
            {
                AsnNo = nAsnNo,
                Barcode = nBarcodeLotNo,
                VendorCode = nVendorCode,
                MaterialCode = nMaterialCode,
                MaterialName = nMaterial?.MName,
                MaterialStandard = nMaterial?.MDesc,
                MGroupCode = nMaterial?.MGroupCode,
                Unit = nMaterial?.MUom,
                LotQty = nBarcodeQty,
                LotDateString = nLotDate,
                LotDate = nDateCode,
                PeriodDays = nMaterial.PERIODDAYS,
                FIFO = nMaterial.FIFO,
                SafeStorageQty = nMaterial.SAFEQTY,
                StateFlag = nStateFlag,
                IsBox = isBox,
                SnList = snList,
                LotNo = nBarcodeLotNo,
                AsnLineList = asnLines,
                SnBarcodeList = snBarcodeList,
                CartonNo = nCartonNo,
                PalletNo = nPalletNo
            };
            return result;
        }


        private static bool BarcodeIsBox(string barcode)
        {
            bool isBox = false;

            // 从WMS_SRM_ASN表查找单据编号，判断是否为ASN
            if (Biz.Db.Queryable<WMS_SRMSNList>().Where(t => t.OuterBarcode == barcode || t.BigBarcode == barcode).Any())
                isBox = true;

            return isBox;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="inputBarcode"></param>
        /// <returns></returns>
        public static List<SRMSNStatus> GetSrmAsn(string inputBarcode)
        {
            var query = Biz.Db.Queryable<WMS_SRMSNList, WMS_SRM_ASN>((t, m) =>
                                new JoinQueryInfos(
                                    JoinType.Left, t.DeliveryNo == m.DeliveryNo
                                    ))
            .Where((t, m) => t.SmallBarcode == inputBarcode || t.BigBarcode == inputBarcode || t.OuterBarcode == inputBarcode)
            .Select((t, m) => new SRMSNStatus
            {
                DeliveryNo = t.DeliveryNo,
                VendorCode = m.innerVendorCode,
                Status = m.status
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 获取 SRM ASN 行
        /// </summary>
        /// <param name="inputAsnNo"></param>
        /// <returns></returns>
        public static List<InputAsnLineDto> GetSrmAsnLines(string inputAsnNo)
        {
            var query = Biz.Db.Queryable<WMS_SRM_ASN_LINES>()
            .Where(t => t.DeliveryNo == inputAsnNo)
            .Select(t => new InputAsnLineDto
            {
                DeliveryNo = t.DeliveryNo,
                LineNo = t.lineNo,
                ProductCode = t.productCode,
                PurchaseType = t.purchaseType,
                PoErpNo = t.poErpNo,
                PoLineNo = t.poLineNo,
                DeliveryQty = t.deliveryQty
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 获取 SRM ASN 行
        /// </summary>
        /// <param name="inputAsnNo"></param>
        /// <param name="inputMaterialCode"></param>
        /// <returns></returns>
        public static List<InputAsnLineDto> GetSrmAsnLines(string inputAsnNo, string inputMaterialCode)
        {
            var query = Biz.Db.Queryable<WMS_SRM_ASN_LINES>()
            .Where(t => t.DeliveryNo == inputAsnNo && t.productCode == inputMaterialCode)
            .Select(t => new InputAsnLineDto
            {
                DeliveryNo = t.DeliveryNo,
                LineNo = t.lineNo,
                ProductCode = t.productCode,
                PurchaseType = t.purchaseType,
                PoErpNo = t.poErpNo,
                PoLineNo = t.poLineNo,
                DeliveryQty = t.deliveryQty
            })
            .ToList();
            return query;
        }

        /// <summary>
        /// 获取 SRM 条码列表
        /// </summary>
        /// <param name="inputBarcode"></param>
        /// <returns></returns>
        public static List<WMS_SRMSNList> GetSrmBarcodeList(string inputBarcode)
        {
            return Biz.Db.Queryable<WMS_SRMSNList>().Where(t => t.OuterBarcode == inputBarcode || t.BigBarcode == inputBarcode || t.SmallBarcode == inputBarcode).ToList();
        }

        /// <summary>
        /// 当前周的第一天(星期一)
        /// </summary>
        /// <param name="yearWeek">周数，格式：yyyywww</param>
        /// <returns></returns>
        private static DateTime GetWeekStartTime(string yearWeek)
        {
            //年份
            int year = 0;
            //周数
            int weekNum = 0;

            if (yearWeek.Length == 4)
            {
                year = 2000 + int.Parse(yearWeek.Substring(0, 2));
                weekNum = int.Parse(yearWeek.Substring(2));
            }

            if (yearWeek.Length == 6)
            {
                year = int.Parse(yearWeek.Substring(0, 4));
                weekNum = int.Parse(yearWeek.Substring(4));
            }
            //本年1月1日
            DateTime firstOfYear = new DateTime(year, 1, 1);
            //本年1月1日与本周星期一相差的天数
            int dayDiff = (firstOfYear.DayOfWeek == DayOfWeek.Sunday ? 7 : Convert.ToInt32(firstOfYear.DayOfWeek)) - 1;
            //第一周的星期一
            DateTime firstDayOfFirstWeek = firstOfYear.AddDays(-dayDiff);
            //当前周的星期一
            DateTime firstDayOfThisWeek = firstDayOfFirstWeek.AddDays((weekNum - 1) * 7);
            return firstDayOfThisWeek;
        }

        // 根据单据编号判断是都为 ASN
        private static bool BillIsAsn(string billCode)
        {
            // 从WMS_SRM_ASN表查找单据编号，判断是否为ASN
            return Biz.Db.Queryable<WMS_SRMSNList>().Where(q => q.DeliveryNo == billCode).Any();
        }

        /// <summary>
        /// 获取单号根据单据类型
        /// </summary>
        /// <param name="billType"></param>
        /// <returns></returns>
        public static string GetBillNoByType(string billType)
        {
            //根据BillType去表中找到相关前缀、日期码、流水号、长度
            var billNoRule = Biz.Db.Queryable<MesBillNoHelper>().Where(t => t.BillType.Equals(billType)).ToList();
            if (billNoRule.Count == 1)
            {
                var nowRule = billNoRule[0];
                string prefix = nowRule.BillPrefix.Trim();
                string datecode = nowRule.DateCode.Trim();
                string today = DateTime.Now.ToString("yyyyMMdd");
                int serial = nowRule.SerialNo;
                int maxSerial = GetMaxNumByLength(nowRule.SerialNoLength);
                if (serial >= maxSerial)
                {
                    return "over";
                }
                else
                {
                    if (datecode != string.Empty && datecode != today)
                    {
                        serial = 0;
                        datecode = today;
                    }
                    string serialNo = (serial + 1).ToString().PadLeft(nowRule.SerialNoLength, '0');
                    //update serialNo
                    nowRule.DateCode = datecode;
                    nowRule.SerialNo = serial + 1;
                    Biz.Db.Updateable(nowRule).ExecuteCommand();
                    //返回编号
                    return prefix + datecode + serialNo;
                }
            }
            else
            {
                return "";
            }
        }
        private static int GetMaxNumByLength(int length)
        {
            if (length == 0)
            {
                return 0;
            }
            else
            {
                string strNum = string.Empty;
                for (int i = 1; i <= length; i++)
                {
                    strNum += "9";
                }
                return Convert.ToInt32(strNum);
            }
        }

        /// <summary>
        /// 生成送检单
        /// </summary>
        /// <param name="detail"></param>
        /// <param name="nUrgent"></param>
        /// <returns></returns>
        private static Result<WMS_IQC_H> CreateIqcHeader(WMS_RECEIPT_D detail, string nUrgent, DbClient db)
        {
            Result<WMS_IQC_H> result = new(Result.Flags.Success, $"生成送检单成功");
            var nMaterial = Biz.Db.Queryable<WMS_MesMaterial>().Where(t => t.MCode.ToUpper() == detail.MATERIALCODE.ToUpper()).First();
            var nAql = Biz.Db.Queryable<WMS_IQCMATERIAL_AQL>().Where(t => t.MATERIALID.Equals(nMaterial.Id)).First();

            var nIqcHeader = new WMS_IQC_H
            {
                BILLCODE = iWMS.GetBillNoByType("IQC"),
                SOURCETYPE = (int)InventoryTransferSides.BillType.CustSupplyInStock,
                SOURCECODE = detail.BILLCODE,
                SOURCELINE = detail.BILLLINE,
                PONO = detail.SOURCECODE,
                POLINE = detail.POLINE ?? 0,
                MEASURE = nUrgent,
                QCTIMES = 0,
                QCSTATUS = (int)IqcManagementSides.QCStatus.UnFinish, /*(int)IqcManagementSides.QCStatus.UnFinish,*/
                QCRESULT = (int)IqcManagementSides.QCResult.Wait,
                QCREVIEW = (int)IqcManagementSides.QCReview.UnReview,
                CreationTime = DateTime.Now,
                CreatorUserId = 1,
                MATERIALCODE = detail.MATERIALCODE
                //ReceiveQty = detail.Qty, //生成送检单加上接收数量 2022/07/27 Ben Lin 2022/09/03 Ben Lin 注释
            };

            var nIQCMaterial = Biz.Db.Queryable<WMS_IQCMATERIAL>().Where(t => t.MATERIALID.Equals(nMaterial.Id)).First();

            if (nIQCMaterial == null)
            {
                nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.NormalI;
            }
            //免检
            else if (nIQCMaterial.CHECKTYPE == "Exemption")
            {
                nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.Exemption;
            }
            //抽检
            else if (nIQCMaterial.CHECKTYPE == "Sampling")
            {
                var nIQCMaterial2AQL = Biz.Db.Queryable<WMS_IQCMATERIAL_AQL>().Where(t => t.IQCMATERIALID.Equals(nIQCMaterial.Id)).ToList();
                if (nIQCMaterial2AQL.Any())
                {
                    var nIQCMaterial2CheckItem = Biz.Db.Queryable<WMS_IQCMATERIAL_CHECKITEM>().Where(t => t.IQCMATERIALID.Equals(nIQCMaterial.Id)).ToList();
                    if (nIQCMaterial2CheckItem.Any())
                    {
                        //高检II，抽检物料，AQL和检验项目都维护了
                        nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.HighII;
                        Result<WMS_IQC_H> result1 = GetAqlSettingAsync(nAql, nIqcHeader, detail, db);
                        if (result1.Flag != Result.Flags.Success)
                        {
                            result.Flag = result1.Flag;
                            result.Message = result1.Message;
                        }
                        else
                        {
                            nIqcHeader = result1.Data;
                        }
                    }
                    else
                    {
                        //高检I，抽检物料，维护了AQL、但是没有维护检验项目
                        nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.HighI;
                        Result<WMS_IQC_H> result2 = GetAqlSettingAsync(nAql, nIqcHeader, detail, db);
                        if (result2.Flag != Result.Flags.Success)
                        {
                            result.Flag = result2.Flag;
                            result.Message = result2.Message;
                        }
                        else
                        {
                            nIqcHeader = result2.Data;
                        }
                    }
                }
                else
                {
                    var nIQCMaterial2CheckItem = Biz.Db.Queryable<WMS_IQCMATERIAL_CHECKITEM>().Where(t => t.IQCMATERIALID.Equals(nIQCMaterial.Id)).ToList();
                    if (nIQCMaterial2CheckItem.Any())
                    {
                        //普检II，抽检物料，没有维护AQL、但是维护了检验项目
                        nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.NormalII;
                    }
                    else
                    {
                        //普检I，抽检物料，但是没有维护AQL和检验项目
                        nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.NormalI;
                    }
                }
            }
            //全检
            else if (nIQCMaterial.CHECKTYPE == "FullInspection")
            {
                nIqcHeader.QCLEVEL = (int)IqcManagementSides.QCLevel.FullInspection;
                nIqcHeader.SAMPLENGQTY = detail.QTY;
            }
            result.Data = nIqcHeader;
            return result;
        }

        private static Result<WMS_IQC_H> GetAqlSettingAsync(WMS_IQCMATERIAL_AQL nAql, WMS_IQC_H nIqcHeader, WMS_RECEIPT_D nDetail, DbClient db)
        {
            Result<WMS_IQC_H> result = new(Result.Flags.Success, $"获取Aql成功");
            if (nAql.AUTOSTRICT == true)
            {
                nIqcHeader.STRICTLEVEL = nAql.CURRENTSTRICT.IsNullOrEmpty() ? nAql.DEFAULTSTRICT : nAql.CURRENTSTRICT;
                nIqcHeader.LEVELCODE = nIqcHeader.STRICTLEVEL.ToUpper() == "NORMAL" ? nAql.NORMALLEVEL : (nIqcHeader.STRICTLEVEL.ToUpper() == "STRICT" ? nAql.STRICTLEVEL : nAql.RELAXLEVEL);
                nIqcHeader.AQL = nIqcHeader.STRICTLEVEL.ToUpper() == "NORMAL" ? nAql.NORMALAQLLEVEL : (nIqcHeader.STRICTLEVEL.ToUpper() == "STRICT" ? nAql.STRICTAQLLEVEL : nAql.RELAXAQLLEVEL);
            }
            else
            {
                nIqcHeader.STRICTLEVEL = nAql.DEFAULTSTRICT;
                nIqcHeader.LEVELCODE = nAql.DEFAULTLEVEL;
                nIqcHeader.AQL = nAql.DEFAULTAQL;
            }

            //找到该 LevelCode和AqlCode配置下，符合的批次数量范围
            var nAqlDetail = Biz.Db.Queryable<WMS_AQL_D>()
                .Where(t => t.LEVELCODE.ToUpper() == nIqcHeader.LEVELCODE.ToUpper() && t.AQLCODE.ToUpper() == nIqcHeader.AQL.ToUpper())
                .Where(t => t.LOTMAXQTY >= nDetail.QTY && t.LOTMAXQTY <= nDetail.QTY)
                .First();

            if (nAqlDetail == null)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = $"未能在水准[{nIqcHeader.LEVELCODE}]下的AQL[{nIqcHeader.AQL}]下找到符合[{nDetail.QTY}]的批次范围";
            }

            nIqcHeader.BEGINQTY = nAqlDetail.LOTMINQTY;
            nIqcHeader.ENDQTY = nAqlDetail.LOTMAXQTY;
            nIqcHeader.SAMPLEQTY = nAqlDetail.SAMPLEQTY > nDetail.QTY ? nDetail.QTY : nAqlDetail.SAMPLEQTY;
            result.Data = nIqcHeader;

            return result;
        }

    }//endClass
}