SX-WMS/wms.service/Service/SXService.cs

using AutoMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using SqlSugar;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Linq;
using WCS.Entity.sx;
using wms.dataservice.IDataSetvice;
using wms.dto;
using wms.dto.request;
using wms.dto.request.cp;
using wms.dto.request.fj;
using wms.dto.request.hj;
using wms.dto.request.hj.dto;
using wms.dto.request.share;
using wms.dto.request.sx;
using wms.dto.response;
using wms.dto.response.cp;
using wms.dto.response.hj;
using wms.dto.response.share;
using wms.dto.response.sx;
using wms.service.Help;
using wms.service.Help.Packing;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model;
using wms.sqlsugar.model.sx;
using wms.util;
using wms.util.Check;
using wms.util.Ext;
using wms.util.Http;
using TaskStatus = wms.dto.TaskStatus;

namespace wms.service.Service
{
    /// <summary>
    /// SX业务逻辑
    /// </summary>
    public class SXService : ISXService
    {
        private readonly IMapper _mapper;
        private readonly ILogger<SXService> _logger;
        private readonly ISXDataService _sxtDataService;
        private static object lockerPalletizingPackTask = new object();
        private static object lockerApplyLoc = new object();

        /// <summary>
        /// 包材-托盘重量
        /// </summary>
        private static decimal TuoPan { get => 12.6M; }

        /// <summary>
        /// 包材-塑料袋重量
        /// </summary>
        private static decimal SuLiaoDai { get => 1.03M; }

        /// <summary>
        /// 包材-隔板重量
        /// </summary>
        private static decimal GeBan { get => 0.77M; }

        /// <summary>
        /// 包材-纸箱重量
        /// </summary>
        private static decimal ZhiXiang { get => 1.09M; }

        public SXService(IMapper mapper, ILogger<SXService> logger, ISXDataService sxtDataService)
        {
            _mapper = mapper;
            _logger = logger;
            _sxtDataService = sxtDataService;
        }

        private Repository<sxSysConfig> _sysconfigrepository => new Repository<sxSysConfig>();

        /// <summary>
        ///  容器表
        /// </summary>
        private Repository<BaseContinfo> _baseContinfo => new Repository<BaseContinfo>();

        /// <summary>
        ///  当前任务表
        /// </summary>
        private RepositoryTask<WCS_TaskInfo> _taskrepository => new RepositoryTask<WCS_TaskInfo>();

        /// <summary>
        ///  库存表
        /// </summary>
        private Repository<BillInvnow> _billInvnowrepository => new Repository<BillInvnow>();

        /// <summary>
        ///  条码表
        /// </summary>
        private Repository<BillInvinit> _billInvinitrepository => new Repository<BillInvinit>();

        /// <summary>
        ///  物料表
        /// </summary>
        private Repository<BaseMatinfo> _basematerrepository => new Repository<BaseMatinfo>();

        /// <summary>
        ///  单据表
        /// </summary>
        private Repository<BillDocsinfo> _billdocrepository => new Repository<BillDocsinfo>();

        /// <summary>
        ///  任务历史表
        /// </summary>
        private RepositoryTask<WCS_TaskOld> _wcstaskoldrepository => new RepositoryTask<WCS_TaskOld>();

        /// <summary>
        ///  流水表
        /// </summary>
        private Repository<BillInvflow> _billInvflow => new Repository<BillInvflow>();

        /// <summary>
        ///  甲方管理系统推送反馈
        /// </summary>
        private Repository<BillPushinfo> _billPushinforepository => new Repository<BillPushinfo>();

        /// <summary>
        ///  货位表
        /// </summary>
        private Repository<BaseWarecell> _basewarecellrepository => new Repository<BaseWarecell>();

        /// <summary>
        ///  仓库表
        /// </summary>
        private Repository<BaseWarehouse> _basewarehouserepository => new Repository<BaseWarehouse>();

        private RepositoryTask<WCS_TaskDtl> _taskdetailrepository => new RepositoryTask<WCS_TaskDtl>();

        /// <summary>
        ///  机台表
        /// </summary>
        private Repository<BillMachinfo> _basemachinforepository => new Repository<BillMachinfo>();

        private Repository<sxSysJob> _jobrepository => new Repository<sxSysJob>();
        private Repository<sxSysJobApiRelation> _jobApirepository => new Repository<sxSysJobApiRelation>();
        private Repository<BillSkuInfo> _skuInforepository => new Repository<BillSkuInfo>();
        private Repository<BillPackInfo> _packInforepository => new Repository<BillPackInfo>();
        private Repository<BillPboxrule> _boxrulerepository => new Repository<BillPboxrule>();
        private Repository<BillBoxSerial> _boxserialrepository => new Repository<BillBoxSerial>();
        private Repository<PalletLayerMath> _palletlayerMathrepository => new Repository<PalletLayerMath>();
        private Repository<Palletizingdetail> _palletizdetailrepository => new Repository<Palletizingdetail>();
        private Repository<Palletizing> _palletizrepository => new Repository<Palletizing>();
        private Repository<BaseTorchbandinfo> _torchbandinforepository => new Repository<BaseTorchbandinfo>();
        private Repository<BaseErrorinfo> _errorinforepository => new Repository<BaseErrorinfo>();
        private Repository<TorschWbCount> _torschwbcount => new Repository<TorschWbCount>();
        private Repository<BaseErrorinfoWcs> _errorinfowcs => new Repository<BaseErrorinfoWcs>();
        private RepositoryTask<BillTimeOutRecord> _timeoutrecord => new RepositoryTask<BillTimeOutRecord>();
        private RepositoryTask<Bill_InvflowHty> _flowhtyrepository => new RepositoryTask<Bill_InvflowHty>();
        private RepositoryTask<BillPboxruleHty> _pboxrulehtyrepository => new RepositoryTask<BillPboxruleHty>();
        private RepositoryTask<BillPushinfoHty> _pushhtyrepository => new RepositoryTask<BillPushinfoHty>();
        private RepositoryTask<PalletizingHty> _pallethtyrepository => new RepositoryTask<PalletizingHty>();

        private ITenant _db => SqlSugarHelper.Db;//处理事务

        /// <summary>
        /// 获取配置内容信息
        /// </summary>
        /// <param name="code">配置表code值</param>
        /// <returns></returns>
        public string GetSysConfigContentByCode(string code)
        {
            //先读缓存
            var cacheContent = RedisHelper.Get("sys_config" + code);
            if (!string.IsNullOrEmpty(cacheContent))
            {
                return cacheContent;
            }
            var sysconf = _sysconfigrepository.GetSingle(p => p.Code == code);
            if (sysconf == null)
            {
                throw new Exception("数据表没有配置" + code);
            }
            var content = sysconf.SContent;
            string sysname = sysconf.Default1;//所属系统mes/erp
            RedisHelper.Set("sys_config" + code, content + "|" + sysname);
            return content;
        }

        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public sxSysConfig GetSysConfigByCode(string code)
        {
            //Repository<dynamic> _billdtrepository = new Repository<dynamic>();
            return _sysconfigrepository.GetSingle(p => p.Code == code);
        }

        public bool SyncMaterInfo(List<SxSyncMaterInfoRequestItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_basematerrepository.IsAny(p => p.Code == item.MatCode))
                {
                    _basematerrepository.UpdateModelColumns(p => new BaseMatinfo() { IsHold = item.IsHold, HoldDuration = item.HoldDuration, Name = item.MatName, EditTime = DateTime.Now, Description = item.Describe },
                       p => p.Code == item.MatCode);
                }
                else
                {
                    var model = _mapper.Map<BaseMatinfo>(item);
                    model.AddTime = DateTime.Now;
                    _basematerrepository.Insert(model);
                }
            }
            return true;
        }

        /// <summary>
        /// 帘线工单信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            var res = new SRes();
            List<BillPboxrule> rulelist = new List<BillPboxrule>();
            var skuinfolist = _skuInforepository.GetList(p => p.SkuCode == reqDto.SkuCode);
            if (!skuinfolist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有找到SKU，单据信息无法接收，请先推送" + reqDto.SkuCode;
                RedisHelper.Set("Sx:WMSErrorInfo:MESEquip2", new RedisErrorInfo() { Equip = "MESEquip2", Con = "没有找到SKU，单据信息无法接收，请先推送" + reqDto.SkuCode, Time = DateTime.Now });
                return res;
            }
            var l = reqDto.WindingList.FirstOrDefault(x => x.LR_TYPE.Contains("L"));
            var r = reqDto.WindingList.FirstOrDefault(x => x.LR_TYPE.Contains("R"));
            if (l == null || r == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "缺少L/R绕向相关信息";
                return res;
            }
            //箱号处理
            foreach (var item in reqDto.ListBoxInfo)
            {
                var rule = _boxrulerepository.AsQueryable().With(SqlWith.NoLock).Single(p => p.PBoxCode == item.BoxNo);
                if (rule == null)
                {
                    //判断历史数据箱号
                    if (_pboxrulehtyrepository.AsQueryable().With(SqlWith.NoLock).SplitTable(p => p.Take(12)).Where(p => p.PBoxCode == item.BoxNo).Any())
                    {
                        continue;
                    }

                    var packinfllist = _packInforepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PackCode == item.PackCode).ToList();
                    if (!packinfllist.Any())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = "没有找到包号，请先推送" + item.PackCode;
                        RedisHelper.Set("Sx:WMSErrorInfo:MESEquip2", new RedisErrorInfo() { Equip = "MESEquip2", Con = "没有找到包号，请先推送" + item.PackCode, Time = DateTime.Now });
                        return res;
                    }

                    int solrder = Convert.ToInt32(reqDto.SolderJointMax);
                    int perSolderMaxCount = Convert.ToInt32(reqDto.HuSolderJointMax);
                    decimal torsion24Qty = 0;
                    decimal torsion48Qty = 0;
                    decimal torsionErrRange = 0;
                    decimal hold = 0;

                    if (skuinfolist.Where(p => p.FieldCode == "QC_C03").Any() && !string.IsNullOrEmpty(skuinfolist.Where(p => p.FieldCode == "QC_C03").First().FieldValue))
                    {
                        hold = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C03").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C04").Any() && !string.IsNullOrWhiteSpace(skuinfolist.Where(p => p.FieldCode == "QC_C04").First().FieldValue))
                    {
                        torsion24Qty = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C04").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C06").Any())
                    {
                        torsion48Qty = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C06").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C05").Any())
                    {
                        torsionErrRange = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C05").First().FieldValue);
                    }
                    rule = new BillPboxrule();
                    rule.IsStop = 0;
                    rule.DocsNo = reqDto.BillCode;
                    rule.SkuCode = reqDto.SkuCode;
                    rule.PBoxCode = item.BoxNo;
                    rule.PackRule = reqDto.PackRule;
                    rule.FullCountQty = item.FullCount;
                    rule.IsSolder = solrder > 0 ? 1 : 0;
                    rule.SolderMaxCount = solrder;
                    rule.PerSolderMaxCount = perSolderMaxCount;
                    rule.Torsion24Qty = torsion24Qty;
                    rule.Torsion48Qty = torsion48Qty;
                    rule.Torsion72Qty = 0;
                    rule.TorsionErrRange = torsionErrRange;
                    rule.TorsChkValue = decimal.Parse(reqDto.TorsionTargetval);
                    rule.TorsChkValueRange = decimal.Parse(reqDto.TorsionTargetscope);
                    rule.ZXStateCode = 0;
                    rule.BlackCount = 0;
                    rule.ReturnCount = 0;
                    rule.EmptyCountQty = item.EmptyCount;
                    rule.TorsionMaxQty = 4;
                    rule.TorsionMinQty = 1;
                    rule.SpoolType = packinfllist.First().Spool;
                    rule.HoldTime = hold;
                    rule.PackJsonContent = JsonConvert.SerializeObject(packinfllist);
                    rule.Wind = item.Winding;
                    rule.BatchNo = item.Batch;
                    rule.Dryer = item.PackCode;
                    rule.LR_TYPE_L = l.LR_TYPE;
                    rule.SPOOL_MAJOR_COLOR_L = l.SPOOL_MAJOR_COLOR;
                    rule.TAKEUP_SIDE_L = l.TAKEUP_SIDE;
                    rule.LR_TYPE_R = r.LR_TYPE;
                    rule.SPOOL_MAJOR_COLOR_R = r.SPOOL_MAJOR_COLOR;
                    rule.TAKEUP_SIDE_R = r.TAKEUP_SIDE;

                    if (reqDto.ListPackagelnfo.Sum(p => p.Weight) > 0)
                    {
                        rule.PackWeight = reqDto.ListPackagelnfo.Sum(p => p.Weight) / 1000;
                    }
                    else
                    {
                        rule.PackWeight = packinfllist.Sum(p => p.Weight) / 1000;
                    }

                    if (packinfllist.Where(p => p.MatCode.StartsWith("C06-02-09") || p.MatCode.StartsWith("C12-01-06-0009")).Any())
                    {
                        if (packinfllist.Where(p => reqDto.ListPackagelnfo.Select(p => p.MaterialCode).Contains(p.MatCode)).Any())
                        {
                            rule.TrayCode = packinfllist.Where(p => reqDto.ListPackagelnfo.Select(p => p.MaterialCode).Contains(p.MatCode)).First().MatCode;
                            //rule.TrayCode = "mutuopan";
                            //rule.TrayCode = "rechulituopan";
                        }
                    }
                    rulelist.Add(rule);
                }
                else
                {
                    int solrder = Convert.ToInt32(reqDto.SolderJointMax);
                    int perSolderMaxCount = Convert.ToInt32(reqDto.HuSolderJointMax);
                    decimal torsion24Qty = 0;
                    decimal torsion48Qty = 0;
                    decimal torsionErrRange = 0;
                    decimal hold = 0;

                    //if (skuinfolist.Where(p => p.FieldCode == "QC_B02").Any())
                    //{
                    //    solrder = int.Parse(skuinfolist.Where(p => p.FieldCode == "QC_B02").First().FieldValue);
                    //}
                    //if (skuinfolist.Where(p => p.FieldCode == "QC_B03").Any())
                    //{
                    //    perSolderMaxCount = int.Parse(skuinfolist.Where(p => p.FieldCode == "QC_B03").First().FieldValue);
                    //}
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C03").Any() && !string.IsNullOrEmpty(skuinfolist.Where(p => p.FieldCode == "QC_C03").First().FieldValue))
                    {
                        hold = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C03").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C04").Any() && !string.IsNullOrWhiteSpace(skuinfolist.Where(p => p.FieldCode == "QC_C04").First().FieldValue))
                    {
                        torsion24Qty = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C04").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C06").Any())
                    {
                        torsion48Qty = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C06").First().FieldValue);
                    }
                    if (skuinfolist.Where(p => p.FieldCode == "QC_C05").Any())
                    {
                        torsionErrRange = decimal.Parse(skuinfolist.Where(p => p.FieldCode == "QC_C05").First().FieldValue);
                    }
                    _boxrulerepository.AsUpdateable().SetColumns(p => new BillPboxrule()
                    {
                        SkuCode = reqDto.SkuCode,
                        PackRule = reqDto.PackRule,
                        IsSolder = solrder > 0 ? 1 : 0,
                        SolderMaxCount = solrder,
                        PerSolderMaxCount = perSolderMaxCount,
                        Torsion24Qty = torsion24Qty,
                        Torsion48Qty = torsion48Qty,
                        TorsChkValue = decimal.Parse(reqDto.TorsionTargetval),
                        TorsChkValueRange = decimal.Parse(reqDto.TorsionTargetscope),
                        EditWho = "MES重复推送",
                        EditTime = DateTime.Now,
                        LR_TYPE_L = l.LR_TYPE,
                        SPOOL_MAJOR_COLOR_L = l.SPOOL_MAJOR_COLOR,
                        TAKEUP_SIDE_L = l.TAKEUP_SIDE,
                        LR_TYPE_R = r.LR_TYPE,
                        SPOOL_MAJOR_COLOR_R = r.SPOOL_MAJOR_COLOR,
                        TAKEUP_SIDE_R = r.TAKEUP_SIDE,
                    }).Where(p => p.PBoxCode == rule.PBoxCode && p.ZXStateCode == 0).ExecuteCommand();
                }
            }
            _boxrulerepository.InsertRange(rulelist);

            return res;
        }

        /// <summary>
        /// 帘线工字轮信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SpoolMaterialInfoTrans(SxSpoolMaterialInfoTransRequest reqDto)
        {
            var res = new SRes();
            try
            {
                //var materlist = AppSettings.GetConfig("MaterInfo").Split(",");
                if (!_sysconfigrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Code == "MaterConfig").Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = reqDto.MatCode + "需要先配置该物料基础信息";
                    return res;
                }
                var materlist = _sysconfigrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Code == "MaterConfig").First().Memo.Split(",");
                if (!materlist.Contains(reqDto.MatCode))
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = reqDto.MatCode + "需要先配置该物料基础信息";
                    return res;
                }
                //var container = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.SpoolCode);
                //if (container == null)
                //{
                //    var insertcon = new BaseContinfo()
                //    {
                //        ContBarCode = reqDto.SpoolCode,
                //        Name = reqDto.SpoolCode,
                //        TypeCode = ContainerType.ContainerType_Spool.ToString(),
                //        PrintQty = 1,
                //        IsStop = 0,
                //        WarehouseId = 0,
                //        WeightQty = 0,
                //        AddWho = "wms",
                //        AddTime = DateTime.Now
                //    };
                //    if (!_baseContinfo.Insert(insertcon))
                //    {
                //        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                //        res.ResMsg = "工字轮载具初始化失败";
                //        return res;
                //    }
                //}
                var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == "sxhouse");

                var mater = _basematerrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Code == reqDto.MatCode).First();
                if (mater == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                    res.ResMsg = reqDto.SpoolCode + ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription() + reqDto.MatCode;
                    //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription() + ",物料编码:" + reqDto.MatCode, Time = DateTime.Now });
                    InsertErrorinfo(reqDto.SpoolCode, "帘线下线异常|" + res.ResMsg + "自动排出" + DateTime.Now);
                    return res;
                }
                var Winding = "";
                if (reqDto.SpoolCode.EndsWith("R"))
                {
                    Winding = "R";
                }
                else
                {
                    Winding = "L";
                }
                var barstock = _billInvinitrepository.GetFirst(p => p.ContGrpBarCode == reqDto.SpoolCode);
                if (barstock == null)
                {
                    var barinfo = new BillInvinit()
                    {
                        InvBarCode = reqDto.MatBarCode,
                        WarehouseId = wareHosue != null ? wareHosue.Id : 0,
                        ExecStateCode = InvLockState.InvState_Normal.ToString(),
                        ExecDocsNo = reqDto.WorkOrder,
                        ExecDocsRowNo = reqDto.MatBarCode,
                        ExecDocsTypeCode = DocType.DocType_FJ_WetStockIn.GetHashCode().ToString(),
                        InvInOut = InvInOutType.In,
                        ExecWho = "MES",
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        InDocsNo = reqDto.WorkOrder,
                        InDocsRowNo = reqDto.MatBarCode,
                        SuppCode = "",
                        BomDocsNo = "",
                        BomSetId = 0,
                        SetGrpCode = "",
                        BomMatCode = "",
                        BomMatId = 0,
                        BomMatName = "",
                        MatId = mater.Id,
                        MatCode = mater.Code,
                        MatName = mater.Name,

                        LengthQty = reqDto.Length,
                        TareWQty = reqDto.Weight,
                        ProductTime = DateTime.ParseExact(reqDto.ProductDate, "yyyyMMddHHmmss", System.Globalization.CultureInfo.InvariantCulture),
                        RFIDBarCode = "",
                        ProductMachCode = reqDto.WbCode,
                        Grade = reqDto.Grade,
                        HWBarCode = reqDto.SpoolCode,
                        HWTypeCode = mater.SpoolCode,  //BS80 大轮子 货物类型1
                        ContGrpBarCode = reqDto.SpoolCode,
                        ContGrpId = IdFactory.NewId(),
                        IsFast = false,
                        IsRework = reqDto.IsRework,
                        CLBarCode = reqDto.MatBarCode,
                        Size = 1,
                        BackReason = "",
                        IsBack = reqDto.IsBlack,
                        IsCore = reqDto.IsCore,
                        SolderCount = (int)reqDto.SolderCount,
                        IsTorsChk = reqDto.IsTorsChk,
                        WbGroupCode = reqDto.WbGroupCode,
                        IsControlpanel = reqDto.IsControl,
                        HoldTime = reqDto.HoldDuration,
                        Wind = Winding,
                        BatchNo = reqDto.Batch
                        //IsMulti = reqDto.IsMulti
                    };
                    if (!string.IsNullOrEmpty(reqDto.ReAutoPackFlag))
                    {
                        barinfo.IsMulti = reqDto.ReAutoPackFlag == "1" ? true : false;
                    }
                    _billInvinitrepository.Insert(barinfo);
                }
                else
                {
                }

                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.SpoolCode);
                if (stock == null)
                {
                    var inv = new BillInvnow()
                    {
                        InvBarCode = reqDto.MatBarCode,
                        WarehouseId = wareHosue != null ? wareHosue.Id : 0,
                        ExecStateCode = InvLockState.InvState_Normal.ToString(),
                        ExecDocsNo = reqDto.WorkOrder,
                        ExecDocsRowNo = reqDto.MatBarCode,
                        ExecDocsTypeCode = DocType.DocType_FJ_WetStockIn.GetHashCode().ToString(),
                        InvInOut = InvInOutType.In,
                        ExecWho = "MES",
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        InDocsNo = reqDto.WorkOrder,
                        SuppCode = "",
                        BomDocsNo = "",
                        BomSetId = 0,
                        SetGrpCode = "",
                        BomMatCode = "",
                        BomMatId = 0,
                        BomMatName = "",
                        MatId = mater.Id,
                        MatCode = mater.Code,
                        MatName = mater.Name,
                        LengthQty = reqDto.Length,
                        TareWQty = reqDto.Weight,
                        ProductTime = DateTime.ParseExact(reqDto.ProductDate, "yyyyMMddHHmmss", System.Globalization.CultureInfo.InvariantCulture),
                        RFIDBarCode = "",
                        ProductMachCode = reqDto.WbCode,
                        Grade = reqDto.Grade,
                        HWBarCode = reqDto.SpoolCode,
                        HWTypeCode = mater.SpoolCode,
                        ContGrpBarCode = reqDto.SpoolCode,
                        ContGrpId = IdFactory.NewId(),
                        IsFast = false,
                        IsRework = reqDto.IsRework,
                        CLBarCode = reqDto.MatBarCode,
                        ContGrpType = ContGrpType.Material,
                        Size = 1,
                        BackReason = "",
                        IsBlack = reqDto.IsBlack,
                        IsCore = reqDto.IsCore,
                        WbGroupCode = reqDto.WbGroupCode,
                        IsTorsChk = reqDto.IsTorsChk,
                        IsControlpanel = reqDto.IsControl,
                        HoldTime = reqDto.HoldDuration,
                        SolderCount = reqDto.SolderCount,
                        Wind = Winding,
                        BatchNo = reqDto.Batch
                        //IsMulti = reqDto.IsMulti
                    };
                    if (!string.IsNullOrEmpty(reqDto.ReAutoPackFlag))
                    {
                        inv.IsMulti = reqDto.ReAutoPackFlag == "1" ? true : false;
                    }
                    if (!string.IsNullOrEmpty(reqDto.OvcValue))//已经扭转过的
                    {
                        inv.TorsChkValue = decimal.Parse(reqDto.OvcValue);
                        inv.Memo = "接收数据含有扭转值";
                        inv.Ovced = 1;
                        inv.TorsChkQty = 1;
                    }
                    _billInvnowrepository.Insert(inv);
                    _billInvflow.Insert(_mapper.Map<BillInvflow>(inv));
                }
                else
                {
                    if (stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString())
                    {
                        //if (!string.IsNullOrEmpty(reqDto.ReAutoPackFlag))
                        //{
                        //    stoc.IsMulti =  reqDto.ReAutoPackFlag == "1" ? true : false;
                        //}
                        bool isMulti = reqDto.ReAutoPackFlag == "1" ? true : false;

                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            IsBlack = reqDto.IsBlack,
                            IsCore = reqDto.IsCore,
                            WbGroupCode = reqDto.WbGroupCode,
                            IsTorsChk = reqDto.IsTorsChk,
                            IsControlpanel = reqDto.IsControl,
                            HoldTime = reqDto.HoldDuration,
                            SolderCount = reqDto.SolderCount,
                            IsRework = reqDto.IsRework,
                            CLBarCode = reqDto.MatBarCode,
                            MatCode = mater.Code,
                            MatName = mater.Name,
                            LengthQty = reqDto.Length,
                            TareWQty = reqDto.Weight,
                            ProductTime = DateTime.ParseExact(reqDto.ProductDate, "yyyyMMddHHmmss", System.Globalization.CultureInfo.InvariantCulture),
                            RFIDBarCode = "",
                            ProductMachCode = reqDto.WbCode,
                            Grade = reqDto.Grade,
                            InDocsNo = reqDto.WorkOrder,
                            Wind = Winding,
                            EditTime = DateTime.Now,
                            IsMulti = isMulti
                        }, p => p.ContGrpBarCode == reqDto.SpoolCode && p.Id == stock.Id);
                    }
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_In.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.BarcodeContainerRepeat.GetHashCode();
                        res.ResMsg = reqDto.SpoolCode + ResponseStatusCodeEnum.BarcodeContainerRepeat.GetDescription();
                        //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + ResponseStatusCodeEnum.BarcodeContainerRepeat.GetDescription(), Time = DateTime.Now });
                        InsertErrorinfo(reqDto.SpoolCode, "帘线下线异常|" + res.ResMsg + "自动排出" + DateTime.Now);
                        return res;
                    }
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = reqDto.SpoolCode + "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
                        //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成", Time = DateTime.Now });
                        InsertErrorinfo(reqDto.SpoolCode, "帘线下线异常|" + res.ResMsg + "自动排出" + DateTime.Now);
                        return res;
                    }
                }
                var task = _wcstaskoldrepository.AsQueryable().Where(p => p.BarCode == reqDto.SpoolCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                if (task != null && task.Type == TaskType.OutDepot)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = reqDto.SpoolCode + "存在上一个未结束的出库任务，不允许创建入库任务";
                    //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + "存在上一个未结束的出库任务，不允许创建入库任务", Time = DateTime.Now });
                    InsertErrorinfo(reqDto.SpoolCode, "帘线下线异常|" + res.ResMsg + "自动排出" + DateTime.Now);
                    return res;
                }
                if (task != null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                    res.ResMsg = reqDto.SpoolCode + ResponseStatusCodeEnum.WcsTaskExist.GetDescription();
                    //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + ResponseStatusCodeEnum.WcsTaskExist.GetDescription(), Time = DateTime.Now });
                    return res;
                }
                var wcs = new WCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = "",
                    AddrFrom = "root",
                    BarCode = reqDto.SpoolCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = wareHosue.Code,
                    AddrTo = "",
                    Tunnel = "",
                    MaterialCode = mater.Code,
                    MatCode = mater.Code,
                    BusType = SxTaskBusType.TaskBusType_SX_LineStockIn.GetDescription(),
                    Floor = 0,
                    Grade = reqDto.Grade,
                    Length = reqDto.Length,
                    WorkBench = reqDto.WbCode,
                    WorkOrder = reqDto.WorkOrder
                };
                _db.BeginTran();
                var wcstask = _taskrepository.InsertReturnEntity(wcs);
                _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                var wcsdtl = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.SpoolCode,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcstask.ID,
                    Desc = wcstask.BusType
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtl);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                InsertErrorinfo(reqDto.SpoolCode, "帘线下线异常|" + res.ResMsg + "自动排出" + DateTime.Now);
                //RedisHelper.Set("Sx:WMSErrorInfo:MESEquip1", new RedisErrorInfo() { Equip = "MESEquip1", Con = reqDto.SpoolCode + ex.Message, Time = DateTime.Now });
            }
            return res;
        }

        /// <summary>
        ///  关闭工单
        /// </summary>
        /// <returns></returns>
        public SRes CloseWorkOrder(CloseWorkOrderRequest reqDto)
        {
            var res = new SRes();
            try
            {
                foreach (var item in reqDto.listinfo)
                {
                    var boxrule = _boxrulerepository.AsQueryable().Where(x => x.DocsNo.Contains(item)).ToList();
                    var boxruleId = boxrule.Where(x => x.ZXStateCode == 0).Select(x => x.Id).ToList();
                    if (boxruleId.Any())
                    {
                        _db.BeginTran();
                        _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                        {
                            ZXStateCode = 2,
                            Memo = "工单终止，自动停用"
                        }, x => boxruleId.Contains(x.Id) && x.ZXStateCode == 0);
                        _db.CommitTran();
                    }
                }
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = e.Message;
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription();
            return res;
        }

        /// <summary>
        /// 同步箱号状态
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SynchronizeBoxStatus(SynchronizeBoxStatusRequest reqDto)
        {
            var res = new SRes();
            try
            {
                var boxrule = _boxrulerepository.AsQueryable().First(x => x.PBoxCode == reqDto.HuNr && x.ZXStateCode == 0);
                if (boxrule != null)
                {
                    _db.BeginTran();
                    var result = _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                    {
                        ZXStateCode = 2,
                        Memo = "MES通知停用此箱号"
                    }, x => boxrule.Id == x.Id && x.ZXStateCode == 0);
                    if (!result)
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = "箱号正在使用";
                        return res;
                    }
                    _db.CommitTran();
                }
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = e.Message;
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription();
            return res;
        }

        /// <summary>
        /// 扭转出库申请
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes TorsChkStockOut(TorsChkStockOutRequest request)
        {
            var res = new SRes();
            try
            {
                var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                              join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.IsTorsChk == true && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0 && p.TorsChkQty < 1
                              && !p.ProductMachCode.Contains("R") && p.Grade == "A")
                              on loc.ContGrpBarCode equals stock.ContGrpBarCode
                              select new
                              {
                                  stock.MatCode,
                                  stock.InvBarCode,
                                  stock.Grade,
                                  stock.InvStateCode,
                                  stock.ProductTime,
                                  stock.SkuCode,
                                  stock.WbGroupCode,
                                  stock.IsTorsChk,
                                  stock.TorsChkQty,
                                  stock.TorsChkValue,
                                  stock.HoldTime,
                                  stock.ProductMachCode,
                                  stock.HWTypeCode,
                                  loc.Col,
                                  loc.Layer,
                                  loc.Shelf,
                                  loc.Depth,
                                  loc.Code,
                                  loc.Tunnel,
                                  loc.SCRel,
                                  loc.Floor,
                                  loc.WarehouseCode,
                                  loc.ContGrpBarCode,
                                  loc.Id,
                                  loc.StateNum,
                              };
                var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
                if (tunlist.Any())
                {
                    if (tunlist.Where(p => p.Default2 == "1").Any())
                    {
                        var inv = invlist.Where(p => p.Floor == 1 && tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                        invlist = invlist.Except(inv).Distinct(); //过滤1层被禁用的出库巷道
                    }
                    if (tunlist.Where(p => p.Default2 == "2").Any())
                    {
                        var inv = invlist.Where(p => p.Floor == 2 && tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                        invlist = invlist.Except(inv).Distinct(); //过滤2层被禁用的出库巷道
                    }
                    if (tunlist.Where(p => p.Default2 == "3").Any())
                    {
                        var inv = invlist.Where(p => p.Floor == 3 && tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                        invlist = invlist.Except(inv).Distinct(); //过滤3层被禁用的出库巷道
                    }
                }
                var TorschkDate = _sysconfigrepository.GetSingle(p => p.Code == "TorsChkDateCount");
                int srarthour = int.Parse(TorschkDate.Default2);
                int endhour = int.Parse(TorschkDate.Default3);

                //2025-01-02 客户要求所有未扭转在库内的工字轮都要扭转
                //invlist = invlist.ToList().Where(p => decimal.Parse((DateTime.Now - p.ProductTime).TotalHours.ToString("f2")) >= (p.HoldTime - decimal.Parse(TorschkDate.Default1)) && DateTime.Now.Hour >= srarthour && DateTime.Now.Hour <= endhour);
                if (!invlist.Any())
                {
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip1", new RedisErrorInfo() { Equip = "TorsChkEquip1", Con = ResponseStatusCodeEnum.NotEnoughStock.GetDescription() + "没有需要扭转检测的工字轮", Time = DateTime.Now });
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.NotEnoughStock.GetDescription() + "没有需要扭转检测的工字轮";
                    return res;
                }
                var startTime = DateTime.Now.Date.AddDays(-1).AddMilliseconds(-1);
                invlist = invlist.Where(x => x.ProductTime <= startTime).ToList().OrderBy(p => p.Depth).ThenByDescending(p => p.ProductTime.Day);
                var tasklist = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription() && p.Type == TaskType.OutDepot).ToList();
                var torTaskCount = _sysconfigrepository.GetFirst(p => p.Code == "TorTaskCount").SContent;
                if (tasklist.Any() && tasklist.Count > int.Parse(torTaskCount))
                {
                    res.ResMsg = "任务已经超最大数量";
                    return res;
                }
                //var taskcount = (from task in tasklist.GroupBy(p => p.Floor)
                //                 select new FloorCountTemp
                //                 {
                //                     Floor = task.Key,//楼层的任务数量
                //                     Count = task.Count()
                //                 }).ToList();

                #region 按照堆垛机平均分配任务

                var tempcount = 12;//还可以创建的任务数量
                var mastinvlist = tasklist.Where(p => p.Status < TaskStatus.StackerCompleted);
                var tempinvlist = invlist;
                var srmlist = tempinvlist.Select(p => p.SCRel).Distinct();//总共多少个堆垛机

                var mustsrmtasktobe = from x in mastinvlist.GroupBy(p => p.Device)
                                      select new SrmTaskTmep
                                      {
                                          Srm = x.Key,
                                          TaskCount = x.Count(),
                                          LocList = x.Select(q => q.AddrFrom).ToList()
                                      };
                var srmtasktobe = new List<SrmTaskTmep>();

                foreach (var srmlistitem in srmlist)
                {
                    if (!mustsrmtasktobe.Where(p => p.Srm == srmlistitem).Any())
                    {
                        srmtasktobe.Add(new SrmTaskTmep()
                        {
                            Srm = srmlistitem,
                            TaskCount = 0,
                            LocList = new List<string>()
                        });
                    }
                }
                srmtasktobe.AddRange(mustsrmtasktobe);//所有堆垛机任务数量
                var srmtasktobetemplocs = new List<string>();
                for (int i = 0; i < tempcount; i++)
                {
                    srmtasktobe = srmtasktobe.OrderBy(p => p.LocList.Count).ToList();//堆垛机任务排序，少的优先
                    var templocs = srmtasktobe.SelectMany(q => q.LocList);
                    foreach (var srmtasktobeitem in srmtasktobe)
                    {
                        if (tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).Any())
                        {
                            var first = tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).First();
                            srmtasktobe.Where(p => p.Srm == srmtasktobeitem.Srm).First().LocList.Add(first.Code);
                            srmtasktobetemplocs.Add(first.Code);
                            break;
                        }
                    }
                }

                #endregion 按照堆垛机平均分配任务

                invlist = invlist.Where(p => srmtasktobetemplocs.Contains(p.Code));

                //for (int floor = 1; floor <= 3; floor++)
                //{
                int pp = 0;
                //invlist = invlist.Where(p => p.Floor == floor);

                foreach (var item in invlist)
                {
                    if (item.TorsChkValue != null)
                    {
                        continue;
                    }
                    //if (pp == 4)
                    //{
                    //    break;
                    //}
                    var time1 = item.HoldTime + decimal.Parse(TorschkDate.SContent); //时效上限
                    var time2 = item.HoldTime - decimal.Parse(TorschkDate.Default1); //时效下限
                                                                                     //|| (decimal.Parse((DateTime.Now - item.ProductTime).TotalHours.ToString("f2")) > 72 && decimal.Parse((DateTime.Now - item.ProductTime).TotalHours.ToString("f2")) > item.HoldTime)
                                                                                     //if (decimal.Parse((DateTime.Now - item.ProductTime).TotalHours.ToString("f2")) >= time2) //按小时判断是否扭转的方式应客户要求停用-2024-12-24
                    if (item.ProductTime <= startTime) //时间在此范围即可流转，例:3号标记的检测盘(00:00到23:59之间)，5号全部出库进行检测(7点开始出
                    {
                        var inv = _billInvnowrepository.GetSingle(p =>
                            p.ContGrpBarCode == item.ContGrpBarCode &&
                            p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (inv == null)
                        {
                            RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip2",
                                new RedisErrorInfo
                                {
                                    Equip = "TorsChkEquip2",
                                    Con = item.ContGrpBarCode +
                                          ResponseStatusCodeEnum.StockNotExist.GetDescription(),
                                    Time = DateTime.Now
                                });
                            continue;
                        }

                        if (item.Depth == 2)
                        {
                            var taskold = _wcstaskoldrepository.AsQueryable()
                                .Where(p => p.BarCode == item.ContGrpBarCode && p.Status < TaskStatus.Finish)
                                .SplitTable(p => p.Take(2)).First();
                            if (taskold != null)
                            {
                                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip2",
                                    new RedisErrorInfo
                                    {
                                        Equip = "TorsChkEquip2",
                                        Con = item.ContGrpBarCode +
                                              ResponseStatusCodeEnum.StockNotExist.GetDescription(),
                                        Time = DateTime.Now
                                    });
                                continue;
                            }

                            var respon = MoveTask(item.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1") continue;
                        }
                        else
                        {
                            //判断存不存在任务
                            var taskoldexist = _wcstaskoldrepository.AsQueryable()
                                .Where(p => p.BarCode == item.ContGrpBarCode && p.Status < TaskStatus.Finish)
                                .SplitTable(p => p.Take(2)).First();
                            if (taskoldexist != null)
                            {
                                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip2",
                                    new RedisErrorInfo
                                    {
                                        Equip = "TorsChkEquip2",
                                        Con = item.ContGrpBarCode + "已经存在任务，不能再创建扭转出库任务",
                                        Time = DateTime.Now
                                    });
                                _logger.LogInformation(item.ContGrpBarCode + "已经存在任务，不能再创建扭转出库任务");
                                continue;
                            }
                        }

                        var wcs = new WCS_TaskInfo
                        {
                            Status = TaskStatus.NewBuild,
                            Type = TaskType.OutDepot,
                            Priority = 0,
                            Device = item.SCRel,
                            SrmStation = item.SCRel,
                            AddrFrom = item.Code,
                            BarCode = inv.ContGrpBarCode,
                            AddWho = "wms",
                            EditWho = "wms",
                            WarehouseCode = item.WarehouseCode,
                            AddrTo = "",
                            Tunnel = item.Tunnel.ToString(),
                            MaterialCode = item.MatCode,
                            MatCode = item.MatCode,
                            BusType = SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription(),
                            Floor = item.Floor,
                            Grade = item.Grade,
                            GoodsType = item.HWTypeCode == "BS80/33" ? 1 : 2
                        };
                        _db.BeginTran();
                        if (decimal.Parse((DateTime.Now - item.ProductTime).TotalHours.ToString("f2")) > time1)
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow
                            {
                                InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                                //ContUsageQty = 2,  //扭转超时异常盘,2024-11-29客户要求不再更新异常
                                EditTime = DateTime.Now
                            }, p => p.ContGrpBarCode == inv.ContGrpBarCode);
                        else
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow
                            {
                                InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                                EditTime = DateTime.Now
                            }, p => p.ContGrpBarCode == inv.ContGrpBarCode);
                        _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell
                        {
                            StateNum = LocationState.LocationState_StockOut,
                            EditTime = DateTime.Now
                        }, p => p.Code == item.Code);
                        var flow = _mapper.Map<BillInvflow>(inv);
                        flow.Id = GetId();
                        flow.AddTime = DateTime.Now;
                        flow.EditTime = DateTime.Now;
                        flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                        flow.Memo = "扭转出库";
                        _billInvflow.Insert(flow);
                        var wcstask = _taskrepository.InsertReturnEntity(wcs);
                        _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                        var wcsdtl = new WCS_TaskDtl
                        {
                            ID = Guid.NewGuid(),
                            CurPoint = wcstask.AddrFrom,
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            Enabled = true,
                            ParentTaskCode = wcstask.ID,
                            Desc = wcstask.BusType
                        };
                        _taskdetailrepository.InsertableSplitTable(wcsdtl);
                        _db.CommitTran();
                        //return res;
                        pp++;
                    }
                }

                //}
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.InnerServerErr.GetDescription() + ex.Message;
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip2", new RedisErrorInfo() { Equip = "TorsChkEquip2", Con = ex.Message, Time = DateTime.Now });
                return res;
            }

            return res;
        }

        public SRes<int> TorsChkComplete(TorsChkCompleteRequest request)
        {
            var res = new SRes<int>();
            try
            {
                if (string.IsNullOrEmpty(request.TaskNo))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                    return res;
                }
                var ware = _basewarehouserepository.GetSingle(p => p.Code == "sxhouse");
                if (ware == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                    return res;
                }
                var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == int.Parse(request.TaskNo) && p.Status < TaskStatus.Finish && p.Type == TaskType.OutDepot).SplitTable(p => p.Take(2)).First();
                if (task == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    res.ResMsg = request.TaskNo + "不存在扭转出库的任务";
                    return res;
                }
                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && p.IsTorsChk == true && p.TorsChkQty > 0);
                if (stock == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.TaskNo + "没有找到扭转出库的库存信息";
                    return res;
                }
                _db.BeginTran();
                _billInvnowrepository.Delete(p => p.Id == stock.Id);
                var flow = _mapper.Map<BillInvflow>(stock);
                flow.Id = GetId();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.Memo = "扭转出库任务完成";
                flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                _billInvflow.Insert(flow);
                _taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo));
                _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                {
                    Status = TaskStatus.Finish,
                    EditTime = DateTime.Now,
                    ManualRemarks = "扭转完成"
                }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                var wcsdtl = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = stock.TorsChkMachCode,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.Id,
                    Desc = "扭转完成"
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtl);

                var inv = stock;
                inv.Id = GetId();
                inv.ContGrpId = GetId();
                inv.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
                inv.Memo = "扭转回库";
                _billInvnowrepository.Insert(inv);
                _billInvflow.Insert(_mapper.Map<BillInvflow>(inv));
                var wcs = new WCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = "",
                    AddrFrom = inv.TorsChkMachCode,
                    BarCode = stock.ContGrpBarCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = ware.Code,
                    AddrTo = "",
                    Tunnel = "",
                    MaterialCode = inv.MatCode,
                    MatCode = inv.MatCode,
                    BusType = SxTaskBusType.TaskBusType_SX_TorCheckStockIn.GetDescription(),
                    Grade = inv.Grade
                };
                var wcstask = _taskrepository.InsertReturnEntity(wcs);
                _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                var wcsdtls = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = wcstask.AddrFrom,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcstask.ID,
                    Desc = wcstask.BusType
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtls);
                res.ResData = wcstask.ID;
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            return res;
        }

        private long GetId()
        {
            return IdFactory.NewId();
        }

        /// <summary>
        /// sku信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SKUInfoTrans(SKUInfoTransRequest reqDto)
        {
            var res = new SRes();
            foreach (var item in reqDto.ListInfo)
            {
                var model = _skuInforepository.GetSingle(p => p.SkuCode == reqDto.SkuCode && p.FieldCode == item.FieldCode);
                if (model == null)
                {
                    _skuInforepository.Insert(new BillSkuInfo()
                    {
                        SkuCode = reqDto.SkuCode,
                        TypeCode = item.TypeCode,
                        TypeName = item.TypeName,
                        FieldCode = item.FieldCode,
                        FieldName = item.FieldName,
                        FieldUnit = item.FieldUnit,
                        FieldValue = item.FieldValue
                    });
                }
                else
                {
                    //if (model.FieldCode == "QC_B02" || model.FieldCode == "QC_B03")
                    //{
                    _skuInforepository.UpdateSetColumnsTrue(p => new BillSkuInfo()
                    {
                        //TypeCode = item.TypeCode,
                        //TypeName = item.TypeName,
                        //FieldCode = item.FieldCode,
                        //FieldName = item.FieldName,
                        FieldUnit = item.FieldUnit,
                        FieldValue = item.FieldValue,
                        EditTime = DateTime.Now
                    }, p => p.SkuCode == reqDto.SkuCode && p.FieldCode == item.FieldCode);
                    //}
                }
            }

            return res;
        }

        /// <summary>
        /// 包装信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes PackInfoTrans(PackInfoTrans reqDto)
        {
            var res = new SRes();
            foreach (var item in reqDto.ListInfo)
            {
                var model = _packInforepository.GetSingle(p => p.PackCode == reqDto.PackCode && p.MatCode == item.MatCode);
                if (model == null)
                {
                    _packInforepository.Insert(new BillPackInfo()
                    {
                        PackCode = reqDto.PackCode,
                        MatCode = item.MatCode,
                        MatName = item.MatName,
                        Count = item.Count,
                        UnitName = item.UnitName,
                        Weight = item.Weight,
                        PackDesc = reqDto.PackDesc,
                        PackMethodCode = reqDto.PackMethodCode,
                        PackMethod = reqDto.PackMethod,
                        EmptySpoolNum = reqDto.EmptySpoolNum,
                        Spool = reqDto.Spool,
                        SpoolNum = reqDto.SpoolNum,
                        LayersSpoolNum = reqDto.LayersSpoolNum,
                        LayersNum = reqDto.LayersNum,
                        AddWho = "MES",
                        EditWho = ""
                    });
                }
                else
                {
                    _packInforepository.UpdateSetColumnsTrue(p => new BillPackInfo()
                    {
                        Count = item.Count,
                        UnitName = item.UnitName,
                        Weight = item.Weight,
                        PackDesc = reqDto.PackDesc,
                        PackMethodCode = reqDto.PackMethodCode,
                        PackMethod = reqDto.PackMethod,
                        EmptySpoolNum = reqDto.EmptySpoolNum,
                        Spool = reqDto.Spool,
                        SpoolNum = reqDto.SpoolNum,
                        LayersSpoolNum = reqDto.LayersSpoolNum,
                        LayersNum = reqDto.LayersNum,
                        EditWho = "MES"
                    }, p => p.PackCode == reqDto.PackCode && p.MatCode == item.MatCode);
                }
            }
            return res;
        }

        /// <summary>
        /// 异常信息通用方法
        /// </summary>
        /// <param name="Code"></param>
        /// <param name="Message"></param>
        /// <returns></returns>
        private SRes InsertErrorinfo(string Code, string Message)
        {
            var res = new SRes();
            var error = new BaseErrorinfo()
            {
                ContBarCode = Code,
                Message = Message,
                AddWho = "",
                EditWho = "",
                Count = 1
            };
            var errorinfo = _errorinforepository.GetSingle(p => p.ContBarCode == Code && p.Message == Message);
            if (errorinfo != null)
            {
                _errorinforepository.UpdateSetColumnsTrue(p => new BaseErrorinfo()
                {
                    Count = errorinfo.Count + 1
                }, p => p.ContBarCode == errorinfo.ContBarCode);
            }
            else
            {
                _errorinforepository.Insert(error);
            }
            return res;
        }

        /// <summary>
        /// 分配楼层
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<ApplyFloorResponse> ApplyFloor(ApplyFloorRequest reqDto)
        {
            var time = new Stopwatch();
            time.Restart();
            var result = new SRes<ApplyFloorResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new ApplyFloorResponse(),
            };
            if (!Const.SxFloorEquip.Contains(reqDto.EquNo))
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqDto.EquNo + "没有当前扫码设备";
                InsertErrorinfo(reqDto.Code, "异常口：" + result.ResMsg + "自动排出" + DateTime.Now);
                return result;
            }

            //C质量异常排出处理
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.Code && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
            if (stock == null)
            {
                _billInvinitrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = reqDto.Code + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                return result;
            }
            else
            {
                if (stock.Grade == "C" || stock.Grade == "D" || stock.Grade == "B")
                {
                    try
                    {
                        _db.BeginTran();
                        _billInvinitrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                        _billInvnowrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                        var flow = _mapper.Map<BillInvflow>(stock);
                        flow.Id = GetId();
                        flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                        flow.AddTime = DateTime.Now;
                        flow.EditTime = DateTime.Now;
                        flow.Memo = "BCD质量异常排出";
                        _billInvflow.Insert(flow);
                        _db.CommitTran();
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = reqDto.Code + "当前BCD质量工字轮不允许入库";
                        InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                        return result;
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = reqDto.Code + "当前BCD质量工字轮不允许入库";
                        InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                        return result;
                    }
                }
            }
            //由于重绕盘间隔时间太长，所以查当前任务表
            //var wcstask = _wcstaskoldrepository.AsQueryable().Where(p => p.BarCode == reqDto.Code && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(3)).First();
            var wcstask = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == reqDto.Code && p.Status < TaskStatus.Finish).First();
            if (wcstask == null)
            {
                try
                {
                    _db.BeginTran();
                    _billInvinitrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                    var stocks = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.Code);
                    if (stocks != null)
                    {
                        _billInvnowrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                        var flow = _mapper.Map<BillInvflow>(stocks);
                        flow.Id = GetId();
                        flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                        flow.AddTime = DateTime.Now;
                        flow.EditTime = DateTime.Now;
                        flow.Memo = "任务异常排出";
                        _billInvflow.Insert(flow);
                    }
                    _db.CommitTran();
                    result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    result.ResMsg = reqDto.Code + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                    return result;
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    result.ResMsg = reqDto.Code + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                    return result;
                }
            }
            if (wcstask.Type != TaskType.EnterDepot)
            {
                _billInvinitrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                var stocks = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.Code);
                if (stocks != null)
                {
                    _billInvnowrepository.Delete(p => p.ContGrpBarCode == reqDto.Code);
                    var flow = _mapper.Map<BillInvflow>(stocks);
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = "任务异常排出";
                    _billInvflow.Insert(flow);
                }
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqDto.Code + "不是入库任务，不允许分配楼层";
                InsertErrorinfo(reqDto.Code, "异常口：" + reqDto.EquNo + "|" + result.ResMsg + "自动排出" + DateTime.Now);
                return result;
            }
            result.ResData.TaskNo = wcstask.ID;
            if (stock.HWTypeCode == "BS60" || stock.HWTypeCode == "BS40")
            {
                result.Memo1 = "1";
            }
            else
            {
                result.Memo1 = "2";
            }

            var existstock = _billInvnowrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Wind == stock.Wind && p.HWTypeCode == stock.HWTypeCode && p.WbGroupCode == stock.WbGroupCode && p.IsControlpanel == stock.IsControlpanel && p.IsTorsChk == stock.IsTorsChk && p.Ovced == stock.Ovced).ToList();
            //去掉禁用巷道
            List<int> distuns = new List<int>();
            var time1 = new Stopwatch();
            time1.Restart();
            var time2 = new Stopwatch();
            time2.Restart();
            // 提前查询并返回符合条件的 cell 列表
            var cellQuery = _basewarecellrepository.AsQueryable()
                .With(SqlWith.NoLock)
                .Where(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Empty); ;

            var cell = new List<BaseWarecell>();

            // 获取禁用的巷道信息
            var disabletunnels = _sysconfigrepository.GetList(p => p.SType == "InStop" && !string.IsNullOrEmpty(p.SContent));
            if (disabletunnels != null && disabletunnels.Any())
            {
                foreach (var item in disabletunnels)
                {
                    var distun = int.Parse(item.Default1);
                    var disfloor = int.Parse(item.Default2);
                    cellQuery.Where(x => !(x.Tunnel == distun && x.Floor == disfloor));
                }
                // 执行查询，获取最终的 cell 列表
                cell = cellQuery.Clone().ToList();
            }
            else cell = cellQuery.ToList();
            time2.Stop();
            bool isTobeTors = false;
            int tun = 2;
            int row = 8;
            if (stock.IsTorsChk == true && stock.IsControlpanel == true && stock.TorsChkQty <= 0 && stock.Ovced == 0)
            {
                isTobeTors = true;
            }

            #region 检测库存占比是否符合要求

            if (isTobeTors)
            {
                //扭转检测库存最大比
                var torsInventoryRate = _sysconfigrepository.GetFirst(p => p.Code == "TorsInventoryRate").SContent;
                var torsInventoryRateValue = decimal.Parse(torsInventoryRate) / 100;
                //计算已使用货位占比
                decimal cellCount = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Tunnel <= 2 && p.IsStop == LocationStop.LocationInvoke.GetHashCode()).Count();
                decimal fullCellCount = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock)
                    .Where(p => p.Tunnel <= 2 && p.IsStop == LocationStop.LocationInvoke.GetHashCode()
                    && p.StateNum != LocationState.LocationState_Empty).Count();  //所有不是空的货位都算作满货位
                var fullCellRate = fullCellCount / cellCount;

                if (fullCellRate >= torsInventoryRateValue)
                {
                    result.ResData.TaskNo = 0;
                    result.ResMsg = reqDto.Code + $"扭转库存占比已达{ToPercentage(fullCellRate)},根据系统配置开始禁止入库";
                    return result;
                }
            }
            else
            {
                //码垛库存最大比
                var palletizingInventoryRate = _sysconfigrepository.GetFirst(p => p.Code == "PalletizingInventoryRate").SContent;
                var palletizingInventoryRateValue = decimal.Parse(palletizingInventoryRate) / 100;
                //计算已使用货位占比
                decimal cellCount = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Tunnel > 2 && p.IsStop == LocationStop.LocationInvoke.GetHashCode()).Count();
                decimal fullCellCount = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock)
                    .Where(p => p.Tunnel > 2 && p.IsStop == LocationStop.LocationInvoke.GetHashCode()
                    && p.StateNum != LocationState.LocationState_Empty).Count();  //所有不是空的货位都算作满货位
                var fullCellRate = fullCellCount / cellCount;

                if (fullCellRate >= palletizingInventoryRateValue)
                {
                    result.ResData.TaskNo = 0;
                    result.ResMsg = reqDto.Code + $"码垛库存占比已达{ToPercentage(fullCellRate)},根据系统配置开始禁止入库";
                    return result;
                }
            }

            #endregion 检测库存占比是否符合要求

            // 最小有效货位数量，用于保留移库
            const int MinAvailableCells = 30;
            var forbidLayer = wms.util.AppSettings.GetConfig("ForbidLayer");
            // 定义楼层信息结构
            var floors = Enumerable.Range(1, 3).Select(floorNumber =>
            {
                // 获取货位数
                var cellQuery = cell.Where(p => p.Floor == floorNumber);
                var cellCount = isTobeTors ? cellQuery.Count(p => p.Tunnel <= tun) : cellQuery.Count(p => p.Tunnel > tun);
                if (!string.IsNullOrEmpty(forbidLayer) && forbidLayer.Contains(floorNumber.ToString())) cellCount = 0;
                // 获取同规格库存数
                var (minLayer, maxLayer) = floorNumber switch
                {
                    1 => (1, 4),
                    2 => (5, 8),
                    3 => (9, 12),
                    _ => (0, 0)
                };

                var stockQuery = existstock.Where(p => p.PutLayer >= minLayer && p.PutLayer <= maxLayer && (isTobeTors ? p.PutRow <= row : p.PutRow > row));

                // 计算库存比率
                var stockRatio = cellCount > 0 ? stockQuery.Count() / (double)cellCount : 0;

                // 获取任务限制数
                var taskLimit = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == $"FloorTaskCount{floorNumber}").SContent);

                return new
                {
                    Floor = floorNumber,
                    CellCount = cellCount,
                    StockRatio = stockRatio,
                    TaskLimit = taskLimit
                };
            })
            // 排序：库存比例低优先 > 货位数高优先
            .OrderBy(f => f.StockRatio)
            .ThenByDescending(f => f.CellCount)
            .ToList();

            // 获取各楼层当前任务数
            var floorTasks = _taskrepository.AsQueryable()
                .Where(p => p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.BusType == "帘线工字轮入库")
                .ToList()
                .GroupBy(p => p.Floor).ToDictionary(x => x.Key, x => x.Count());

            var time10 = new Stopwatch();
            time10.Restart();
            // 选择楼层的策略
            var selectedFloor = floors.FirstOrDefault(f =>
                f.CellCount > MinAvailableCells &&
                floorTasks.GetValueOrDefault(f.Floor, 0) < f.TaskLimit
            );

            // 次选策略：允许货位较少但未超限的楼层
            selectedFloor ??= floors.FirstOrDefault(f =>
                f.CellCount > 0 &&
                floorTasks.GetValueOrDefault(f.Floor, 0) < f.TaskLimit
            );

            // 返回结果处理
            if (selectedFloor != null)
            {
                result.ResData.Floor = selectedFloor.Floor;
            }
            else
            {
                result.ResData.TaskNo = 0;
                result.ResMsg = $"{reqDto.Code} 所有楼层任务配额已满，当前各楼层任务数：" + string.Join("", floors.Select(f =>
                 $"{f.Floor}层({floorTasks.GetValueOrDefault(f.Floor)}/{f.TaskLimit}) "));
            }

            //var cellfloor1count = isTobeTors == true ? cell.Where(p => p.Floor == 1 && p.Tunnel <= tun).Count() : cell.Where(p => p.Floor == 1 && p.Tunnel > tun).Count();  //1楼层可用的货位数
            //var cellfloor2count = isTobeTors == true ? cell.Where(p => p.Floor == 2 && p.Tunnel <= tun).Count() : cell.Where(p => p.Floor == 2 && p.Tunnel > tun).Count();  //2楼层可用的货位数
            //var cellfloor3count = isTobeTors == true ? cell.Where(p => p.Floor == 3 && p.Tunnel <= tun).Count() : cell.Where(p => p.Floor == 3 && p.Tunnel > tun).Count();  //3楼层可用的货位数

            //var cellfloor1stockcount = isTobeTors == true ? existstock.Where(p => p.PutLayer >= 1 && p.PutLayer <= 4 && p.PutRow <= row).Count() : existstock.Where(p => p.PutLayer >= 1 && p.PutLayer <= 4 && p.PutRow > row).Count();  //1楼层同规格数量
            //var cellfloor2stockcount = isTobeTors == true ? existstock.Where(p => p.PutLayer >= 5 && p.PutLayer <= 8 && p.PutRow <= row).Count() : existstock.Where(p => p.PutLayer >= 5 && p.PutLayer <= 8 && p.PutRow > row).Count();  //2楼层同规格数量
            //var cellfloor3stockcount = isTobeTors == true ? existstock.Where(p => p.PutLayer >= 9 && p.PutLayer <= 12 && p.PutRow <= row).Count() : existstock.Where(p => p.PutLayer >= 9 && p.PutLayer <= 12 && p.PutRow > row).Count();  //3楼层同规格数量

            //var floorTaskCount = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "FloorTaskCount").SContent);
            //var forbidlayer = wms.util.AppSettings.GetConfig("ForbidLayer");//禁用的楼层
            //if (!string.IsNullOrEmpty(forbidlayer))
            //{
            //    if (forbidlayer.Contains("1")) cellfloor1count = 0;
            //    if (forbidlayer.Contains("2")) cellfloor2count = 0;
            //    if (forbidlayer.Contains("3")) cellfloor3count = 0;
            //}
            ////cellfloor2count = 0;//临时修改,限制楼层分配
            //var tempcells = new List<Tuple<int, int, double, int>>() {
            // new Tuple<int, int,double,int>(1,cellfloor1count,cellfloor1stockcount / (cellfloor1count*1.0),int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "FloorTaskCount1").SContent)),
            // new Tuple<int, int,double,int>(2,cellfloor2count,cellfloor2stockcount / (cellfloor2count*1.0),int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "FloorTaskCount2").SContent)),
            // new Tuple<int, int,double,int>(3,cellfloor3count,cellfloor3stockcount / (cellfloor3count*1.0),int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "FloorTaskCount3").SContent)),
            //};
            ////tempcells = tempcells.OrderByDescending(p => p.Item2).ToList();//按照空位数排序
            //tempcells = tempcells.OrderBy(p => p.Item3).ToList();//按照同规则物料少的排序

            ////每个扫码固定楼层，如果固定楼层设备坏了或者库存满了，再换楼层
            //var taskcount = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.Floor != 0).ToList();
            //var time10 = new Stopwatch();
            //time10.Restart();
            //if (tempcells[0].Item2 > 30)
            //{
            //    if (taskcount.Where(p => p.Floor == tempcells[0].Item1).Count() > tempcells[0].Item4 || tempcells[0].Item2 == 0)
            //    {
            //        if (taskcount.Where(p => p.Floor == tempcells[1].Item1).Count() > tempcells[1].Item4 || tempcells[1].Item2 == 0)
            //        {
            //            if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() > tempcells[2].Item4 || tempcells[2].Item2 == 0)
            //            {
            //                var it1 = taskcount.Where(p => p.Floor == tempcells[0].Item1).Count();
            //                var it2 = taskcount.Where(p => p.Floor == tempcells[1].Item1).Count();
            //                var it3 = taskcount.Where(p => p.Floor == tempcells[2].Item1).Count();
            //                result.ResData.TaskNo = 0;
            //                result.ResMsg = reqDto.Code + $"当前环线三个楼层执行中的任务数已满，不允许分配楼层1-{tempcells[0].Item1}:{it1}:{tempcells[0].Item2}--{tempcells[1].Item1}:{it2}:{tempcells[1].Item2}--{tempcells[2].Item1}:{it3}:{tempcells[2].Item2}";
            //                result.ResData.Floor = 0;
            //                return result;
            //            }
            //            else
            //            {
            //                result.ResData.Floor = tempcells[2].Item1;
            //            }
            //        }
            //        else
            //        {
            //            result.ResData.Floor = tempcells[1].Item1;
            //        }
            //    }
            //    else
            //    {
            //        result.ResData.Floor = tempcells[0].Item1;
            //    }
            //}
            //else
            //{
            //    if (tempcells[1].Item2 > 30)
            //    {
            //        if (taskcount.Where(p => p.Floor == tempcells[1].Item1).Count() > floorTaskCount || tempcells[1].Item2 == 0)
            //        {
            //            if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() > floorTaskCount || tempcells[2].Item2 == 0)
            //            {
            //                result.ResData.TaskNo = 0;
            //                result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层2";
            //                result.ResData.Floor = 0;
            //                return result;
            //            }
            //            else
            //            {
            //                result.ResData.Floor = tempcells[2].Item1;
            //            }
            //        }
            //        else
            //        {
            //            result.ResData.Floor = tempcells[1].Item1;
            //        }
            //    }
            //    else
            //    {
            //        if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() < floorTaskCount && tempcells[2].Item2 > 30)
            //        {
            //            result.ResData.Floor = tempcells[2].Item1;
            //        }
            //        else
            //        {
            //            result.ResData.TaskNo = 0;
            //            result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层3";
            //            result.ResData.Floor = 0;
            //            return result;
            //        }
            //    }
            //}
            time10.Stop();
            time1.Stop();
            time.Stop();
            _logger.LogInformation($"ApplyFloor:{reqDto.Code}--总耗时{time.ElapsedMilliseconds}-可用楼层计算耗时{time1.ElapsedMilliseconds}-排除禁用巷道{time2.ElapsedMilliseconds}-计算目标楼层耗时{time2.ElapsedMilliseconds}");

            #region 逻辑暂时不用(不换楼层优先)

            //switch (reqDto.EquNo)
            //{
            //    case "2134":     //一号分层扫码器
            //        if (cellfloor1count > 30)
            //        {
            //            if (taskcount.Where(p => p.Floor == 1).Count() > 32)
            //            {
            //                if (taskcount.Where(p => p.Floor == 2).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 3).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 3;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 2;
            //                }
            //            }
            //            else
            //            {
            //                result.ResData.Floor = 1;
            //            }
            //        }
            //        else
            //        {
            //            if (cellfloor2count > 30)
            //            {
            //                if (taskcount.Where(p => p.Floor == 2).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 3).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 3;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 2;
            //                }
            //            }
            //            else
            //            {
            //                if (taskcount.Where(p => p.Floor == 3).Count() < 32 && cellfloor3count > 30)
            //                {
            //                    result.ResData.Floor = 3;
            //                }
            //                else
            //                {
            //                    result.ResData.TaskNo = 0;
            //                    result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                    result.ResData.Floor = 0;
            //                    return result;
            //                }
            //            }
            //        }
            //        break;
            //    case "2258":     //二号分层扫码器
            //        if (cellfloor2count > 30)
            //        {
            //            if (taskcount.Where(p => p.Floor == 2).Count() > 32)
            //            {
            //                if (taskcount.Where(p => p.Floor == 1).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 3).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 3;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 1;
            //                }
            //            }
            //            else
            //            {
            //                result.ResData.Floor = 2;
            //            }
            //        }
            //        else
            //        {
            //            if (cellfloor1count > 30)
            //            {
            //                if (taskcount.Where(p => p.Floor == 1).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 3).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 3;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 1;
            //                }
            //            }
            //            else
            //            {
            //                if (taskcount.Where(p => p.Floor == 3).Count() < 32 && cellfloor3count > 30)
            //                {
            //                    result.ResData.Floor = 3;
            //                }
            //                else
            //                {
            //                    result.ResData.TaskNo = 0;
            //                    result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                    result.ResData.Floor = 0;
            //                    return result;
            //                }
            //            }
            //        }
            //        break;
            //    case "2419":    //三号分层扫码器
            //        if (cellfloor3count > 30)
            //        {
            //            if (taskcount.Where(p => p.Floor == 3).Count() > 32)
            //            {
            //                if (taskcount.Where(p => p.Floor == 2).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 1).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 1;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 2;
            //                }
            //            }
            //            else
            //            {
            //                result.ResData.Floor = 3;
            //            }
            //        }
            //        else
            //        {
            //            if (cellfloor1count > 30)
            //            {
            //                if (taskcount.Where(p => p.Floor == 1).Count() > 32)
            //                {
            //                    if (taskcount.Where(p => p.Floor == 2).Count() > 32)
            //                    {
            //                        result.ResData.TaskNo = 0;
            //                        result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                        result.ResData.Floor = 0;
            //                        return result;
            //                    }
            //                    else
            //                    {
            //                        result.ResData.Floor = 2;
            //                    }
            //                }
            //                else
            //                {
            //                    result.ResData.Floor = 1;
            //                }
            //            }
            //            else
            //            {
            //                if (taskcount.Where(p => p.Floor == 2).Count() < 32 && cellfloor2count > 30)
            //                {
            //                    result.ResData.Floor = 2;
            //                }
            //                else
            //                {
            //                    result.ResData.TaskNo = 0;
            //                    result.ResMsg = reqDto.Code + "当前环线三个楼层执行中的任务数已满，不允许分配楼层";
            //                    result.ResData.Floor = 0;
            //                    return result;
            //                }
            //            }
            //        }
            //        break;
            //    default:
            //        break;
            //}

            #endregion 逻辑暂时不用(不换楼层优先)

            //var maxcount = cellfloor1count > cellfloor2count ? (cellfloor1count > cellfloor3count ? cellfloor1count : cellfloor3count) : (cellfloor2count > cellfloor3count ? cellfloor2count : cellfloor3count);
            //if (maxcount == cellfloor1count)
            //{
            //    result.ResData.Floor = 1;
            //}
            //else if (maxcount == cellfloor2count)
            //{
            //    result.ResData.Floor = 2;
            //}
            //else if (maxcount == cellfloor3count)
            //{
            //    result.ResData.Floor = 3;
            //}

            //楼层禁用
            //var floorlist = _sysconfigrepository.GetList(p => p.SType == "FloorType" && !string.IsNullOrEmpty(p.SContent));
            //if (floorlist.Any())
            //{
            //    if (floorlist.Select(p => p.Code).ToList().Contains(result.ResData.Floor.ToString()))
            //    {
            //        result.ResData.Floor = 0;
            //    }
            //}
            result.Memo2 = stock.Grade;
            return result;
        }

        /// <summary>
        /// 获取巷道
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        public SRes<string> GetTunnelPriorityList(GetSxTunnelPriorityListRequest reqEntity)
        {
            var result = new SRes<string>();
            if (reqEntity.Floor <= 0 || reqEntity.Floor > 3)
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqEntity.Code + "楼层参数不能为0或大于3";
                result.ResData = "";
                return result;
            }
            var wcstask = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == reqEntity.Code && p.Status < TaskStatus.Finish).First();
            if (wcstask == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = reqEntity.Code + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            if (wcstask.Type != TaskType.EnterDepot)
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqEntity.Code + "不是入库任务，不允许分配巷道";
                return result;
            }

            //获取任务数占用最少的
            var wcstasks = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.WarehouseCode == wcstask.WarehouseCode && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.Floor == reqEntity.Floor && p.Tunnel != "0" && p.Tunnel != "" && p.Tunnel != null);

            var tunnelcountlist = new List<TunnelCountTemp>();
            var runningtasks = wcstasks.ToList();
            if (runningtasks.Any())
            {
                tunnelcountlist = (from task in runningtasks.GroupBy(p => p.Tunnel)
                                   select new TunnelCountTemp
                                   {
                                       Tunnel = task.Key,
                                       Count = task.Count()
                                   }).ToList();
            }

            //获取库位所有巷道列表
            var alltunnels = _basewarecellrepository.GetList(p => p.Floor == reqEntity.Floor).Select(p => p.Tunnel).Distinct();
            foreach (var item in alltunnels)
            {
                if (!tunnelcountlist.Where(p => p.Tunnel == item.ToString()).Any())
                {
                    tunnelcountlist.Add(new TunnelCountTemp()
                    {
                        Tunnel = item.ToString(),
                        Count = 0
                    });
                }
            }
            var tasktunnelcountlist = tunnelcountlist.OrderBy(p => p.Count).ToList();
            var warehouse = _basewarehouserepository.GetSingle(p => p.Code == wcstask.WarehouseCode);
            //获取已占用库位最少的货架
            var threshold = 5; //int.Parse(ConfigUtil.GetConfiguration["Threshold"]);//阈值
            var locationsreturn = _basewarecellrepository.GetList(p => p.WarehouseId == warehouse.Id && p.Floor == reqEntity.Floor && p.Size >= wcstask.Height && p.StateNum == LocationState.LocationState_Full && p.IsStop == 0);
            var shelflocationcount = _basewarecellrepository.GetList(p => p.WarehouseCode == wcstask.WarehouseCode && p.Floor == reqEntity.Floor && p.Size >= wcstask.Height && p.TypeNum == LocationType.LocationType_StorageLocation && p.IsStop == 0).GroupBy(p => new { p.Tunnel, p.Shelf }).Select(p => new { Tunnel = p.Key.Tunnel, Shelf = p.Key.Shelf, LocationCount = p.Select(q => q.Id).Count() });
            List<TunnelCountTemp> tempProportion = new List<TunnelCountTemp>();
            if (locationsreturn == null || !locationsreturn.Any())
            {
                result.ResData = string.Join(",", tasktunnelcountlist.OrderBy(p => p.Count).Select(p => p.Tunnel));
            }
            else
            {
                var grouplocationtunnels = (from location in locationsreturn.GroupBy(p => p.Tunnel)
                                            select new TunnelCountTemp
                                            {
                                                Tunnel = location.Key.ToString(),
                                                Count = location.Count(),
                                                Proportion = location.Count() / (shelflocationcount.Where(p => p.Tunnel == location.Key).Any() ? decimal.Parse(shelflocationcount.Where(p => p.Tunnel == location.Key).Sum(p => p.LocationCount).ToString()) : 1)
                                            }).ToList().OrderBy(p => p.Count).ToList();

                foreach (var item in alltunnels)
                {
                    if (!grouplocationtunnels.Where(p => p.Tunnel == item.ToString()).Any())
                    {
                        grouplocationtunnels.Add(new TunnelCountTemp()
                        {
                            Tunnel = item.ToString(),
                            Count = 0,
                            Proportion = 0
                        });
                    }
                }
                tempProportion = grouplocationtunnels;
                grouplocationtunnels = grouplocationtunnels.OrderBy(p => p.Proportion).ToList();
                var sorttunnels = grouplocationtunnels.OrderBy(p => p.Proportion).Select(p => p.Tunnel).ToList();
                for (var i = 0; i < grouplocationtunnels.Count - 1; i++)
                {
                    if (tasktunnelcountlist.Where(p => p.Tunnel == grouplocationtunnels[i].Tunnel).First().Count - threshold > tasktunnelcountlist.Where(p => p.Tunnel == grouplocationtunnels[i + 1].Tunnel).First().Count)
                    {
                        sorttunnels[i] = grouplocationtunnels[i + 1].Tunnel;
                        sorttunnels[i + 1] = grouplocationtunnels[i].Tunnel;
                        i++;
                    }
                    else
                    {
                        sorttunnels[i] = grouplocationtunnels[i].Tunnel;
                    }
                }
                result.ResData = string.Join(",", sorttunnels);
            }
            //删除没有空闲货位的货架
            var arrresultTunnels = result.ResData.Split(',');
            var emptylocationsreturn = _basewarecellrepository.GetList(p => p.WarehouseCode == wcstask.WarehouseCode && p.Floor == reqEntity.Floor && p.Size >= wcstask.Height && p.StateNum == LocationState.LocationState_Empty && p.IsStop == 0);
            var resultTunenls = new List<string>();
            foreach (var sorttunnel in arrresultTunnels)
            {
                //获取巷道的入库任务数
                var tunneltaskcount = runningtasks.Where(p => p.Tunnel == sorttunnel).Count();  //_taskrepository.GetList(p => p.WarehouseCode == wcstask.WarehouseCode && p.Floor == reqEntity.Floor && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.Height >= wcstask.Height && p.Tunnel == wcstask.Tunnel).Count();
                int left = 0;

                if (emptylocationsreturn.Where(p => p.Tunnel == int.Parse(sorttunnel)).Count() - tunneltaskcount > left)
                {
                    resultTunenls.Add(sorttunnel);
                }
                result.ResData = string.Join(",", resultTunenls);
            }

            //已分巷道的按巷道、物料编码分组，凑齐两个物料
            var materTunenls = new List<string>();
            var evenlist = new List<string>();
            foreach (var item in result.ResData.Split(','))
            {
                var ss = runningtasks.Where(p => p.Tunnel == item);
                var code = (from mat in ss.GroupBy(p => p.MatCode)
                            select new MaterCodeItems
                            {
                                MaterCode = mat.Key,
                                Count = mat.Count()
                            }).ToList();

                if (code.Where(p => p.MaterCode == wcstask.MatCode).Any())
                {
                    if (code.Where(p => p.MaterCode == wcstask.MatCode).First().Count % 2 == 1)
                    {
                        materTunenls.Add(item);
                    }
                    else
                    {
                        evenlist.Add(item);
                    }
                }
                else
                {
                    evenlist.Add(item);
                }
            }
            if (materTunenls.Any())
            {
                var tunlist = materTunenls.Union(evenlist).ToList();
                result.ResData = string.Join(",", tunlist);
            }
            else
            {
                result.ResData = string.Join(",", evenlist);
            }

            //每条巷道最多允许存在2组任务
            var MaxtaskcountTunnels = result.ResData.Split(',');
            var tunnellist = new List<string>();
            foreach (var item in MaxtaskcountTunnels)
            {
                if (runningtasks.Where(p => p.Tunnel == item).Count() > 5)
                {
                    continue;
                }
                else
                {
                    tunnellist.Add(item);
                }
                result.ResData = string.Join(",", tunnellist);
            }

            //根据配置过滤禁用的巷道
            var disabletunnels = _sysconfigrepository.GetList(p => p.SType == "InStop" && !string.IsNullOrEmpty(p.SContent) && p.Default2 == reqEntity.Floor.ToString());
            if (disabletunnels != null && disabletunnels.Any())
            {
                var resultTunenlsNew = new List<string>();
                var resultTunenlsTemp = result.ResData.Split(',');
                foreach (var tun in resultTunenlsTemp)
                {
                    if (!disabletunnels.Select(p => p.Default1).Contains(tun))
                    {
                        resultTunenlsNew.Add(tun);
                    }
                }
                result.ResData = string.Join(",", resultTunenlsNew);
            }
            if (!string.IsNullOrEmpty(reqEntity.Memo1))
            {
                if (result.ResData.Contains(reqEntity.Memo1))
                {
                    result.ResData = reqEntity.Memo1;
                }
            }
            result.Memo1 = wcstask.ID.ToString();
            //待检测的优先1-2巷道，检测过的或者不需要检测的优先3-8巷道

            var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == wcstask.BarCode);
            var tunellist = result.ResData.Split(',');
            var tunlen2list = tunellist.Where(p => int.Parse(p) < 4);
            var tunthen2list = tunellist.Where(p => int.Parse(p) >= 4);
            if (stock.IsTorsChk == true && stock.TorsChkQty == 0 && stock.Ovced == 0)
            {
                if (tunlen2list.Any())
                {
                    result.ResData = string.Join(",", tunlen2list);
                }
            }
            else if ((stock.IsTorsChk == true && stock.TorsChkQty == 1) || stock.IsTorsChk == false)
            {
                var torsTunelEnable = _sysconfigrepository.GetFirst(p => p.Code == "TorsTunelEnable");
                //如果扭转任务数量小于20，并且库容量小于0.5的可以使用
                if (torsTunelEnable.SContent == "1" && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.WarehouseCode == wcstask.WarehouseCode && p.Type == TaskType.OutDepot && p.Status < TaskStatus.Finish && p.BusType == "扭转检测").Count() < 20)
                {
                    foreach (var item in tunlen2list.OrderByDescending(p => int.Parse(p)))
                    {
                        if (tempProportion.Where(p => p.Tunnel == item).Any() && tempProportion.Where(p => p.Tunnel == item).First().Proportion < decimal.Parse(torsTunelEnable.Default1))
                        {
                            tunthen2list = tunthen2list.Prepend(item);
                        }
                    }
                }

                if (tunthen2list.Any())
                {
                    result.ResData = string.Join(",", tunthen2list);
                }
                else
                {
                    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    result.ResMsg = reqEntity.Code + "没有可用巷道";
                    return result;
                }
            }

            if (string.IsNullOrEmpty(result.ResData))
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqEntity.Code + "没有可用巷道";
                return result;
            }
            return result;
        }

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<List<ApplyStockInLocResponse>> ApplyStockInLoc(SxApplyStockInLocRequest reqEntity)
        {
            var res = new SRes<List<ApplyStockInLocResponse>>();
            if (reqEntity.Floor == 0 || reqEntity.Floor > 3)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = string.Join(',', reqEntity.TaskNum) + "楼层参数传递错误";
                res.ResData = new List<ApplyStockInLocResponse>();
                return res;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                res.ResCode = ResponseStatusCodeEnum.NotTunnelNum.GetHashCode();
                res.ResMsg = string.Join(',', reqEntity.TaskNum) + ResponseStatusCodeEnum.NotTunnelNum.GetDescription();
                return res;
            }
            if (reqEntity.TaskNum.Count > 2)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "当前申请分配货位的任务数大于2";
                return res;
            }
            if (reqEntity.TaskNum.Count == 0)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "任务号" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            lock (lockerApplyLoc)
            {
                res = reqEntity.ApplyStockInLocTemp(_wcstaskoldrepository, _basewarehouserepository, _billInvnowrepository, _basewarecellrepository, _db, _mapper, _logger);
                if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    if (res.ResData.Any())
                    {
                        _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                        {
                            StateNum = LocationState.LocationState_Empty
                        }, p => res.ResData.Select(p => p.CellNo).Contains(p.Code));
                        _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                        {
                            AddrTo = "",
                            Fork = 0
                        }).Where(p => reqEntity.TaskNum.Contains(p.Id)).SplitTable(p => p.Take(2)).ExecuteCommand();
                        res.ResData = new List<ApplyStockInLocResponse>();
                    }
                    else
                    {
                    }

                    return res;
                }
            }

            return res;
        }

        /// <summary>
        /// 完成出库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> CompleteTask(SxCompleteTaskRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription()
            };
            //var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.AddrTo == reqDto.Equip && p.Status < TaskStatus.Finish && p.Type < TaskType.OutDepot).SplitTable(p => p.Take(2));
            //if (!tasklist.Any())
            //{
            //    result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
            //    result.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
            //    return result;
            //}

            ////处理时效库存
            //var stocklist = _billInvnowrepository.GetList(p => tasklist.Select(p => p.BarCode).ToList().Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
            //if (!stocklist.Any())
            //{
            //    result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
            //    result.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
            //    return result;
            //}
            //var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
            //foreach (var flow in flowlist)
            //{
            //    flow.Id = IdFactory.NewId();
            //    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
            //    flow.AddTime = DateTime.Now;
            //    flow.EditTime = DateTime.Now;
            //    flow.Memo = "码垛装箱完成";
            //}
            //var palletizing = _palletizrepository.GetSingle(p => p.Id == tasklist.First().PalletizingId && p.PalletizState == 0 && p.Equip == reqDto.Equip);
            //if (palletizing == null)
            //{
            //    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            //    result.ResMsg = "没有找到符合条件的码垛信息";
            //    return result;
            //}
            //var pallctdetail = _palletizdetailrepository.GetList(p => p.PalletizingId == palletizing.Id);
            //if (!pallctdetail.Any())
            //{
            //    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            //    result.ResMsg = "未找到码垛明细数据";
            //    return result;
            //}
            ////转向成品

            //try
            //{
            //    _db.BeginTran();
            //    _billInvnowrepository.Delete(p => stocklist.Select(p => p.Id).Contains(p.Id));
            //    _billInvinitrepository.Delete(p => tasklist.Select(p => p.BarCode).ToList().Contains(p.ContGrpBarCode));
            //    _palletizrepository.UpdateSetColumnsTrue(p => new Palletizing()
            //    {
            //        PalletizState = 1
            //    }, p => p.Equip == reqDto.Equip && p.Id == palletizing.Id);
            //    _palletizdetailrepository.Delete(p => p.PalletizingId == palletizing.Id);
            //    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
            //        p => p.StateNum == LocationState.LocationState_StockOut && p.ContGrpId == flowlist.First().ContGrpId && tasklist.Select(p => p.AddrFrom).ToList().Contains(p.Code));
            //    _billInvflow.InsertRange(flowlist);

            //    _db.CommitTran();
            //}
            //catch (Exception ex)
            //{
            //    _db.RollbackTran();
            //    _logger.LogInformation(ex.ToString());
            //    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
            //    result.ResMsg = "完成码垛任务异常";
            //}

            return result;
        }

        /// <summary>
        /// 堆垛机放完
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> SrmCompleted(SxCompleteTaskRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = reqDto.TaskNum
            };

            var wcstask = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == reqDto.TaskNum).SplitTable(tabs => tabs.Take(2)).First(); ;
            if (wcstask == null || wcstask.Id <= 0)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            if (wcstask.Type == TaskType.EnterDepot)
            {
                //库存,货位
                try
                {
                    var warehouse = _basewarehouserepository.GetSingle(p => p.Code == wcstask.WarehouseCode);
                    var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    if (stock == null)
                    {
                        var stocks = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (stocks != null)
                        {
                            return result;
                        }
                        else
                        {
                            result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                            result.ResMsg = wcstask.BarCode + "没有已组盘的信息";
                            return result;
                        }
                    }
                    int row = int.Parse(wcstask.AddrTo.Split('-')[0]);
                    int col = int.Parse(wcstask.AddrTo.Split('-')[1]);
                    int layer = int.Parse(wcstask.AddrTo.Split('-')[2]);
                    int depth = int.Parse(wcstask.AddrTo.Split('-')[4]);

                    _db.BeginTran();
                    //更新库存
                    _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { InvStateCode = InvState.InvEcecState_In.ToString(), PutRow = row, PutCol = col, PutLayer = layer, Depth = depth, OneInTime = DateTime.Now, EditTime = DateTime.Now },
                           p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    //更新货位
                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Full, ContGrpBarCode = stock.ContGrpBarCode, ContGrpId = stock.ContGrpId, EditTime = DateTime.Now },
                           p => p.Row == row && p.Col == col && p.Layer == layer);
                    var stocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                    foreach (var flow in stocklist)
                    {
                        flow.Id = IdFactory.NewId();
                        flow.AddTime = DateTime.Now;
                        flow.EditTime = DateTime.Now;
                        flow.Memo = "入库任务完成";
                    }
                    _billInvflow.InsertRange(_mapper.Map<List<BillInvflow>>(stocklist));
                    //单据
                    var list = new List<BillPushinfo>();

                    string pushtype = SxFackbeekType.InterfaceType_SX_CurtainStockIn.ToString();
                    //回调数据
                    foreach (var push in stocklist)
                    {
                        list.Add(new BillPushinfo
                        {
                            DocsNo = stock.ExecDocsNo,
                            TypeCode = pushtype,
                            RFIDBarCode = stock.ContGrpBarCode,
                            HWBarCode = stock.ContGrpBarCode,
                            CLBarCode = push.CLBarCode,
                            WarehouseId = warehouse.Id,
                            WarehouseCode = warehouse.Code,
                            WareCellId = 0,
                            WareCellCode = wcstask.AddrTo,
                            MatId = push.MatId,
                            MatCode = push.MatCode,
                            MatName = push.MatName,
                            TolWQty = push.TolWQty,
                            NetWQty = push.NetWQty,
                            TareWQty = push.TareWQty,
                            ReqNo = Guid.NewGuid().ToString()
                        });
                    }
                    _billPushinforepository.InsertRange(list);
                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = wcstask.Id + "完成入库任务异常";
                    _logger.LogInformation("完成入库任务异常" + ex.ToString());
                }
            }
            else if (wcstask.Type == TaskType.OutDepot)
            {
                //库存删除
                var stocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                if (stocklist == null || !stocklist.Any())
                {
                    //result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    //result.ResMsg = wcstask.Id + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                    return result;
                }
                var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == wcstask.BarCode && p.StateNum == LocationState.LocationState_StockOut);
                if (cell == null)
                {
                    //result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    //result.ResMsg = wcstask.Id + "货位清除不符合条件";
                    return result;
                }
                var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
                foreach (var flow in flowlist)
                {
                    flow.Id = IdFactory.NewId();
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = "出库任务堆垛机放货完成";
                }
                try
                {
                    _db.BeginTran();
                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                                                                p => p.StateNum == LocationState.LocationState_StockOut && p.Code.Contains(wcstask.AddrFrom));
                    if (wcstask.BusType == SxTaskBusType.TaskBusType_SX_StackStockOut.GetDescription())
                    {
                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            PutRow = 0,
                            PutCol = 0,
                            PutLayer = 0
                        }, p => p.ContGrpBarCode == wcstask.BarCode);
                        var purch = new BillPushinfo()
                        {
                            DocsNo = stocklist.FirstOrDefault().InDocsNo,
                            TypeCode = SxFackbeekType.InterfaceType_SX_CurtainStockOut.ToString(),
                            RFIDBarCode = stocklist.FirstOrDefault().ContGrpBarCode,
                            HWBarCode = stocklist.FirstOrDefault().ContGrpBarCode,
                            CLBarCode = stocklist.FirstOrDefault().CLBarCode,
                            WarehouseId = cell.WarehouseId,
                            WarehouseCode = "sxhouse",
                            WareCellId = cell.Id,
                            WareCellCode = wcstask.AddrFrom,
                            MatId = stocklist.FirstOrDefault().MatId,
                            MatCode = stocklist.FirstOrDefault().MatCode,
                            MatName = stocklist.FirstOrDefault().MatName,
                            TolWQty = stocklist.FirstOrDefault().TolWQty,
                            NetWQty = stocklist.FirstOrDefault().NetWQty,
                            TareWQty = stocklist.FirstOrDefault().TareWQty,
                            ReqNo = Guid.NewGuid().ToString()
                        };
                        _billPushinforepository.Insert(purch);
                    }
                    else if (wcstask.BusType == SxTaskBusType.TaskBusType_SX_ErrorStockOut.GetDescription())
                    {
                        var purch = new BillPushinfo()
                        {
                            DocsNo = stocklist.FirstOrDefault().InDocsNo,
                            TypeCode = SxFackbeekType.InterfaceType_SX_ErrorStockOut.ToString(),
                            RFIDBarCode = stocklist.FirstOrDefault().ContGrpBarCode,
                            HWBarCode = stocklist.FirstOrDefault().ContGrpBarCode,
                            CLBarCode = stocklist.FirstOrDefault().CLBarCode,
                            WarehouseId = cell.WarehouseId,
                            WarehouseCode = "sxhouse",
                            WareCellId = cell.Id,
                            WareCellCode = wcstask.AddrFrom,
                            MatId = stocklist.FirstOrDefault().MatId,
                            MatCode = stocklist.FirstOrDefault().MatCode,
                            MatName = stocklist.FirstOrDefault().MatName,
                            TolWQty = stocklist.FirstOrDefault().TolWQty,
                            NetWQty = stocklist.FirstOrDefault().NetWQty,
                            TareWQty = stocklist.FirstOrDefault().TareWQty,
                            ReqNo = Guid.NewGuid().ToString()
                        };
                        _billPushinforepository.Insert(purch);
                    }
                    else if (wcstask.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription())
                    {
                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            PutRow = 0,
                            PutCol = 0,
                            PutLayer = 0
                        }, p => p.ContGrpBarCode == wcstask.BarCode);
                    }
                    else if (wcstask.BusType == "Test" || wcstask.BusType == "异常出库")
                    {
                        _billInvnowrepository.Delete(p => p.ContGrpBarCode == wcstask.BarCode);
                        _billInvflow.InsertRange(flowlist);
                    }

                    //_taskrepository.Delete(p => p.BarCode == wcstask.BarCode);
                    //_wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld() { Status = TaskStatus.Finish }).Where(p => p.Id == wcstask.Id).SplitTable(p => p.Take(2)).ExecuteCommand();

                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    _logger.LogInformation(ex.ToString());
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = wcstask.Id + "出库任务堆垛机放货完成异常";
                }
            }
            else if (wcstask.Type == TaskType.TransferDepot)
            {
                var fromcell = _basewarecellrepository.GetFirst(p => p.Code == wcstask.AddrFrom);
                if (string.IsNullOrEmpty(fromcell.ContGrpBarCode) || fromcell.ContGrpBarCode != wcstask.BarCode)
                {
                    _logger.LogInformation(wcstask.Id + "移库任务重复完成");
                    return result;
                }
                var grcontid = fromcell.ContGrpId;
                var grcontcode = fromcell.ContGrpBarCode;
                var fromcellno = fromcell.Code;
                var tocellno = wcstask.AddrTo;

                try
                {
                    _db.BeginTran();
                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now }, p => p.Code == fromcellno);
                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Full, ContGrpBarCode = grcontcode, ContGrpId = grcontid, EditTime = DateTime.Now }, p => p.Code == tocellno);

                    int row = int.Parse(tocellno.Split('-')[0]);
                    int col = int.Parse(tocellno.Split('-')[1]);
                    int layer = int.Parse(tocellno.Split('-')[2]);
                    _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { PutRow = row, PutCol = col, PutLayer = layer }, p => p.ContGrpId == grcontid && p.InvStateCode == InvState.InvEcecState_In.ToString());
                    _db.CommitTran();
                    var stock = _billInvnowrepository.GetFirst(p => p.ContGrpId == grcontid && p.ContGrpBarCode == grcontcode && p.InvStateCode == InvState.InvEcecState_In.ToString());

                    //流水表
                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = IdFactory.NewId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = grcontcode + "移库(" + fromcellno + "至" + tocellno + ")";
                    _billInvflow.Insert(flow);
                    //推送表
                    var purch = new BillPushinfo()
                    {
                        DocsNo = stock.InDocsNo,
                        TypeCode = SxFackbeekType.InterfaceType_SX_CellMove.ToString(),
                        RFIDBarCode = stock.ContGrpBarCode,
                        HWBarCode = stock.ContGrpBarCode,
                        CLBarCode = stock.CLBarCode,
                        WarehouseId = fromcell.WarehouseId,
                        WarehouseCode = "sxhouse",
                        WareCellId = 0,
                        WareCellCode = wcstask.AddrFrom,
                        RodBarCode = wcstask.AddrTo,
                        MatId = stock.MatId,
                        MatCode = stock.MatCode,
                        MatName = stock.MatName,
                        TolWQty = stock.TolWQty,
                        NetWQty = stock.NetWQty,
                        TareWQty = stock.TareWQty,
                        ReqNo = Guid.NewGuid().ToString()
                    };
                    _billPushinforepository.Insert(purch);
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = wcstask.Id + "完成移库任务异常";
                    _logger.LogInformation("完成移库任务异常" + ex.ToString());
                }
            }

            return result;
        }

        /// <summary>
        /// 完成码垛任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> CompletePalletizingTask(SxPalletizingCompleteRequest reqDto)
        {
            var res = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription()
            };

            var palletizing = _palletizrepository.GetFirst(p => p.PalletizState == 0 && p.Equip == reqDto.Equip);
            if (palletizing == null)
            {
                //兼容wcs任务没有清掉的情况
                var lefttask = _taskrepository.GetFirst(p => p.AddrTo == reqDto.Equip && p.Status == TaskStatus.码垛抓取完成);
                if (lefttask != null)
                {
                    var pazid = lefttask.PalletizingId;
                    if (_palletizrepository.IsAny(p => p.Id == pazid && p.PalletizState == 1) && !_palletizdetailrepository.IsAny(p => p.PalletizingId == pazid) && !_palletlayerMathrepository.IsAny(p => p.PalletizingId == pazid))
                    {
                        res.Memo1 = lefttask.PalletizingId.ToString();
                        res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                        return res;
                    }
                }

                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.Equip + "没有找到正在码垛的信息";
                return res;
            }

            var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.PalletizingId == palletizing.Id && p.AddrTo == reqDto.Equip && p.Status < TaskStatus.Finish && p.Type == TaskType.OutDepot).SplitTable(p => p.Take(2)).ToList();
            if (!tasklist.Any())
            {
                //兼容wcs任务没有清掉的情况
                var lefttask = _taskrepository.GetFirst(p => p.AddrTo == reqDto.Equip && p.Status == TaskStatus.码垛抓取完成);
                if (lefttask != null)
                {
                    var pazid = lefttask.PalletizingId;
                    if (_palletizrepository.IsAny(p => p.Id == pazid && p.PalletizState == 1) && !_palletizdetailrepository.IsAny(p => p.PalletizingId == pazid) && !_palletlayerMathrepository.IsAny(p => p.PalletizingId == pazid))
                    {
                        res.Memo1 = lefttask.PalletizingId.ToString();
                        res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                        return res;
                    }
                }

                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = reqDto.Equip + "不存在该码垛工位的出库任务";
                return res;
            }
            //处理时效库存
            var stocklist = _billInvnowrepository.GetList(p => tasklist.Select(p => p.BarCode).ToList().Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
            if (!stocklist.Any())
            {
                if (!_palletizrepository.IsAny(p => p.Equip == reqDto.Equip && p.PalletizState == 0))
                {
                    return res;
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                    return res;
                }
            }

            var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
            foreach (var flow in flowlist)
            {
                flow.Id = IdFactory.NewId();
                flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.Memo = "码垛装箱完成";
            }

            var pallctdetail = _palletizdetailrepository.GetList(p => p.PalletizingId == palletizing.Id);
            if (!pallctdetail.Any())
            {
                //兼容wcs任务没有清掉的情况
                var lefttask = _taskrepository.GetFirst(p => p.AddrTo == reqDto.Equip && p.Status == TaskStatus.码垛抓取完成);
                if (lefttask != null)
                {
                    var pazid = lefttask.PalletizingId;
                    if (_palletizrepository.IsAny(p => p.Id == pazid && p.PalletizState == 1) && !_palletizdetailrepository.IsAny(p => p.PalletizingId == pazid) && !_palletlayerMathrepository.IsAny(p => p.PalletizingId == pazid))
                    {
                        res.Memo1 = lefttask.PalletizingId.ToString();
                        res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                        return res;
                    }
                }

                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.Equip + "未找到码垛明细数据";
                return res;
            }
            if (palletizing.Finish == 0)
            {
                if (palletizing.PalletMax != pallctdetail.Count)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = reqDto.Equip + "已码数量不符最大码垛数量";
                    return res;
                }
            }
            var boxcode = _boxrulerepository.GetSingle(p => p.Id == palletizing.BoxRuleId && p.ZXStateCode != 2);
            if (boxcode == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.Equip + "跺型未找到关联的装箱信息";
                return res;
            }
            var packinfo = _packInforepository.GetList(p => p.MatCode == boxcode.TrayCode).First();
            var packlist = _packInforepository.GetList(p => p.PackCode == boxcode.Dryer);
            decimal wqty = boxcode.BaoCaiWeight;
            if (wqty == null || wqty <= 0)
            {
                wqty = TuoPan + SuLiaoDai + GeBan + ZhiXiang;
            }
            //if (packlist.Any())
            //{
            //    decimal tuopanqty = 0;
            //    decimal packsqty = 0;
            //    decimal dituoqty = 0;
            //    decimal gebanqty = 0;
            //    if (packlist.Any(p => p.MatCode == "C06-02-09-0043"))
            //    {
            //        var tuopan = packlist.Where(p => p.MatCode == "C06-02-09-0043").FirstOrDefault();
            //        tuopanqty = tuopan.Count * tuopan.Weight / 1000;
            //    }
            //    if (packlist.Any(p => p.MatCode == "C12-01-08-0004"))
            //    {
            //        var packs = packlist.Where(p => p.MatCode == "C12-01-08-0004").FirstOrDefault();
            //        packsqty = packs.Count * packs.Weight / 1000;
            //    }
            //    if (packlist.Any(p => p.MatCode == "C12-01-10-0003"))
            //    {
            //        var dituo = packlist.Where(p => p.MatCode == "C12-01-10-0003").FirstOrDefault();
            //        dituoqty = dituo.Count * dituo.Weight / 1000;
            //    }
            //    if (packlist.Any(p => p.MatCode == "C12-01-09-0003"))
            //    {
            //        var geban = packlist.Where(p => p.MatCode == "C12-01-09-0003").FirstOrDefault();
            //        gebanqty = 1 * geban.Weight / 1000;
            //    }
            //    wqty = tuopanqty + packsqty + dituoqty + gebanqty;
            //}
            //if (wqty == 0)
            //{
            //    wqty = 16;
            //}

            //判断托盘号是否一致
            //var wcstask = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == palletizing.TaskNum).SplitTable(tabs => tabs.Take(2)).First(); ;
            //if (wcstask == null)
            //{
            //    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
            //    res.ResMsg = reqDto.Equip + "码垛主表的托盘任务id不存在任务信息";
            //    return res;
            //}
            var tray = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code = " + palletizing.Equip).First();

            //if (wcstask.BarCode != tray.Code)
            //{
            //    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
            //    res.ResMsg = reqDto.Equip + "托盘号不匹配";
            //    return res;
            //}

            //转向成品
            var info = _mapper.Map<List<PalletinfoDetail>>(pallctdetail);
            info.ForEach(p => p.HuNr = boxcode.PBoxCode);
            var product = new PalletBoxCodeinfoRequest()
            {
                TaskNum = palletizing.TaskNum,
                Equip = tray.Code,
                BoxCode = boxcode.PBoxCode,
                TrayCode = tray.SContent,
                HwType = stocklist.First().HWTypeCode,
                TrayType = packinfo.MatName,
                Wqty = wqty,
                PackWeight = boxcode.PackWeight,
                list = info
            };
            try
            {
                var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/PalletAutoInTask", JsonConvert.SerializeObject(product));
                var resp = JsonConvert.DeserializeObject<SRes>(response);
                if (resp.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    res.ResCode = resp.ResCode;
                    res.ResMsg = reqDto.Equip + resp.ResMsg;
                    return res;
                }
                _db.BeginTran();
                _billInvnowrepository.Delete(p => stocklist.Select(p => p.Id).Contains(p.Id));
                _billInvinitrepository.Delete(p => tasklist.Select(p => p.BarCode).ToList().Contains(p.ContGrpBarCode));
                _palletlayerMathrepository.Delete(p => p.PboxruleId == boxcode.Id);
                _palletizrepository.AsUpdateable()
                    .SetColumns(p => new Palletizing() { PalletizState = 1, EditTime = DateTime.Now })
                    .Where(p => p.Equip == reqDto.Equip && p.Id == palletizing.Id)
                    .ExecuteCommand();

                _palletizrepository.AsUpdateable()
                .SetColumns(p => new Palletizing() { PalletizState = 0 })
                .Where(p => p.Equip == reqDto.Equip && p.PalletizState == 2)
                .ExecuteCommand();
                //_palletizrepository.UpdateSetColumnsTrue(p => new Palletizing()
                //{
                //    PalletizState = 0
                //}, p => p.Equip == reqDto.Equip && p.PalletizState == 2);
                _boxrulerepository.AsUpdateable().SetColumns(p => new BillPboxrule() { ZXStateCode = 2, EditTime = DateTime.Now }).Where(p => p.Id == boxcode.Id).ExecuteCommand();
                _palletizdetailrepository.Delete(p => p.PalletizingId == palletizing.Id);
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                    p => p.StateNum == LocationState.LocationState_StockOut && p.ContGrpId == flowlist.First().ContGrpId && tasklist.Select(p => p.AddrFrom).ToList().Contains(p.Code));
                _billInvflow.InsertRange(flowlist);
                //_boxrulerepository.Delete(p => p.Id == boxcode.Id);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
                res.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                res.ResMsg = "完成码垛任务异常" + ex.Message;
            }
            return res;
        }

        /// <summary>
        /// 码垛层配装箱出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PalletizingLayerPackStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "CP");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    if (tasklist.Any())
                    {
                        continue;
                    }

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip);

                    if (equips == null)
                    {
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 0 && p.PboxruleId == item.BoxRuleId).OrderBy(p => p.Layer);
                    if (!palletMach.Any())
                    {
                        continue;
                    }
                    //var layers = (from aa in match.GroupBy(p => p.Layer)
                    //             select new LayerCount
                    //             {
                    //                 Layer = aa.Key,
                    //                 Count = aa.Count()
                    //             }).ToList();

                    #region 分层出库

                    if (palletMach.Where(p => p.Layer == 1).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 1);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else if (palletMach.Where(p => p.Layer == 2).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 2);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else if (palletMach.Where(p => p.Layer == 3).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 3);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else if (palletMach.Where(p => p.Layer == 4).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 4);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else if (palletMach.Where(p => p.Layer == 5).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 5);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else if (palletMach.Where(p => p.Layer == 6).Any())
                    {
                        var pallectMachs = palletMach.Where(p => p.Layer == 6);
                        foreach (var pallets in pallectMachs)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = invs.SkuCode,
                                PalletLayer = pallets.Layer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }

                    #endregion 分层出库
                }
            }
            var palletLayerList = _palletizrepository.GetList(p => p.PalletizState != 1 && p.BoxRule == "CP");
            if (palletLayerList.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "已有层配装箱任务";
                return res;
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            equiplist = equiplist.GetAvailablePalletizingStationsByConfiguration(_sysconfigrepository, "CP_Palletizing");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            //var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            //var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            var devices = new List<DevincePh>() { new DevincePh() { deviceCode = "8019", pH_STATUS = true }, new DevincePh() { deviceCode = "8011", pH_STATUS = true }, new DevincePh() { deviceCode = "8003", pH_STATUS = true } };
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            devices = devices.Where(p => p.pH_STATUS == true).ToList();

            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Grade == "A" && p.IsTorsChk == true && p.TorsChkQty > 0 && string.IsNullOrEmpty(p.PreStock)
                          && p.TorsChkChordIsGood == "OK" && p.TorsChkFlatnessIsGood == "OK" && p.TorsChkValueIsGood == "OK" && p.ContUsageQty <= 0)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          join rule1 in _boxrulerepository.GetList(p => p.ZXStateCode == 0 && p.PackRule == "CP")
                          on stock.InDocsNo equals rule1.DocsNo
                          select new
                          {
                              stock.MatCode,
                              stock.InvBarCode,
                              stock.Grade,
                              stock.InvStateCode,
                              stock.ProductTime,
                              stock.WbGroupCode,
                              stock.IsTorsChk,
                              stock.TorsChkQty,
                              stock.TorsChkValue,
                              stock.HoldTime,
                              stock.ProductMachCode,
                              stock.IsRework,
                              stock.IsBlack,
                              stock.SolderCount,
                              stock.HWTypeCode,
                              stock.TorsChkChord,
                              stock.TorsChkFlatness,
                              loc.Col,
                              loc.Layer,
                              loc.Shelf,
                              loc.Depth,
                              loc.Code,
                              loc.Tunnel,
                              loc.SCRel,
                              loc.Floor,
                              loc.WarehouseCode,
                              loc.ContGrpBarCode,
                              loc.ContGrpId,
                              loc.Id,
                              loc.StateNum,
                              rule1.SkuCode
                          };
            if (!invlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var invlist2 = invlist;
            var sku = invlist.GroupBy(p => p.SkuCode).ToList();
            if (!sku.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库中没有SKU或SKU不能为空";
                return res;
            }
            var rulelist = _boxrulerepository.GetList(p => p.ZXStateCode == 0 && p.PackRule == "CP");
            if (!rulelist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.NotBoxRule.GetHashCode();
                res.ResMsg = "层配装箱" + ResponseStatusCodeEnum.NotBoxRule.GetDescription();
                return res;
            }
            foreach (var item in sku)
            {
                var rules = rulelist.Where(p => p.SkuCode == item.Key && p.ZXStateCode == 0 && p.PackRule == "CP").OrderBy(p => p.AddTime);
                if (!rules.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"没有可用箱号,SKU:{item.Key}";
                    continue;
                }
                foreach (var rule in rules)
                {
                    var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
                    List<string> equips = new List<string>();
                    foreach (var pp in sys)
                    {
                        if (pp.SContent.Split(",").Contains(rule.TrayCode))
                        {
                            equips.Add(pp.Code);
                        }
                    }
                    if (!equips.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut10", new RedisErrorInfo() { Equip = "NoControlOut10", Con = rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码", Time = DateTime.Now });
                        _logger.LogInformation(rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码");
                        //自动更新子托盘配置
                        foreach (var item1 in sys)
                        {
                            if (!item1.SContent.Contains(rule.TrayCode))
                            {
                                string con = item1.SContent + "," + rule.TrayCode;
                                _sysconfigrepository.AsUpdateable()
                                    .SetColumns(p => new sxSysConfig() { SContent = con })
                                    .Where(p => p.Id == item1.Id)
                                    .ExecuteCommand();
                            }
                        }
                    }

                    var dev = devices.Where(p => sys.Select(p => p.Code).Contains(p.deviceCode)).ToList();
                    if (!dev.Any())
                    {
                        //_logger.LogInformation(rule.TrayCode + "没有可用拆盘机");
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"没有可用拆盘机,SKU:{item.Key},箱号:{rule.PBoxCode}";
                        continue;
                    }
                    var wbgrouplist = invlist.Where(p => p.SkuCode == rule.SkuCode).GroupBy(p => p.WbGroupCode);
                    if (!wbgrouplist.Any())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"不存在可用SKU产品,SKU:{item.Key},箱号:{rule.PBoxCode}";
                        continue;
                    }
                    foreach (var wbgroup in wbgrouplist)
                    {
                        invlist2 = invlist.Where(p => p.SkuCode == item.Key && p.WbGroupCode == wbgroup.Key && p.HWTypeCode == rule.SpoolType);
                        if (invlist2.Any() && invlist2.Count() >= rule.FullCountQty)
                        {
                            break;
                        }
                    }

                    //焊点、返工盘、黑盘一些基本属性筛选
                    if (!string.IsNullOrEmpty(rule.SpoolType))
                    {
                        invlist2 = invlist2.Where(p => p.HWTypeCode == rule.SpoolType);
                    }

                    if (rule.PerSolderMaxCount > 0)  //允许焊点盘
                    {
                        var tt = invlist2.Where(p => p.SolderCount <= rule.PerSolderMaxCount).OrderByDescending(p => p.SolderCount).Take(rule.SolderMaxCount);
                        invlist2 = tt.Union(invlist2.Where(p => p.SolderCount == 0));
                    }
                    else
                    {
                        //不允许焊点盘
                        invlist2 = invlist2.Where(p => p.SolderCount == 0);
                    }
                    if (rule.ReturnCount > 0)
                    {
                        var tt = invlist2.Where(p => p.IsRework == true).Take(rule.ReturnCount);
                        invlist2 = tt.Union(invlist2);
                    }
                    else
                    {
                        invlist2 = invlist2.Where(p => p.IsRework == false);
                    }
                    //黑盘
                    if (rule.SpoolType == "BS60" || rule.SpoolType == "BS40")
                    {
                        rule.BlackCount = 3;
                    }
                    else
                    {
                        rule.BlackCount = 1;
                    }
                    if (rule.BlackCount > 0)
                    {
                        var tt = invlist2.Where(p => p.IsBlack == true).Take(rule.BlackCount);
                        invlist2 = tt.Union(invlist2);
                    }
                    else
                    {
                        invlist2 = invlist2.Where(p => p.IsBlack == false);
                    }

                    if (!invlist2.Any())
                    {
                        continue;
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    //if (invlist2.Count() < rule.FullCountQty)
                    //{
                    //    continue;
                    //}
                    int layer = rule.FullCountQty / 12;
                    int num = 12;

                    #region 计算扭转层工字轮

                    for (int i = 0; i < layer; i++)
                    {
                        #region 计算扭转

                        var torslist = invlist2.OrderBy(p => p.ProductTime).ToList().GetRange(0, num);
                        if (Math.Abs((decimal)(rule.Torsion48Qty - torslist.Average(p => p.TorsChkValue))) < rule.TorsionErrRange)
                        {
                            //barcode.AddRange(torslist.Select(p => p.ContGrpBarCode));

                            #region 记录码垛的每层工字轮明细

                            foreach (var palletla in torslist)
                            {
                                var palletlayer = new PalletLayerMath()
                                {
                                    ContGrpId = (long)palletla.ContGrpId,
                                    ContBarCode = palletla.ContGrpBarCode,
                                    Layer = i + 1,
                                    SkuCode = palletla.SkuCode,
                                    Finish = 0,
                                    PboxruleId = rule.Id,
                                    Istask = 0,
                                    Palletequip = palletequip.Code
                                };

                                _palletlayerMathrepository.Insert(palletlayer);
                            }

                            #endregion 记录码垛的每层工字轮明细

                            invlist2 = invlist2.Except(torslist);
                        }
                        else
                        {
                            //记下头尾元素
                            var start = torslist.First();
                            var end = torslist.Last();
                            List<string> code = new List<string>() { start.ContGrpBarCode, end.ContGrpBarCode };
                            //去掉头尾
                            torslist = torslist.Skip(1).Take(torslist.Count - 2).ToList();
                            //追加两个筹齐12个重新计算
                            torslist.AddRange(invlist2.Where(p => !code.Contains(p.ContGrpBarCode)).OrderBy(p => p.ProductTime).Take(2));
                            if (Math.Abs((decimal)(rule.Torsion48Qty - torslist.Average(p => p.TorsChkValue))) < rule.TorsionErrRange)
                            {
                                //barcode.AddRange(torslist.Select(p => p.ContGrpBarCode));

                                #region 记录码垛的每层工字轮明细

                                foreach (var palletla in torslist)
                                {
                                    var palletlayer = new PalletLayerMath()
                                    {
                                        ContGrpId = (long)palletla.ContGrpId,
                                        ContBarCode = palletla.ContGrpBarCode,
                                        Layer = i + 1,
                                        SkuCode = palletla.SkuCode,
                                        Finish = 0,
                                        PboxruleId = rule.Id,
                                        Istask = 0,
                                        Palletequip = palletequip.Code
                                    };

                                    _palletlayerMathrepository.Insert(palletlayer);
                                }

                                #endregion 记录码垛的每层工字轮明细

                                invlist2 = invlist2.Except(torslist);
                            }
                        }

                        #endregion 计算扭转
                    }

                    #endregion 计算扭转层工字轮

                    var palletCodelist = _palletlayerMathrepository.GetList(p => p.PboxruleId == rule.Id);
                    if (!palletCodelist.Any())
                    {
                        continue;
                    }
                    if (palletCodelist.Count != rule.FullCountQty)
                    {
                        _palletlayerMathrepository.Delete(p => p.PboxruleId == rule.Id);
                        continue;
                    }
                    var palletCode = palletCodelist.OrderBy(p => p.Layer).Take(12);

                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = rule.TrayCode, WareHouse = "cphouse", Equip = palletequip.Code, Start = dev.First().deviceCode };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        return res;
                    }
                    var pallet = new Palletizing()
                    {
                        PalletMax = rule.FullCountQty,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rule.PackRule,
                        BoxRuleId = rule.Id,
                        IsControlpanel = true,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                    {
                        ZXStateCode = 1
                    }, p => p.Id == rule.Id);

                    foreach (var code in palletCode)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var inv = invlist2.Where(p => p.ContGrpBarCode == code.ContBarCode && p.ContGrpId == code.ContGrpId).First();
                        var root = DetermineRoot(palletequip.Code);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }
                        PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContBarCode,
                            Equip = pallects.Equip,
                            Mater = inv.MatCode,
                            Srm = inv.SCRel,
                            PalletLayer = code.Layer,
                            Grade = inv.Grade,
                            Tunnel = inv.Tunnel.ToString(),
                            CellCode = inv.Code,
                            SkuCode = rule.SkuCode,
                            ProductMachCode = inv.ProductMachCode,
                            Floor = inv.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2
                        });
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1
                        }, p => p.ContBarCode == code.ContBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        /// <summary>
        /// 层配装箱预锁库存
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PreLockInventoryForLayerPacking(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            try
            {
                // 1. 验证预占箱数
                var validationResult = SxPackingHelp.ValidatePreBoxCount(_sysconfigrepository, _boxrulerepository);
                if (!validationResult.IsSuccess)
                {
                    return new SRes { ResMsg = validationResult.Message };
                }
                var sxLayerPackingHelp = new SxLayerPackingHelp(_basewarecellrepository,
                  _billInvnowrepository, _boxrulerepository, _sysconfigrepository,
                  _timeoutrecord, _logger, _palletlayerMathrepository, _billInvflow,
                  _wcstaskoldrepository, _basewarehouserepository, _taskdetailrepository,
                  _taskrepository, _palletizrepository, _db, _mapper, lockerPalletizingPackTask, lockerApplyLoc);

                // 2. 获取可用库存
                var inventory = sxLayerPackingHelp.GetAvailableInventory();
                if (!inventory.Any())
                {
                    _logger.LogError("库存不足");
                    RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut6", new RedisErrorInfo { Equip = "NoControlOut6", Con = "层配盘库存不足", Time = DateTime.Now });
                    return new SRes { ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(), ResMsg = "库存不足" };
                }

                // 3. 获取可用箱号规则
                var boxRules = SxPackingHelp.GetAvailableBoxRules("CP", _boxrulerepository);
                if (!boxRules.Any())
                {
                    return sxLayerPackingHelp.HandleNoBoxRuleError(inventory);
                }

                // 4. 按SKU分组处理
                var skuGroups = inventory.OrderBy(p => p.ProductTime).GroupBy(p => p.SkuCode).ToList();

                foreach (var skuGroup in skuGroups)
                {
                    var result = sxLayerPackingHelp.ProcessSkuGroup(skuGroup, boxRules, inventory);
                    if (result.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        return result;
                    }
                    else
                    {
                        res.ResMsg += $"[{skuGroup.Key}:[{result.ResMsg}]]";
                    }
                }
            }
            catch (Exception ex)
            {
                return new SRes { ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(), ResMsg = ex.Message + ":" + ex.StackTrace };
            }
            return res;
        }

        /// <summary>
        /// 层配装箱出库及缓存托盘
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes ProcessLayerPackingOutboundAndCachePallets(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "CP" && p.IsControlpanel == false);
            if (palletlist.Any())
            {
                var maxtaskStemp = _palletlayerMathrepository.GetList(p => p.Istask == 0 && palletlist.Select(p => p.Id).Contains(p.PalletizingId)).GroupBy(p => p.Palletequip);
                if (maxtaskStemp.Any())
                {
                    var maxtaskcount = (from tas in maxtaskStemp
                                        select new TunnelCountTemp()
                                        {
                                            Tunnel = tas.Key,
                                            Count = tas.Count()
                                        }).ToList();
                    palletlist = palletlist.OrderByDescending(p => maxtaskcount.Where(q => q.Tunnel == p.Equip).Any() ? maxtaskcount.Where(q => q.Tunnel == p.Equip).FirstOrDefault().Count : 0).ToList();
                }
                //箱之间状态卡控限制标识
                TaskStatus taskstatus = (TaskStatus)int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskStatus").SContent);
                //某个机械手最大下发的限制状态任务数量
                int robotmaxtaskcount = int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskCount").SContent);
                int robotMaxLayerCount = 5;
                foreach (var item in palletlist)
                {
                    //判断任务数量
                    if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Status < TaskStatus.码垛抓取完成 && p.Robot == item.Robot && p.BusType == "装箱码垛").Count() >= robotmaxtaskcount)
                    {
                        _logger.LogInformation(item.Robot + "当前机械手任务数量已经超最大值" + robotmaxtaskcount);
                        continue;
                    }

                    //找到当前机械手较早的码垛信息，然后判断是否已经过了某个点
                    var prepalletid = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).FirstOrDefault().Id;
                    if (item.Id != prepalletid)//不是靠前的那一码垛信息
                    {
                        //判断是不是第3箱

                        //判断是否是第三箱
                        if (_palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).Count >= 3)
                        {
                            var thirdbox = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).Take(3).Last().Id;
                            if (item.Id == thirdbox)//第3箱子
                            {
                                if (_palletlayerMathrepository.GetList(p => p.PalletizingId == prepalletid && p.Istask == 0).Any() || _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == prepalletid && p.Status < taskstatus).Any())
                                {
                                    _logger.LogInformation("第3箱卡控同一机械手最早的箱子的码垛任务没有全部过卡控点" + taskstatus.GetDescription());
                                    continue;
                                }
                                //判断前两箱子如果都是同一目标地址，那么第三箱也不要下
                                var pre2list = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot && p.Id < thirdbox);
                                if (pre2list.Count == 2 && pre2list.Select(p => p.Equip).Distinct().Count() == 1)
                                {
                                    _logger.LogInformation("第3箱卡控同一机械手前面两箱都是同一目标地址，则不下第3箱任务" + taskstatus.GetDescription());
                                    continue;
                                }
                            }
                            else if (item.Id > thirdbox)
                            {
                                _logger.LogInformation("同一机械手第3箱之后的任务不允许下发，码垛主表id：" + item.Id);
                                continue;
                            }
                        }
                    }

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut2", new RedisErrorInfo() { Equip = "NoControlOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }

                    // 判断层数是否超出限制
                    // 获取当前机械手正在处理的任务中涉及的层数
                    var currentProcessingLayers = _taskrepository.AsQueryable()
                        .With(SqlWith.NoLock)
                        .Where(p => p.Status < TaskStatus.码垛抓取完成 &&
                               p.Robot == item.Robot &&
                               p.BusType == "装箱码垛")
                        .Select(p => new { PalletizingId = p.PalletizingId, Layer = p.Layer })
                        .Distinct()
                        .Count();
                    //判断层是否超出限制
                    if (currentProcessingLayers >= robotMaxLayerCount)
                    {
                        _logger.LogInformation($"{item.Robot} 当前机械手正在处理的层数已达到最大值 {robotMaxLayerCount}");
                        continue;
                    }

                    var availableLayer = robotMaxLayerCount - currentProcessingLayers;
                    var availableTaskCount = availableLayer * 12;

                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(x => x.Layer).ThenBy(x => x.Depth).Take(availableTaskCount);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut3", new RedisErrorInfo() { Equip = "NoControlOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }

                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut23", new RedisErrorInfo() { Equip = "NoControlOut23", Con = cell.Code + "库位下发移库任务失败，请检查一深货位状态", Time = DateTime.Now });
                                _logger.LogInformation(cell.Code + "库位下发移库任务失败，请检查一深货位状态");
                                continue;
                            }
                        }
                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = invs.PackingLayer,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                    //下完任务后将标识值加1
                    var taskflag = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == item.Robot).Max(p => p.TaskFlag);
                    taskflag = taskflag + 1;
                    _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set taskflag=" + taskflag + " where code='" + item.Equip + "'");
                }
            }

            //待码垛箱任务下发
            var palletlisttobe = _palletizrepository.GetList(p => p.PalletizState == 2 && p.BoxRule == "CP" && p.IsControlpanel == false);
            if (palletlisttobe.Any())
            {
                foreach (var item in palletlisttobe.OrderBy(p => p.Id))
                {
                    //判断当前工位有没有正在码垛的，没的话，则把待码垛的更新成正在码垛的
                    if (!_palletizrepository.GetList(p => p.PalletizState == 0 && p.Equip == item.Equip).Any())
                    {
                        _palletizrepository.AsUpdateable()
                       .SetColumns(p => new Palletizing() { PalletizState = 0 })
                       .Where(p => p.Id == item.Id)
                       .ExecuteCommand();
                    }

                    var temppalletlist = _palletizrepository.GetList(p => p.PalletizState == 0);

                    if (temppalletlist.Where(p => p.Robot == item.Robot).Any())
                    {
                        List<long> mdtempequiplist = temppalletlist.Where(p => p.Robot == item.Robot).Select(p => p.Id).ToList();
                        //判断当前机械手正在码垛的两个工位任务都已经下发完成
                        if (_palletlayerMathrepository.GetList(p => mdtempequiplist.Contains(p.PalletizingId) && p.Istask == 0).Any())
                        {
                            _logger.LogInformation(item.Robot + "正在码垛的任务没有下完，不允许下发待码垛任务");
                            continue;
                        }
                        //箱之间状态卡控限制标识
                        TaskStatus taskstatus = (TaskStatus)int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskStatus").SContent);
                        //判断任务数量
                        int robotmaxtaskcount = int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskCount").SContent);
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Status < TaskStatus.码垛抓取完成 && p.Robot == item.Robot && p.BusType == "装箱码垛").Count() >= robotmaxtaskcount)
                        {
                            _logger.LogInformation(item.Robot + "当前机械手任务数量已经超最大值" + robotmaxtaskcount);
                            continue;
                        }
                        //var curpalletid = temppalletlist.Where(p => p.Equip == item.Equip).First().Id;
                        var robotMaxLayerCount = 5;
                        if (!_palletlayerMathrepository.GetList(p => mdtempequiplist.Contains(p.PalletizingId) && p.Istask == 0).Any())// && !_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => mdtempequiplist.Contains(p.PalletizingId) && p.Status < taskstatus).Any()
                        {
                            //判断是否是第三箱
                            if (_palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).Count >= 3)
                            {
                                var prepalletid = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).FirstOrDefault().Id;
                                var thirdbox = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).Take(3).Last().Id;
                                if (item.Id == thirdbox)//第3箱子
                                {
                                    if (_palletlayerMathrepository.GetList(p => p.PalletizingId == prepalletid && p.Istask == 0).Any() || _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == prepalletid && p.Status < taskstatus).Any())
                                    {
                                        _logger.LogInformation("第3箱卡控同一机械手最早的箱子的码垛任务没有全部过卡控点" + taskstatus.GetDescription());
                                        continue;
                                    }
                                    //判断前两箱子如果都是同一目标地址，那么第三箱也不要下
                                    var pre2list = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot && p.Id < thirdbox);
                                    if (pre2list.Count == 2 && pre2list.Select(p => p.Equip).Distinct().Count() == 1)
                                    {
                                        _logger.LogInformation("第3箱卡控同一机械手前面两箱都是同一目标地址，则不下第3箱任务" + taskstatus.GetDescription());
                                        continue;
                                    }
                                }
                                else if (item.Id > thirdbox)
                                {
                                    _logger.LogInformation("同一机械手第3箱之后的待码垛任务不允许下发，码垛主表id：" + item.Id);
                                    continue;
                                }
                            }

                            int takecount = int.Parse(AppSettings.GetConfig("FloorCount"));
                            if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == item.Id).Count() < takecount)
                            {
                                // 判断层数是否超出限制
                                // 获取当前机械手正在处理的任务中涉及的层数
                                var currentProcessingLayers = _taskrepository.AsQueryable()
                                    .With(SqlWith.NoLock)
                                    .Where(p => p.Status < TaskStatus.码垛抓取完成 &&
                                           p.Robot == item.Robot &&
                                           p.BusType == "装箱码垛")
                                    .Select(p => new { PalletizingId = p.PalletizingId, Layer = p.Layer })
                                    .Distinct()
                                    .Count();
                                //判断层是否超出限制
                                if (currentProcessingLayers >= robotMaxLayerCount)
                                {
                                    _logger.LogInformation($"{item.Robot} 当前机械手正在处理的层数已达到最大值 {robotMaxLayerCount}");
                                    continue;
                                }

                                var availableLayer = robotMaxLayerCount - currentProcessingLayers;
                                var availableTaskCount = availableLayer * 12;

                                var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(x => x.Layer).ThenBy(x => x.Depth).Take(availableTaskCount);
                                if (!palletMach.Any())
                                {
                                    RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut3", new RedisErrorInfo() { Equip = "NoControlOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                                    continue;
                                }

                                var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                                var curdocid = maxdocid + 1;
                                if (palletMach.Any())
                                {
                                    var pid = palletMach.First().PalletizingId;
                                    if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                                    {
                                        curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                                    }
                                }

                                foreach (var pallets in palletMach)
                                {
                                    var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                                    if (cell == null)
                                    {
                                        continue;
                                    }
                                    var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                                    if (invs == null)
                                    {
                                        continue;
                                    }
                                    var root = DetermineRoot(pallets.Palletequip);

                                    //先判断二升位是否能出库
                                    if (cell.Depth == 2)
                                    {
                                        var respon = MoveTask(cell.Code);
                                        if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                        {
                                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut23", new RedisErrorInfo() { Equip = "NoControlOut23", Con = cell.Code + "库位下发移库任务失败，请检查一深货位状态", Time = DateTime.Now });
                                            _logger.LogInformation(cell.Code + "库位下发移库任务失败，请检查一深货位状态");
                                            continue;
                                        }
                                    }
                                    var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                                    {
                                        Code = pallets.ContBarCode,
                                        CellCode = cell.Code,
                                        Srm = cell.SCRel,
                                        Tunnel = cell.Tunnel.ToString(),
                                        Floor = cell.Floor,
                                        Grade = invs.Grade,
                                        Mater = invs.MatCode,
                                        SkuCode = pallets.SkuCode,
                                        PalletLayer = invs.PackingLayer,
                                        ProductMachCode = invs.ProductMachCode,
                                        Equip = item.Equip,
                                        PalletizingId = item.Id,
                                        Robot = root,
                                        GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                                        DocId = curdocid
                                    });
                                    if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                                    {
                                        continue;
                                    }
                                    _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                                    {
                                        Istask = 1,
                                        Layer = 0
                                    }, p => p.ContBarCode == invs.ContGrpBarCode);
                                }
                                //下完任务后将标识值加1
                                var taskflag = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == item.Robot).Max(p => p.TaskFlag);
                                taskflag = taskflag + 1;
                                _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set taskflag=" + taskflag + " where code='" + item.Equip + "'");
                            }
                        }
                    }
                    else
                    {
                        _palletizrepository.AsUpdateable()
                         .SetColumns(p => new Palletizing() { PalletizState = 0 })
                         .Where(p => p.Id == item.Id)
                         .ExecuteCommand();
                    }
                }
            }

            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");

            equiplist = equiplist.GetAvailablePalletizingStationsByConfiguration(_sysconfigrepository, "CP_Palletizing");
            var iscontinue = false;
            foreach (var palletequip in equiplist.OrderByDescending(p => p.Default3).ThenBy(p => p.Default1))
            {
                if (string.IsNullOrEmpty(palletequip.Default1))
                {
                    if (!string.IsNullOrEmpty(palletequip.Default3))//Default3是绑定的托盘搬运任务的id，对应预锁库存标识
                    {
                        //根据码垛工位找任务，找到则下任务，找不到则继续执行
                        var preinvlist = _billInvnowrepository.GetList(p => p.BomMatCode == palletequip.Default3 && p.BomSetId == 0 && p.PreStock == "1" && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (preinvlist.Any())
                        {
                            //机械手交叉下任务需求,上一个码垛信息是该工位的，则跳过
                            if (equiplist.Where(p => p.Code == palletequip.Code).Any() && _palletizrepository.AsQueryable().Where(p => p.Robot == palletequip.Robot).OrderByDescending(p => p.Id).First().Equip == palletequip.Code)
                            {
                                //如果较小的工位已经没有任务那么，则继续下该工位任务
                                var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot && p.Code != palletequip.Code).FirstOrDefault();
                                if (minequ != null)
                                {
                                    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                                        && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                                    {
                                    }
                                    else
                                    {
                                        iscontinue = false;
                                        continue;
                                    }
                                }
                            }

                            if (preinvlist.Select(p => p.BomMatName).Distinct().Count() > 1)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "预锁库存中存在两个箱号，不允许下任务";
                                _logger.LogInformation(palletequip.Code + "预锁库存中存在两个箱号，不允许下任务");
                                return res;
                            }
                            var rule = _boxrulerepository.GetSingle(p => p.PBoxCode == preinvlist.First().BomMatName);
                            //码垛信息校验
                            if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                                _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                                return res;
                            }
                            var root = DetermineRoot(palletequip.Code);
                            var pallet = new Palletizing()
                            {
                                PalletMax = rule.FullCountQty,
                                PalletizState = 0,
                                Equip = palletequip.Code,
                                Finish = 0,
                                AddWho = "",
                                EditWho = "",
                                BoxRule = rule.PackRule,
                                BoxRuleId = rule.Id,
                                IsControlpanel = false,
                                TaskNum = int.Parse(palletequip.Default3),
                                GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                                Robot = root
                            };
                            var pallects = _palletizrepository.InsertReturnEntity(pallet);
                            if (pallects.Id == 0)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                                _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                                return res;
                            }
                            var palletizId = pallects.Id;
                            _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                            {
                                ZXStateCode = 1
                            }, p => p.Id == rule.Id);
                            List<PalletLayerMath> math = new List<PalletLayerMath>();
                            foreach (var invs in preinvlist)
                            {
                                var palletlayer = new PalletLayerMath()
                                {
                                    PalletizingId = palletizId,
                                    ContGrpId = (long)invs.ContGrpId,
                                    ContBarCode = invs.ContGrpBarCode,
                                    Layer = invs.PackingLayer,
                                    SkuCode = rule.SkuCode,
                                    Finish = 0,
                                    PboxruleId = rule.Id,
                                    Istask = 0,
                                    Palletequip = palletequip.Code,
                                    Depth = invs.Depth,
                                    IsBlack = invs.IsBlack,
                                    SolderCount = invs.SolderCount,
                                    BoxCode = rule.PBoxCode,
                                    Wbgroup = invs.WbGroupCode,
                                    StockDonse = invs.InDocsNo,
                                    BoxDonse = rule.DocsNo
                                };
                                math.Add(palletlayer);
                            }
                            _palletlayerMathrepository.InsertRange(math);
                            //把库存预锁标志更新掉
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                BomDocsNo = palletequip.Default3,//托盘的任务号，仅做记录使用，不参与逻辑;箱号记录在BomMatName
                                BomMatCode = "",
                                PreStock = "1"
                            }, p => preinvlist.Select(p => p.ContGrpBarCode).ToList().Contains(p.ContGrpBarCode));

                            _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set default3='' where code='" + palletequip.Code + "'");
                            res.ResMsg = "非控制捞取预锁库存处理成功";
                            return res;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                    if (string.IsNullOrEmpty(palletequip.Cache1State))
                    {
                        iscontinue = true;
                        break;
                    }
                    else
                    {
                        iscontinue = false;
                        continue;
                    }
                }
                else
                {
                    if (!string.IsNullOrEmpty(palletequip.Default3))
                    {
                        //根据码垛工位找任务，找到则下任务，找不到则继续执行
                        var preinvlist = _billInvnowrepository.GetList(p => p.BomMatCode == palletequip.Default3 && p.BomSetId == 0 && p.PreStock == "1" && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (preinvlist.Any())
                        {
                            //机械手交叉下任务需求,上一个码垛信息是该工位的，则跳过
                            if (equiplist.Where(p => p.Code == palletequip.Code).Any() && _palletizrepository.AsQueryable().Where(p => p.Robot == palletequip.Robot).OrderByDescending(p => p.Id).First().Equip == palletequip.Code)
                            {
                                //如果较小的工位已经没有任务那么，则继续下该工位任务
                                var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot && p.Code != palletequip.Code).FirstOrDefault();
                                if (minequ != null)
                                {
                                    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                                  && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                                    {
                                    }
                                    else
                                    {
                                        iscontinue = false;
                                        continue;
                                    }
                                }
                            }

                            if (preinvlist.Select(p => p.BomMatName).Distinct().Count() > 1)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "预锁库存中存在两个箱号，不允许下任务";
                                _logger.LogInformation(palletequip.Code + "预锁库存中存在两个箱号，不允许下任务");
                                return res;
                            }
                            var rule = _boxrulerepository.GetSingle(p => p.PBoxCode == preinvlist.First().BomMatName);
                            //码垛信息校验
                            if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 2))
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "已经存在待装箱未装箱中数据";
                                _logger.LogInformation(palletequip.Code + "已经存在待装箱未装箱中数据");
                                return res;
                            }
                            var root = DetermineRoot(palletequip.Code);
                            var pallet = new Palletizing()
                            {
                                PalletMax = rule.FullCountQty,
                                PalletizState = 2,
                                Equip = palletequip.Code,
                                Finish = 0,
                                AddWho = "",
                                EditWho = "",
                                BoxRule = rule.PackRule,
                                BoxRuleId = rule.Id,
                                IsControlpanel = false,
                                TaskNum = int.Parse(palletequip.Default3),
                                GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                                Robot = root
                            };
                            var pallects = _palletizrepository.InsertReturnEntity(pallet);
                            if (pallects.Id == 0)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                                _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                                return res;
                            }
                            var palletizId = pallects.Id;
                            _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                            {
                                ZXStateCode = 1
                            }, p => p.Id == rule.Id);
                            List<PalletLayerMath> math = new List<PalletLayerMath>();
                            foreach (var invs in preinvlist)
                            {
                                var palletlayer = new PalletLayerMath()
                                {
                                    PalletizingId = palletizId,
                                    ContGrpId = (long)invs.ContGrpId,
                                    ContBarCode = invs.ContGrpBarCode,
                                    Layer = invs.PackingLayer,
                                    SkuCode = rule.SkuCode,
                                    Finish = 0,
                                    PboxruleId = rule.Id,
                                    Istask = 0,
                                    Palletequip = palletequip.Code,
                                    Depth = invs.Depth,
                                    IsBlack = invs.IsBlack,
                                    SolderCount = invs.SolderCount,
                                    BoxCode = rule.PBoxCode,
                                    Wbgroup = invs.WbGroupCode,
                                    StockDonse = invs.InDocsNo,
                                    BoxDonse = rule.DocsNo
                                };
                                math.Add(palletlayer);
                            }
                            _palletlayerMathrepository.InsertRange(math);
                            //把库存预锁标志更新掉
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                BomDocsNo = palletequip.Default3,//托盘的任务号，仅做记录使用，不参与逻辑;箱号记录在BomMatName
                                BomMatCode = "",
                                PreStock = "1"
                            }, p => preinvlist.Select(p => p.ContGrpBarCode).ToList().Contains(p.ContGrpBarCode));

                            _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set default3='' where code='" + palletequip.Code + "'");
                            res.ResMsg = "非控制捞取预锁库存处理成功";
                            return res;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State) && string.IsNullOrEmpty(palletequip.Memo))
                        {
                            iscontinue = true;
                            break;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                }
            }

            if (!iscontinue)
            {
                //判断缓存工位2是否有空余，并且缓存工位1的托盘要到位
                var equlist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDevicePalletizingEquip", JsonConvert.SerializeObject(""));
                var devices1 = JsonConvert.DeserializeObject<List<DevincePh1>>(equlist);
                var huancun1list = new List<string>() { "8089", "8091", "8095", "8097", "8306" };
                if (!devices1.Where(p => huancun1list.Contains(p.deviceCode) && p.TaskCode > 0).Any())
                {
                    RedisHelper.Set("Sx:WMSErrorInfo:ControlOut4", new RedisErrorInfo() { Equip = "ControlOut4", Con = "没有空闲的码垛工位及缓存工位", Time = DateTime.Now });
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有空闲的码垛工位";
                    return res;
                }

                if (!equiplist.Where(p => string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.Cache2Task) && string.IsNullOrEmpty(p.Default3)).Any())
                {
                    RedisHelper.Set("Sx:WMSErrorInfo:ControlOut4", new RedisErrorInfo() { Equip = "ControlOut4", Con = "没有空闲的码垛工位及缓存工位", Time = DateTime.Now });
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有空闲的码垛工位";
                    return res;
                }
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut5", new RedisErrorInfo() { Equip = "NoControlOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }

            devices = devices.Where(p => p.pH_STATUS == true).ToList();

            var prerules = _boxrulerepository.GetList(p => p.ZXStateCode == 3 && p.PackRule == "CP").OrderBy(p => p.EditTime);
            if (prerules != null && prerules.Any())
            {
                foreach (var rule in prerules)
                {
                    var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
                    List<string> equips = new List<string>();
                    foreach (var pp in sys)
                    {
                        if (pp.SContent.Split(",").Contains(rule.TrayCode))
                        {
                            equips.Add(pp.Code);
                        }
                    }
                    if (!equips.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut10", new RedisErrorInfo() { Equip = "NoControlOut10", Con = rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码", Time = DateTime.Now });
                        _logger.LogInformation(rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码");
                        //自动更新子托盘配置
                        foreach (var item1 in sys)
                        {
                            if (!item1.SContent.Contains(rule.TrayCode))
                            {
                                string con = item1.SContent + "," + rule.TrayCode;
                                _sysconfigrepository.AsUpdateable()
                                    .SetColumns(p => new sxSysConfig() { SContent = con })
                                    .Where(p => p.Id == item1.Id)
                                    .ExecuteCommand();
                            }
                        }
                    }
                    var invlist2 = _billInvnowrepository.GetList(p => p.PreStock == rule.Id.ToString() && p.InvStateCode == "InvEcecState_In");
                    if (!invlist2.Any())
                    {
                        _logger.LogInformation(rule.Id + "规则表预占数据没有查到对应库存信息");
                        continue;
                    }
                    var dev = devices.Where(p => equips.Contains(p.deviceCode)).ToList();
                    if (!dev.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut11", new RedisErrorInfo() { Equip = "NoControlOut11", Con = rule.TrayCode + "没有可用拆盘机", Time = DateTime.Now });
                        WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), rule.TrayCode + "没有可用子托拆盘机，请及时补充子托盘；");
                        continue;
                    }

                    var robotlist = new List<string>() { "Robot1", "Robot2", "Robot3" }.GetAvailablePalletizingRobotsByConfiguration(_sysconfigrepository, "CP_Palletizing");
                    sxSysConfig palletequip = null;
                    foreach (var robot in robotlist)
                    {
                        if (_sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == robot && p.AddWho != "禁用").Any())
                        {
                            var palletequiptemp = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == robot && p.AddWho != "禁用")
                                .ToList().GetAvailablePalletizingStationsByConfiguration(_sysconfigrepository, "CP_Palletizing").OrderBy(p => p.TaskFlag).FirstOrDefault();
                            //码垛工位
                            if (string.IsNullOrEmpty(palletequiptemp.Default1) && string.IsNullOrEmpty(palletequiptemp.Memo))
                            {
                                palletequip = palletequiptemp;
                                break;
                            }
                            //缓存工位1
                            else if (string.IsNullOrEmpty(palletequiptemp.Cache1State) && string.IsNullOrEmpty(palletequiptemp.Memo))
                            {
                                palletequip = palletequiptemp;
                                break;
                            }
                            //缓存工位2
                            else if (string.IsNullOrEmpty(palletequiptemp.Cache2State) && string.IsNullOrEmpty(palletequiptemp.Cache2State) && string.IsNullOrEmpty(palletequiptemp.Default3))
                            {
                                var equlist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDevicePalletizingEquip", JsonConvert.SerializeObject(""));
                                var devices1 = JsonConvert.DeserializeObject<List<DevincePh1>>(equlist);
                                var code = (int.Parse(palletequiptemp.Code) - 1).ToString();
                                if (devices1.Where(p => p.deviceCode == code && p.TaskCode > 0).Any())//缓存工位1的托盘必须到位，防止托盘输送任务排序错乱
                                {
                                    palletequip = palletequiptemp;
                                    break;
                                }
                            }
                        }
                    }

                    if (palletequip == null)
                    {
                        res.ResMsg = "没有空闲的码垛工位";
                        WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "没有空闲的码垛工位,无法出库码垛");
                        return res;
                    }

                    int acttype = 0;
                    //判断是缓存工位锁定库存还是码垛工位直接下任务
                    if (string.IsNullOrEmpty(palletequip.Default1))
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State))
                        {
                            acttype = 1;//直接执行下任务
                        }
                        else
                        {
                            //等待下一轮循环，往math表插数据放在前面
                            res.ResMsg = "等待下一轮循环";
                            return res;
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State))
                        {
                            //判断码垛工位的任务号是否锁定了库存，如果有则不做操作，等待下一轮循环
                            if (!string.IsNullOrEmpty(palletequip.Default3))
                            {
                                res.ResMsg = "等待下一轮循环";
                                return res;
                            }
                            else
                            {
                                acttype = 2;//预锁库存
                            }
                        }
                        else
                        {
                            //判断缓存工位2(缓存工位1的托盘要到位之后)
                            if (string.IsNullOrEmpty(palletequip.Cache2State) && string.IsNullOrEmpty(palletequip.Cache2Task))
                            {
                                //使用缓存2工位
                                acttype = 3;
                            }
                            else
                            {
                                res.ResMsg = "没有空闲的码垛工位";
                                WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "没有空闲的码垛工位,无法出库码垛");
                                return res;
                            }
                        }
                    }

                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = rule.TrayCode, WareHouse = "cphouse", Equip = palletequip.Code, Start = dev.First().deviceCode, ActType = acttype };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut18", new RedisErrorInfo() { Equip = "NoControlOut18", Con = rule.TrayCode + trayres.ResMsg, Time = DateTime.Now });
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        return res;
                    }

                    if (acttype == 1)
                    {
                        //码垛信息校验
                        if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                        {
                            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                            _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), palletequip.Code + "已经存在未装箱中数据");
                            return res;
                        }
                        var root = DetermineRoot(palletequip.Code);
                        var pallet = new Palletizing()
                        {
                            PalletMax = rule.FullCountQty,
                            PalletizState = 0,
                            Equip = palletequip.Code,
                            Finish = 0,
                            AddWho = "",
                            EditWho = "",
                            BoxRule = rule.PackRule,
                            BoxRuleId = rule.Id,
                            IsControlpanel = false,
                            TaskNum = int.Parse(trayres.Memo1),
                            GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                            Robot = root
                        };

                        var pallects = _palletizrepository.InsertReturnEntity(pallet);
                        if (pallects.Id == 0)
                        {
                            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                            _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), palletequip.Code + "装箱主表数据保存失败");
                            return res;
                        }
                        var palletizId = pallects.Id;
                        _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                        {
                            ZXStateCode = 1
                        }, p => p.Id == rule.Id);

                        List<PalletLayerMath> math = new List<PalletLayerMath>();
                        foreach (var invs in invlist2)
                        {
                            var palletlayer = new PalletLayerMath()
                            {
                                PalletizingId = palletizId,
                                ContGrpId = (long)invs.ContGrpId,
                                ContBarCode = invs.ContGrpBarCode,
                                Layer = invs.PackingLayer,
                                SkuCode = rule.SkuCode,
                                Finish = 0,
                                PboxruleId = rule.Id,
                                Istask = 0,
                                Palletequip = palletequip.Code,
                                IsBlack = invs.IsBlack,
                                Depth = invs.Depth,
                                SolderCount = invs.SolderCount,
                                BoxCode = rule.PBoxCode,
                                StockDonse = invs.InDocsNo,
                                Wbgroup = invs.WbGroupCode,
                                BoxDonse = rule.DocsNo
                            };
                            math.Add(palletlayer);
                        }
                        _palletlayerMathrepository.InsertRange(math);
                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            PreStock = "1"
                        }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));

                        res.ResCode = 200;
                        res.ResMsg = "成功";
                        return res;
                    }
                    else if (acttype == 2 || acttype == 3)//缓存工位1，2
                    {
                        var codes = new List<string>();

                        codes.AddRange(invlist2.Select(p => p.ContGrpBarCode));
                        if (codes.Any())
                        {
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                PreStock = "1",
                                BomMatCode = trayres.Memo1,//预锁托盘任务id
                                BomMatName = rule.PBoxCode, //预锁的箱号
                                BomSetId = 0 //代表非控制箱标识
                            }, p => codes.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            //锁定缓存工位
                            _logger.LogInformation(string.Format("非控制装箱预锁：托盘任务id{0},箱号{1},条码列表{2}", trayres.Memo1, rule.PBoxCode, JsonConvert.SerializeObject(codes)));
                        }
                        res.ResCode = 200;
                        res.ResMsg = "成功";
                        return res;
                    }
                }
            }
            else
            {
                res.ResMsg = "没有预占状态的规则数据";
            }

            return res;
        }

        /// <summary>
        /// 码垛SPC非控制装箱（缓存托盘）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PalletizingSpcNotPackStockOut3(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "SPC" && p.IsControlpanel == false);
            if (palletlist.Any())
            {
                var maxtaskStemp = _palletlayerMathrepository.GetList(p => p.Istask == 0 && palletlist.Select(p => p.Id).Contains(p.PalletizingId)).GroupBy(p => p.Palletequip);
                if (maxtaskStemp.Any())
                {
                    var maxtaskcount = (from tas in maxtaskStemp
                                        select new TunnelCountTemp()
                                        {
                                            Tunnel = tas.Key,
                                            Count = tas.Count()
                                        }).ToList();
                    palletlist = palletlist.OrderByDescending(p => maxtaskcount.Where(q => q.Tunnel == p.Equip).Any() ? maxtaskcount.Where(q => q.Tunnel == p.Equip).FirstOrDefault().Count : 0).ToList();
                }
                //箱之间状态卡控限制标识
                TaskStatus taskstatus = (TaskStatus)int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskStatus").SContent);
                //某个机械手最大下发的限制状态任务数量
                int robotmaxtaskcount = int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskCount").SContent);
                foreach (var item in palletlist)
                {
                    //判断任务数量
                    if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Status < TaskStatus.码垛抓取完成 && p.Robot == item.Robot && p.BusType == "装箱码垛").Count() >= robotmaxtaskcount)
                    {
                        _logger.LogInformation(item.Robot + "当前机械手任务数量已经超最大值" + robotmaxtaskcount);
                        continue;
                    }

                    //找到当前机械手较早的码垛信息，然后判断是否已经过了某个点
                    var prepalletid = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).FirstOrDefault().Id;
                    if (item.Id != prepalletid)//不是靠前的那一码垛信息
                    {
                        //判断是不是第3箱

                        //判断是否是第三箱
                        if (_palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).Count >= 3)
                        {
                            var thirdbox = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).Take(3).Last().Id;
                            if (item.Id == thirdbox)//第3箱子
                            {
                                if (_palletlayerMathrepository.GetList(p => p.PalletizingId == prepalletid && p.Istask == 0).Any() || _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == prepalletid && p.Status < taskstatus).Any())
                                {
                                    _logger.LogInformation("第3箱卡控同一机械手最早的箱子的码垛任务没有全部过卡控点" + taskstatus.GetDescription());
                                    continue;
                                }
                                //判断前两箱子如果都是同一目标地址，那么第三箱也不要下
                                var pre2list = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot && p.Id < thirdbox);
                                if (pre2list.Count == 2 && pre2list.Select(p => p.Equip).Distinct().Count() == 1)
                                {
                                    _logger.LogInformation("第3箱卡控同一机械手前面两箱都是同一目标地址，则不下第3箱任务" + taskstatus.GetDescription());
                                    continue;
                                }
                            }
                            else if (item.Id > thirdbox)
                            {
                                _logger.LogInformation("同一机械手第3箱之后的任务不允许下发，码垛主表id：" + item.Id);
                                continue;
                            }
                        }

                        //if (_palletlayerMathrepository.GetList(p => p.PalletizingId == prepalletid && p.Istask == 0).Any() || _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == prepalletid && p.Status < taskstatus).Any())
                        //{
                        //    _logger.LogInformation("同一机械手最早的箱子的码垛任务没有全部过卡控点" + taskstatus.GetDescription());
                        //    continue;
                        //}
                    }

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut2", new RedisErrorInfo() { Equip = "NoControlOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.Depth).Take(72);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut3", new RedisErrorInfo() { Equip = "NoControlOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }

                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut23", new RedisErrorInfo() { Equip = "NoControlOut23", Con = cell.Code + "库位下发移库任务失败，请检查一深货位状态", Time = DateTime.Now });
                                _logger.LogInformation(cell.Code + "库位下发移库任务失败，请检查一深货位状态");
                                continue;
                            }
                        }
                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = 0,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                    //下完任务后将标识值加1
                    var taskflag = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == item.Robot).Max(p => p.TaskFlag);
                    taskflag = taskflag + 1;
                    _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set taskflag=" + taskflag + " where code='" + item.Equip + "'");
                }
            }

            //待码垛箱任务下发
            var palletlisttobe = _palletizrepository.GetList(p => p.PalletizState == 2 && p.BoxRule == "SPC" && p.IsControlpanel == false);
            if (palletlisttobe.Any())
            {
                foreach (var item in palletlisttobe.OrderBy(p => p.Id))
                {
                    //判断当前工位有没有正在码垛的，没的话，则把待码垛的更新成正在码垛的
                    if (!_palletizrepository.GetList(p => p.PalletizState == 0 && p.Equip == item.Equip).Any())
                    {
                        _palletizrepository.AsUpdateable()
                       .SetColumns(p => new Palletizing() { PalletizState = 0 })
                       .Where(p => p.Id == item.Id)
                       .ExecuteCommand();
                    }

                    var temppalletlist = _palletizrepository.GetList(p => p.PalletizState == 0);

                    if (temppalletlist.Where(p => p.Robot == item.Robot).Any())
                    {
                        List<long> mdtempequiplist = temppalletlist.Where(p => p.Robot == item.Robot).Select(p => p.Id).ToList();
                        //判断当前机械手正在码垛的两个工位任务都已经下发完成
                        if (_palletlayerMathrepository.GetList(p => mdtempequiplist.Contains(p.PalletizingId) && p.Istask == 0).Any())
                        {
                            _logger.LogInformation(item.Robot + "正在码垛的任务没有下完，不允许下发待码垛任务");
                            continue;
                        }
                        //箱之间状态卡控限制标识
                        TaskStatus taskstatus = (TaskStatus)int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskStatus").SContent);
                        //判断任务数量
                        int robotmaxtaskcount = int.Parse(_sysconfigrepository.GetSingle(p => p.Code == "PreNextTaskCount").SContent);
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Status < TaskStatus.码垛抓取完成 && p.Robot == item.Robot && p.BusType == "装箱码垛").Count() >= robotmaxtaskcount)
                        {
                            _logger.LogInformation(item.Robot + "当前机械手任务数量已经超最大值" + robotmaxtaskcount);
                            continue;
                        }
                        //var curpalletid = temppalletlist.Where(p => p.Equip == item.Equip).First().Id;
                        if (!_palletlayerMathrepository.GetList(p => mdtempequiplist.Contains(p.PalletizingId) && p.Istask == 0).Any())// && !_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => mdtempequiplist.Contains(p.PalletizingId) && p.Status < taskstatus).Any()
                        {
                            //判断是否是第三箱
                            if (_palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).Count >= 3)
                            {
                                var prepalletid = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).FirstOrDefault().Id;
                                var thirdbox = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot).OrderBy(p => p.Id).Take(3).Last().Id;
                                if (item.Id == thirdbox)//第3箱子
                                {
                                    if (_palletlayerMathrepository.GetList(p => p.PalletizingId == prepalletid && p.Istask == 0).Any() || _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == prepalletid && p.Status < taskstatus).Any())
                                    {
                                        _logger.LogInformation("第3箱卡控同一机械手最早的箱子的码垛任务没有全部过卡控点" + taskstatus.GetDescription());
                                        continue;
                                    }
                                    //判断前两箱子如果都是同一目标地址，那么第三箱也不要下
                                    var pre2list = _palletizrepository.GetList(p => p.PalletizState != 1 && p.Robot == item.Robot && p.Id < thirdbox);
                                    if (pre2list.Count == 2 && pre2list.Select(p => p.Equip).Distinct().Count() == 1)
                                    {
                                        _logger.LogInformation("第3箱卡控同一机械手前面两箱都是同一目标地址，则不下第3箱任务" + taskstatus.GetDescription());
                                        continue;
                                    }
                                }
                                else if (item.Id > thirdbox)
                                {
                                    _logger.LogInformation("同一机械手第3箱之后的待码垛任务不允许下发，码垛主表id：" + item.Id);
                                    continue;
                                }
                            }

                            int takecount = int.Parse(AppSettings.GetConfig("FloorCount"));
                            if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == item.Id).Count() < takecount)
                            {
                                var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.Depth).Take(takecount);
                                if (!palletMach.Any())
                                {
                                    RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut3", new RedisErrorInfo() { Equip = "NoControlOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                                    continue;
                                }

                                var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                                var curdocid = maxdocid + 1;
                                if (palletMach.Any())
                                {
                                    var pid = palletMach.First().PalletizingId;
                                    if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                                    {
                                        curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                                    }
                                }

                                foreach (var pallets in palletMach)
                                {
                                    var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                                    if (cell == null)
                                    {
                                        continue;
                                    }
                                    var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                                    if (invs == null)
                                    {
                                        continue;
                                    }
                                    var root = DetermineRoot(pallets.Palletequip);

                                    //先判断二升位是否能出库
                                    if (cell.Depth == 2)
                                    {
                                        var respon = MoveTask(cell.Code);
                                        if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                        {
                                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut23", new RedisErrorInfo() { Equip = "NoControlOut23", Con = cell.Code + "库位下发移库任务失败，请检查一深货位状态", Time = DateTime.Now });
                                            _logger.LogInformation(cell.Code + "库位下发移库任务失败，请检查一深货位状态");
                                            continue;
                                        }
                                    }
                                    var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                                    {
                                        Code = pallets.ContBarCode,
                                        CellCode = cell.Code,
                                        Srm = cell.SCRel,
                                        Tunnel = cell.Tunnel.ToString(),
                                        Floor = cell.Floor,
                                        Grade = invs.Grade,
                                        Mater = invs.MatCode,
                                        SkuCode = pallets.SkuCode,
                                        PalletLayer = 0,
                                        ProductMachCode = invs.ProductMachCode,
                                        Equip = item.Equip,
                                        PalletizingId = item.Id,
                                        Robot = root,
                                        GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                                        DocId = curdocid
                                    });
                                    if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                                    {
                                        continue;
                                    }
                                    _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                                    {
                                        Istask = 1,
                                        Layer = 0
                                    }, p => p.ContBarCode == invs.ContGrpBarCode);
                                }
                                //下完任务后将标识值加1
                                var taskflag = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == item.Robot).Max(p => p.TaskFlag);
                                taskflag = taskflag + 1;
                                _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set taskflag=" + taskflag + " where code='" + item.Equip + "'");
                            }
                        }
                    }
                    else
                    {
                        _palletizrepository.AsUpdateable()
                         .SetColumns(p => new Palletizing() { PalletizState = 0 })
                         .Where(p => p.Id == item.Id)
                         .ExecuteCommand();
                    }
                }
            }

            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");

            equiplist = equiplist.GetAvailablePalletizingStationsByConfiguration(_sysconfigrepository, "SPC_Palletizing");
            var iscontinue = false;
            foreach (var palletequip in equiplist.OrderByDescending(p => p.Default3).ThenBy(p => p.Default1))
            {
                if (string.IsNullOrEmpty(palletequip.Default1))
                {
                    if (!string.IsNullOrEmpty(palletequip.Default3))//Default3是绑定的托盘搬运任务的id，对应预锁库存标识
                    {
                        //根据码垛工位找任务，找到则下任务，找不到则继续执行
                        var preinvlist = _billInvnowrepository.GetList(p => p.BomMatCode == palletequip.Default3 && p.BomSetId == 0 && p.PreStock == "1" && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (preinvlist.Any())
                        {
                            //机械手交叉下任务需求
                            //if (_sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot).Min(p => p.TaskFlag) < palletequip.TaskFlag)
                            //{
                            //    var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot).OrderBy(p => p.TaskFlag).First();
                            //    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                            //        && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                            //    {
                            //    }
                            //    else
                            //    {
                            //        iscontinue = false;
                            //        continue;
                            //    }
                            //}
                            //机械手交叉下任务需求,上一个码垛信息是该工位的，则跳过
                            if (equiplist.Where(p => p.Code == palletequip.Code).Any() && _palletizrepository.AsQueryable().Where(p => p.Robot == palletequip.Robot).OrderByDescending(p => p.Id).First().Equip == palletequip.Code)
                            {
                                //如果较小的工位已经没有任务那么，则继续下该工位任务
                                var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot && p.Code != palletequip.Code).FirstOrDefault();
                                if (minequ != null)
                                {
                                    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                                        && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                                    {
                                    }
                                    else
                                    {
                                        iscontinue = false;
                                        continue;
                                    }
                                }
                            }

                            if (preinvlist.Select(p => p.BomMatName).Distinct().Count() > 1)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "预锁库存中存在两个箱号，不允许下任务";
                                _logger.LogInformation(palletequip.Code + "预锁库存中存在两个箱号，不允许下任务");
                                return res;
                            }
                            var rule = _boxrulerepository.GetSingle(p => p.PBoxCode == preinvlist.First().BomMatName);
                            //码垛信息校验
                            if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                                _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                                return res;
                            }
                            var root = DetermineRoot(palletequip.Code);
                            var pallet = new Palletizing()
                            {
                                PalletMax = rule.FullCountQty,
                                PalletizState = 0,
                                Equip = palletequip.Code,
                                Finish = 0,
                                AddWho = "",
                                EditWho = "",
                                BoxRule = rule.PackRule,
                                BoxRuleId = rule.Id,
                                IsControlpanel = false,
                                TaskNum = int.Parse(palletequip.Default3),
                                GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                                Robot = root
                            };
                            var pallects = _palletizrepository.InsertReturnEntity(pallet);
                            if (pallects.Id == 0)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                                _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                                return res;
                            }
                            var palletizId = pallects.Id;
                            _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                            {
                                ZXStateCode = 1
                            }, p => p.Id == rule.Id);
                            List<PalletLayerMath> math = new List<PalletLayerMath>();
                            foreach (var invs in preinvlist)
                            {
                                var palletlayer = new PalletLayerMath()
                                {
                                    PalletizingId = palletizId,
                                    ContGrpId = (long)invs.ContGrpId,
                                    ContBarCode = invs.ContGrpBarCode,
                                    Layer = 0,
                                    SkuCode = rule.SkuCode,
                                    Finish = 0,
                                    PboxruleId = rule.Id,
                                    Istask = 0,
                                    Palletequip = palletequip.Code,
                                    Depth = invs.Depth,
                                    IsBlack = invs.IsBlack,
                                    SolderCount = invs.SolderCount,
                                    BoxCode = rule.PBoxCode,
                                    Wbgroup = invs.WbGroupCode,
                                    StockDonse = invs.InDocsNo,
                                    BoxDonse = rule.DocsNo
                                };
                                math.Add(palletlayer);
                            }
                            _palletlayerMathrepository.InsertRange(math);
                            //把库存预锁标志更新掉
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                BomDocsNo = palletequip.Default3,//托盘的任务号，仅做记录使用，不参与逻辑;箱号记录在BomMatName
                                BomMatCode = "",
                                PreStock = "1"
                            }, p => preinvlist.Select(p => p.ContGrpBarCode).ToList().Contains(p.ContGrpBarCode));

                            _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set default3='' where code='" + palletequip.Code + "'");
                            res.ResMsg = "非控制捞取预锁库存处理成功";
                            return res;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                    if (string.IsNullOrEmpty(palletequip.Cache1State))
                    {
                        iscontinue = true;
                        break;
                    }
                    else
                    {
                        iscontinue = false;
                        continue;
                    }
                }
                else
                {
                    if (!string.IsNullOrEmpty(palletequip.Default3))
                    {
                        //根据码垛工位找任务，找到则下任务，找不到则继续执行
                        var preinvlist = _billInvnowrepository.GetList(p => p.BomMatCode == palletequip.Default3 && p.BomSetId == 0 && p.PreStock == "1" && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (preinvlist.Any())
                        {
                            //机械手交叉下任务需求
                            //if (_sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot).Min(p => p.TaskFlag) < palletequip.TaskFlag)
                            //{
                            //    var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot).OrderBy(p => p.TaskFlag).First();
                            //    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                            //        && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                            //    {
                            //    }
                            //    else
                            //    {
                            //        iscontinue = false;
                            //        continue;
                            //    }
                            //}
                            //机械手交叉下任务需求,上一个码垛信息是该工位的，则跳过
                            if (equiplist.Where(p => p.Code == palletequip.Code).Any() && _palletizrepository.AsQueryable().Where(p => p.Robot == palletequip.Robot).OrderByDescending(p => p.Id).First().Equip == palletequip.Code)
                            {
                                //如果较小的工位已经没有任务那么，则继续下该工位任务
                                var minequ = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == palletequip.Robot && p.Code != palletequip.Code).FirstOrDefault();
                                if (minequ != null)
                                {
                                    if (string.IsNullOrEmpty(minequ.SContent) && string.IsNullOrEmpty(minequ.Default1) && string.IsNullOrEmpty(minequ.Default2) && string.IsNullOrEmpty(minequ.Default3)
                                  && string.IsNullOrEmpty(minequ.Cache1State) && string.IsNullOrEmpty(minequ.Memo) && string.IsNullOrEmpty(minequ.Cache2State))
                                    {
                                    }
                                    else
                                    {
                                        iscontinue = false;
                                        continue;
                                    }
                                }
                            }

                            if (preinvlist.Select(p => p.BomMatName).Distinct().Count() > 1)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "预锁库存中存在两个箱号，不允许下任务";
                                _logger.LogInformation(palletequip.Code + "预锁库存中存在两个箱号，不允许下任务");
                                return res;
                            }
                            var rule = _boxrulerepository.GetSingle(p => p.PBoxCode == preinvlist.First().BomMatName);
                            //码垛信息校验
                            if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 2))
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "已经存在待装箱未装箱中数据";
                                _logger.LogInformation(palletequip.Code + "已经存在待装箱未装箱中数据");
                                return res;
                            }
                            var root = DetermineRoot(palletequip.Code);
                            var pallet = new Palletizing()
                            {
                                PalletMax = rule.FullCountQty,
                                PalletizState = 2,
                                Equip = palletequip.Code,
                                Finish = 0,
                                AddWho = "",
                                EditWho = "",
                                BoxRule = rule.PackRule,
                                BoxRuleId = rule.Id,
                                IsControlpanel = false,
                                TaskNum = int.Parse(palletequip.Default3),
                                GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                                Robot = root
                            };
                            var pallects = _palletizrepository.InsertReturnEntity(pallet);
                            if (pallects.Id == 0)
                            {
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                                _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                                return res;
                            }
                            var palletizId = pallects.Id;
                            _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                            {
                                ZXStateCode = 1
                            }, p => p.Id == rule.Id);
                            List<PalletLayerMath> math = new List<PalletLayerMath>();
                            foreach (var invs in preinvlist)
                            {
                                var palletlayer = new PalletLayerMath()
                                {
                                    PalletizingId = palletizId,
                                    ContGrpId = (long)invs.ContGrpId,
                                    ContBarCode = invs.ContGrpBarCode,
                                    Layer = 0,
                                    SkuCode = rule.SkuCode,
                                    Finish = 0,
                                    PboxruleId = rule.Id,
                                    Istask = 0,
                                    Palletequip = palletequip.Code,
                                    Depth = invs.Depth,
                                    IsBlack = invs.IsBlack,
                                    SolderCount = invs.SolderCount,
                                    BoxCode = rule.PBoxCode,
                                    Wbgroup = invs.WbGroupCode,
                                    StockDonse = invs.InDocsNo,
                                    BoxDonse = rule.DocsNo
                                };
                                math.Add(palletlayer);
                            }
                            _palletlayerMathrepository.InsertRange(math);
                            //把库存预锁标志更新掉
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                BomDocsNo = palletequip.Default3,//托盘的任务号，仅做记录使用，不参与逻辑;箱号记录在BomMatName
                                BomMatCode = "",
                                PreStock = "1"
                            }, p => preinvlist.Select(p => p.ContGrpBarCode).ToList().Contains(p.ContGrpBarCode));

                            _sysconfigrepository.Context.Ado.ExecuteCommand("update WMS_ZT_01CP.dbo.sys_config  set default3='' where code='" + palletequip.Code + "'");
                            res.ResMsg = "非控制捞取预锁库存处理成功";
                            return res;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State) && string.IsNullOrEmpty(palletequip.Memo))
                        {
                            iscontinue = true;
                            break;
                        }
                        else
                        {
                            iscontinue = false;
                            continue;
                        }
                    }
                }
            }

            if (!iscontinue)
            {
                //判断缓存工位2是否有空余，并且缓存工位1的托盘要到位
                var equlist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDevicePalletizingEquip", JsonConvert.SerializeObject(""));
                var devices1 = JsonConvert.DeserializeObject<List<DevincePh1>>(equlist);
                var huancun1list = new List<string>() { "8089", "8091", "8095", "8097", "8306" };
                if (!devices1.Where(p => huancun1list.Contains(p.deviceCode) && p.TaskCode > 0).Any())
                {
                    RedisHelper.Set("Sx:WMSErrorInfo:ControlOut4", new RedisErrorInfo() { Equip = "ControlOut4", Con = "没有空闲的码垛工位及缓存工位", Time = DateTime.Now });
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有空闲的码垛工位";
                    return res;
                }

                if (!equiplist.Where(p => string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.Cache2Task) && string.IsNullOrEmpty(p.Default3)).Any())
                {
                    RedisHelper.Set("Sx:WMSErrorInfo:ControlOut4", new RedisErrorInfo() { Equip = "ControlOut4", Con = "没有空闲的码垛工位及缓存工位", Time = DateTime.Now });
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有空闲的码垛工位";
                    return res;
                }
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut5", new RedisErrorInfo() { Equip = "NoControlOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }

            devices = devices.Where(p => p.pH_STATUS == true).ToList();

            var prerules = _boxrulerepository.GetList(p => p.ZXStateCode == 4 && p.PackRule == "SPC").OrderBy(p => p.EditTime);
            if (prerules != null && prerules.Any())
            {
                foreach (var rule in prerules)
                {
                    var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
                    List<string> equips = new List<string>();
                    foreach (var pp in sys)
                    {
                        if (pp.SContent.Split(",").Contains(rule.TrayCode))
                        {
                            equips.Add(pp.Code);
                        }
                    }
                    if (!equips.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut10", new RedisErrorInfo() { Equip = "NoControlOut10", Con = rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码", Time = DateTime.Now });
                        _logger.LogInformation(rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码");
                        //自动更新子托盘配置
                        foreach (var item1 in sys)
                        {
                            if (!item1.SContent.Contains(rule.TrayCode))
                            {
                                string con = item1.SContent + "," + rule.TrayCode;
                                _sysconfigrepository.AsUpdateable()
                                    .SetColumns(p => new sxSysConfig() { SContent = con })
                                    .Where(p => p.Id == item1.Id)
                                    .ExecuteCommand();
                            }
                        }
                    }
                    var invlist2 = _billInvnowrepository.GetList(p => p.PreStock == rule.Id.ToString() && p.InvStateCode == "InvEcecState_In");
                    if (!invlist2.Any())
                    {
                        _logger.LogInformation(rule.Id + "规则表预占数据没有查到对应库存信息");
                        continue;
                    }
                    var dev = devices.Where(p => equips.Contains(p.deviceCode)).ToList();
                    if (!dev.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut11", new RedisErrorInfo() { Equip = "NoControlOut11", Con = rule.TrayCode + "没有可用拆盘机", Time = DateTime.Now });
                        WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), rule.TrayCode + "没有可用子托拆盘机，请及时补充子托盘；");
                        continue;
                    }

                    var robotlist = new List<string>() { "Robot1", "Robot2", "Robot3" }.GetAvailablePalletizingRobotsByConfiguration(_sysconfigrepository, "SPC_Palletizing");
                    sxSysConfig palletequip = null;
                    foreach (var robot in robotlist)
                    {
                        if (_sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == robot && p.AddWho != "禁用").Any())
                        {
                            var palletequiptemp = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack").Where(p => p.Robot == robot && p.AddWho != "禁用")
                                .ToList().GetAvailablePalletizingStationsByConfiguration(_sysconfigrepository, "SPC_Palletizing").OrderBy(p => p.TaskFlag).FirstOrDefault();
                            //码垛工位
                            if (string.IsNullOrEmpty(palletequiptemp.Default1) && string.IsNullOrEmpty(palletequiptemp.Memo))
                            {
                                palletequip = palletequiptemp;
                                break;
                            }
                            //缓存工位1
                            else if (string.IsNullOrEmpty(palletequiptemp.Cache1State) && string.IsNullOrEmpty(palletequiptemp.Memo))
                            {
                                palletequip = palletequiptemp;
                                break;
                            }
                            //缓存工位2
                            else if (string.IsNullOrEmpty(palletequiptemp.Cache2State) && string.IsNullOrEmpty(palletequiptemp.Cache2State) && string.IsNullOrEmpty(palletequiptemp.Default3))
                            {
                                var equlist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDevicePalletizingEquip", JsonConvert.SerializeObject(""));
                                var devices1 = JsonConvert.DeserializeObject<List<DevincePh1>>(equlist);
                                var code = (int.Parse(palletequiptemp.Code) - 1).ToString();
                                if (devices1.Where(p => p.deviceCode == code && p.TaskCode > 0).Any())//缓存工位1的托盘必须到位，防止托盘输送任务排序错乱
                                {
                                    palletequip = palletequiptemp;
                                    break;
                                }
                            }
                        }
                    }

                    if (palletequip == null)
                    {
                        res.ResMsg = "没有空闲的码垛工位";
                        WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "没有空闲的码垛工位,无法出库码垛");
                        return res;
                    }

                    int acttype = 0;
                    //判断是缓存工位锁定库存还是码垛工位直接下任务
                    if (string.IsNullOrEmpty(palletequip.Default1))
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State))
                        {
                            acttype = 1;//直接执行下任务
                        }
                        else
                        {
                            //等待下一轮循环，往math表插数据放在前面
                            res.ResMsg = "等待下一轮循环";
                            return res;
                        }
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(palletequip.Cache1State))
                        {
                            //判断码垛工位的任务号是否锁定了库存，如果有则不做操作，等待下一轮循环
                            if (!string.IsNullOrEmpty(palletequip.Default3))
                            {
                                res.ResMsg = "等待下一轮循环";
                                return res;
                            }
                            else
                            {
                                acttype = 2;//预锁库存
                            }
                        }
                        else
                        {
                            //判断缓存工位2(缓存工位1的托盘要到位之后)
                            if (string.IsNullOrEmpty(palletequip.Cache2State) && string.IsNullOrEmpty(palletequip.Cache2Task))
                            {
                                //使用缓存2工位
                                acttype = 3;
                            }
                            else
                            {
                                res.ResMsg = "没有空闲的码垛工位";
                                WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "没有空闲的码垛工位,无法出库码垛");
                                return res;
                            }
                        }
                    }

                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = rule.TrayCode, WareHouse = "cphouse", Equip = palletequip.Code, Start = dev.First().deviceCode, ActType = acttype };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut18", new RedisErrorInfo() { Equip = "NoControlOut18", Con = rule.TrayCode + trayres.ResMsg, Time = DateTime.Now });
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        return res;
                    }

                    if (acttype == 1)
                    {
                        //码垛信息校验
                        if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                        {
                            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                            _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), palletequip.Code + "已经存在未装箱中数据");
                            return res;
                        }
                        var root = DetermineRoot(palletequip.Code);
                        var pallet = new Palletizing()
                        {
                            PalletMax = rule.FullCountQty,
                            PalletizState = 0,
                            Equip = palletequip.Code,
                            Finish = 0,
                            AddWho = "",
                            EditWho = "",
                            BoxRule = rule.PackRule,
                            BoxRuleId = rule.Id,
                            IsControlpanel = false,
                            TaskNum = int.Parse(trayres.Memo1),
                            GoodsType = rule.SpoolType == "BS80/33" ? 1 : 2,
                            Robot = root
                        };

                        var pallects = _palletizrepository.InsertReturnEntity(pallet);
                        if (pallects.Id == 0)
                        {
                            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            res.ResMsg = palletequip.Code + "装箱主表数据保存失败";
                            _logger.LogInformation(palletequip.Code + "装箱主表数据保存失败");
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), palletequip.Code + "装箱主表数据保存失败");
                            return res;
                        }
                        var palletizId = pallects.Id;
                        _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                        {
                            ZXStateCode = 1
                        }, p => p.Id == rule.Id);

                        List<PalletLayerMath> math = new List<PalletLayerMath>();
                        foreach (var invs in invlist2)
                        {
                            var palletlayer = new PalletLayerMath()
                            {
                                PalletizingId = palletizId,
                                ContGrpId = (long)invs.ContGrpId,
                                ContBarCode = invs.ContGrpBarCode,
                                Layer = 0,
                                SkuCode = rule.SkuCode,
                                Finish = 0,
                                PboxruleId = rule.Id,
                                Istask = 0,
                                Palletequip = palletequip.Code,
                                IsBlack = invs.IsBlack,
                                Depth = invs.Depth,
                                SolderCount = invs.SolderCount,
                                BoxCode = rule.PBoxCode,
                                StockDonse = invs.InDocsNo,
                                Wbgroup = invs.WbGroupCode,
                                BoxDonse = rule.DocsNo
                            };
                            math.Add(palletlayer);
                        }
                        _palletlayerMathrepository.InsertRange(math);
                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            PreStock = "1"
                        }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));

                        res.ResCode = 200;
                        res.ResMsg = "成功";
                        return res;
                    }
                    else if (acttype == 2 || acttype == 3)//缓存工位1，2
                    {
                        var codes = new List<string>();

                        codes.AddRange(invlist2.Select(p => p.ContGrpBarCode));
                        if (codes.Any())
                        {
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                PreStock = "1",
                                BomMatCode = trayres.Memo1,//预锁托盘任务id
                                BomMatName = rule.PBoxCode, //预锁的箱号
                                BomSetId = 0 //代表非控制箱标识
                            }, p => codes.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            //锁定缓存工位
                            _logger.LogInformation(string.Format("非控制装箱预锁：托盘任务id{0},箱号{1},条码列表{2}", trayres.Memo1, rule.PBoxCode, JsonConvert.SerializeObject(codes)));
                        }
                        res.ResCode = 200;
                        res.ResMsg = "成功";
                        return res;
                    }
                }
            }
            else
            {
                res.ResMsg = "没有预占状态的规则数据";
            }

            return res;
        }

        /// <summary>
        /// 码垛SPC非控制装箱计算预占箱号-去掉黑盘和批次限制
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PalletizingSpcNotPackRulePre2(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();

            int precount = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "PreBoxNum").SContent);
            if (_boxrulerepository.Count(p => p.ZXStateCode > 2 && p.PackRule == "SPC") > precount)
            {
                res.ResMsg = "预占箱数已经大于设置值";
                return res;
            }
            var timeOutHoldHours = int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));//超时时间配置
            //获取库存列表
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && (p.IsControlpanel == false && p.IsTorsChk == false) && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0 && !p.ProductMachCode.Contains("R")
                          && (DateTime.Now - p.ProductTime).TotalHours < timeOutHoldHours)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                          on stock.InDocsNo equals rule1.DocsNo
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              SkuCode = rule1.SkuCode,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo,
                              BatchNo = stock.BatchNo
                          };

            var invlistchognrao = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                                  join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && (p.IsControlpanel == false && p.IsTorsChk == false) && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0 && p.ProductMachCode.Contains("R")
                                  && (DateTime.Now - p.OneInTime).TotalHours < timeOutHoldHours)
                                  on loc.ContGrpBarCode equals stock.ContGrpBarCode
                                  join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                                  on stock.InDocsNo equals rule1.DocsNo
                                  select new StockTemp
                                  {
                                      MatCode = stock.MatCode,
                                      InvBarCode = stock.InvBarCode,
                                      Grade = stock.Grade,
                                      InvStateCode = stock.InvStateCode,
                                      ProductTime = stock.ProductTime,
                                      WbGroupCode = stock.WbGroupCode,
                                      IsTorsChk = stock.IsTorsChk,
                                      TorsChkQty = stock.TorsChkQty,
                                      TorsChkValue = stock.TorsChkValue,
                                      HoldTime = stock.HoldTime,
                                      ProductMachCode = stock.ProductMachCode,
                                      IsControlpanel = stock.IsControlpanel,
                                      HWTypeCode = stock.HWTypeCode,
                                      SolderCount = stock.SolderCount,
                                      IsRework = stock.IsRework,
                                      IsBlack = stock.IsBlack,
                                      Col = loc.Col,
                                      Layer = loc.Layer,
                                      Shelf = loc.Shelf,
                                      Depth = loc.Depth,
                                      Code = loc.Code,
                                      Tunnel = loc.Tunnel,
                                      SCRel = loc.SCRel,
                                      Floor = loc.Floor,
                                      WarehouseCode = loc.WarehouseCode,
                                      ContGrpBarCode = loc.ContGrpBarCode,
                                      ContGrpId = loc.ContGrpId,
                                      Id = loc.Id,
                                      StateNum = loc.StateNum,
                                      SkuCode = rule1.SkuCode,
                                      Wind = stock.Wind,
                                      InDocsNo = stock.InDocsNo,
                                      BatchNo = stock.BatchNo
                                  };
            //查找满足时效但是没有全部检测完成的盘所在的机器组
            var invlistTors = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                              join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && p.IsControlpanel == true && p.IsTorsChk == true && p.TorsChkQty > 0 && string.IsNullOrEmpty(p.PreStock) && !p.ProductMachCode.Contains("R")
                              && p.ContUsageQty <= 0 && (DateTime.Now - p.ProductTime).TotalHours < timeOutHoldHours)
                              on loc.ContGrpBarCode equals stock.ContGrpBarCode
                              join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                              on stock.InDocsNo equals rule1.DocsNo
                              select new StockTemp
                              {
                                  MatCode = stock.MatCode,
                                  InvBarCode = stock.InvBarCode,
                                  Grade = stock.Grade,
                                  InvStateCode = stock.InvStateCode,
                                  ProductTime = stock.ProductTime,
                                  WbGroupCode = stock.WbGroupCode,
                                  IsTorsChk = stock.IsTorsChk,
                                  TorsChkQty = stock.TorsChkQty,
                                  TorsChkValue = stock.TorsChkValue,
                                  HoldTime = stock.HoldTime,
                                  ProductMachCode = stock.ProductMachCode,
                                  IsControlpanel = stock.IsControlpanel,
                                  HWTypeCode = stock.HWTypeCode,
                                  SolderCount = stock.SolderCount,
                                  IsRework = stock.IsRework,
                                  IsBlack = stock.IsBlack,
                                  Col = loc.Col,
                                  Layer = loc.Layer,
                                  Shelf = loc.Shelf,
                                  Depth = loc.Depth,
                                  Code = loc.Code,
                                  Tunnel = loc.Tunnel,
                                  SCRel = loc.SCRel,
                                  Floor = loc.Floor,
                                  WarehouseCode = loc.WarehouseCode,
                                  ContGrpBarCode = loc.ContGrpBarCode,
                                  ContGrpId = loc.ContGrpId,
                                  Id = loc.Id,
                                  StateNum = loc.StateNum,
                                  SkuCode = rule1.SkuCode,
                                  Wind = stock.Wind,
                                  InDocsNo = stock.InDocsNo,
                                  BatchNo = stock.BatchNo
                              };
            var invlistTorschongrao = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                                      join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && p.IsControlpanel == true && p.IsTorsChk == true && p.TorsChkQty > 0 && string.IsNullOrEmpty(p.PreStock) && p.ProductMachCode.Contains("R")
                                      && p.ContUsageQty <= 0 && (DateTime.Now - p.OneInTime).TotalHours < timeOutHoldHours)
                                      on loc.ContGrpBarCode equals stock.ContGrpBarCode
                                      join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                                      on stock.InDocsNo equals rule1.DocsNo
                                      select new StockTemp
                                      {
                                          MatCode = stock.MatCode,
                                          InvBarCode = stock.InvBarCode,
                                          Grade = stock.Grade,
                                          InvStateCode = stock.InvStateCode,
                                          ProductTime = stock.ProductTime,
                                          WbGroupCode = stock.WbGroupCode,
                                          IsTorsChk = stock.IsTorsChk,
                                          TorsChkQty = stock.TorsChkQty,
                                          TorsChkValue = stock.TorsChkValue,
                                          HoldTime = stock.HoldTime,
                                          ProductMachCode = stock.ProductMachCode,
                                          IsControlpanel = stock.IsControlpanel,
                                          HWTypeCode = stock.HWTypeCode,
                                          SolderCount = stock.SolderCount,
                                          IsRework = stock.IsRework,
                                          IsBlack = stock.IsBlack,
                                          Col = loc.Col,
                                          Layer = loc.Layer,
                                          Shelf = loc.Shelf,
                                          Depth = loc.Depth,
                                          Code = loc.Code,
                                          Tunnel = loc.Tunnel,
                                          SCRel = loc.SCRel,
                                          Floor = loc.Floor,
                                          WarehouseCode = loc.WarehouseCode,
                                          ContGrpBarCode = loc.ContGrpBarCode,
                                          ContGrpId = loc.ContGrpId,
                                          Id = loc.Id,
                                          StateNum = loc.StateNum,
                                          SkuCode = rule1.SkuCode,
                                          Wind = stock.Wind,
                                          InDocsNo = stock.InDocsNo,
                                          BatchNo = stock.BatchNo
                                      };
            invlist = invlist.Union(invlistchognrao);
            invlist = invlist.Union(invlistTors);
            invlist = invlist.Union(invlistTorschongrao);

            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut6", new RedisErrorInfo() { Equip = "NoControlOut6", Con = "非控制盘库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            //invlist = invlist.Where(p => p.WbGroupCode == "A14" && p.Wind == "R");

            invlist = invlist.Distinct(new CompareStock());
            //禁用巷道过滤
            var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
            if (tunlist.Any())
            {
                if (tunlist.Where(p => p.Default2 == "1").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 1 && tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤1层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "2").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 2 && tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤2层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "3").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 3 && tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤3层被禁用的出库巷道
                }
            }
            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut6", new RedisErrorInfo() { Equip = "NoControlOut6", Con = "非控制盘禁用巷道后 | 库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "禁用巷道后 | 库存不足";
                return res;
            }
            var invlist2 = invlist;

            var sku = invlist.OrderBy(p => p.ProductTime).GroupBy(p => p.SkuCode).ToList();
            if (!sku.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut7", new RedisErrorInfo() { Equip = "NoControlOut7", Con = "库中没有SKU或SKU不能为空", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库中没有SKU或SKU不能为空";
                return res;
            }

            var rulelist = _boxrulerepository.GetList(p => p.ZXStateCode == 0 && p.PackRule == "SPC" && !string.IsNullOrEmpty(p.Wind) && (p.FullCountQty == 72 || p.FullCountQty == 36));
            if (!rulelist.Any())
            {
                string msg = "SPC" + ResponseStatusCodeEnum.NotBoxRule.GetDescription();
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut8", new RedisErrorInfo() { Equip = "NoControlOut8", Con = msg, Time = DateTime.Now });
                _logger.LogInformation("非控制不满足装箱：" + msg);

                WreTimeOutRecord(invlist.Select(p => p.ContGrpBarCode).ToList(), "没有箱号可以使用，单号：" + JsonConvert.SerializeObject(invlist.GroupBy(v => v.InDocsNo).Select(p => p.Key).Distinct().ToList()));

                res.ResCode = ResponseStatusCodeEnum.NotBoxRule.GetHashCode();
                res.ResMsg = "SPC" + ResponseStatusCodeEnum.NotBoxRule.GetDescription();
                return res;
            }

            //SKU循环
            foreach (var item in sku)
            {
                //满足sku下的箱号列表
                var rules = rulelist.Where(p => p.SkuCode == item.Key && p.PackRule == "SPC" && p.ZXStateCode == 0 && !string.IsNullOrEmpty(p.Wind) && (p.FullCountQty == 72 || p.FullCountQty == 36)).OrderBy(p => p.BatchNo).ThenBy(p => p.PBoxCode);
                if (!rules.Any())
                {
                    string msg = "SKU:" + item.Key + ",没有可用箱号";
                    RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut9", new RedisErrorInfo() { Equip = "NoControlOut9", Con = msg, Time = DateTime.Now });
                    _logger.LogInformation("非控制不满足装箱：" + msg);
                    res.ResMsg = msg;
                    WreTimeOutRecord(invlist.Where(p => p.SkuCode == item.Key).Select(p => p.ContGrpBarCode).ToList(), "没有箱号可以使用,SKU:" + item.Key + ",单号：" + JsonConvert.SerializeObject(invlist.GroupBy(v => v.InDocsNo).Select(p => p.Key).Distinct().ToList()));
                    continue;
                }
                var rulegroup = rules.GroupBy(p => new
                {
                    p.Wind,
                    p.SpoolType,
                    p.FullCountQty
                }).ToList();
                //绕向、工字轮循环
                foreach (var rulestem in rulegroup)
                {
                    //  满足sku、绕向、工字轮规格、满箱个数的箱号列表
                    var rule = rules.Where(p => p.SkuCode == item.Key && p.SpoolType == rulestem.Key.SpoolType && p.Wind == rulestem.Key.Wind && p.FullCountQty == rulestem.Key.FullCountQty).OrderBy(p => p.BatchNo).ThenBy(p => p.PBoxCode).FirstOrDefault();
                    //拆盘机配置，可用于禁用拆盘机
                    var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
                    List<string> equips = new List<string>();
                    foreach (var pp in sys)
                    {
                        if (pp.SContent.Split(",").Contains(rule.TrayCode))
                        {
                            equips.Add(pp.Code);
                        }
                    }
                    if (!equips.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut10", new RedisErrorInfo() { Equip = "NoControlOut10", Con = rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码" + "SKU:" + item.Key, Time = DateTime.Now });
                        _logger.LogInformation(rule.TrayCode + "当前子托盘没有配置，请先配置子托盘编码" + "SKU:" + item.Key);
                        //自动更新子托盘配置，不需要手动配置
                        foreach (var item1 in sys)
                        {
                            if (!item1.SContent.Contains(rule.TrayCode))
                            {
                                string con = item1.SContent + "," + rule.TrayCode;
                                _sysconfigrepository.AsUpdateable()
                                 .SetColumns(p => new sxSysConfig() { SContent = con })
                                 .Where(p => p.Id == item1.Id)
                                 .ExecuteCommand();
                            }
                        }
                        continue;
                    }

                    if (rule.SkuCode == "6210010401" || rule.SkuCode == "6210120101")
                    {
                        var wbgroup = invlist.Where(p => p.SkuCode == rule.SkuCode).OrderBy(p => p.ProductTime);
                        if (!wbgroup.Any())
                        {
                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut12", new RedisErrorInfo() { Equip = "NoControlOut12", Con = "SKU:" + rule.SkuCode + "下的库存机器组不能为空1", Time = DateTime.Now });
                            WreTimeOutRecord(invlist.Where(p => p.SkuCode == rule.SkuCode).Select(p => p.ContGrpBarCode).ToList(), "条码信息机器组为空1");

                            continue;
                        }

                        invlist2 = invlist.Where(p => p.SkuCode == item.Key && p.HWTypeCode == rule.SpoolType && p.Wind == rule.Wind);

                        //invlist2 = invlistchongrao.Union(invlist2);

                        if (invlist2.Any() && invlist2.Count() >= rule.FullCountQty)
                        {
                        }
                        else
                        {
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "不满足装箱数量，数量为" + invlist2.Count() + ",SKU:" + item.Key + "，机器组;" + "999999999999" + ",型号:" + rule.SpoolType + ",绕向:" + rule.Wind);
                            continue;
                        }

                        if (!string.IsNullOrEmpty(rule.SpoolType))
                        {
                            invlist2 = invlist2.Where(p => p.HWTypeCode == rule.SpoolType);
                        }
                        if (!string.IsNullOrEmpty(rule.Wind))
                        {
                            invlist2 = invlist2.Where(p => p.Wind == rule.Wind);
                        }

                        #region 焊点相关处理

                        var tempoutrecord = invlist2.ToList();
                        var solderinvlist = SxServiceHelp.ProcessWeldingPointsBoxing(rule, invlist2, out invlist2);

                        #endregion 焊点相关处理

                        var returninvlist = new List<StockTemp>();
                        if (rule.ReturnCount > 0)
                        {
                            returninvlist = invlist2.Where(p => p.IsRework == true).Take(rule.ReturnCount).ToList();
                            invlist2 = invlist2.Where(p => p.IsRework == false);
                        }
                        else
                        {
                            invlist2 = invlist2.Where(p => p.IsRework == false);
                        }

                        if (!invlist2.Any())
                        {
                            string msg = "SPC非控制箱不满足装箱规则，箱号：" + rule.PBoxCode + "sku:" + rule.SkuCode;
                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut15", new RedisErrorInfo() { Equip = "NoControlOut15", Con = msg, Time = DateTime.Now });
                            _logger.LogInformation("非控制不满足装箱：" + msg);
                            res.ResMsg = msg;
                            WreTimeOutRecord(tempoutrecord.Select(p => p.ContGrpBarCode).ToList(), "焊点不满足," + "SKU:" + rule.SkuCode + ",机器组：" + "999999999999" + ",绕向：" + rule.Wind);
                            continue;
                        }

                        if ((invlist2.Count() + solderinvlist.Count + returninvlist.Count) < rule.FullCountQty)
                        {
                            string msg = "sku:" + rule.SkuCode + ",机器组：" + "999999999999" + ",绕向:" + rule.Wind + ",型号:" + invlist2.First().HWTypeCode + ",SPC非控制箱不满足装箱数量，需要装" + rule.FullCountQty + "实际数量：" + (invlist2.Count() + solderinvlist.Count + returninvlist.Count) + "；普通盘" + invlist2.Count() + ",焊点盘" + solderinvlist.Count + ",返工盘" + returninvlist.Count;
                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut16", new RedisErrorInfo() { Equip = "NoControlOut16", Con = msg, Time = DateTime.Now });
                            _logger.LogInformation("非控制不满足装箱：" + msg);
                            res.ResMsg = msg;
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), msg);
                            WreTimeOutRecord(returninvlist.Select(p => p.ContGrpBarCode).ToList(), msg);
                            WreTimeOutRecord(solderinvlist.Select(p => p.ContGrpBarCode).ToList(), msg);
                            continue;
                        }

                        var firstproducttime = invlist2.OrderBy(p => p.ProductTime).First().ProductTime;
                        var invlist2temp6hours = invlist2.ToList().Where(p => (p.ProductTime - firstproducttime).TotalHours <= 72); //72小时之内的按堆垛机平均分

                        #region 按照堆垛机平均分配任务,6小时之内

                        var tempcount = rule.FullCountQty - (solderinvlist.Count + returninvlist.Count);//符合条件的普通盘数量
                        var mastinvlist = solderinvlist.Union(returninvlist);
                        var tempinvlist = invlist2temp6hours.Union(mastinvlist);
                        var srmlist = tempinvlist.Select(p => p.SCRel).Distinct();//总共多少个堆垛机

                        var mustsrmtasktobe = from x in mastinvlist.GroupBy(p => p.SCRel)
                                              select new SrmTaskTmep
                                              {
                                                  Srm = x.Key,
                                                  TaskCount = x.Count(),
                                                  LocList = x.Select(q => q.Code).ToList()
                                              };
                        var srmtasktobe = new List<SrmTaskTmep>();

                        foreach (var srmlistitem in srmlist)
                        {
                            if (!mustsrmtasktobe.Where(p => p.Srm == srmlistitem).Any())
                            {
                                srmtasktobe.Add(new SrmTaskTmep()
                                {
                                    Srm = srmlistitem,
                                    TaskCount = 0,
                                    LocList = new List<string>()
                                });
                            }
                        }
                        srmtasktobe.AddRange(mustsrmtasktobe);//所有堆垛机任务数量，接占用的库位数
                        var srmtasktobetemplocs = new List<string>();
                        for (int i = 0; i < tempcount; i++)
                        {
                            srmtasktobe = srmtasktobe.OrderBy(p => p.LocList.Count).ToList();//堆垛机任务排序，少的优先
                            var templocs = srmtasktobe.SelectMany(q => q.LocList);
                            foreach (var srmtasktobeitem in srmtasktobe)
                            {
                                if (tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).Any())
                                {
                                    var first = tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).First();
                                    srmtasktobe.Where(p => p.Srm == srmtasktobeitem.Srm).First().LocList.Add(first.Code);
                                    srmtasktobetemplocs.Add(first.Code);
                                    break;
                                }
                            }
                        }

                        #endregion 按照堆垛机平均分配任务,6小时之内

                        var tempbuchong = new List<StockTemp>();
                        if (tempcount > srmtasktobetemplocs.Count())
                        {
                            tempbuchong = invlist2.Where(p => !srmtasktobetemplocs.Contains(p.Code)).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).Take(tempcount - srmtasktobetemplocs.Count()).ToList();
                        }
                        invlist2 = invlist2.Where(p => srmtasktobetemplocs.Contains(p.Code)).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).Take(rule.FullCountQty - (solderinvlist.Count + returninvlist.Count));
                        invlist2 = invlist2.Union(solderinvlist).Union(returninvlist);
                        invlist2 = invlist2.Union(tempbuchong);

                        var finstocks = invlist2.ToList();
                        //最后验证数据

                        #region 最后验证数据

                        if (finstocks.Select(p => p.ContGrpBarCode).Distinct().Count() != 36 && finstocks.Select(p => p.ContGrpBarCode).Distinct().Count() != 72)
                        {
                            _logger.LogInformation("非控制盘最终检查装箱数量不配置ContGrpBarCode" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            continue;
                        }
                        if (finstocks.Select(p => p.ContGrpId).Distinct().Count() != 36 && finstocks.Select(p => p.ContGrpId).Distinct().Count() != 72)
                        {
                            _logger.LogInformation("非控制盘最终检查装箱数量不配置ContGrpId" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            continue;
                        }
                        if (finstocks.Select(p => p.Wind).Distinct().Count() > 1)
                        {
                            _logger.LogInformation("非控制盘最终检查装箱绕向大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            continue;
                        }

                        //if (finstocks.Where(p => !string.IsNullOrWhiteSpace(p.WbGroupCode) && !p.InDocsNo.Contains("CHA")).Select(p => p.WbGroupCode).Distinct().Count() > 1)
                        //{
                        //    _logger.LogInformation("非控制盘最终检查装箱机器组大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                        //    continue;
                        //}
                        if (finstocks.Select(p => p.HWTypeCode).Distinct().Count() > 1)
                        {
                            _logger.LogInformation("非控制盘最终检查装箱轮子种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            continue;
                        }
                        if (finstocks.Select(p => p.MatCode).Distinct().Count() > 1)
                        {
                            _logger.LogInformation("非控制盘最终检查物料种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            continue;
                        }
                        var docs = finstocks.Select(p => p.InDocsNo).Distinct().ToList();
                        if (_boxrulerepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PackRule == "SPC" && docs.Contains(p.DocsNo)).Select(p => p.SkuCode).Distinct().Count() > 1)
                        {
                            _logger.LogInformation("非控制盘最终检查SKU种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                            _logger.LogInformation("非控制盘最终检查SKU种类大于1" + JsonConvert.SerializeObject(finstocks.Select(p => p.ContGrpBarCode).Distinct().ToList()));
                            continue;
                        }

                        #endregion 最后验证数据

                        #region Mes箱号校验

                        var boxmes = new MesBoxVerify() { HuNr = rule.PBoxCode, Batch = rule.BatchNo };
                        var url = wms.util.AppSettings.GetConfig("EsbMesPushUrl");
                        var reqids = Guid.NewGuid().ToString();
                        var reqs = new EsbReq() { headers = new HeadersReq() { serviceCode = "163K162003", requestId = reqids, TrackId = reqids, sourceCode = "163K" } };
                        var str = HttpUtil.PostRequest(url, JsonConvert.SerializeObject(boxmes), 30000, "UTF-8", "application/json", reqids, reqs.headers.sourceCode, reqs.headers.serviceCode);
                        var mesresponse = JsonConvert.DeserializeObject<TorschMesResponse>(str);
                        _logger.LogInformation("非控制装箱：申请箱号mes返回" + str);

                        if (mesresponse.success == false)
                        {
                            _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                            {
                                ZXStateCode = 2,
                                EditTime = DateTime.Now,
                                Memo = mesresponse.message
                            }, p => p.Id == rule.Id);
                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut17", new RedisErrorInfo() { Equip = "NoControlOut17", Con = "非控制装箱mes申请箱号返回：" + mesresponse.message, Time = DateTime.Now });
                            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            res.ResMsg = "非控制装箱：申请箱号mes返回" + mesresponse.message;
                            _logger.LogInformation(res.ResMsg);
                            WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "非控制装箱：申请箱号mes返回" + mesresponse.message);
                            break;
                        }
                        else
                        {
                            try
                            {
                                var listid = finstocks.Select(p => p.ContGrpId).ToList();
                                _db.BeginTran();
                                //非控制箱预占状态更新成4
                                _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                                {
                                    ZXStateCode = 4,
                                    EditTime = DateTime.Now,
                                    Memo = mesresponse.message
                                }, p => p.Id == rule.Id);
                                var presign = rule.Id.ToString();
                                _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                                {
                                    PreStock = presign,
                                    EditTime = DateTime.Now,
                                    Memo = "箱号预占用:" + rule.PBoxCode
                                }, p => listid.Contains(p.ContGrpId));
                                _db.CommitTran();
                                _logger.LogInformation(rule.PBoxCode + "预占:" + JsonConvert.SerializeObject(listid));
                            }
                            catch (Exception ex)
                            {
                                _logger.LogInformation("箱号预占用异常" + ex.ToString());
                                _db.RollbackTran();
                            }
                            return res;
                        }

                        #endregion Mes箱号校验
                    }
                    else
                    {
                        var wbgrouplist = invlist.Where(p => p.SkuCode == rule.SkuCode).OrderBy(p => p.ProductTime).GroupBy(p => p.WbGroupCode);
                        if (!wbgrouplist.Any())
                        {
                            RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut12", new RedisErrorInfo() { Equip = "NoControlOut12", Con = "SKU:" + rule.SkuCode + "下的库存机器组不能为空", Time = DateTime.Now });
                            WreTimeOutRecord(invlist.Where(p => p.SkuCode == rule.SkuCode).Select(p => p.ContGrpBarCode).ToList(), "条码信息机器组为空");

                            continue;
                        }

;
                        //机器组循环
                        foreach (var wbgroup in wbgrouplist)
                        {
                            invlist2 = invlist.Where(p => p.SkuCode == item.Key && p.WbGroupCode == wbgroup.Key && p.HWTypeCode == rule.SpoolType && p.Wind == rule.Wind);

                            //invlist2 = invlistchongrao.Union(invlist2);

                            if (invlist2.Any() && invlist2.Count() >= rule.FullCountQty)
                            {
                            }
                            else
                            {
                                WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "不满足装箱数量，数量为" + invlist2.Count() + ",SKU:" + item.Key + "，机器组;" + wbgroup.Key + ",型号:" + rule.SpoolType + ",绕向:" + rule.Wind);
                                continue;
                            }

                            if (!string.IsNullOrEmpty(rule.SpoolType))
                            {
                                invlist2 = invlist2.Where(p => p.HWTypeCode == rule.SpoolType);
                            }
                            if (!string.IsNullOrEmpty(rule.Wind))
                            {
                                invlist2 = invlist2.Where(p => p.Wind == rule.Wind);
                            }

                            #region 焊点相关处理

                            var tempoutrecord = invlist2.ToList();
                            var solderinvlist = SxServiceHelp.ProcessWeldingPointsBoxing(rule, invlist2, out invlist2);

                            #endregion 焊点相关处理

                            var returninvlist = new List<StockTemp>();
                            if (rule.ReturnCount > 0)
                            {
                                returninvlist = invlist2.Where(p => p.IsRework == true).Take(rule.ReturnCount).ToList();
                                invlist2 = invlist2.Where(p => p.IsRework == false);
                            }
                            else
                            {
                                invlist2 = invlist2.Where(p => p.IsRework == false);
                            }

                            if (!invlist2.Any())
                            {
                                string msg = "SPC非控制箱不满足装箱规则，箱号：" + rule.PBoxCode + "sku:" + rule.SkuCode;
                                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut15", new RedisErrorInfo() { Equip = "NoControlOut15", Con = msg, Time = DateTime.Now });
                                _logger.LogInformation("非控制不满足装箱：" + msg);
                                res.ResMsg = msg;
                                WreTimeOutRecord(tempoutrecord.Select(p => p.ContGrpBarCode).ToList(), "焊点不满足," + "SKU:" + rule.SkuCode + ",机器组：" + tempoutrecord.First().WbGroupCode + ",绕向：" + rule.Wind);
                                continue;
                            }

                            if ((invlist2.Count() + solderinvlist.Count + returninvlist.Count) < rule.FullCountQty)
                            {
                                string msg = "sku:" + rule.SkuCode + ",机器组：" + invlist2.First().WbGroupCode + ",绕向:" + rule.Wind + ",型号:" + invlist2.First().HWTypeCode + ",SPC非控制箱不满足装箱数量，需要装" + rule.FullCountQty + "实际数量：" + (invlist2.Count() + solderinvlist.Count + returninvlist.Count) + "；普通盘" + invlist2.Count() + ",焊点盘" + solderinvlist.Count + ",返工盘" + returninvlist.Count;
                                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut16", new RedisErrorInfo() { Equip = "NoControlOut16", Con = msg, Time = DateTime.Now });
                                _logger.LogInformation("非控制不满足装箱：" + msg);
                                res.ResMsg = msg;
                                WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), msg);
                                WreTimeOutRecord(returninvlist.Select(p => p.ContGrpBarCode).ToList(), msg);
                                WreTimeOutRecord(solderinvlist.Select(p => p.ContGrpBarCode).ToList(), msg);
                                continue;
                            }

                            var firstproducttime = invlist2.OrderBy(p => p.ProductTime).First().ProductTime;
                            var invlist2temp6hours = invlist2.ToList().Where(p => (p.ProductTime - firstproducttime).TotalHours <= 72); //72小时之内的按堆垛机平均分

                            #region 按照堆垛机平均分配任务,6小时之内

                            var tempcount = rule.FullCountQty - (solderinvlist.Count + returninvlist.Count);//符合条件的普通盘数量
                            var mastinvlist = solderinvlist.Union(returninvlist);
                            var tempinvlist = invlist2temp6hours.Union(mastinvlist);
                            var srmlist = tempinvlist.Select(p => p.SCRel).Distinct();//总共多少个堆垛机

                            var mustsrmtasktobe = from x in mastinvlist.GroupBy(p => p.SCRel)
                                                  select new SrmTaskTmep
                                                  {
                                                      Srm = x.Key,
                                                      TaskCount = x.Count(),
                                                      LocList = x.Select(q => q.Code).ToList()
                                                  };
                            var srmtasktobe = new List<SrmTaskTmep>();

                            foreach (var srmlistitem in srmlist)
                            {
                                if (!mustsrmtasktobe.Where(p => p.Srm == srmlistitem).Any())
                                {
                                    srmtasktobe.Add(new SrmTaskTmep()
                                    {
                                        Srm = srmlistitem,
                                        TaskCount = 0,
                                        LocList = new List<string>()
                                    });
                                }
                            }
                            srmtasktobe.AddRange(mustsrmtasktobe);//所有堆垛机任务数量，接占用的库位数
                            var srmtasktobetemplocs = new List<string>();
                            for (int i = 0; i < tempcount; i++)
                            {
                                srmtasktobe = srmtasktobe.OrderBy(p => p.LocList.Count).ToList();//堆垛机任务排序，少的优先
                                var templocs = srmtasktobe.SelectMany(q => q.LocList);
                                foreach (var srmtasktobeitem in srmtasktobe)
                                {
                                    if (tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).Any())
                                    {
                                        var first = tempinvlist.Where(p => !templocs.Contains(p.Code) && srmtasktobeitem.Srm == p.SCRel).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).First();
                                        srmtasktobe.Where(p => p.Srm == srmtasktobeitem.Srm).First().LocList.Add(first.Code);
                                        srmtasktobetemplocs.Add(first.Code);
                                        break;
                                    }
                                }
                            }

                            #endregion 按照堆垛机平均分配任务,6小时之内

                            var tempbuchong = new List<StockTemp>();
                            if (tempcount > srmtasktobetemplocs.Count())
                            {
                                tempbuchong = invlist2.Where(p => !srmtasktobetemplocs.Contains(p.Code)).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).Take(tempcount - srmtasktobetemplocs.Count()).ToList();
                            }
                            invlist2 = invlist2.Where(p => srmtasktobetemplocs.Contains(p.Code)).OrderBy(p => p.Depth).ThenBy(p => p.ProductTime).Take(rule.FullCountQty - (solderinvlist.Count + returninvlist.Count));
                            invlist2 = invlist2.Union(solderinvlist).Union(returninvlist);
                            invlist2 = invlist2.Union(tempbuchong);

                            var finstocks = invlist2.ToList();
                            //最后验证数据

                            #region 最后验证数据

                            if (finstocks.Select(p => p.ContGrpBarCode).Distinct().Count() != 36 && finstocks.Select(p => p.ContGrpBarCode).Distinct().Count() != 72)
                            {
                                _logger.LogInformation("非控制盘最终检查装箱数量不配置ContGrpBarCode" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }
                            if (finstocks.Select(p => p.ContGrpId).Distinct().Count() != 36 && finstocks.Select(p => p.ContGrpId).Distinct().Count() != 72)
                            {
                                _logger.LogInformation("非控制盘最终检查装箱数量不配置ContGrpId" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }
                            if (finstocks.Select(p => p.Wind).Distinct().Count() > 1)
                            {
                                _logger.LogInformation("非控制盘最终检查装箱绕向大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }

                            if (finstocks.Where(p => !string.IsNullOrWhiteSpace(p.WbGroupCode) && !p.InDocsNo.Contains("CHA")).Select(p => p.WbGroupCode).Distinct().Count() > 1)
                            {
                                _logger.LogInformation("非控制盘最终检查装箱机器组大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }
                            if (finstocks.Select(p => p.HWTypeCode).Distinct().Count() > 1)
                            {
                                _logger.LogInformation("非控制盘最终检查装箱轮子种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }
                            if (finstocks.Select(p => p.MatCode).Distinct().Count() > 1)
                            {
                                _logger.LogInformation("非控制盘最终检查物料种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                continue;
                            }
                            var docs = finstocks.Select(p => p.InDocsNo).Distinct().ToList();
                            if (_boxrulerepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PackRule == "SPC" && docs.Contains(p.DocsNo)).Select(p => p.SkuCode).Distinct().Count() > 1)
                            {
                                _logger.LogInformation("非控制盘最终检查SKU种类大于1" + string.Format("{0},{1},{2},{3}", invlist2.First().WbGroupCode, invlist2.First().Wind, invlist2.First().SkuCode, invlist2.First().HWTypeCode));
                                _logger.LogInformation("非控制盘最终检查SKU种类大于1" + JsonConvert.SerializeObject(finstocks.Select(p => p.ContGrpBarCode).Distinct().ToList()));
                                continue;
                            }

                            #endregion 最后验证数据

                            #region Mes箱号校验

                            var boxmes = new MesBoxVerify() { HuNr = rule.PBoxCode, Batch = rule.BatchNo };
                            var url = wms.util.AppSettings.GetConfig("EsbMesPushUrl");
                            var reqids = Guid.NewGuid().ToString();
                            var reqs = new EsbReq() { headers = new HeadersReq() { serviceCode = "163K162003", requestId = reqids, TrackId = reqids, sourceCode = "163K" } };
                            var str = HttpUtil.PostRequest(url, JsonConvert.SerializeObject(boxmes), 30000, "UTF-8", "application/json", reqids, reqs.headers.sourceCode, reqs.headers.serviceCode);
                            var mesresponse = JsonConvert.DeserializeObject<TorschMesResponse>(str);
                            _logger.LogInformation("非控制装箱：申请箱号mes返回" + str);

                            if (mesresponse.success == false)
                            {
                                _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                                {
                                    ZXStateCode = 2,
                                    EditTime = DateTime.Now,
                                    Memo = mesresponse.message
                                }, p => p.Id == rule.Id);
                                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut17", new RedisErrorInfo() { Equip = "NoControlOut17", Con = "非控制装箱mes申请箱号返回：" + mesresponse.message, Time = DateTime.Now });
                                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                                res.ResMsg = "非控制装箱：申请箱号mes返回" + mesresponse.message;
                                _logger.LogInformation(res.ResMsg);
                                WreTimeOutRecord(invlist2.Select(p => p.ContGrpBarCode).ToList(), "非控制装箱：申请箱号mes返回" + mesresponse.message);
                                break;
                            }
                            else
                            {
                                try
                                {
                                    var listid = finstocks.Select(p => p.ContGrpId).ToList();
                                    _db.BeginTran();
                                    //非控制箱预占状态更新成4
                                    _boxrulerepository.UpdateSetColumnsTrue(p => new BillPboxrule()
                                    {
                                        ZXStateCode = 4,
                                        EditTime = DateTime.Now,
                                        Memo = mesresponse.message
                                    }, p => p.Id == rule.Id);
                                    var presign = rule.Id.ToString();
                                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                                    {
                                        PreStock = presign,
                                        EditTime = DateTime.Now,
                                        Memo = "箱号预占用:" + rule.PBoxCode
                                    }, p => listid.Contains(p.ContGrpId));
                                    _db.CommitTran();
                                    _logger.LogInformation(rule.PBoxCode + "预占:" + JsonConvert.SerializeObject(listid));
                                }
                                catch (Exception ex)
                                {
                                    _logger.LogInformation("箱号预占用异常" + ex.ToString());
                                    _db.RollbackTran();
                                }
                                return res;
                            }

                            #endregion Mes箱号校验
                        }
                    }
                }
            }
            return res;
        }

        private SRes PalletizingPackTask(PalletizingPackTaskRequest request)
        {
            return SxServiceHelp.PalletizingPackTask(request, _basewarecellrepository, _billInvnowrepository,
                _billInvflow, _taskrepository, _wcstaskoldrepository, _taskdetailrepository, _db, _mapper, lockerPalletizingPackTask);
        }

        public SRes CancelTaskVerify(CancelTaskRequest request)
        {
            var res = new SRes();
            if (!request.TaskNo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            foreach (var item in request.TaskNo)
            {
                var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == item && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                if (task == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    res.ResMsg = item + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    return res;
                }

                if (task.Type == TaskType.EnterDepot)
                {
                    //验证组盘状态
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = task.BarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }

                    if (request.State == HandleTaskTypeEnum.完成任务)
                    {
                        if (stock.InvStateCode != InvState.InvEcecState_BuildUp.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.RFIDStockStateFail.GetHashCode();
                            res.ResMsg = stock.ContGrpBarCode + "不是已组盘状态，不允许完成";
                            return res;
                        }
                        if (stock.InvStateCode == InvState.InvEcecState_In.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                            res.ResMsg = stock.ContGrpBarCode + "组盘信息是已入库，请确认是否重复";
                            return res;
                        }
                    }
                    else if (request.State == HandleTaskTypeEnum.取消任务)
                    {
                        if (stock.InvStateCode == InvState.InvEcecState_In.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                            res.ResMsg = stock.ContGrpBarCode + ResponseStatusCodeEnum.StockStateFail.GetDescription();
                            return res;
                        }
                    }
                }
                else if (task.Type == TaskType.OutDepot)
                {
                    //验证组盘状态
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = task.BarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }

                    if (request.State == HandleTaskTypeEnum.完成任务)
                    {
                        if (stock.InvStateCode != InvState.InvEcecState_OutGoing.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                            res.ResMsg = stock.ContGrpBarCode + "当前的组盘状态不是出库中，不允许完成";
                            return res;
                        }
                    }
                    else if (request.State == HandleTaskTypeEnum.取消任务)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                        if (cell == null)
                        {
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            res.ResMsg = stock + ResponseStatusCodeEnum.Fail.GetDescription() + "堆垛机已放货完成，不支持取消";
                            return res;
                        }
                        if (stock.InvStateCode == InvState.InvEcecState_Out.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                            res.ResMsg = ResponseStatusCodeEnum.StockStateFail.GetDescription();
                            return res;
                        }
                    }
                }
                else if (task.Type == TaskType.TransferDepot)
                {
                    //验证组盘状态
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = task.BarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }

                    if (request.State == HandleTaskTypeEnum.完成任务)
                    {
                        if (stock.InvStateCode != InvState.InvEcecState_In.ToString())
                        {
                            res.ResCode = ResponseStatusCodeEnum.RFIDStockStateFail.GetHashCode();
                            res.ResMsg = stock.ContGrpBarCode + "移库任务组盘信息不是已入库，不允许完成";
                            return res;
                        }
                    }
                    else if (request.State == HandleTaskTypeEnum.取消任务)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                        res.ResMsg = stock.ContGrpBarCode + "移库任务不允许取消";
                        return res;
                    }
                }
            }
            return res;
        }

        public SRes CarryTaskInfo(CancelTaskRequest request)
        {
            var res = new SRes();
            if (!request.TaskNo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            foreach (var item in request.TaskNo)
            {
                if (request.State == HandleTaskTypeEnum.完成任务)
                {
                    var con = SrmCompleted(new SxCompleteTaskRequest() { TaskNum = item, OperationType = 2, WCSUpdateName = "手动完成任务", Memo1 = "", Memo2 = "" });
                    if (con.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        return res = con;
                    }
                }
                if (request.State == HandleTaskTypeEnum.取消任务)
                {
                    var con = CancelTask(new CompleteTaskRequest() { TaskNum = item, OperationType = 2, WCSUpdateName = "手动取消任务", Memo1 = "", Memo2 = "" });
                    if (con.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        return res = con;
                    }
                }
            }
            return res;
        }

        public SRes CancelTask(CompleteTaskRequest request)
        {
            var res = new SRes();

            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == request.TaskNum && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            try
            {
                if (task.Type == TaskType.EnterDepot)
                {
                    //验证组盘状态
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.Memo = "客户端取消入库任务";
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    _db.BeginTran();
                    _billInvnowrepository.DeleteById(stock.Id);
                    _billInvinitrepository.Delete(p => p.ContGrpBarCode == task.BarCode);
                    _billInvflow.Insert(flow);
                    _db.CommitTran();
                }
                else if (task.Type == TaskType.OutDepot)
                {
                    //验证组盘状态
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (cell == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = task.BarCode + ResponseStatusCodeEnum.Fail.GetDescription() + "堆垛机已放货完成，不允许取消";
                        return res;
                    }
                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_In.ToString();
                    flow.Memo = "客户端取消出库任务";
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    _db.BeginTran();
                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        StateNum = LocationState.LocationState_Full,
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == task.BarCode);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_In.ToString(),
                        PutRow = cell.Row,
                        PutCol = cell.Col,
                        PutLayer = cell.Layer,
                        EditTime = DateTime.Now,
                        PreStock = ""//把预锁的标记去掉
                    }, p => p.ContGrpBarCode == task.BarCode);

                    //取消任务把响应的码垛信息表业删除
                    _palletlayerMathrepository.Delete(p => p.ContBarCode == task.BarCode);
                    _billInvflow.Insert(flow);
                    _db.CommitTran();
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + "该任务类型不允许取消";
                    return res;
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = task.Id + ResponseStatusCodeEnum.Fail.GetDescription();
                _logger.LogInformation("任务取消失败,任务号：" + task.Id + ex.Message);
                return res;
            }

            return res;
        }

        public List<BillPushinfo> GetPushDatelistAuto(PushDate request)
        {
            var list = _billPushinforepository.GetList(p => p.PostResult != 1 && p.PostQty <= 5 && p.TypeCode == request.Type).OrderBy(p => p.AddTime).Take(request.Count).ToList();

            return list;
        }

        public bool UpdatePushModelColumns(UpdateModelColumns<BillPushinfo> updateModel)
        {
            return _billPushinforepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        /// <summary>
        /// 库存改判
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes StockChange(SxStockChangeRequest reqDto)
        {
            var res = new StockChangeResponse();
            if (!reqDto.ListInfo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return res;
            }

            List<BillInvnow> stocklist = new List<BillInvnow>();
            List<BillInvflow> flowlist = new List<BillInvflow>();

            foreach (var item in reqDto.ListInfo)
            {
                var stock = _billInvnowrepository.GetSingle(p => p.InvBarCode == item.MatBarCode && p.ContGrpBarCode == item.SpoolCode);
                if (stock != null)
                {
                    var flow = _mapper.Map<BillInvflow>(stock);
                    switch (item.State)
                    {
                        case "Lock":
                            stock.ExecStateCode = InvLockState.InvState_Lock.ToString();
                            flow.Memo = flow.Memo + "|执行改判状态" + item.State;
                            break;

                        case "Normal":
                            stock.ExecStateCode = InvLockState.InvState_Normal.ToString();
                            flow.Memo = flow.Memo + "|执行改判状态" + item.State;
                            break;

                        default:
                            break;
                    }
                    if (!string.IsNullOrEmpty(item.Grade))
                    {
                        stock.Grade = item.Grade;
                        flow.Memo = flow.Memo + "|执行改判等级" + item.Grade;
                    }
                    if (!string.IsNullOrEmpty(item.Reason))
                    {
                        stock.Memo = item.Reason;
                        flow.Memo = flow.Memo + "|执行改判原因" + item.Grade;
                    }
                    if (!string.IsNullOrEmpty(item.NewTorsValue))
                    {
                        flow.Memo = flow.Memo + "|执行改判扭转值新值" + item.NewTorsValue + "，原来值" + stock.TorsChkValue;
                        stock.TorsChkValue = decimal.Parse(item.NewTorsValue);
                        stock.TorsChkQty = 1;
                    }
                    stock.EditTime = DateTime.Now;
                    flow.AddTime = DateTime.Now;
                    flow.Id = IdFactory.NewId();

                    if (stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = stock.InvBarCode + "出库中不允许改判";
                        return res;
                    }
                    else
                    {
                        stocklist.Add(stock);
                    }
                    flowlist.Add(flow);
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = item.MatBarCode + "库存不存在";
                    return res;
                }
            }
            try
            {
                _db.BeginTran();
                _billInvflow.InsertRange(flowlist);
                _billInvnowrepository.UpdateRange(stocklist);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation("改判异常" + ex.ToString());
            }
            return res;
        }

        /// <summary>
        /// 预赋扭转值
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes PreSpecifiedTorsionValues(SxStockChangeRequest reqDto)
        {
            var res = new StockChangeResponse();
            if (!reqDto.ListInfo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return res;
            }

            List<BillInvnow> stocklist = new List<BillInvnow>();
            List<BillInvflow> flowlist = new List<BillInvflow>();

            foreach (var item in reqDto.ListInfo)
            {
                var stock = _billInvnowrepository.GetSingle(p => p.InvBarCode == item.MatBarCode && p.ContGrpBarCode == item.SpoolCode);
                if (stock != null)
                {
                    var flow = _mapper.Map<BillInvflow>(stock);
                    if (stock.IsTorsChk)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg += stock.InvBarCode + "等待扭转检测";
                        continue;
                    }
                    if (stock.TorsChkValue != null || stock.TorsChkQty >= 1)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg += stock.InvBarCode + "已有扭转值无法执行预赋值";
                        continue;
                    }
                    if (!string.IsNullOrEmpty(item.NewTorsValue))
                    {
                        flow.Memo = flow.Memo + "|预赋扭转值" + item.NewTorsValue + "，原来值" + stock.TorsChkValue;
                        stock.TorsChkValue = decimal.Parse(item.NewTorsValue);
                        stock.TorsChkQty = 1;
                    }

                    stock.EditTime = DateTime.Now;
                    flow.AddTime = DateTime.Now;
                    flow.Id = IdFactory.NewId();

                    if (stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString() || stock.InvStateCode == InvState.InvEcecState_Out.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg += stock.InvBarCode + "出库中不允许改变";
                        continue;
                    }
                    else
                    {
                        stocklist.Add(stock);
                    }
                    flowlist.Add(flow);
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg += item.MatBarCode + "库存不存在";
                    continue;
                }
            }
            try
            {
                _db.BeginTran();
                _billInvflow.InsertRange(flowlist);
                _billInvnowrepository.UpdateRange(stocklist);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation("改判异常" + ex.ToString());
            }
            return res;
        }

        public SRes InitWareCell(int row, int col, int deot, int rowcount, int tun)
        {
            var res = new SRes();
            var ware = _basewarehouserepository.GetFirst(p => p.IsStop == 0);
            for (int i = 0; i < row; i++)
            {
                string shlf = tun.ToString();
                if (row == 2)
                {
                    if (i == 0)
                    {
                        shlf = shlf + "L";
                    }
                    else
                    {
                        shlf = shlf + "R";
                    }
                }
                else if (row == 4)  //双升位
                {
                    if (i == 0 || i == 1)
                    {
                        shlf = shlf + "L";
                    }
                    else
                    {
                        shlf = shlf + "R";
                    }
                }
                for (int j = 0; j < deot; j++)
                {
                    for (int k = 0; k < col; k++)
                    {
                        var dept = "";
                        if (i == 0 || i == 3)
                        {
                            dept = "2";
                        }
                        else
                        {
                            dept = "1";
                        }
                        var code = new BaseWarecell()
                        {
                            Code = (rowcount + i).ToString() + "-" + (k + 1).ToString() + "-" + (j + 1).ToString() + "-" + shlf + "-" + dept,
                            Tunnel = tun,
                            IsStop = 0,
                            Name = (rowcount + i).ToString() + "行" + (k + 1).ToString() + "列" + (j + 1).ToString() + "层" + shlf + "货架" + dept + "深度",
                            WarehouseId = ware.Id,
                            WarehouseCode = ware.Code,
                            WareAreaId = 0,
                            StateNum = LocationState.LocationState_Empty,
                            TypeNum = LocationType.LocationType_StorageLocation,
                            Size = 1,
                            Row = (rowcount + i),
                            Col = (k + 1),
                            Layer = (j + 1),
                            Depth = int.Parse(dept),
                            SCRel = "SRM",
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            AddWho = "wms",
                            EditWho = "wms",
                            Shelf = shlf,
                            Floor = (j + 1) <= 4 ? 1 : (j + 1) > 4 && (j + 1) <= 8 ? 2 : (j + 1) > 8 && (j + 1) <= 12 ? 3 : 0
                        };
                        _basewarecellrepository.Insert(code);
                    }
                }
            }
            return res;
        }

        public sxSysJob GetJobEntityByid(string id)
        {
            return _jobrepository.GetSingle(p => p.Id == long.Parse(id));
        }

        public sxSysJob GetJobEntityByCode(string Code)
        {
            return _jobrepository.GetSingle(p => p.Code == Code);
        }

        public List<sxSysJobApiRelation> GetJobapilist(long id)
        {
            return _jobApirepository.GetList(p => p.JobId == id);
        }

        public List<sxSysJob> GetJobList()
        {
            return _jobrepository.GetList();
        }

        /// <summary>
        /// 接收扭转结果
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes TorsChkValue(TorsChkValueRequest request)
        {
            var res = new SRes();
            try
            {
                var taskold = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == int.Parse(request.TaskNo) && p.Type == TaskType.OutDepot && p.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription()).SplitTable(p => p.Take(2)).First();
                if (taskold == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription(), Time = DateTime.Now });
                    return res;
                }
                if (taskold.Status == TaskStatus.Finish && !_torchbandinforepository.IsAny(p => p.TaskNo == request.TaskNo))
                {
                    var codes = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == taskold.BarCode && p.IsTorsChk == true);
                    if (codes == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = request.TaskNo + "条码信息不存在";
                        RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + "条码信息不存在", Time = DateTime.Now });
                        return res;
                    }
                    _logger.LogInformation("扭转下位机重复上抛扭转值，任务号" + request.TaskNo);
                    return res;
                }
                var code = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == taskold.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                if (code == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + "库存状态不对，不是出库中", Time = DateTime.Now });
                    return res;
                }

                var torch = _torchbandinforepository.GetSingle(p => p.TaskNo == request.TaskNo);
                if (torch == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.TaskNo + "该工字轮没有扭转绑定信息";
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + "该工字轮没有扭转绑定信息", Time = DateTime.Now });
                    return res;
                }
                if (torch.Machine != request.TorsChkWb)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.TaskNo + "该工字轮已绑定的扭转机台与扭转上位机上传的机台不符";
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + "该工字轮已绑定的扭转机台与扭转上位机上传的机台不符", Time = DateTime.Now });
                    return res;
                }
                if (torch.WorkStation != request.TorsChkStation)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.TaskNo + "该工字轮已绑定的扭转机台工位与扭转上位机上传的工位不符";
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + "该工字轮已绑定的扭转机台工位与扭转上位机上传的工位不符", Time = DateTime.Now });
                    return res;
                }

                if (code.SideNum == 1)
                {
                }
                else
                {
                    #region 扭转值结果处理

                    //上传mes扭转结果
                    var time = DateTime.Now.ToString("yyyyMMddHHmmssfff");
                    var apiurl = wms.util.AppSettings.GetConfig("EsbMesPushUrl");
                    var reqid = Guid.NewGuid().ToString();
                    var req = new EsbReq() { headers = new HeadersReq() { serviceCode = "163K162001", requestId = reqid, TrackId = reqid, sourceCode = "163K" } };
                    var torschk = new TorsChkUploadMes() { SpoolCode = code.ContGrpBarCode, MatBarCode = code.CLBarCode, ChkMacCode = $"{request.TorsChkWb}_{request.TorsChkStation}", ChkVal = decimal.Parse(request.TorsChkValue), ChkTime = time, Bow = decimal.Parse(request.TorsChkChord), Straight = decimal.Parse(request.TorsChkFlatness) };
                    if (request.TorsChkValue == "9.990000")
                    {
                        torschk.OvcResult = false;
                        torschk.ChkVal = 0;
                    }
                    if (request.TorsChkChord == "49.999001")
                    {
                        torschk.Bow = 5;
                        torschk.BowResult = false;
                    }
                    if (request.TorsChkFlatness == "299.998993")
                    {
                        torschk.Straight = 10;
                        torschk.StraightResult = false;
                    }
                    //CK0701\CK0702\CK0703\CK0704\CK0705\CK0706\CK0707\CK0708\CK0709\CK0710
                    _logger.LogInformation("扭转值接口调用,传参条码：" + code.ContGrpBarCode);
                    var strEsbRes = HttpUtil.PostRequest(apiurl, JsonConvert.SerializeObject(torschk), 30000, "UTF-8", "application/json", reqid, req.headers.sourceCode, req.headers.serviceCode);
                    var response = JsonConvert.DeserializeObject<TorschMesResponse>(strEsbRes);
                    _logger.LogInformation("MES扭转值返回结果：条码" + code.ContGrpBarCode + "，结果：" + response.success + ",扭转等级:" + response.data.GradeCode);
                    if (response.success == false)
                    {
                        //记录描述信息
                        var error = new BaseErrorinfo()
                        {
                            ContBarCode = code.ContGrpBarCode,
                            Message = response.message,
                            AddWho = "",
                            EditWho = "",
                            Count = 1
                        };
                        var errorinfo = _errorinforepository.GetSingle(p => p.ContBarCode == code.ContGrpBarCode && p.Message == error.Message);
                        if (errorinfo != null)
                        {
                            _errorinforepository.UpdateSetColumnsTrue(p => new BaseErrorinfo()
                            {
                                Count = errorinfo.Count + 1
                            }, p => p.ContBarCode == errorinfo.ContBarCode);
                        }
                        else
                        {
                            _errorinforepository.Insert(error);
                        }
                        //异常工字轮暂时先回库
                        //if (code.ContUsageQty == 2)
                        //{
                        //    _billInvnowrepository.Delete(p => p.ContGrpBarCode == code.ContGrpBarCode);
                        //    var flow2 = _mapper.Map<BillInvflow>(code);
                        //    flow2.Id = GetId();
                        //    flow2.AddTime = DateTime.Now;
                        //    flow2.EditTime = DateTime.Now;
                        //    flow2.Memo = "扭转超时出库完成";
                        //    flow2.InvStateCode = InvState.InvEcecState_Out.ToString();
                        //    _billInvflow.Insert(flow2);
                        //    _torchbandinforepository.Delete(p => p.TaskNo == request.TaskNo);
                        //    _taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo));
                        //    _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                        //    {
                        //        Status = TaskStatus.Finish,
                        //        EditTime = DateTime.Now,
                        //        ManualRemarks = "扭转超时"
                        //    }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                        //    var wcsdt = new WCS_TaskDtl()
                        //    {
                        //        ID = Guid.NewGuid(),
                        //        CurPoint = request.TorsChkWb,
                        //        AddTime = DateTime.Now,
                        //        AddWho = "wms",
                        //        Enabled = true,
                        //        ParentTaskCode = taskold.Id,
                        //        Desc = "扭转超时"
                        //    };
                        //    _taskdetailrepository.InsertableSplitTable(wcsdt);
                        //    return res;
                        //}

                        _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                        {
                            TorsChkQty = code.TorsChkQty + 1,
                            TorsChkTime = DateTime.ParseExact(time, "yyyyMMddHHmmssfff", System.Globalization.CultureInfo.InvariantCulture),
                            TorsChkValue = torschk.ChkVal,
                            TorsChkChord = torschk.Bow,
                            TorsChkFlatness = torschk.Straight,
                            TorsChkMachCode = request.TorsChkWb,
                            TorsChkStation = request.TorsChkStation,
                            TorsChkChordIsGood = request.TorsChkChordIsGood,
                            TorsChkFlatnessIsGood = request.TorsChkFlatnessIsGood,
                            TorsChkValueIsGood = request.TorsChkValueIsGood,
                            Grade = "C",
                            SideNum = 1,
                            ExecWho = string.IsNullOrEmpty(request.User) ? "0" : request.User
                        }, p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                    }
                    else
                    {
                        //异常工字轮暂时先回库
                        //if (code.ContUsageQty == 2)
                        //{
                        //    //记录描述信息
                        //    var error = new BaseErrorinfo()
                        //    {
                        //        ContBarCode = code.ContGrpBarCode,
                        //        Message = code.ContGrpBarCode + "扭转超时，直接异常排出",
                        //        AddWho = "",
                        //        EditWho = "",
                        //        Count = 1
                        //    };
                        //    var errorinfo = _errorinforepository.GetSingle(p => p.ContBarCode == code.ContGrpBarCode && p.Message == error.Message);
                        //    if (errorinfo != null)
                        //    {
                        //        _errorinforepository.UpdateSetColumnsTrue(p => new BaseErrorinfo()
                        //        {
                        //            Count = errorinfo.Count + 1
                        //        }, p => p.ContBarCode == errorinfo.ContBarCode);
                        //    }
                        //    else
                        //    {
                        //        _errorinforepository.Insert(error);
                        //    }
                        //    _billInvnowrepository.Delete(p => p.ContGrpBarCode == code.ContGrpBarCode);
                        //    var flow2 = _mapper.Map<BillInvflow>(code);
                        //    flow2.Id = GetId();
                        //    flow2.AddTime = DateTime.Now;
                        //    flow2.EditTime = DateTime.Now;
                        //    flow2.Memo = "扭转超时出库完成";
                        //    flow2.InvStateCode = InvState.InvEcecState_Out.ToString();
                        //    _billInvflow.Insert(flow2);
                        //    _torchbandinforepository.Delete(p => p.TaskNo == request.TaskNo);
                        //    _taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo));
                        //    _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                        //    {
                        //        Status = TaskStatus.Finish,
                        //        EditTime = DateTime.Now,
                        //        ManualRemarks = "扭转超时"
                        //    }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                        //    var wcsdt = new WCS_TaskDtl()
                        //    {
                        //        ID = Guid.NewGuid(),
                        //        CurPoint = request.TorsChkWb,
                        //        AddTime = DateTime.Now,
                        //        AddWho = "wms",
                        //        Enabled = true,
                        //        ParentTaskCode = taskold.Id,
                        //        Desc = "扭转超时"
                        //    };
                        //    _taskdetailrepository.InsertableSplitTable(wcsdt);
                        //    return res;
                        //}
                        if (response.success == true && response.data.GradeCode == "A")
                        {
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                TorsChkQty = code.TorsChkQty + 1,
                                TorsChkTime = DateTime.ParseExact(time, "yyyyMMddHHmmssfff", System.Globalization.CultureInfo.InvariantCulture),
                                TorsChkValue = torschk.ChkVal,
                                TorsChkChord = torschk.Bow,
                                TorsChkFlatness = torschk.Straight,
                                TorsChkMachCode = request.TorsChkWb,
                                TorsChkStation = request.TorsChkStation,
                                TorsChkChordIsGood = request.TorsChkChordIsGood,
                                TorsChkFlatnessIsGood = request.TorsChkFlatnessIsGood,
                                TorsChkValueIsGood = request.TorsChkValueIsGood,
                                Grade = "A",
                                SideNum = 1,
                                ExecWho = string.IsNullOrEmpty(request.User) ? "0" : request.User
                            }, p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                        }
                        else
                        {
                            var error = new BaseErrorinfo()
                            {
                                ContBarCode = code.ContGrpBarCode,
                                Message = response.message,
                                AddWho = "",
                                EditWho = "",
                                Count = 1
                            };
                            var errorinfo = _errorinforepository.GetSingle(p => p.ContBarCode == code.ContGrpBarCode && p.Message == error.Message);
                            if (errorinfo != null)
                            {
                                _errorinforepository.UpdateSetColumnsTrue(p => new BaseErrorinfo()
                                {
                                    Count = errorinfo.Count + 1
                                }, p => p.ContBarCode == errorinfo.ContBarCode);
                            }
                            else
                            {
                                _errorinforepository.Insert(error);
                            }
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                TorsChkQty = code.TorsChkQty + 1,
                                TorsChkTime = DateTime.ParseExact(time, "yyyyMMddHHmmssfff", System.Globalization.CultureInfo.InvariantCulture),
                                TorsChkValue = torschk.ChkVal,
                                TorsChkChord = torschk.Bow,
                                TorsChkFlatness = torschk.Straight,
                                TorsChkMachCode = request.TorsChkWb,
                                TorsChkStation = request.TorsChkStation,
                                TorsChkChordIsGood = request.TorsChkChordIsGood,
                                TorsChkFlatnessIsGood = request.TorsChkFlatnessIsGood,
                                TorsChkValueIsGood = request.TorsChkValueIsGood,
                                SideNum = 1,
                                Grade = "C",
                                ExecWho = string.IsNullOrEmpty(request.User) ? "0" : request.User
                            }, p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                        }
                    }

                    #endregion 扭转值结果处理
                }

                _db.BeginTran();
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                    p => p.StateNum == LocationState.LocationState_StockOut && p.ContGrpId == code.ContGrpId && p.Code == taskold.AddrFrom && p.ContGrpBarCode == code.ContGrpBarCode);
                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode);
                _billInvnowrepository.Delete(p => p.Id == code.Id);
                var flow = _mapper.Map<BillInvflow>(stock);
                flow.Id = GetId();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.Memo = "扭转出库任务完成";
                flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                _billInvflow.Insert(flow);
                _torchbandinforepository.Delete(p => p.TaskNo == request.TaskNo);
                _taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo));
                _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                {
                    Status = TaskStatus.Finish,
                    EditTime = DateTime.Now,
                    ManualRemarks = "扭转完成，操作人" + request.User
                }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                var wcsdtl = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = stock.TorsChkMachCode,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = taskold.Id,
                    Desc = "扭转完成，操作人" + request.User
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtl);

                var inv = stock;
                inv.Id = GetId();
                inv.ContGrpId = GetId();
                inv.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
                inv.Memo = "扭转回库";
                _billInvnowrepository.Insert(inv);
                _billInvflow.Insert(_mapper.Map<BillInvflow>(inv));
                var wcs = new WCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = "",
                    AddrFrom = inv.TorsChkMachCode,
                    BarCode = stock.ContGrpBarCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = "sxhouse",
                    AddrTo = "",
                    Tunnel = "",
                    MaterialCode = inv.MatCode,
                    MatCode = inv.MatCode,
                    BusType = SxTaskBusType.TaskBusType_SX_TorCheckStockIn.GetDescription(),
                    Grade = inv.Grade
                };
                var wcstask = _taskrepository.InsertReturnEntity(wcs);
                _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                var wcsdtls = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = wcstask.AddrFrom,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcstask.ID,
                    Desc = wcstask.BusType
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtls);
                _torschwbcount.UpdateSetColumnsTrue(p => new TorschWbCount()
                {
                    WbCount = p.WbCount - 1
                }, p => p.Code == request.TorsChkWb);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip5", new RedisErrorInfo() { Equip = "TorsChkEquip5", Con = request.TaskNo + ex.Message, Time = DateTime.Now });
                return res;
            }
            return res;
        }

        public SRes TorsChkStationbinde(TorsChkStationbindeRequest request)
        {
            var res = new SRes();
            try
            {
                if (request.Memo1.Trim() == "2")
                {
                    var taskold = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Id == int.Parse(request.TaskNo) && p.Type == TaskType.OutDepot && p.Status < TaskStatus.Finish && p.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription()).SplitTable(p => p.Take(2)).First();
                    if (taskold == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                        res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                        RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip4", new RedisErrorInfo() { Equip = "TorsChkEquip4", Con = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription(), Time = DateTime.Now });
                        return res;
                    }
                    var torchbandinfo = _torchbandinforepository.GetSingle(p => p.TaskNo == request.TaskNo && p.WorkStation == request.WorkStation && p.Machine == request.Machine);
                    if (torchbandinfo != null)
                    {
                        return res;
                    }
                    var count = _torchbandinforepository.GetList(p => p.TaskNo == request.TaskNo).Count;
                    if (count > 0)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = request.TaskNo + "扭转入料绑定失败，一个任务不允许绑定两个工位";
                        RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip4", new RedisErrorInfo() { Equip = "TorsChkEquip4", Con = request.TaskNo + "扭转入料绑定失败，一个任务不允许绑定两个工位", Time = DateTime.Now });
                        return res;
                    }

                    var tors = new BaseTorchbandinfo()
                    {
                        TaskNo = request.TaskNo,
                        ContBarCode = taskold.BarCode,
                        WorkStation = request.WorkStation,
                        Machine = request.Machine,
                        IsStop = 0,
                        AddWho = "",
                        EditWho = ""
                    };
                    _torchbandinforepository.Insert(tors);
                }
                else
                {
                    var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Id == int.Parse(request.TaskNo) && p.Status < TaskStatus.Finish && p.Type == TaskType.OutDepot && p.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription()).SplitTable(p => p.Take(2)).First();
                    if (task == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                        res.ResMsg = request.TaskNo + "不存在扭转出库的任务";
                        RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip4", new RedisErrorInfo() { Equip = "TorsChkEquip4", Con = request.TaskNo + "不存在扭转出库的任务", Time = DateTime.Now });
                        return res;
                    }
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = request.TaskNo + "没有找到扭转出库的库存信息";
                        RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip4", new RedisErrorInfo() { Equip = "TorsChkEquip4", Con = request.TaskNo + "没有找到扭转出库的库存信息", Time = DateTime.Now });
                        return res;
                    }
                    _db.BeginTran();
                    _billInvnowrepository.Delete(p => p.Id == stock.Id);
                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = GetId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = "不需扭转";
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    _billInvflow.Insert(flow);
                    _taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo));
                    _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                    {
                        Status = TaskStatus.Finish,
                        EditTime = DateTime.Now,
                        ManualRemarks = "未扭转"
                    }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                    var wcsdtl = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = request.Machine,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = task.Id,
                        Desc = "未扭转"
                    };
                    _taskdetailrepository.InsertableSplitTable(wcsdtl);

                    var inv = stock;
                    inv.Id = GetId();
                    inv.ContGrpId = GetId();
                    inv.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
                    inv.Memo = "未扭转";
                    _billInvnowrepository.Insert(inv);
                    _billInvflow.Insert(_mapper.Map<BillInvflow>(inv));
                    var wcs = new WCS_TaskInfo()
                    {
                        Status = TaskStatus.NewBuild,
                        Type = TaskType.EnterDepot,
                        Priority = 0,
                        Device = "",
                        SrmStation = "",
                        AddrFrom = request.Machine,
                        BarCode = stock.ContGrpBarCode,
                        AddWho = "wms",
                        EditWho = "wms",
                        WarehouseCode = "sxhouse",
                        AddrTo = "",
                        Tunnel = "",
                        MaterialCode = inv.MatCode,
                        MatCode = inv.MatCode,
                        BusType = SxTaskBusType.TaskBusType_SX_TorCheckStockIn.GetDescription(),
                        Grade = inv.Grade
                    };
                    var wcstask = _taskrepository.InsertReturnEntity(wcs);
                    _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                    var wcsdtls = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = wcstask.AddrFrom,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcstask.ID,
                        Desc = wcstask.BusType
                    };
                    _taskdetailrepository.InsertableSplitTable(wcsdtls);
                    _db.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip4", new RedisErrorInfo() { Equip = "TorsChkEquip4", Con = ex.Message, Time = DateTime.Now });
                return res;
            }
            return res;
        }

        public SRes TorsChkErrorinfo(TorsChkErrorinfoRequest request)
        {
            var res = new SRes();
            RedisHelper.Set("Sx:WMSErrorInfo:TorsChk" + request.Machine + request.WorkStation, new RedisErrorInfo() { Equip = "TorsChk" + request.Machine + request.WorkStation, Con = "扭转设备号" + request.Machine + "_" + request.WorkStation + request.ExcMessage, Time = DateTime.Now });
            return res;
        }

        public SRes CellInfo(string code)
        {
            var res = new SRes();
            MoveTask(code);
            return res;
        }

        public TorsChkResponse GetTorsChkinfo(GetTorsChkinfoRequest request)
        {
            var res = new TorsChkResponse();
            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == request.TaskNo && p.Status < TaskStatus.Finish && p.Type == TaskType.OutDepot && p.BusType == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription()).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip3", new RedisErrorInfo() { Equip = "TorsChkEquip3", Con = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription(), Time = DateTime.Now });
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip3", new RedisErrorInfo() { Equip = "TorsChkEquip3", Con = request.TaskNo + ResponseStatusCodeEnum.StockNotExist.GetDescription(), Time = DateTime.Now });
                return res;
            }
            var marter = _basematerrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Code == stock.MatCode).First();
            if (marter == null)
            {
                res.ResCode = ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetHashCode();
                res.ResMsg = request.TaskNo.ToString() + ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetDescription();
                RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip3", new RedisErrorInfo() { Equip = "TorsChkEquip3", Con = request.TaskNo + ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetDescription(), Time = DateTime.Now });
                return res;
            }
            var isOld = false;
            //获取绕向
            var wind = stock.Wind;
            //获取颜色
            var boxRule = _boxrulerepository.AsQueryable().With(SqlWith.NoLock).First(x => x.DocsNo == stock.InDocsNo);
            var currentColor = wind == "L" ? boxRule.TAKEUP_SIDE_L : boxRule.TAKEUP_SIDE_R;
            if (currentColor == null)
            {
                isOld = true;
            }
            //L代表顺时针R代表逆时针
            if (isOld) res.Face = task.BarCode.EndsWith("R") ? "R" : "L";
            else res.Face = currentColor.Contains("顺") ? "L" : "R";

            res.GoodsType = task.GoodsType;
            res.Isdetection = 2;
            res.Diameter = marter.Diameter;
            return res;
        }

        public SRes Manaler(DetailCodeStrdtoRequest request)
        {
            var res = new SRes();
            //var list = _basewarecellrepository.GetList(p => p.StateNum == LocationState.LocationState_Full && p.IsStop == 0 && p.Floor == 3).OrderBy(p => p.Depth).Take(50);

            foreach (var item in request.Location)
            {
                var cellcode = _basewarecellrepository.GetSingle(p => p.Code == item && p.StateNum == LocationState.LocationState_Full && p.IsStop == 0);
                if (cellcode == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = item + "不满足出库条件，请检查当前货位的状态";
                    return res;
                }
                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == cellcode.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                if (stock == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    res.ResMsg = item + "没有库存";
                    return res;
                }
                if (!string.IsNullOrEmpty(stock.PreStock))
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = stock.ContGrpBarCode + "该库存已被锁定，不允许手动出库";
                    return res;
                }
                if (cellcode.Depth == 2)
                {
                    var respon = MoveTask(cellcode.Code);
                    if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                    {
                        return respon;
                    }
                }
                try
                {
                    var bus = "";
                    if (request.EndPoint == SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetHashCode())
                    {
                        bus = SxTaskBusType.TaskBusType_SX_TorCheckStockOut.GetDescription();
                    }
                    //else if (request.EndPoint == SxTaskBusType.TaskBusType_SX_StackStockOut.GetHashCode())
                    //{
                    //    bus = SxTaskBusType.TaskBusType_SX_StackStockOut.GetDescription();
                    //}
                    else if (request.EndPoint == SxTaskBusType.TaskBusType_SX_ErrorStockOut.GetHashCode())
                    {
                        bus = SxTaskBusType.TaskBusType_SX_ErrorStockOut.GetDescription();
                    }
                    else
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = stock.ContGrpBarCode + "业务类型参数错误";
                        return res;
                    }
                    var wcs = new WCS_TaskInfo()
                    {
                        Status = TaskStatus.NewBuild,
                        Type = TaskType.OutDepot,
                        Priority = 0,
                        Device = cellcode.SCRel,
                        SrmStation = "1",
                        AddrFrom = cellcode.Code,
                        BarCode = stock.ContGrpBarCode,
                        AddWho = "wms",
                        EditWho = "wms",
                        WarehouseCode = cellcode.WarehouseCode,
                        AddrTo = "",
                        Tunnel = cellcode.Tunnel.ToString(),
                        MaterialCode = stock.MatCode,
                        MatCode = stock.MatCode,
                        BusType = bus,
                        Floor = cellcode.Floor,
                        Grade = stock.Grade,
                        Length = stock.LengthQty,
                        ManualRemarks = request.User + "下发手动出库任务"
                    };
                    _db.BeginTran();
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        StateNum = LocationState.LocationState_StockOut,
                        EditTime = DateTime.Now
                    }, p => p.Code == cellcode.Code);
                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = GetId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    flow.Memo = "Test";
                    _billInvflow.Insert(flow);
                    var wcstask = _taskrepository.InsertReturnEntity(wcs);
                    _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                    var wcsdtl = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = wcstask.AddrFrom,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcstask.ID,
                        Desc = wcstask.BusType
                    };
                    _taskdetailrepository.InsertableSplitTable(wcsdtl);
                    _db.CommitTran();
                    InsertErrorinfo(stock.ContGrpBarCode, "环线异常排出口:5186|，人工异常排出" + "操作人员:" + request.User + "|" + DateTime.Now);
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                    return res;
                }
            }

            return res;
        }

        /// <summary>
        /// 移库任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<WcsMoveTaskResponse> WcsMoveTask(WcsMoveTaskRequest request)
        {
            var res = new SRes<WcsMoveTaskResponse>()
            {
                ResData = new WcsMoveTaskResponse()
                {
                    ResType = WcsContractWcsMoveTaskEnum.失败.GetHashCode(),
                    CellNo = ""
                }
            };

            var wcstask = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == request.TaskNum && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2)).First();
            if (wcstask == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            var dept2Loc = _basewarecellrepository.GetFirst(p => p.Code == wcstask.AddrFrom && p.Depth == 2);
            if (dept2Loc == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = "该任务所在货位不是二深货位";
                return res;
            }
            var dept1Loc = _basewarecellrepository.GetFirst(p => p.Col == dept2Loc.Col && p.Layer == dept2Loc.Layer && p.Shelf == dept2Loc.Shelf && p.Depth == 1 && p.IsStop == 0 && p.Floor == dept2Loc.Floor);
            if (dept1Loc == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = dept2Loc.Code + "对应一深位货位被禁用或者不存在";
                return res;
            }
            if (wcstask.Type != TaskType.OutDepot)
            {
                res.ResCode = WcsContractWcsMoveTaskEnum.失败.GetHashCode();
                res.ResMsg = "只有出库任务才能调用此接口";
                return res;
            }
            res.ResData.CellNo = dept1Loc.Code;
            lock (lockerApplyLoc)
            {
                try
                {
                    if (dept1Loc.StateNum == LocationState.LocationState_Empty)
                    {
                        res.ResData.ResType = WcsContractWcsMoveTaskEnum.允许2升位执行.GetHashCode();
                        res.ResData.CellNo = "";
                        return res;
                    }
                    else if (dept1Loc.StateNum == LocationState.LocationState_Full)
                    {
                        res.ResData.ResType = WcsContractWcsMoveTaskEnum.执行移库任务.GetHashCode();
                        res.ResData.CellNo = dept1Loc.Code;
                        var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == dept1Loc.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (stock == null)
                        {
                            res.ResCode = WcsContractWcsMoveTaskEnum.失败.GetHashCode();
                            res.ResMsg = "一深位库存信息异常，没有查到库存信息";
                            return res;
                        }
                        var wareshouse = _basewarehouserepository.GetFirst(p => p.Code == wcstask.WarehouseCode);
                        //库位
                        var cell = SxServiceHelp.ApplyLoc(new ApplyLocRequest()
                        {
                            IsMove = true,
                            MaterialId = stock.MatId,
                            MaterialCode = stock.MatCode,
                            TunnelNum = dept1Loc.Tunnel,
                            WarehuoseId = wareshouse.Id,
                            Floor = dept1Loc.Floor,
                            Fork = 2,
                            Wbgroup = stock.WbGroupCode,
                            Wind = stock.Wind,
                            IsControlpanel = stock.IsControlpanel,
                            IsTorsChk = stock.IsTorsChk,
                            TorsChkQty = stock.TorsChkQty,
                            ProductTime = stock.ProductTime
                        }, _basewarecellrepository, _basewarehouserepository, _billInvnowrepository, _logger);
                        if (string.IsNullOrEmpty(cell.ResData.CellNo))
                        {
                            res.ResCode = WcsContractWcsMoveTaskEnum.失败.GetHashCode();
                            res.ResMsg = cell.ResMsg;
                            return res;
                        }
                        var wcs = new WCS_TaskInfo()
                        {
                            Type = TaskType.TransferDepot,
                            Status = TaskStatus.NewBuild,
                            Priority = 0,
                            Device = dept1Loc.SCRel,
                            SrmStation = "",
                            AddrFrom = dept1Loc.Code,
                            AddrTo = cell.ResData.CellNo,
                            LastInteractionPoint = "",
                            BarCode = stock.ContGrpBarCode,
                            Length = stock.LengthQty,
                            AddTime = DateTime.Now,
                            StartTime = DateTime.Now,
                            DocID = 0,
                            PalletType = 1,
                            ProdLine = 0,
                            AddWho = "wms",
                            WarehouseCode = wareshouse.Code,
                            Enabled = true,
                            WorkBench = "",
                            Tunnel = dept1Loc.Tunnel.ToString(),
                            Floor = dept1Loc.Floor,
                            BusType = CpTaskBusType.TaskBusType_CP_Move.GetDescription()
                        };

                        _db.BeginTran();

                        var task = _taskrepository.InsertReturnEntity(wcs);
                        _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(task));
                        var taskdlt = new WCS_TaskDtl()
                        {
                            ID = Guid.NewGuid(),
                            CurPoint = task.AddrFrom,
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            Enabled = true,
                            ParentTaskCode = task.ID,
                            Desc = task.AddrFrom + "移库至" + task.AddrTo,
                        };
                        _taskdetailrepository.InsertableSplitTable(taskdlt);
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_StockMove, EditTime = DateTime.Now }, p => p.Code == task.AddrFrom);
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = LocationState.LocationState_StockMove, EditTime = DateTime.Now }, p => p.Code == task.AddrTo);
                        _db.CommitTran();
                        return res;
                    }
                    else if (dept1Loc.StateNum == LocationState.LocationState_StockOut)
                    {
                        res.ResData.ResType = WcsContractWcsMoveTaskEnum.一深位有出库任务.GetHashCode();
                        res.ResData.CellNo = dept1Loc.Code;
                        return res;
                    }
                    //判断移库任务是否已经存在
                    else if (dept1Loc.StateNum == LocationState.LocationState_StockMove)
                    {
                        res.ResData.ResType = WcsContractWcsMoveTaskEnum.执行移库任务.GetHashCode();
                        res.ResData.CellNo = dept1Loc.Code;
                        return res;
                    }
                    else
                    {
                        res.ResCode = WcsContractWcsMoveTaskEnum.失败.GetHashCode();
                        res.ResMsg = "一深位有入库任务，优先执行入库任务";
                        return res;
                    }
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = WcsContractWcsMoveTaskEnum.失败.GetHashCode();
                    res.ResMsg = WcsContractWcsMoveTaskEnum.失败.GetDescription();
                    _logger.LogInformation(ex.ToString());
                    return res;
                }
            }
            return res;
        }

        private SRes SpoolMaterialInfoTrans1(SxSpoolMaterialInfoTrans1Request reqDto)
        {
            var res = new SRes();
            try
            {
                var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == "sxhouse");
                //物料
                var mater = _basematerrepository.GetSingle(p => p.Code == reqDto.MatCode);
                if (mater == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetDescription();
                    return res;
                }

                //检查条码
                var barstock = _billInvinitrepository.GetFirst(p => p.ContGrpBarCode == reqDto.SpoolCode);
                if (barstock == null)
                {
                    //创建条码
                    var barinfo = new BillInvinit()
                    {
                        InvBarCode = reqDto.MatBarCode,
                        WarehouseId = wareHosue != null ? wareHosue.Id : 0,
                        ExecStateCode = InvLockState.InvState_Normal.ToString(),
                        ExecDocsNo = reqDto.WorkOrder,
                        ExecDocsRowNo = reqDto.MatBarCode,
                        ExecDocsTypeCode = DocType.DocType_FJ_WetStockIn.GetHashCode().ToString(),
                        InvInOut = InvInOutType.In,
                        ExecWho = "MES",
                        EditTime = DateTime.Now,
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        InDocsNo = reqDto.WorkOrder,
                        InDocsRowNo = reqDto.MatBarCode,
                        SuppCode = "",
                        BomDocsNo = "",
                        BomSetId = 0,
                        SetGrpCode = "",
                        BomMatCode = "",
                        BomMatId = 0,
                        BomMatName = "",
                        MatId = mater.Id,
                        MatCode = mater.Code,
                        MatName = mater.Name,
                        LengthQty = reqDto.Length,
                        TareWQty = reqDto.Weight,
                        ProductTime = reqDto.ProductDate,
                        RFIDBarCode = "",
                        ProductMachCode = reqDto.WbCode,
                        Grade = reqDto.Grade,
                        HWBarCode = reqDto.SpoolCode,
                        HWTypeCode = reqDto.SpoolType,
                        ContGrpBarCode = reqDto.SpoolCode,
                        ContGrpId = IdFactory.NewId(),
                        IsFast = false,
                        IsRework = reqDto.IsRework,
                        CLBarCode = reqDto.MatBarCode,
                        Size = 1,
                        BackReason = "",
                        IsBack = reqDto.IsBlack,
                        IsCore = reqDto.IsCore,
                        SolderCount = reqDto.SolderCount,
                        IsTorsChk = reqDto.IsTorsChk,
                        WbGroupCode = reqDto.WbGroupCode
                    };
                    _billInvinitrepository.Insert(barinfo);
                }
                else
                {
                }
                //库存
                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.SpoolCode);
                if (stock == null)
                {
                    var inv = new BillInvnow()
                    {
                        InvBarCode = reqDto.MatBarCode,
                        WarehouseId = wareHosue != null ? wareHosue.Id : 0,
                        ExecStateCode = InvLockState.InvState_Normal.ToString(),
                        ExecDocsNo = reqDto.WorkOrder,
                        ExecDocsRowNo = reqDto.MatBarCode,
                        ExecDocsTypeCode = DocType.DocType_FJ_WetStockIn.GetHashCode().ToString(),
                        InvInOut = InvInOutType.In,
                        ExecWho = "MES",
                        EditTime = DateTime.Now,
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        InDocsNo = reqDto.WorkOrder,
                        InDocsRowNo = reqDto.MatBarCode,
                        SuppCode = "",
                        BomDocsNo = "",
                        BomSetId = 0,
                        SetGrpCode = "",
                        BomMatCode = "",
                        BomMatId = 0,
                        BomMatName = "",
                        MatId = mater.Id,
                        MatCode = mater.Code,
                        MatName = mater.Name,
                        LengthQty = reqDto.Length,
                        TareWQty = reqDto.Weight,
                        ProductTime = reqDto.ProductDate,
                        RFIDBarCode = "",
                        ProductMachCode = reqDto.WbCode,
                        Grade = reqDto.Grade,
                        HWBarCode = reqDto.SpoolCode,
                        HWTypeCode = "BS1",
                        ContGrpBarCode = reqDto.SpoolCode,
                        ContGrpId = IdFactory.NewId(),
                        IsFast = false,
                        IsRework = reqDto.IsRework,
                        CLBarCode = reqDto.MatBarCode,
                        Size = 1,
                        BackReason = "",
                        IsBack = reqDto.IsBlack,
                        IsCore = reqDto.IsCore,
                        WbGroupCode = reqDto.WbGroupCode,
                        IsTorsChk = reqDto.IsTorsChk,
                        IsControlpanel = false,
                        SkuCode = ""
                    };
                    _billInvnowrepository.Insert(inv);
                    _billInvflow.Insert(_mapper.Map<BillInvflow>(inv));
                }
                else
                {
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_In.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = "该工字轮条码号已在库中，请检查RFID号是否重复";
                        return res;
                    }
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
                        return res;
                    }
                }
                var task = _wcstaskoldrepository.AsQueryable().Where(p => p.BarCode == reqDto.SpoolCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                if (task != null && task.Type == TaskType.OutDepot)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = reqDto.SpoolCode + "存在上一个未结束的出库任务，不允许创建入库任务";
                    return res;
                }
                if (task != null && task.Type == TaskType.EnterDepot)
                {
                    //res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                    //res.ResMsg = reqDto.SpoolCode + ResponseStatusCodeEnum.WcsTaskExist.GetDescription();
                    return res;
                }
                var wcs = new WCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = "",
                    AddrFrom = "root",
                    BarCode = reqDto.SpoolCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = wareHosue.Code,
                    AddrTo = "",
                    Tunnel = "",
                    MaterialCode = mater.Code,
                    MatCode = mater.Code,
                    BusType = SxTaskBusType.TaskBusType_SX_LineStockIn.GetDescription(),
                    Grade = reqDto.Grade,
                    Length = reqDto.Length,
                    WorkBench = reqDto.WbCode,
                    WorkOrder = reqDto.WorkOrder,
                    GoodsType = 0
                };
                _db.BeginTran();
                var wcstask = _taskrepository.InsertReturnEntity(wcs);
                _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                var wcsdtl = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.SpoolCode,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcstask.ID,
                    Desc = wcstask.BusType
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtl);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.ToString();
            }
            return res;
        }

        /// <summary>
        /// 扭转入库分配楼层
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> TorsChkFloor(TorsChkFloorRequest reqDto)
        {
            var res = new SRes<int>();
            try
            {
                if (reqDto.Count <= 0)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription() + "任务数量不能为0";
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip6", new RedisErrorInfo() { Equip = "TorsChkEquip6", Con = "参数错误，请求任务数量不能为0", Time = DateTime.Now });
                    return res;
                }
                var floorTaskCount = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "FloorTaskCount").SContent);
                var bar = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.BusType == "扭转回库").OrderByDescending(p => p.AddTime).First();
                if (bar == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "没有扭转回库任务需要分配楼层";
                    RedisHelper.Set("Sx:WMSErrorInfo:TorsChkEquip6", new RedisErrorInfo() { Equip = "TorsChkEquip6", Con = "没有扭转回库任务需要分配楼层，请检查扭转回库位置任务实际是否有货", Time = DateTime.Now });
                    return res;
                }
                var stock = _billInvnowrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.ContGrpBarCode == bar.BarCode && p.InvStateCode == "InvEcecState_BuildUp").First();
                var currentTime = stock.ProductTime;

                var startTime = currentTime.Hour >= 13 ? currentTime.Date.AddHours(13) : currentTime.Date.AddDays(-1).AddHours(13);
                var endTime = currentTime.Hour >= 13 ? currentTime.Date.AddDays(1).AddHours(8) : currentTime.Date.AddHours(8);

                //今天这一批次的扭转入库的分配楼层数量
                var existstock = _billInvnowrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.IsTorsChk == true && p.TorsChkQty == 1 && p.ProductTime >= startTime && p.ProductTime <= endTime).ToList();
                int row = 8;
                //var cellfloor1stockcount = existstock.Where(p => p.PutLayer >= 1 && p.PutLayer <= 4 && p.PutRow > row).Count();  //1楼层同规格数量
                //var cellfloor2stockcount = existstock.Where(p => p.PutLayer >= 5 && p.PutLayer <= 8 && p.PutRow > row).Count();  //2楼层同规格数量
                //var cellfloor3stockcount = existstock.Where(p => p.PutLayer >= 9 && p.PutLayer <= 12 && p.PutRow > row).Count();  //3楼层同规格数量

                //bool isTobeTors = false;
                int tun = 2;
                //int row = 8;
                var cell = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Empty).ToList();

                var disabletunnels = _sysconfigrepository.GetList(p => p.SType == "InStop" && !string.IsNullOrEmpty(p.SContent));
                if (disabletunnels != null && disabletunnels.Any())
                {
                    foreach (var item in disabletunnels)
                    {
                        var distun = int.Parse(item.Default1);
                        var disfloor = int.Parse(item.Default2);
                        var disids = cell.Where(p => p.Floor == disfloor && p.Tunnel == distun).Select(p => p.Id);
                        cell = cell.Where(p => !disids.Contains(p.Id)).ToList();
                    }
                }

                const int MinAvailableCells = 30;// 最小有效货位数量，用于保留移库
                var forbidLayer = wms.util.AppSettings.GetConfig("ForbidLayer");
                // 定义楼层信息结构
                var floors = Enumerable.Range(1, 3).Select(floorNumber =>
                {
                    // 获取货位数
                    var cellQuery = cell.Where(p => p.Floor == floorNumber);
                    var cellCount = cellQuery.Count(p => p.Tunnel > tun);
                    if (!string.IsNullOrEmpty(forbidLayer) && forbidLayer.Contains(floorNumber.ToString())) cellCount = 0;

                    // 获取同规格库存数
                    var (minLayer, maxLayer) = floorNumber switch
                    {
                        1 => (1, 4),
                        2 => (5, 8),
                        3 => (9, 12),
                        _ => (0, 0)
                    };
                    var stockQuery = existstock.Where(p => p.PutLayer >= minLayer && p.PutLayer <= maxLayer && p.PutRow > row);

                    // 计算库存比率
                    var stockRatio = cellCount > 0 ? stockQuery.Count() / (double)cellCount : 0;

                    // 获取任务限制数
                    var taskLimit = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == $"FloorTaskCount{floorNumber}").SType);

                    return new
                    {
                        Floor = floorNumber,
                        CellCount = cellCount,
                        StockRatio = stockRatio,
                        TaskLimit = taskLimit
                    };
                })
                // 排序：库存比例低优先 > 货位数高优先
                .OrderBy(f => f.StockRatio)
                .ThenByDescending(f => f.CellCount)
                .ToList();

                // 获取各楼层当前任务数
                var floorTasks = _taskrepository.AsQueryable()
                    .Where(p => p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.BusType == "扭转回库")
                    .ToList()
                    .GroupBy(p => p.Floor).ToDictionary(x => x.Key, x => x.Count());

                var time10 = new Stopwatch();
                time10.Restart();
                // 选择楼层的策略
                var selectedFloor = floors.FirstOrDefault(f =>
                    f.CellCount > MinAvailableCells &&
                    floorTasks.GetValueOrDefault(f.Floor, 0) < f.TaskLimit
                );

                // 次选策略：允许货位较少但未超限的楼层
                selectedFloor ??= floors.FirstOrDefault(f =>
                    f.CellCount > 0 &&
                    floorTasks.GetValueOrDefault(f.Floor, 0) < f.TaskLimit
                );

                // 返回结果处理
                if (selectedFloor != null)
                {
                    res.ResData = selectedFloor.Floor;
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"{reqDto.Count} 扭转回库申请楼层失败，当前环线三个楼层执行中的任务数已满，不允许分配楼层：" + string.Join("", floors.Select(f =>
                     $"{f.Floor}层({floorTasks.GetValueOrDefault(f.Floor)}/{f.TaskLimit}) "));
                }

                //    var cellfloor1count = cell.Where(p => p.Floor == 1 && p.Tunnel > tun).Count();  //1楼层可用的货位数
                //    var cellfloor2count = cell.Where(p => p.Floor == 2 && p.Tunnel > tun).Count();  //2楼层可用的货位数
                //    var cellfloor3count = cell.Where(p => p.Floor == 3 && p.Tunnel > tun).Count();  //3楼层可用的货位数

                //    var forbidlayer = wms.util.AppSettings.GetConfig("ForbidLayer");//禁用的楼层
                //    if (!string.IsNullOrEmpty(forbidlayer))
                //    {
                //        if (forbidlayer.Contains("1")) cellfloor1count = 0;
                //        if (forbidlayer.Contains("2")) cellfloor2count = 0;
                //        if (forbidlayer.Contains("3")) cellfloor3count = 0;
                //    }

                //    var tempcells = new List<Tuple<int, int, double>>() {
                // new Tuple<int, int,double>(1,cellfloor1count,cellfloor1stockcount / (cellfloor1count * 1.0)),
                // new Tuple<int, int,double>(2,cellfloor2count,cellfloor2stockcount / (cellfloor2count * 1.0)),
                // new Tuple<int, int,double>(3,cellfloor3count,cellfloor3stockcount / (cellfloor3count * 1.0)),
                //};
                //    //tempcells = tempcells.OrderByDescending(p => p.Item2).ToList();
                //    tempcells = tempcells.OrderBy(p => p.Item3).ToList();//按照同规则物料少的排序

                //    //每个扫码固定楼层，如果固定楼层设备坏了或者库存满了，再换楼层
                //    var taskcount = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish && p.Floor != 0).ToList();

                //    if (tempcells[0].Item2 > (reqDto.Count + 10))
                //    {
                //        if (taskcount.Where(p => p.Floor == tempcells[0].Item1).Count() > floorTaskCount || tempcells[0].Item2 == 0)
                //        {
                //            if (taskcount.Where(p => p.Floor == tempcells[1].Item1).Count() > floorTaskCount || tempcells[1].Item2 == 0)
                //            {
                //                if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() > floorTaskCount || tempcells[2].Item2 == 0)
                //                {
                //                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //                    res.ResMsg = reqDto.Count + "扭转回库申请楼层失败，当前环线三个楼层执行中的任务数已满，不允许分配楼层";
                //                    res.ResData = 0;
                //                    return res;
                //                }
                //                else
                //                {
                //                    res.ResData = tempcells[2].Item1;
                //                }
                //            }
                //            else
                //            {
                //                res.ResData = tempcells[1].Item1;
                //            }
                //        }
                //        else
                //        {
                //            res.ResData = tempcells[0].Item1;
                //        }
                //    }
                //    else
                //    {
                //        if (tempcells[1].Item2 > (reqDto.Count + 10))
                //        {
                //            if (taskcount.Where(p => p.Floor == tempcells[1].Item1).Count() > floorTaskCount || tempcells[1].Item2 == 0)
                //            {
                //                if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() > floorTaskCount || tempcells[2].Item2 == 0)
                //                {
                //                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //                    res.ResMsg = reqDto.Count + "扭转回库申请楼层失败，当前环线三个楼层执行中的任务数已满，不允许分配楼层";
                //                    res.ResData = 0;
                //                    return res;
                //                }
                //                else
                //                {
                //                    res.ResData = tempcells[2].Item1;
                //                }
                //            }
                //            else
                //            {
                //                res.ResData = tempcells[1].Item1;
                //            }
                //        }
                //        else
                //        {
                //            if (taskcount.Where(p => p.Floor == tempcells[2].Item1).Count() < floorTaskCount && tempcells[2].Item2 > 30)
                //            {
                //                res.ResData = tempcells[2].Item1;
                //            }
                //            else
                //            {
                //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //                res.ResMsg = reqDto.Count + "扭转回库申请楼层失败，当前环线三个楼层执行中的任务数已满，不允许分配楼层";
                //                res.ResData = 0;
                //                return res;
                //            }
                //        }
                //    }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.StackTrace;
                res.ResData = 0;
                return res;
            }
            return res;
        }

        public SRes PalletizingPatchWheel(PalletizingPatchWheelRequest request)
        {
            var res = new SRes();
            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == request.TaskNum && p.Status < TaskStatus.Finish && p.Type == TaskType.OutDepot).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            var taskold = _wcstaskoldrepository.AsQueryable().Where(p => p.WmsTask == request.TaskNum && p.Id != request.TaskNum).SplitTable(p => p.Take(2)).First();
            if (taskold != null)
            {
                return res;
            }
            var pallet = _palletizrepository.GetSingle(p => p.Id == task.PalletizingId && p.PalletizState == 0);
            if (pallet == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.TaskNum + "没有找到码垛基础信息";
                return res;
            }
            var stocks = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
            if (stocks == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            var rulebox = _boxrulerepository.GetSingle(p => p.Id == pallet.BoxRuleId);
            try
            {
                var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                              join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Grade == stocks.Grade && p.HWTypeCode == stocks.HWTypeCode
                              && p.IsRework == stocks.IsRework && p.IsBlack == stocks.IsBlack && p.MatCode == task.MatCode && p.WbGroupCode == stocks.WbGroupCode && p.SolderCount == stocks.SolderCount
                              && p.IsControlpanel == stocks.IsControlpanel && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0)
                              on loc.ContGrpBarCode equals stock.ContGrpBarCode
                              join rule1 in _boxrulerepository.GetList(p => p.ZXStateCode == 1 && p.Id == pallet.BoxRuleId)
                              on stock.InDocsNo equals rule1.DocsNo
                              select new
                              {
                                  stock.MatCode,
                                  stock.InvBarCode,
                                  stock.Grade,
                                  stock.InvStateCode,
                                  stock.ProductTime,
                                  stock.WbGroupCode,
                                  stock.IsTorsChk,
                                  stock.TorsChkQty,
                                  stock.TorsChkValue,
                                  stock.TorsChkChord,
                                  stock.TorsChkFlatness,
                                  stock.HoldTime,
                                  stock.ProductMachCode,
                                  stock.IsControlpanel,
                                  stock.HWTypeCode,
                                  stock.IsBlack,
                                  stock.IsRework,
                                  stock.SolderCount,
                                  stock.TorsChkChordIsGood,
                                  stock.TorsChkFlatnessIsGood,
                                  stock.TorsChkValueIsGood,
                                  loc.Col,
                                  loc.Layer,
                                  loc.Shelf,
                                  loc.Depth,
                                  loc.Code,
                                  loc.Tunnel,
                                  loc.SCRel,
                                  loc.Floor,
                                  loc.WarehouseCode,
                                  loc.ContGrpBarCode,
                                  loc.ContGrpId,
                                  loc.Id,
                                  loc.StateNum,
                                  rule1.SkuCode
                              };
                invlist = invlist.Distinct();
                if (!string.IsNullOrEmpty(rulebox.SkuCode))
                {
                    invlist = invlist.Where(p => p.SkuCode == rulebox.SkuCode);
                }

                if (pallet.BoxRule == "CP")
                {
                    //计算扭转值、弓高、平直度
                    invlist = invlist.Where(p => p.TorsChkValueIsGood == "OK" && p.TorsChkChordIsGood == "OK" && p.TorsChkFlatnessIsGood == "OK" && p.IsTorsChk == true && p.TorsChkQty > 0 &&
                    Math.Abs((decimal)(stocks.TorsChkValue - p.TorsChkValue)) > 0.1.ObjToDecimal() && Math.Abs((decimal)(stocks.TorsChkFlatness - p.TorsChkFlatness)) > 0.1.ObjToDecimal() && Math.Abs((decimal)(stocks.TorsChkChord - p.TorsChkChord)) > 0.1.ObjToDecimal());
                }
                else
                {
                    if (stocks.IsControlpanel == true)
                    {
                        invlist = invlist.Where(p => p.IsTorsChk == true && p.IsControlpanel == true && p.TorsChkQty > 0);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.IsControlpanel == false);
                    }
                }
                var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
                if (tunlist.Any())
                {
                    if (tunlist.Where(p => p.Default2 == "1").Any())
                    {
                        invlist = invlist.Where(p => p.Floor == 1 && !tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤1层被禁用的出库巷道
                                                                                                                                                                             //invlist3 = invlist3.Where(p => p.Floor == 1 && !tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤1层被禁用的出库巷道
                    }
                    if (tunlist.Where(p => p.Default2 == "2").Any())
                    {
                        invlist = invlist.Where(p => p.Floor == 2 && !tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤2层被禁用的出库巷道
                                                                                                                                                                             //invlist3 = invlist3.Where(p => p.Floor == 2 && !tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤2层被禁用的出库巷道
                    }
                    if (tunlist.Where(p => p.Default2 == "3").Any())
                    {
                        invlist = invlist.Where(p => p.Floor == 3 && !tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤3层被禁用的出库巷道
                                                                                                                                                                             //invlist3 = invlist3.Where(p => p.Floor == 3 && !tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString())); //过滤3层被禁用的出库巷道
                    }
                }
                if (!invlist.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.NotEnoughStock.GetDescription() + "没有待补的工字轮";
                    return res;
                }
                invlist = invlist.OrderBy(p => p.ProductTime);
                foreach (var item in invlist)
                {
                    if (item.Depth == 2)
                    {
                        var respon = MoveTask(item.Code);
                        if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                        {
                            continue;
                        }
                    }

                    var wcs = new WCS_TaskInfo()
                    {
                        Status = TaskStatus.NewBuild,
                        Type = TaskType.OutDepot,
                        Priority = 0,
                        Device = item.SCRel,
                        SrmStation = item.SCRel,
                        AddrFrom = item.Code,
                        BarCode = item.ContGrpBarCode,
                        AddWho = "wms",
                        EditWho = "wms",
                        WarehouseCode = "sxhouse",
                        AddrTo = task.AddrTo,
                        FullQty = 1,
                        AgvTaskID = task.AgvTaskID,  //层配层数
                        Tunnel = item.Tunnel.ToString(),
                        MaterialCode = item.MatCode,
                        MatCode = item.MatCode,
                        OutType = OutTypeEnum.自动出库任务,
                        BusType = SxTaskBusType.TaskBusType_SX_StackStockOut.GetDescription(),
                        Floor = item.Floor,
                        Grade = item.Grade,
                        WorkBench = item.ProductMachCode,
                        WmsTask = request.TaskNum,   //需要补轮子的任务号
                        PalletizingId = task.PalletizingId,
                        Robot = task.Robot,
                        ProdLine = task.ProdLine,
                        GoodsType = item.HWTypeCode == "BS80/33" ? 1 : 2,
                        ManualRemarks = "排走的工字轮" + task.BarCode + "扫码设备" + request.Equip
                    };

                    _db.BeginTran();
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = DateTime.Now,
                        Memo = "补轮子任务号" + task.Id.ToString() + "条码" + task.BarCode + "扫码器" + request.Equip
                    }, p => p.ContGrpBarCode == item.ContGrpBarCode);
                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        StateNum = LocationState.LocationState_StockOut,
                        EditTime = DateTime.Now
                    }, p => p.Code == item.Code);
                    var stock1 = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == item.ContGrpBarCode);

                    var flow1 = _mapper.Map<BillInvflow>(stock1);
                    flow1.Id = GetId();
                    flow1.AddTime = DateTime.Now;
                    flow1.EditTime = DateTime.Now;
                    flow1.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    flow1.Memo = "装箱码垛出库";
                    _billInvflow.Insert(flow1);
                    var flow = _mapper.Map<BillInvflow>(stocks);
                    flow.Id = GetId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.Memo = "异常补轮" + request.TaskNum;

                    _billInvnowrepository.Delete(p => p.ContGrpBarCode == task.BarCode);
                    _billInvflow.Insert(flow);
                    var wcstask = _taskrepository.InsertReturnEntity(wcs);
                    _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                    var wcsdtl = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = wcstask.AddrFrom,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcstask.ID,
                        Desc = wcstask.BusType
                    };
                    _taskdetailrepository.InsertableSplitTable(wcsdtl);
                    _palletlayerMathrepository.Delete(p => p.ContBarCode == task.BarCode);
                    var layer = new PalletLayerMath()
                    {
                        ContGrpId = (long)stock1.ContGrpId,
                        ContBarCode = stock1.ContGrpBarCode,
                        Layer = task.AgvTaskID,
                        SkuCode = rulebox.SkuCode,
                        Finish = 0,
                        PboxruleId = rulebox.Id,
                        Istask = 1,
                        Palletequip = task.AddrTo,
                        Memo = "补轮子任务号" + task.Id.ToString() + "条码" + task.BarCode + "扫码器" + request.Equip,
                        AddWho = "WCS",
                        EditWho = "WCS"
                    };
                    _palletlayerMathrepository.Insert(layer);
                    _db.CommitTran();
                    return res;
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        /// <summary>
        /// 码垛强制结盘
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PalletizingForceknot(PalletizingForceknotRequest request)
        {
            var res = new SRes();
            try
            {
                var pallet = _palletizrepository.GetSingle(p => p.Equip == request.Equip && p.PalletizState == 0);
                if (pallet == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "没有当前码垛工位信息";
                    return res;
                }
                _palletizrepository.AsUpdateable().SetColumns(p => new Palletizing()
                {
                    Finish = 1 + pallet.Finish,
                    Memo = "强制结盘时间：" + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss")
                }).Where(p => p.Id == pallet.Id).ExecuteCommand();
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes Palletizinginfobinde(PalletizinginfobindeRequest request)
        {
            var res = new SRes();
            try
            {
                if (!request.TaskNum.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                    return res;
                }
                var pallet = _palletizrepository.GetSingle(p => p.Equip == request.Equip && p.PalletizState == 0);
                if (pallet == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "没有当前码垛工位的单据信息";
                    return res;
                }
                var rule = _boxrulerepository.GetSingle(p => p.Id == pallet.BoxRuleId);
                if (rule == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "码垛工位没有找到对应的装箱信息";
                    return res;
                }

                DateTime date = DateTime.Now;
                var taskgroup = string.Join("|", request.TaskNum.OrderBy(p => p).ToList());
                foreach (var item in request.TaskNum)
                {
                    var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == item && p.AddrTo == request.Equip && p.Status < dto.TaskStatus.Finish && p.Type == TaskType.OutDepot).SplitTable(p => p.Take(2)).First();
                    if (task == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                        return res;
                    }
                    if (task.PalletizingId != pallet.Id)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                        res.ResMsg = pallet.Equip + "当前工位抓取任务和码垛主表信息不匹配，不能完成抓取，请确认是否混箱";
                        return res;
                    }
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var palletdetails = _palletizdetailrepository.GetSingle(p => p.TaskNum == item);
                    if (palletdetails != null)
                    {
                        if (palletdetails.Memo == taskgroup)
                        {
                            continue;
                        }
                        else
                        {
                            res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                            res.ResMsg = pallet.Equip + "当前任务请确认是否重复上传，不能完成抓取";
                            return res;
                        }
                    }

                    //根据任务实际计算层
                    var fincount = _palletlayerMathrepository.Count(p => p.Palletequip == task.AddrTo && p.Istask == 1 && p.Finish == 1);
                    int layer = (fincount / 12) + 1;
                    //var tables = _wcstaskoldrepository.Context.SplitHelper<WCS_TaskOld>().GetTables().Take(2);//近3张分表
                    //foreach (var tbname in tables)
                    //{
                    //    //更新1点到6点时间内数据
                    //    _wcstaskoldrepository.Context.Updateable<WCS_TaskOld>().AS(tbname.TableName)//使用分表名
                    //                     .SetColumns(it => new WCS_TaskOld()
                    //                     {
                    //                         EndTime = DateTime.Now,
                    //                         ManualRemarks = layer.ToString()
                    //                     })
                    //                     .Where(p => p.Id == item)
                    //                     .ExecuteCommand();
                    //}

                    _db.BeginTran();
                    _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                    {
                        Finish = 1
                    }, p => p.ContBarCode == task.BarCode && p.ContGrpId == stock.ContGrpId && p.Palletequip == task.AddrTo && p.Istask == 1);

                    var palletdetail = new Palletizingdetail()
                    {
                        PalletizingId = pallet.Id,
                        TaskNum = item,
                        PackRule = pallet.BoxRule.ToString(),
                        Sku = rule.SkuCode,
                        BarCode = task.BarCode,
                        Layer = layer,
                        WbGroupCode = stock.WbGroupCode,
                        GradeCode = stock.Grade,
                        AddWho = "",
                        EditWho = "",
                        MaterialCode = stock.MatCode,
                        MaterialDesc = stock.MatName,
                        InDocsNo = stock.InDocsNo,
                        Batch = rule.BatchNo,
                        IsBlack = stock.IsBlack,
                        IsControlpanel = pallet.IsControlpanel,
                        Winding = stock.Wind,
                        SolderCount = stock.SolderCount,
                        PalletizingDate = date,
                        OvcFlag = pallet.IsControlpanel == true ? 2 : 0,
                        OvcValue = string.IsNullOrEmpty(stock.TorsChkValue.ToString()) ? 0.ToString() : stock.TorsChkValue.ToString(),
                        EquNo = pallet.Equip,
                        TolWQty = stock.TolWQty,
                        TareWQty = stock.TareWQty,
                        NetWQty = stock.NetWQty,
                        CLBarCode = stock.CLBarCode,
                        BoxCode = rule.PBoxCode,
                        Memo = taskgroup
                        //Memo = layer.ToString()
                    };
                    _palletizdetailrepository.Insert(palletdetail);
                    //更新历史任务
                    //_wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                    //{
                    //    EndTime = DateTime.Now,
                    //    ManualRemarks = layer.ToString()
                    //}).Where(p => p.Id == task.Id).SplitTable(p => p.Take(2)).ExecuteCommand();
                    _logger.LogInformation("实际层末尾");
                    _db.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                return res;
            }

            return res;
        }

        public SRes GetMesErrorInfo(SxErrorinfoRequest request)
        {
            var res = new SRes();

            var wcsCode = _errorinfowcs.AsQueryable().With(SqlWith.NoLock).Where(v => v.ContBarCode == request.Code).OrderByDescending(p => p.AddTime).ToList();
            if (!wcsCode.Any())
            {
                res.ResMsg = request.Code + "，扫码失败";
                res.Memo1 = request.Code + "，扫码失败";
                return res;
            }
            else
            {
                res.Memo1 = request.Code + "," + wcsCode.First().Message;
                return res;
            }

            return res;
        }

        private SRes SpcErrorTaskinfo(PalletizingPackTaskRequest request)
        {
            var res = new SRes();
            try
            {
                var wcs = new WCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.OutDepot,
                    Priority = 0,
                    Device = request.Srm,
                    SrmStation = request.Srm,
                    AddrFrom = request.CellCode,
                    BarCode = request.Code,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = "sxhouse",
                    AddrTo = "5186",
                    Tunnel = request.Tunnel,
                    MaterialCode = request.Mater,
                    MatCode = request.Mater,
                    OutType = OutTypeEnum.自动出库任务,
                    BusType = SxTaskBusType.TaskBusType_SX_ErrorStockOut.GetDescription(),
                    Floor = request.Floor,
                    Grade = request.Grade,
                    ManualRemarks = request.Memo
                };
                _db.BeginTran();
                _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                {
                    InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                    EditTime = DateTime.Now
                }, p => p.ContGrpBarCode == request.Code);
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    StateNum = LocationState.LocationState_StockOut,
                    EditTime = DateTime.Now
                }, p => p.Code == request.CellCode);
                var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.Code);

                var flow = _mapper.Map<BillInvflow>(stock);
                flow.Id = GetId();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                flow.Memo = "异常出库";
                _billInvflow.Insert(flow);
                var wcstask = _taskrepository.InsertReturnEntity(wcs);
                _wcstaskoldrepository.InsertableSplitTable(_mapper.Map<WCS_TaskOld>(wcstask));
                var wcsdtl = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = request.Code,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcstask.ID,
                    Desc = wcstask.BusType
                };
                _taskdetailrepository.InsertableSplitTable(wcsdtl);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        /// <summary>
        /// B质量码垛出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PalletizingPackBStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            var isforbid = _sysconfigrepository.GetModelByExpression(p => p.Code == "BGradeTimeOut").Default1;
            if (isforbid == "1")
            {
                res.ResMsg = "B质量码垛已禁用";
                return res;
            }

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "BGrade");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        //RedisHelper.Set("Sx:WMSErrorInfo:BGradeOut2", new RedisErrorInfo() { Equip = "BGradeOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(72);
                    if (!palletMach.Any())
                    {
                        //RedisHelper.Set("Sx:WMSErrorInfo:BGradeOut3", new RedisErrorInfo() { Equip = "BGradeOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    //var curlayer = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 1).Any() ? _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer) : 1;
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }
                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = 0,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.Memo) && p.AddWho != "禁用").Any())
            {
                //RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut4", new RedisErrorInfo() { Equip = "SpecialOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                //RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut5", new RedisErrorInfo() { Equip = "SpecialOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            devices = devices.Where(p => p.pH_STATUS == true).ToList();
            var timeOutHoldHours = int.Parse(_sysconfigrepository.GetModelByExpression(p => p.Code == "BGradeTimeOut").SContent);
            //
            var invlist1 = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                           join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "B" && string.IsNullOrEmpty(p.PreStock) //&& p.ContUsageQty <= 0
                           && ((p.ProductMachCode.Contains("R") && (DateTime.Now - p.ProductTime).TotalHours <= timeOutHoldHours) || (!p.ProductMachCode.Contains("R") && ((DateTime.Now - p.OneInTime).TotalHours <= timeOutHoldHours))))
                           on loc.ContGrpBarCode equals stock.ContGrpBarCode
                           select new StockTemp
                           {
                               MatCode = stock.MatCode,
                               InvBarCode = stock.InvBarCode,
                               Grade = stock.Grade,
                               InvStateCode = stock.InvStateCode,
                               ProductTime = stock.ProductTime,
                               WbGroupCode = stock.WbGroupCode,
                               IsTorsChk = stock.IsTorsChk,
                               TorsChkQty = stock.TorsChkQty,
                               TorsChkValue = stock.TorsChkValue,
                               HoldTime = stock.HoldTime,
                               ProductMachCode = stock.ProductMachCode,
                               IsControlpanel = stock.IsControlpanel,
                               HWTypeCode = stock.HWTypeCode,
                               SolderCount = stock.SolderCount,
                               IsRework = stock.IsRework,
                               IsBlack = stock.IsBlack,
                               Col = loc.Col,
                               Layer = loc.Layer,
                               Shelf = loc.Shelf,
                               Depth = loc.Depth,
                               Code = loc.Code,
                               Tunnel = loc.Tunnel,
                               SCRel = loc.SCRel,
                               Floor = loc.Floor,
                               WarehouseCode = loc.WarehouseCode,
                               ContGrpBarCode = loc.ContGrpBarCode,
                               ContGrpId = loc.ContGrpId,
                               Id = loc.Id,
                               StateNum = loc.StateNum,
                               Wind = stock.Wind,
                               InDocsNo = stock.InDocsNo
                           };

            if (!invlist1.Any())
            {
                //RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut6", new RedisErrorInfo() { Equip = "SpecialOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist1 = invlist1.Distinct();
            var temps = invlist1.OrderBy(p => p.ProductTime).GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                var invlist2 = invlist1.Where(p => p.HWTypeCode == item.Key);
                if (!invlist2.Any())
                {
                    continue;
                }
                var mater = invlist2.OrderBy(p => p.ProductTime).GroupBy(p => p.MatCode).ToList();
                foreach (var stockTemps in mater)
                {
                    var invlist = invlist2.Where(p => p.MatCode == stockTemps.Key);
                    if (!invlist.Any())
                    {
                        continue;
                    }
                    //else if (invlist.Count() < 36)
                    //{
                    //    res.ResMsg = "B质量数量不满足";
                    //    continue;
                    //}

                    var ti = DateTime.Now;
                    var yaar = ti.Year.ToString().Substring(2, 2);
                    var month = ti.Month.ToString().PadLeft(2, '0');
                    var day = ti.Day.ToString().PadLeft(2, '0');
                    //获取当天最大箱号
                    var maxnumre = _boxserialrepository.AsQueryable().Where(p => p.Grade == "B" && p.Year == yaar && p.Month == month && p.Day == day);
                    string boxserial = "HAZDB";
                    if (maxnumre.Any())
                    {
                        boxserial = boxserial + yaar + month + day + (maxnumre.Max(q => q.Num) + 1).ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = maxnumre.Max(q => q.Num) + 1,
                            BoxNum = boxserial,
                            Grade = "B",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }
                    else
                    {
                        boxserial = boxserial + yaar + month + day + "1".ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = 1,
                            BoxNum = boxserial,
                            Grade = "B",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }
                    //B质量不区分绕向
                    //invlist = invlist.Where(p => p.Wind == "R");
                    var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                    rule.Id = GetId();
                    rule.PBoxCode = boxserial;
                    rule.Wind = "";
                    rule.ZXStateCode = 1;
                    rule.SpoolType = item.Key;
                    rule.PackRule = "BGrade";
                    rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                    rule.SkuCode = "TestBGrade";
                    rule.BatchNo = "1";
                    rules = _boxrulerepository.InsertReturnEntity(rule);

                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo) && string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.SContent) && p.AddWho != "禁用").OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode, ActType = 1 };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        //RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut7", new RedisErrorInfo() { Equip = "SpecialOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var root = DetermineRoot(palletequip.Code);
                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2,
                        Robot = root
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode,
                            PalletizingId = pallects.Id
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(72);

                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == pallects.Id).Take(72);
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        public CurStockListResponse GetCurStockList(CurStockListRequest request)
        {
            var res = new CurStockListResponse() { ResData = new List<resItmes>() };
            var stock = _billInvnowrepository.Context.Queryable<BillInvnow, BaseMatinfo>((inv, mater) => new object[]
            {
                JoinType.Left, inv.MatCode == mater.Code
            })
            .Where((inv, mater) => inv.InvStateCode == InvState.InvEcecState_In.ToString())
            .WhereIF(!string.IsNullOrEmpty(request.MatCode), (inv, mater) => inv.MatCode.Contains(request.MatCode))
            .WhereIF(!string.IsNullOrEmpty(request.MatName), (inv, mater) => inv.MatName.Contains(request.MatName))
            .Select((inv, mater) => new resItmes()
            {
                MatCode = mater.Code,
                MatBarCode = inv.CLBarCode,
                SpoolCode = inv.ContGrpBarCode,
                WbCode = inv.ProductMachCode,
                WorkOrder = inv.InDocsNo,
                SpoolType = inv.HWTypeCode,
                Length = (decimal)mater.Length,
                Weight = (decimal)mater.Weight,
                ProductDate = inv.ProductTime,
                IsHold = mater.IsHold,
                IsBlack = inv.IsBlack,
                IsCore = inv.IsCore,
                IsRework = inv.IsRework,
                Grade = inv.Grade,
                SolderCount = inv.SolderCount,
                HoldDuration = mater.HoldDuration,
                LocRow = inv.PutRow.ToString(),
                LocCell = inv.PutCol.ToString(),
                LocLayer = inv.PutLayer.ToString(),
                WareCode = "sxhouse"
            })
            .ToList();
            res.ResData = stock;
            return res;
        }

        public SRes UpdateBoxNo(UpdateBoxNoRequest request)
        {
            var res = new SRes();
            var list = _boxrulerepository.GetList(p => request.List.Contains(p.DocsNo)).OrderBy(p => p.Id);
            var index = request.StartIndex;
            foreach (var item in list)
            {
                _boxrulerepository.UpdateModelColumns(p => new BillPboxrule() { PBoxCode = "888888" + index.ToString(), EditTime = DateTime.Now },
                       p => p.Id == item.Id);
                index++;
            }
            return res;
        }

        public SRes UpdateBlackCount(UpdateBlackCountReq request)
        {
            var res = new SRes();
            var blackcount = _sysconfigrepository.GetSingle(p => p.Code == "BlackCount");
            if (blackcount == null)
            {
                res.ResCode = 0;
                res.ResMsg = "更新失败，没有配置";
                return res;
            }
            if (request.SpoolType == "1")
            {
                _sysconfigrepository.UpdateModelColumns(p => new sxSysConfig() { Default1 = request.Count.ToString(), EditTime = DateTime.Now, EditWho = "MES" },
                  p => p.Id == blackcount.Id);
            }
            else if (request.SpoolType == "2")
            {
                _sysconfigrepository.UpdateModelColumns(p => new sxSysConfig() { Default2 = request.Count.ToString(), EditTime = DateTime.Now, EditWho = "MES" },
                  p => p.Id == blackcount.Id);
            }
            else
            {
                res.ResCode = 0;
                res.ResMsg = "更新失败，SpoolType传值无效";
                return res;
            }

            return res;
        }

        /// <summary>
        /// 重绕超时码垛
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes ChongraoPackStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "SpecialCHA");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    //var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    //if (tasklist.Any())
                    //{
                    //    RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut1", new RedisErrorInfo() { Equip = "SpecialOut1", Con = "当前码垛工位：" + item.Equip + "存在未码垛的任务，不允许下发新的任务", Time = DateTime.Now });
                    //    continue;
                    //}

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut2", new RedisErrorInfo() { Equip = "SpecialOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(72);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut3", new RedisErrorInfo() { Equip = "SpecialOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    //var curlayer = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 1).Any() ? _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer) : 1;
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }
                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = 0,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut4", new RedisErrorInfo() { Equip = "SpecialOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut5", new RedisErrorInfo() { Equip = "SpecialOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
            devices = devices.Where(p => p.pH_STATUS == true && sys.Select(p => p.Code).Contains(p.deviceCode)).ToList();
            var timeOutHoldHours = int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));
            //
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && string.IsNullOrEmpty(p.PreStock) //&& p.ContUsageQty <= 0
                          && p.InDocsNo.StartsWith("R") && (DateTime.Now - p.OneInTime).TotalHours > timeOutHoldHours)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              OneInTime = stock.OneInTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo
                          };

            //禁用巷道过滤
            var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
            if (tunlist.Any())
            {
                if (tunlist.Where(p => p.Default2 == "1").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 1 && tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤1层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "2").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 2 && tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤2层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "3").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 3 && tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤3层被禁用的出库巷道
                }
            }
            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut6", new RedisErrorInfo() { Equip = "SpecialOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var temps = invlist.OrderBy(p => p.OneInTime).GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                invlist = invlist.Where(p => p.HWTypeCode == item.Key);
                if (!invlist.Any())
                {
                    continue;
                }
                var mater = invlist.OrderBy(p => p.OneInTime).GroupBy(p => p.MatCode).ToList();
                foreach (var stockTemps in mater)
                {
                    invlist = invlist.Where(p => p.MatCode == stockTemps.Key);
                    if (!invlist.Any())
                    {
                        continue;
                    }

                    var ti = DateTime.Now;
                    var yaar = ti.Year.ToString().Substring(2, 2);
                    var month = ti.Month.ToString().PadLeft(2, '0');
                    var day = ti.Day.ToString().PadLeft(2, '0');
                    //获取当天最大箱号
                    var maxnumre = _boxserialrepository.AsQueryable().Where(p => p.Grade == "A" && p.Year == yaar && p.Month == month && p.Day == day);
                    string boxserial = "HAZDA";
                    if (maxnumre.Any())
                    {
                        boxserial = boxserial + yaar + month + day + (maxnumre.Max(q => q.Num) + 1).ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = maxnumre.Max(q => q.Num) + 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }
                    else
                    {
                        boxserial = boxserial + yaar + month + day + "1".ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }

                    if (invlist.Any(p => p.Wind == "L"))
                    {
                        invlist = invlist.Where(p => p.Wind == "L");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        //rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.PBoxCode = boxserial;
                        rule.Wind = "L";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "SpecialCHA";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.Wind == "R");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = boxserial;
                        rule.Wind = "R";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "SpecialCHA";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.OneInTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.OneInTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo) && string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.SContent)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode, ActType = 1 };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut7", new RedisErrorInfo() { Equip = "SpecialOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var root = DetermineRoot(palletequip.Code);

                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2,
                        Robot = root
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode,
                            PalletizingId = pallects.Id
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(72);

                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == pallects.Id).Take(72);
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        public SRes SolderErrorStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && string.IsNullOrEmpty(p.PreStock) && p.SolderCount > 0)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select new
                          {
                              stock.MatCode,
                              stock.InvBarCode,
                              stock.Grade,
                              stock.InvStateCode,
                              stock.ProductTime,
                              stock.WbGroupCode,
                              stock.IsTorsChk,
                              stock.TorsChkQty,
                              stock.TorsChkValue,
                              stock.HoldTime,
                              stock.ProductMachCode,
                              stock.IsControlpanel,
                              stock.HWTypeCode,
                              stock.SolderCount,
                              stock.IsRework,
                              stock.IsBlack,
                              stock.InDocsNo,
                              loc.Col,
                              loc.Layer,
                              loc.Shelf,
                              loc.Depth,
                              loc.Code,
                              loc.Tunnel,
                              loc.SCRel,
                              loc.Floor,
                              loc.WarehouseCode,
                              loc.ContGrpBarCode,
                              loc.ContGrpId,
                              loc.Id,
                              loc.StateNum
                          };
            if (!invlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.OrderBy(p => p.ProductTime);
            foreach (var item in invlist)
            {
                if (!_boxrulerepository.AsQueryable().Where(p => p.DocsNo == item.InDocsNo && p.ZXStateCode == 0 && p.PerSolderMaxCount > item.SolderCount).Any() && int.Parse((DateTime.Now - item.ProductTime).TotalHours.ToString("f2")) > 24)
                {
                    SpcErrorTaskinfo(new PalletizingPackTaskRequest()
                    {
                        Srm = item.SCRel,
                        CellCode = item.Code,
                        Code = item.ContGrpBarCode,
                        Tunnel = item.Tunnel.ToString(),
                        Floor = item.Floor,
                        Grade = item.Grade,
                        Mater = item.MatCode,
                        Memo = "焊点不符，自动排出"
                    });
                }
            }
            return res;
        }

        public SRes ForceCancelTask(ErrorTaskRequest request)
        {
            var res = new SRes();
            if (string.IsNullOrEmpty(request.TaskNo))
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == int.Parse(request.TaskNo) && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            if (_taskrepository.Delete(p => p.ID == int.Parse(request.TaskNo)))
            {
                _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld() { Status = TaskStatus.Cancel, ManualRemarks = "强制取消任务", EditTime = DateTime.Now }).Where(p => p.Id == task.Id).SplitTable(p => p.Take(2)).ExecuteCommand();
                //删除码垛信息
                _palletlayerMathrepository.Delete(p => p.ContBarCode == task.BarCode);
                _palletizdetailrepository.Delete(p => p.BarCode == task.BarCode);
                _logger.LogInformation("强制取消任务" + request.TaskNo);
            }
            return res;
        }

        public SRes DeleteStockInfo(DetailCodeStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.Code);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            else
            {
                //_billInvnowrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                if (stock.InvStateCode == InvState.InvEcecState_In.ToString())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"工字轮{stock.ContGrpBarCode} | 已在库中，不允许删除";
                    return res;
                }
                else if (stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString())
                {
                    _billInvnowrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    _billInvinitrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == stock.ContGrpBarCode).OrderByDescending(p => p.AddTime).First();
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = "异常处理库存";
                    _billInvflow.Insert(flow);
                }
                else if (stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                {
                    if (stock.PutRow == 0 && stock.PutCol == 0 && stock.PutLayer == 0)
                    {
                        _billInvnowrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                        _billInvinitrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                        var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == stock.ContGrpBarCode).OrderByDescending(p => p.AddTime).First();
                        flow.Id = GetId();
                        flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                        flow.AddTime = DateTime.Now;
                        flow.EditTime = DateTime.Now;
                        flow.Memo = "异常处理库存";
                        _billInvflow.Insert(flow);
                    }
                }
            }
            return res;
        }

        public SRes DeleteTorsBind(DetailCodeStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var stock = _torchbandinforepository.GetSingle(p => p.ContBarCode == request.Code);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.Code + "不存在扭转绑定信息";
                return res;
            }
            else
            {
                _torchbandinforepository.Delete(p => p.ContBarCode == request.Code);
            }
            return res;
        }

        public SRes DeleteHwPre(DetailCodeStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.Code);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.Code + "不存在库存信息";
                return res;
            }
            else
            {
                _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                {
                    PreStock = ""
                }, p => p.ContGrpBarCode == request.Code);
            }
            return res;
        }

        public SRes UpdateStockState(DetailCodeStr1Requestdto request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.Code);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            var status = "";
            switch (request.State)
            {
                case 1:
                    status = InvState.InvEcecState_BuildUp.ToString();
                    break;

                case 3:
                    status = InvState.InvEcecState_In.ToString();
                    break;

                case 4:
                    status = InvState.InvEcecState_OutGoing.ToString();
                    break;

                case 5:
                    status = InvState.InvEcecState_Out.ToString();
                    break;

                default:
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "状态" + ResponseStatusCodeEnum.ErrParam.GetDescription();
                    return res;
            }

            try
            {
                var p = _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                {
                    InvStateCode = status,
                    EditTime = DateTime.Now
                }, p => p.ContGrpBarCode == stock.ContGrpBarCode);
                if (!p)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = stock.ContGrpBarCode + ResponseStatusCodeEnum.Fail.GetDescription();
                    return res;
                }
                var flow = _mapper.Map<BillInvflow>(stock);
                flow.Id = GetId();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.InvStateCode = status;
                _billInvflow.Insert(flow);
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }

            return res;
        }

        public SRes UpdateCellState(DetailCodeStr1Requestdto request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var cell = _basewarecellrepository.GetSingle(p => p.Code == request.Code);
            if (cell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            var st = (LocationState)request.State;
            if (request.State == 1)
            {
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    StateNum = st,
                    ContGrpBarCode = "",
                    ContGrpId = 0,
                    EditTime = DateTime.Now
                }, p => p.Code == request.Code);
            }
            else
            {
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    StateNum = st,
                    EditTime = DateTime.Now
                }, p => p.Code == request.Code);
            }

            return res;
        }

        public SRes DataSwapCell(DataSwapCellStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var fromCell = _basewarecellrepository.GetSingle(p => p.Code == request.StatEquip);
            if (fromCell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.StatEquip + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (fromCell.StateNum != LocationState.LocationState_Full)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.StatEquip + "货位不是有货状态，不允许互换";
                return res;
            }
            var fromstock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == fromCell.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
            if (fromstock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.StatEquip + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            var toCell = _basewarecellrepository.GetSingle(p => p.Code == request.EndEquip);
            if (toCell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.EndEquip + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (toCell.StateNum != LocationState.LocationState_Full)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.EndEquip + "货位不是有货状态，不允许互换";
                return res;
            }
            var tostock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == toCell.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
            if (tostock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.EndEquip + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            try
            {
                _db.BeginTran();
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    ContGrpBarCode = fromCell.ContGrpBarCode,
                    ContGrpId = fromCell.ContGrpId
                }, p => p.Code == toCell.Code);
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    ContGrpBarCode = toCell.ContGrpBarCode,
                    ContGrpId = toCell.ContGrpId
                }, p => p.Code == fromCell.Code);
                _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                {
                    PutRow = toCell.Row,
                    PutCol = toCell.Col,
                    PutLayer = toCell.Layer
                }, p => p.ContGrpBarCode == fromCell.ContGrpBarCode);
                _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                {
                    PutRow = fromCell.Row,
                    PutCol = fromCell.Col,
                    PutLayer = fromCell.Layer
                }, p => p.ContGrpBarCode == toCell.ContGrpBarCode);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes DataBasePatch(DataBasePatchRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.Code);
            if (stock != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Code + "存在组盘信息，不允许补数据";
                return res;
            }
            var cell = _basewarecellrepository.GetSingle(p => p.Code == request.Cell);
            if (cell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.Cell + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (cell.StateNum != LocationState.LocationState_Empty)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Cell + "货位状态不是空货位，不允许补数据";
                return res;
            }
            try
            {
                if (request.ContGrpType == 1)
                {
                    var boxCode = _billInvnowrepository.GetSingle(p => p.BoxBarCode == request.BoxCode);
                    if (boxCode != null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.BarcodeContainerRepeat.GetHashCode();
                        res.ResMsg = request.BoxCode + ResponseStatusCodeEnum.BarcodeContainerRepeat.GetDescription();
                        return res;
                    }
                    var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == request.Code && p.BoxBarCode == request.BoxCode && p.ContGrpType == request.ContGrpType).OrderByDescending(p => p.EditTime).First();
                    if (flow == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = request.Code + "不存在流水信息，不允许补数据";
                        return res;
                    }
                }
                else if (request.ContGrpType == 2 || request.ContGrpType == 3)
                {
                    var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == request.Code && p.ContGrpType == request.ContGrpType).OrderByDescending(p => p.EditTime).First();
                    if (flow == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = request.Code + "不存在流水信息，不允许补数据";
                        return res;
                    }
                    flow.InvStateCode = InvState.InvEcecState_In.ToString();
                    flow.Id = GetId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.PutRow = cell.Row;
                    flow.PutCol = cell.Col;
                    flow.PutLayer = cell.Layer;
                    flow.AddWho = "wms";
                    flow.EditWho = "wms";
                    flow.Memo = "手动补数据";
                    _db.BeginTran();
                    _billInvnowrepository.Insert(_mapper.Map<BillInvnow>(flow));
                    _billInvflow.Insert(flow);
                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        ContGrpBarCode = flow.ContGrpBarCode,
                        ContGrpId = flow.ContGrpId,
                        StateNum = LocationState.LocationState_Full,
                        IsStop = 0,
                        EditTime = DateTime.Now
                    }, p => p.Code == cell.Code);
                    _db.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            return res;
        }

        public SRes DataBasePatch2(DataBasePatchRequest request)
        {
            var res = new SRes();

            try
            {
                var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == request.Code && p.Memo == "扭转回库").OrderByDescending(p => p.EditTime).First();
                if (flow == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Code + "不存在扭转流水信息，不允许补数据";
                    return res;
                }
                if (flow.IsControlpanel == true && flow.IsTorsChk)
                {
                    flow.Id = GetId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.AddWho = "wms";
                    flow.EditWho = "wms";
                    flow.Memo = "手动补数据,更新扭转数据";
                    _db.BeginTran();

                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        TorsChkQty = flow.TorsChkQty,
                        TorsChkTime = flow.TorsChkTime,
                        SideNum = 1,
                        TorsChkValue = flow.TorsChkValue,
                        TorsChkMachCode = flow.TorsChkMachCode,
                        Memo = flow.Memo,
                        TorsChkChord = flow.TorsChkChord,
                        TorsChkFlatness = flow.TorsChkFlatness,
                        TorsChkStation = flow.TorsChkStation,
                        TorsChkChordIsGood = flow.TorsChkChordIsGood,
                        TorsChkFlatnessIsGood = flow.TorsChkFlatnessIsGood,
                        TorsChkValueIsGood = flow.TorsChkValueIsGood,
                        //FailReason = "测试"+ flow.Memo
                    }, p => p.ContGrpBarCode == flow.ContGrpBarCode);
                    _billInvflow.Insert(flow);
                    _db.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            return res;
        }

        public SRes DataBasePatch3(DataBasePatchRequest request)
        {
            var res = new SRes();

            try
            {
                var flow = _billInvflow.AsQueryable().Where(p => p.ContGrpBarCode == request.Code && p.Memo == "装箱码垛出库").OrderByDescending(p => p.EditTime).First();
                if (flow == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Code + "不存在扭转流水信息，不允许补数据";
                    return res;
                }
                _billInvnowrepository.Insert(_mapper.Map<BillInvnow>(flow));
                _billInvinitrepository.Insert(_mapper.Map<BillInvinit>(flow));
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            return res;
        }

        public SRes UpdatePurchState(UpdatePurchStateRequestdto request)
        {
            var res = new SRes();
            if (!request.Id.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            foreach (var item in request.Id)
            {
                var pursh = _billPushinforepository.GetSingle(p => p.Id == item);
                if (pursh != null)
                {
                    _billPushinforepository.UpdateSetColumnsTrue(p => new BillPushinfo()
                    {
                        PostQty = 5,
                        PostResult = 0,
                        Memo = "手动推送"
                    }, p => p.Id == pursh.Id);
                }
            }
            return res;
        }

        public SRes DataMoveCell(DataSwapCellStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.SxWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var fromCell = _basewarecellrepository.GetSingle(p => p.Code == request.StatEquip);
            if (fromCell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.StatEquip + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (fromCell.StateNum != LocationState.LocationState_Full)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.StatEquip + "货位不是有货状态，不允许转移";
                return res;
            }
            var toCell = _basewarecellrepository.GetSingle(p => p.Code == request.EndEquip);
            if (toCell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.EndEquip + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (toCell.StateNum != LocationState.LocationState_Empty)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.EndEquip + "货位不是无货状态，不允许转移";
                return res;
            }
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == fromCell.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = fromCell.ContGrpBarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            try
            {
                _db.BeginTran();
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    StateNum = LocationState.LocationState_Empty,
                    ContGrpBarCode = "",
                    ContGrpId = 0,
                    EditTime = DateTime.Now
                }, p => p.Code == fromCell.Code);
                _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                {
                    StateNum = LocationState.LocationState_Full,
                    ContGrpBarCode = fromCell.ContGrpBarCode,
                    ContGrpId = fromCell.ContGrpId,
                    EditTime = DateTime.Now
                }, p => p.Code == toCell.Code);
                _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                {
                    PutRow = toCell.Row,
                    PutCol = toCell.Col,
                    PutLayer = toCell.Layer
                }, p => p.ContGrpBarCode == fromCell.ContGrpBarCode);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes TaskRepeatSend(TaskRepeatRequest request)
        {
            var res = new SRes();
            if (!request.TaskNo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "任务号" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            var wcsTask = _taskrepository.GetList(p => request.TaskNo.Contains(p.ID) && p.Status == TaskStatus.码垛抓取中);
            if (wcsTask.Count == request.TaskNo.Count)
            {
                _taskrepository.UpdateSetColumnsTrue(p => new WCS_TaskInfo()
                {
                    Status = TaskStatus.码垛抓取扫码,
                    EditTime = DateTime.Now,
                    ManualRemarks = "机器人重复下发任务"
                }, p => request.TaskNo.Contains(p.ID));
                _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
                {
                    Status = TaskStatus.码垛抓取扫码,
                    EditTime = DateTime.Now,
                    ManualRemarks = "机器人重复下发任务"
                }).Where(p => request.TaskNo.Contains(p.Id)).SplitTable(p => p.Take(2)).ExecuteCommand();
            }
            else
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "申请的任务数不等于查询结果的任务数";
                return res;
            }
            return res;
        }

        public SRes UpdateTaskState(UpdateTaskStateRequest request)
        {
            var res = new SRes();
            var task = _taskrepository.GetSingle(p => p.ID == request.TaskNo);
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            _taskrepository.UpdateSetColumnsTrue(p => new WCS_TaskInfo()
            {
                Status = request.Status,
                EditTime = DateTime.Now,
                ManualRemarks = "手动修改任务状态"
            }, p => p.ID == request.TaskNo);
            _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld()
            {
                Status = request.Status,
                EditTime = DateTime.Now,
                ManualRemarks = "手动修改任务状态"
            }).Where(p => p.Id == request.TaskNo).SplitTable(p => p.Take(2)).ExecuteCommand();
            return res;
        }

        /// <summary>
        /// 超时码垛
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes SpecialStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "Special");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    //var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    //if (tasklist.Any())
                    //{
                    //    RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut1", new RedisErrorInfo() { Equip = "SpecialOut1", Con = "当前码垛工位：" + item.Equip + "存在未码垛的任务，不允许下发新的任务", Time = DateTime.Now });
                    //    continue;
                    //}

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut2", new RedisErrorInfo() { Equip = "SpecialOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(72);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut3", new RedisErrorInfo() { Equip = "SpecialOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    //var curlayer = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 1).Any() ? _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer) : 1;
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }
                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = 0,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut4", new RedisErrorInfo() { Equip = "SpecialOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut5", new RedisErrorInfo() { Equip = "SpecialOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
            devices = devices.Where(p => p.pH_STATUS == true && sys.Select(p => p.Code).Contains(p.deviceCode)).ToList();
            var timeOutHoldHours = int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));
            //
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && string.IsNullOrEmpty(p.PreStock) && !p.ProductMachCode.Contains("R")
                          && (DateTime.Now - p.ProductTime).TotalHours > timeOutHoldHours)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo
                          };

            var invlist1 = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                           join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && string.IsNullOrEmpty(p.PreStock) && p.ProductMachCode.Contains("R")
                             && (DateTime.Now - p.OneInTime).TotalHours > timeOutHoldHours)
                           on loc.ContGrpBarCode equals stock.ContGrpBarCode
                           select new StockTemp
                           {
                               MatCode = stock.MatCode,
                               InvBarCode = stock.InvBarCode,
                               Grade = stock.Grade,
                               InvStateCode = stock.InvStateCode,
                               ProductTime = stock.ProductTime,
                               WbGroupCode = stock.WbGroupCode,
                               IsTorsChk = stock.IsTorsChk,
                               TorsChkQty = stock.TorsChkQty,
                               TorsChkValue = stock.TorsChkValue,
                               HoldTime = stock.HoldTime,
                               ProductMachCode = stock.ProductMachCode,
                               IsControlpanel = stock.IsControlpanel,
                               HWTypeCode = stock.HWTypeCode,
                               SolderCount = stock.SolderCount,
                               IsRework = stock.IsRework,
                               IsBlack = stock.IsBlack,
                               Col = loc.Col,
                               Layer = loc.Layer,
                               Shelf = loc.Shelf,
                               Depth = loc.Depth,
                               Code = loc.Code,
                               Tunnel = loc.Tunnel,
                               SCRel = loc.SCRel,
                               Floor = loc.Floor,
                               WarehouseCode = loc.WarehouseCode,
                               ContGrpBarCode = loc.ContGrpBarCode,
                               ContGrpId = loc.ContGrpId,
                               Id = loc.Id,
                               StateNum = loc.StateNum,
                               Wind = stock.Wind,
                               InDocsNo = stock.InDocsNo
                           };
            invlist = invlist.Union(invlist1);
            invlist = invlist.Where(x => x.InDocsNo != "O2507080014001ALX01R");
            //禁用巷道过滤
            var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
            if (tunlist.Any())
            {
                if (tunlist.Where(p => p.Default2 == "1").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 1 && tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤1层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "2").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 2 && tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤2层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "3").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 3 && tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤3层被禁用的出库巷道
                }
            }

            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut6", new RedisErrorInfo() { Equip = "SpecialOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var temps = invlist.OrderBy(p => p.ProductTime).GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                invlist = invlist.Where(p => p.HWTypeCode == item.Key);
                if (!invlist.Any())
                {
                    continue;
                }
                var mater = invlist.OrderBy(p => p.ProductTime).GroupBy(p => p.MatCode).ToList();
                foreach (var stockTemps in mater)
                {
                    invlist = invlist.Where(p => p.MatCode == stockTemps.Key);
                    if (!invlist.Any())
                    {
                        continue;
                    }

                    var ti = DateTime.Now;
                    var yaar = ti.Year.ToString().Substring(2, 2);
                    var month = ti.Month.ToString().PadLeft(2, '0');
                    var day = ti.Day.ToString().PadLeft(2, '0');
                    //获取当天最大箱号
                    var maxnumre = _boxserialrepository.AsQueryable().Where(p => p.Grade == "A" && p.Year == yaar && p.Month == month && p.Day == day);
                    string boxserial = "HAZDA";
                    if (maxnumre.Any())
                    {
                        boxserial = boxserial + yaar + month + day + (maxnumre.Max(q => q.Num) + 1).ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = maxnumre.Max(q => q.Num) + 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }
                    else
                    {
                        boxserial = boxserial + yaar + month + day + "1".ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }

                    if (invlist.Any(p => p.Wind == "L"))
                    {
                        invlist = invlist.Where(p => p.Wind == "L");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        //rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.PBoxCode = boxserial;
                        rule.Wind = "L";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "Special";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.Wind == "R");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = boxserial;
                        rule.Wind = "R";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "Special";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo) && string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.SContent)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode, ActType = 1 };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut7", new RedisErrorInfo() { Equip = "SpecialOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var root = DetermineRoot(palletequip.Code);

                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2,
                        Robot = root
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode,
                            PalletizingId = pallects.Id
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(72);

                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == pallects.Id).Take(72);
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        /// <summary>
        /// 手动筛选码垛出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes ManualPalletizingStockOut(ManualPalletizingStockOutRequest request)
        {
            var res = new SRes();

            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "ManualSpecial");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    //var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    //if (tasklist.Any())
                    //{
                    //    RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut1", new RedisErrorInfo() { Equip = "SpecialOut1", Con = "当前码垛工位：" + item.Equip + "存在未码垛的任务，不允许下发新的任务", Time = DateTime.Now });
                    //    continue;
                    //}

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut2", new RedisErrorInfo() { Equip = "SpecialOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(72);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut3", new RedisErrorInfo() { Equip = "SpecialOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    //var curlayer = _palletlayerMathrepository.GetList(p => p.PalletizingId == item.Id && p.Istask == 1).Any() ? _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer) : 1;
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }
                    foreach (var pallets in palletMach)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(pallets.Palletequip);

                        //先判断二升位是否能出库
                        if (cell.Depth == 2)
                        {
                            var respon = MoveTask(cell.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = pallets.ContBarCode,
                            CellCode = cell.Code,
                            Srm = cell.SCRel,
                            Tunnel = cell.Tunnel.ToString(),
                            Floor = cell.Floor,
                            Grade = invs.Grade,
                            Mater = invs.MatCode,
                            SkuCode = pallets.SkuCode,
                            PalletLayer = 0,
                            ProductMachCode = invs.ProductMachCode,
                            Equip = item.Equip,
                            PalletizingId = item.Id,
                            Robot = root,
                            GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 0
                        }, p => p.ContBarCode == invs.ContGrpBarCode);
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut4", new RedisErrorInfo() { Equip = "SpecialOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut5", new RedisErrorInfo() { Equip = "SpecialOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            var sys = _sysconfigrepository.GetList(p => p.SType == "TrayType");
            devices = devices.Where(p => p.pH_STATUS == true && sys.Select(p => p.Code).Contains(p.deviceCode)).ToList();
            var timeOutHoldHours = int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));
            //
            //获取库存列表
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && (p.IsControlpanel == false && p.IsTorsChk == false) && string.IsNullOrEmpty(p.PreStock) //&& !p.ProductMachCode.Contains("R")
                          //&& (DateTime.Now - p.ProductTime).TotalHours < timeOutHoldHours
                          )
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                          on stock.InDocsNo equals rule1.DocsNo
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              OneInTime = stock.OneInTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              SkuCode = rule1.SkuCode,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo,
                              BatchNo = stock.BatchNo
                          };

            //查找满足时效但是没有全部检测完成的盘所在的机器组
            var invlistTors = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                              join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && p.Grade == "A" && p.IsControlpanel == true && p.IsTorsChk == true && p.TorsChkQty > 0 && string.IsNullOrEmpty(p.PreStock) //&& !p.ProductMachCode.Contains("R")
                              //&& (DateTime.Now - p.ProductTime).TotalHours < timeOutHoldHours
                              )
                              on loc.ContGrpBarCode equals stock.ContGrpBarCode
                              join rule1 in _boxrulerepository.AsQueryable().Where(p => p.PackRule == "SPC").Select(p => new { p.DocsNo, p.SkuCode }).Distinct().ToList()
                              on stock.InDocsNo equals rule1.DocsNo
                              select new StockTemp
                              {
                                  MatCode = stock.MatCode,
                                  InvBarCode = stock.InvBarCode,
                                  Grade = stock.Grade,
                                  InvStateCode = stock.InvStateCode,
                                  ProductTime = stock.ProductTime,
                                  OneInTime = stock.OneInTime,
                                  WbGroupCode = stock.WbGroupCode,
                                  IsTorsChk = stock.IsTorsChk,
                                  TorsChkQty = stock.TorsChkQty,
                                  TorsChkValue = stock.TorsChkValue,
                                  HoldTime = stock.HoldTime,
                                  ProductMachCode = stock.ProductMachCode,
                                  IsControlpanel = stock.IsControlpanel,
                                  HWTypeCode = stock.HWTypeCode,
                                  SolderCount = stock.SolderCount,
                                  IsRework = stock.IsRework,
                                  IsBlack = stock.IsBlack,
                                  Col = loc.Col,
                                  Layer = loc.Layer,
                                  Shelf = loc.Shelf,
                                  Depth = loc.Depth,
                                  Code = loc.Code,
                                  Tunnel = loc.Tunnel,
                                  SCRel = loc.SCRel,
                                  Floor = loc.Floor,
                                  WarehouseCode = loc.WarehouseCode,
                                  ContGrpBarCode = loc.ContGrpBarCode,
                                  ContGrpId = loc.ContGrpId,
                                  Id = loc.Id,
                                  StateNum = loc.StateNum,
                                  SkuCode = rule1.SkuCode,
                                  Wind = stock.Wind,
                                  InDocsNo = stock.InDocsNo,
                                  BatchNo = stock.BatchNo
                              };

            invlist = invlist.Union(invlistTors);
            invlist = invlist.Where(x => x.InDocsNo != "O2507080014001ALX01R");

            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:NoControlOut6", new RedisErrorInfo() { Equip = "NoControlOut6", Con = "非控制盘库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }

            if (!string.IsNullOrEmpty(request.Sku))
            {
                invlist = invlist.Where(p => p.SkuCode == request.Sku);
            }
            if (!string.IsNullOrEmpty(request.Wind))
            {
                invlist = invlist.Where(p => p.Wind == request.Wind);
            }
            //if (!string.IsNullOrEmpty(request.WbGroupCode))
            //{
            //    invlist = invlist.Where(p => p.WbGroupCode == request.WbGroupCode);
            //}
            if (!string.IsNullOrEmpty(request.HwType))
            {
                invlist = invlist.Where(p => p.HWTypeCode.Contains(request.HwType));
            }
            if (!string.IsNullOrEmpty(request.IsTimeOut))
            {
                if (request.IsTimeOut == "0")
                {
                    invlist = invlist.Where(p => (!p.WbGroupCode.Contains("R") && (DateTime.Now - p.ProductTime).TotalHours < timeOutHoldHours) || (p.WbGroupCode.Contains("R") && (DateTime.Now - p.OneInTime).TotalHours < timeOutHoldHours));
                }
                else if (request.IsTimeOut == "1")
                {
                    invlist = invlist.Where(p => (!p.WbGroupCode.Contains("R") && (DateTime.Now - p.ProductTime).TotalHours >= timeOutHoldHours) || (p.WbGroupCode.Contains("R") && (DateTime.Now - p.OneInTime).TotalHours >= timeOutHoldHours));
                }
            }
            //禁用巷道过滤
            var tunlist = _sysconfigrepository.GetList(p => p.SType == "OutStop" && !string.IsNullOrEmpty(p.SContent));
            if (tunlist.Any())
            {
                if (tunlist.Where(p => p.Default2 == "1").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 1 && tunlist.Where(x => x.Default2 == "1").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤1层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "2").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 2 && tunlist.Where(x => x.Default2 == "2").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤2层被禁用的出库巷道
                }
                if (tunlist.Where(p => p.Default2 == "3").Any())
                {
                    var inv = invlist.Where(p => p.Floor == 3 && tunlist.Where(x => x.Default2 == "3").Select(x => x.Default1).ToList().Contains(p.Tunnel.ToString()));
                    var pp = inv.Select(p => p.ContGrpBarCode).ToList();
                    invlist = invlist.Where(p => !pp.Contains(p.ContGrpBarCode)); //过滤3层被禁用的出库巷道
                }
            }

            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut6", new RedisErrorInfo() { Equip = "SpecialOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var temps = invlist.OrderBy(p => p.ProductTime).GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                invlist = invlist.Where(p => p.HWTypeCode == item.Key);
                if (!invlist.Any())
                {
                    continue;
                }
                var mater = invlist.OrderBy(p => p.ProductTime).GroupBy(p => new { p.SkuCode, p.Wind, p.WbGroupCode }).ToList();
                foreach (var stockTemps in mater)
                {
                    invlist = invlist.Where(p => p.SkuCode == stockTemps.Key.SkuCode && p.Wind == stockTemps.Key.Wind && p.WbGroupCode == stockTemps.Key.WbGroupCode);
                    if (!invlist.Any())
                    {
                        continue;
                    }

                    var ti = DateTime.Now;
                    var yaar = ti.Year.ToString().Substring(2, 2);
                    var month = ti.Month.ToString().PadLeft(2, '0');
                    var day = ti.Day.ToString().PadLeft(2, '0');
                    //获取当天最大箱号
                    var maxnumre = _boxserialrepository.AsQueryable().Where(p => p.Grade == "A" && p.Year == yaar && p.Month == month && p.Day == day);
                    string boxserial = "HAZDA";
                    if (maxnumre.Any())
                    {
                        boxserial = boxserial + yaar + month + day + (maxnumre.Max(q => q.Num) + 1).ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = maxnumre.Max(q => q.Num) + 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }
                    else
                    {
                        boxserial = boxserial + yaar + month + day + "1".ToString().PadLeft(3, '0');
                        _boxserialrepository.Insert(new BillBoxSerial()
                        {
                            Year = yaar,
                            Month = month,
                            Day = day,
                            Num = 1,
                            BoxNum = boxserial,
                            Grade = "A",
                            AddTime = DateTime.Now,
                            AddWho = "wms",
                            EditTime = DateTime.Now,
                            EditWho = "wms"
                        });
                    }

                    if (invlist.Any(p => p.Wind == "L"))
                    {
                        invlist = invlist.Where(p => p.Wind == "L");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        //rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.PBoxCode = boxserial;
                        rule.Wind = "L";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "ManualSpecial";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.Wind == "R");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = boxserial;
                        rule.Wind = "R";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "ManualSpecial";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test123";
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo) && string.IsNullOrEmpty(p.Cache2State) && string.IsNullOrEmpty(p.SContent)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode, ActType = 1 };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut7", new RedisErrorInfo() { Equip = "SpecialOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var root = DetermineRoot(palletequip.Code);

                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2,
                        Robot = root
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode,
                            PalletizingId = pallects.Id
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(72);

                    var palletMach = _palletlayerMathrepository.GetList(p => p.PalletizingId == pallects.Id).Take(72);
                    var maxdocid = _taskrepository.AsQueryable().Where(p => p.BusType == "装箱码垛").Max(p => p.DocID);
                    var curdocid = maxdocid + 1;
                    if (palletMach.Any())
                    {
                        var pid = palletMach.First().PalletizingId;
                        if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Any() && _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID) > 0)
                        {
                            curdocid = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.PalletizingId == pid).Max(p => p.DocID);
                        }
                    }

                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                            DocId = curdocid
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        public SRes CGrageStockOut(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            return res;//改造后方法没有修改，暂时注释
            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "CGreade");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    //var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    //if (tasklist.Any())
                    //{
                    //    RedisHelper.Set("Sx:WMSErrorInfo:SpecialOut1", new RedisErrorInfo() { Equip = "SpecialOut1", Con = "当前码垛工位：" + item.Equip + "存在未码垛的任务，不允许下发新的任务", Time = DateTime.Now });
                    //    continue;
                    //}

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut2", new RedisErrorInfo() { Equip = "CgradeOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(12);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut3", new RedisErrorInfo() { Equip = "CgradeOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    var curlayer = _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer);
                    var tasklayer = _wcstaskoldrepository.AsQueryable().Where(p => p.AgvTaskID == curlayer && p.AddrTo == item.Equip && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).Count();
                    if (tasklayer != 12 && tasklayer < 12)
                    {
                        palletMach = palletMach.Take(12 - tasklayer);
                        foreach (var pallets in palletMach)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = pallets.SkuCode,
                                PalletLayer = curlayer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                            {
                                continue;
                            }
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1,
                                Layer = curlayer
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else
                    {
                        foreach (var pallets in palletMach)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = pallets.SkuCode,
                                PalletLayer = curlayer + 1,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                            {
                                continue;
                            }
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1,
                                Layer = curlayer + 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut4", new RedisErrorInfo() { Equip = "CgradeOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut5", new RedisErrorInfo() { Equip = "CgradeOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            devices = devices.Where(p => p.pH_STATUS == true).ToList();
            //var timeOutHoldHours = int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));

            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Grade == "C" && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0
                          && !p.InDocsNo.StartsWith("CHA"))
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo
                          };
            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut6", new RedisErrorInfo() { Equip = "CgradeOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var temps = invlist.GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                invlist = invlist.Where(p => p.HWTypeCode == item.Key);
                if (!invlist.Any())
                {
                    continue;
                }
                var mater = invlist.GroupBy(p => p.MatCode).ToList();
                foreach (var stockTemps in mater)
                {
                    invlist = invlist.Where(p => p.MatCode == stockTemps.Key);
                    if (!invlist.Any())
                    {
                        continue;
                    }
                    if (invlist.Any(p => p.Wind == "L"))
                    {
                        invlist = invlist.Where(p => p.Wind == "L");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.Wind = "L";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "CGreade";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "TestC12";
                        rule.BatchNo = "22";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.Wind == "R");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.Wind = "R";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "CGreade";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "TestC12";
                        rule.BatchNo = "22";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }
                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        RedisHelper.Set("Sx:WMSErrorInfo:CgradeOut7", new RedisErrorInfo() { Equip = "CgradeOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(12);
                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(palletequip.Code);

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }

            return res;
        }

        public SRes OnePackStock(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            return res;//改造后方法没有修改，暂时注释
            var palletlist = _palletizrepository.GetList(p => p.PalletizState == 0 && p.BoxRule == "OnePack");
            if (palletlist.Any())
            {
                foreach (var item in palletlist)
                {
                    var tasklist = _wcstaskoldrepository.AsQueryable().Where(p => p.Status < TaskStatus.码垛合流 && p.Type == TaskType.OutDepot && p.PalletizingId == item.Id && p.AddrTo == item.Equip).SplitTable(p => p.Take(2));
                    if (tasklist.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut1", new RedisErrorInfo() { Equip = "OnePackOut1", Con = "当前码垛工位：" + item.Equip + "存在未码垛的任务，不允许下发新的任务", Time = DateTime.Now });
                        continue;
                    }

                    var equips = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack where code =" + item.Equip).First();
                    if (equips == null)
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut2", new RedisErrorInfo() { Equip = "OnePackOut2", Con = "不存在该" + item.Equip + "的码垛工位", Time = DateTime.Now });
                        continue;
                    }
                    var palletMach = _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 0).OrderBy(p => p.IsBlack).ThenBy(p => p.Depth).Take(12);
                    if (!palletMach.Any())
                    {
                        RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut3", new RedisErrorInfo() { Equip = "OnePackOut3", Con = item.Equip + "没有新的码垛任务需要下发", Time = DateTime.Now });
                        continue;
                    }
                    var curlayer = _palletlayerMathrepository.GetList(p => p.Palletequip == item.Equip && p.Istask == 1).Max(p => p.Layer);
                    var tasklayer = _wcstaskoldrepository.AsQueryable().Where(p => p.AgvTaskID == curlayer && p.AddrTo == item.Equip && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).Count();
                    if (tasklayer != 12 && tasklayer < 12)
                    {
                        palletMach = palletMach.Take(12 - tasklayer);
                        foreach (var pallets in palletMach)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = pallets.SkuCode,
                                PalletLayer = curlayer,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                            {
                                continue;
                            }
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1,
                                Layer = curlayer
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                    else
                    {
                        foreach (var pallets in palletMach)
                        {
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == pallets.ContGrpId);
                            if (cell == null)
                            {
                                continue;
                            }
                            var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == pallets.ContBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                            if (invs == null)
                            {
                                continue;
                            }
                            var root = DetermineRoot(pallets.Palletequip);

                            //先判断二升位是否能出库
                            if (cell.Depth == 2)
                            {
                                var respon = MoveTask(cell.Code);
                                if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                                {
                                    continue;
                                }
                            }

                            var taskresponse = PalletizingPackTask(new PalletizingPackTaskRequest()
                            {
                                Code = pallets.ContBarCode,
                                CellCode = cell.Code,
                                Srm = cell.SCRel,
                                Tunnel = cell.Tunnel.ToString(),
                                Floor = cell.Floor,
                                Grade = invs.Grade,
                                Mater = invs.MatCode,
                                SkuCode = pallets.SkuCode,
                                PalletLayer = curlayer + 1,
                                ProductMachCode = invs.ProductMachCode,
                                Equip = item.Equip,
                                PalletizingId = item.Id,
                                Robot = root,
                                GoodsType = invs.HWTypeCode == "BS80/33" ? 1 : 2
                            });
                            if (taskresponse.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                            {
                                continue;
                            }
                            _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                            {
                                Istask = 1,
                                Layer = curlayer + 1
                            }, p => p.ContBarCode == invs.ContGrpBarCode);
                        }
                        return res;
                    }
                }
            }

            //取视图码垛设备号
            var equiplist = _sysconfigrepository.Context.Ado.SqlQuery<sxSysConfig>("select * from WMS_ZT_01SX.dbo.V_PalletizingPack");
            if (!equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut4", new RedisErrorInfo() { Equip = "OnePackOut4", Con = "没有空闲的码垛工位", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有空闲的码垛工位";
                return res;
            }

            var traylist = HttpUtil.PostRequest("http://10.30.43.1:8080/api/Wcs/GetDeviceChaiPan", JsonConvert.SerializeObject(""));
            var devices = JsonConvert.DeserializeObject<List<DevincePh>>(traylist);
            if (!devices.Where(p => p.pH_STATUS == true).Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut5", new RedisErrorInfo() { Equip = "OnePackOut5", Con = "没有可用的子托盘，请先补充子托盘", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有可用的子托盘，请先补充子托盘";
                return res;
            }
            devices = devices.Where(p => p.pH_STATUS == true).ToList();

            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Grade == "A" && string.IsNullOrEmpty(p.PreStock) && p.ContUsageQty <= 0)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select new StockTemp
                          {
                              MatCode = stock.MatCode,
                              InvBarCode = stock.InvBarCode,
                              Grade = stock.Grade,
                              InvStateCode = stock.InvStateCode,
                              ProductTime = stock.ProductTime,
                              WbGroupCode = stock.WbGroupCode,
                              IsTorsChk = stock.IsTorsChk,
                              TorsChkQty = stock.TorsChkQty,
                              TorsChkValue = stock.TorsChkValue,
                              HoldTime = stock.HoldTime,
                              ProductMachCode = stock.ProductMachCode,
                              IsControlpanel = stock.IsControlpanel,
                              HWTypeCode = stock.HWTypeCode,
                              SolderCount = stock.SolderCount,
                              IsRework = stock.IsRework,
                              IsBlack = stock.IsBlack,
                              Col = loc.Col,
                              Layer = loc.Layer,
                              Shelf = loc.Shelf,
                              Depth = loc.Depth,
                              Code = loc.Code,
                              Tunnel = loc.Tunnel,
                              SCRel = loc.SCRel,
                              Floor = loc.Floor,
                              WarehouseCode = loc.WarehouseCode,
                              ContGrpBarCode = loc.ContGrpBarCode,
                              ContGrpId = loc.ContGrpId,
                              Id = loc.Id,
                              StateNum = loc.StateNum,
                              Wind = stock.Wind,
                              InDocsNo = stock.InDocsNo
                          };
            if (!invlist.Any())
            {
                RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut6", new RedisErrorInfo() { Equip = "OnePackOut6", Con = "库存不足", Time = DateTime.Now });
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "库存不足";
                return res;
            }
            invlist = invlist.Distinct();
            var temps = invlist.GroupBy(p => p.HWTypeCode);
            var rules = new BillPboxrule();
            foreach (var item in temps)
            {
                invlist = invlist.Where(p => p.HWTypeCode == item.Key);
                if (!invlist.Any())
                {
                    continue;
                }
                var mater = invlist.GroupBy(p => p.MatCode).ToList();
                foreach (var stockTemps in mater)
                {
                    invlist = invlist.Where(p => p.MatCode == stockTemps.Key);
                    if (!invlist.Any())
                    {
                        continue;
                    }
                    if (invlist.Any(p => p.Wind == "L"))
                    {
                        invlist = invlist.Where(p => p.Wind == "L");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.Wind = "L";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "OnePack";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test" + DateTime.UtcNow.ToString("yyyyMMddHHmmff");
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    else
                    {
                        invlist = invlist.Where(p => p.Wind == "R");
                        var rule = _boxrulerepository.GetFirst(p => p.ZXStateCode == 2);
                        rule.Id = GetId();
                        rule.PBoxCode = DateTime.UtcNow.ToString("yyyyMMddHHmmfff");
                        rule.Wind = "R";
                        rule.ZXStateCode = 1;
                        rule.SpoolType = item.Key;
                        rule.PackRule = "OnePack";
                        rule.FullCountQty = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36;
                        rule.SkuCode = "Test" + DateTime.UtcNow.ToString("yyyyMMddHHmmff");
                        rule.BatchNo = "1";
                        rules = _boxrulerepository.InsertReturnEntity(rule);
                    }
                    if (item.Key == "BS60" || item.Key == "BS40")
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(72);
                    }
                    else
                    {
                        invlist = invlist.OrderBy(p => p.ProductTime).Take(36);
                    }

                    var palletequip = equiplist.Where(p => string.IsNullOrEmpty(p.Default1) && string.IsNullOrEmpty(p.Cache1State) && string.IsNullOrEmpty(p.Memo)).OrderBy(p => p.EditTime).First();
                    //码垛信息校验
                    if (_palletizrepository.IsAny(p => p.Equip == palletequip.Code && p.PalletizState == 0))
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = palletequip.Code + "已经存在未装箱中数据";
                        _logger.LogInformation(palletequip.Code + "已经存在未装箱中数据");
                        return res;
                    }

                    var Trayportage = new dto.request.sx.TrayPortageRequest { Code = "", WareHouse = "cphouse", Equip = palletequip.Code, Start = devices.FirstOrDefault().deviceCode };
                    var response = HttpUtil.PostRequest("http://10.30.44.4:8070/api/Cp/TrayPortageTask", JsonConvert.SerializeObject(Trayportage));
                    var trayres = JsonConvert.DeserializeObject<SRes>(response);
                    if (trayres.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        res.ResCode = trayres.ResCode;
                        res.ResMsg = trayres.ResMsg;
                        RedisHelper.Set("Sx:WMSErrorInfo:OnePackOut7", new RedisErrorInfo() { Equip = "OnePackOut7", Con = "托盘输送任务报错：" + trayres.ResMsg, Time = DateTime.Now });
                        return res;
                    }
                    var pallet = new Palletizing()
                    {
                        PalletMax = (item.Key == "BS60" || item.Key == "BS40") ? 72 : 36,
                        PalletizState = 0,
                        Equip = palletequip.Code,
                        Finish = 0,
                        AddWho = "",
                        EditWho = "",
                        BoxRule = rules.PackRule,
                        BoxRuleId = rules.Id,
                        IsControlpanel = false,
                        TaskNum = int.Parse(trayres.Memo1),
                        GoodsType = item.Key == "BS80/33" ? 1 : 2
                    };
                    var pallects = _palletizrepository.InsertReturnEntity(pallet);
                    List<PalletLayerMath> math = new List<PalletLayerMath>();
                    foreach (var invs in invlist)
                    {
                        var palletlayer = new PalletLayerMath()
                        {
                            ContGrpId = (long)invs.ContGrpId,
                            ContBarCode = invs.ContGrpBarCode,
                            Layer = 0,
                            SkuCode = rules.SkuCode,
                            Finish = 0,
                            PboxruleId = rules.Id,
                            Istask = 0,
                            Palletequip = palletequip.Code,
                            Depth = invs.Depth,
                            IsBlack = invs.IsBlack,
                            SolderCount = invs.SolderCount,
                            BoxCode = rules.PBoxCode
                        };
                        math.Add(palletlayer);
                    }
                    _palletlayerMathrepository.InsertRange(math);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        PreStock = "1"
                    }, p => math.Select(p => p.ContBarCode).ToList().Contains(p.ContGrpBarCode));
                    invlist = invlist.OrderBy(p => p.Depth).Take(12);
                    foreach (var code in invlist)
                    {
                        var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.StateNum == LocationState.LocationState_Full && p.ContGrpId == code.ContGrpId);
                        if (cell == null)
                        {
                            continue;
                        }
                        var invs = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        if (invs == null)
                        {
                            continue;
                        }
                        var root = DetermineRoot(palletequip.Code);

                        //先判断二升位是否能出库
                        if (code.Depth == 2)
                        {
                            var respon = MoveTask(code.Code);
                            if (!string.IsNullOrEmpty(respon.Memo1) && respon.Memo1 == "1")
                            {
                                continue;
                            }
                        }

                        var taskrepso = PalletizingPackTask(new PalletizingPackTaskRequest()
                        {
                            Code = code.ContGrpBarCode,
                            Equip = pallects.Equip,
                            Mater = code.MatCode,
                            Srm = code.SCRel,
                            PalletLayer = 1,
                            Grade = code.Grade,
                            Tunnel = code.Tunnel.ToString(),
                            CellCode = code.Code,
                            SkuCode = rules.SkuCode,
                            ProductMachCode = code.ProductMachCode,
                            Floor = code.Floor,
                            PalletizingId = pallects.Id,
                            Robot = root,
                            GoodsType = code.HWTypeCode == "BS80/33" ? 1 : 2,
                        });
                        if (taskrepso.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                        {
                            continue;
                        }
                        _palletlayerMathrepository.UpdateSetColumnsTrue(p => new PalletLayerMath()
                        {
                            Istask = 1,
                            Layer = 1
                        }, p => p.ContBarCode == code.ContGrpBarCode);
                    }
                    return res;
                }
            }
            return res;
        }

        public SRes<bool> IsExistTask(DetailCodeRequest request)
        {
            var result = new SRes<bool>();
            result.ResData = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == request.Code && p.Status < TaskStatus.Finish).Any();
            return result;
        }

        public SRes<string> GetLocationInfo(DetailCodeRequest request)
        {
            var result = new SRes<string>();
            var cell = _basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.ContGrpBarCode == request.Code && p.StateNum == LocationState.LocationState_Full).ToList();
            result.ResData = cell.Any() ? cell.First().Code : "";

            return result;
        }

        public SRes CancelPreStockinfo(CancelPreStockinfoRequest request)
        {
            var res = new SRes();
            if (!request.Ids.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            foreach (var item in request.Ids)
            {
                var match = _palletlayerMathrepository.GetSingle(p => p.Id == item && p.Istask == 0);
                if (match == null)
                {
                    continue;
                }
                var inv = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == match.ContBarCode && p.ContGrpId == match.ContGrpId && p.PreStock == "1" && p.InvStateCode == InvState.InvEcecState_In.ToString());
                if (inv == null)
                {
                    continue;
                }
                var task = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == inv.ContGrpBarCode).First();
                if (task != null)
                {
                    continue;
                }
                var sucess = _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                {
                    PreStock = string.Empty,
                    Memo = "取消预锁库存"
                }, p => p.Id == inv.Id);
                if (sucess)
                {
                    _palletlayerMathrepository.Delete(p => p.Id == match.Id);
                }
            }
            return res;
        }

        /// <summary>
        /// 获取扭转检测范围
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<GetTorsRangeRes> GetTorsRange(DetailCodeRequest request)
        {
            var result = new SRes<GetTorsRangeRes>() { ResData = new GetTorsRangeRes() };
            var rules = _boxrulerepository.GetList(p => p.PBoxCode == request.Code);
            if (rules != null && rules.Any())
            {
                var rule = rules.First();
                result.ResData.TorsValue = rule.Torsion48Qty > 0 ? rule.Torsion48Qty : rule.Torsion72Qty > 0 ? rule.Torsion72Qty : rule.Torsion24Qty;

                result.ResData.TorsRangeValue = rule.TorsionErrRange;
            }

            return result;
        }

        public SRes<string> GetCGradeList()
        {
            var res = new SRes<string>() { ResDataList = new List<string>() };
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && (p.Grade == "C" || p.Grade == "D") && string.IsNullOrEmpty(p.PreStock)
                          && !p.InDocsNo.StartsWith("CHA"))
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select loc.Code;
            if (!invlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有C级品库存不足";
                return res;
            }
            res.ResDataList = invlist.Distinct().ToList();
            return res;
        }

        public SRes<string> GetBGradeTimeOutList()
        {
            var timeOutHoldHours = int.Parse(_sysconfigrepository.GetModelByExpression(p => p.Code == "BGradeTimeOut").SContent);  // int.Parse(wms.util.AppSettings.GetConfig("TimeOutHoldHours"));
            var res = new SRes<string>() { ResDataList = new List<string>() };
            var invlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == LocationStop.LocationInvoke.GetHashCode() && p.StateNum == LocationState.LocationState_Full)
                          join stock in _billInvnowrepository.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.Grade == "B" && string.IsNullOrEmpty(p.PreStock)
                          && (DateTime.Now - p.ProductTime).TotalHours > timeOutHoldHours)
                          on loc.ContGrpBarCode equals stock.ContGrpBarCode
                          select loc.Code;
            if (!invlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有B级品超时库存不足";
                return res;
            }
            res.ResDataList = invlist.Distinct().ToList();
            return res;
        }

        public SRes ErrorDateclearJob()
        {
            var res = new SRes();
            try
            {
                var task = _taskrepository.AsQueryable().Where(p => p.BusType == SxTaskBusType.TaskBusType_SX_ErrorStockOut.GetDescription() && p.Status == TaskStatus.StackerCompleted && p.Type == TaskType.OutDepot && (DateTime.Now - p.EditTime).TotalMinutes > 20).Take(2).ToList();
                foreach (var item in task)
                {
                    var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == item.BarCode);
                    if (stock == null)
                    {
                        if (_taskrepository.Delete(p => p.ID == item.ID))
                        {
                            _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld() { Status = TaskStatus.Finish, EditTime = DateTime.Now }).Where(p => p.Id == item.ID).SplitTable(p => p.Take(2)).ExecuteCommand();
                        }
                    }
                    else if (stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString() || stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                    {
                        if (_taskrepository.Delete(p => p.ID == item.ID))
                        {
                            _billInvnowrepository.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                            _wcstaskoldrepository.AsUpdateable().SetColumns(p => new WCS_TaskOld() { Status = TaskStatus.Finish, EditTime = DateTime.Now }).Where(p => p.Id == item.ID).SplitTable(p => p.Take(2)).ExecuteCommand();
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            return res;
        }

        public SRes FlowDataMoveJob(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            //流水表
            try
            {
                var flow = _billInvflow.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddTime < DateTime.Now.AddDays(-60)).OrderBy(p => p.Id).Take(100).ToList();
                if (flow.Any())
                {
                    var ids = flow.Select(p => p.Id).Distinct().ToList();
                    var flowhty = _mapper.Map<List<Bill_InvflowHty>>(flow);
                    if (_flowhtyrepository.AsQueryable().With(SqlWith.NoLock).SplitTable(p => p.Take(2)).Where(p => ids.Contains(p.Id)).Any())
                    {
                        _flowhtyrepository.Context.Deleteable<Bill_InvflowHty>(p => ids.Contains(p.Id)).SplitTable(x => x.Take(2)).ExecuteCommand();
                    }
                    _flowhtyrepository.InsertableSplitTable(flowhty);

                    _billInvflow.Delete(p => ids.Contains(p.Id));
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }
            //码垛主表
            try
            {
                var pallet = _palletizrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddTime < DateTime.Now.AddMonths(-6) && p.PalletizState == 1).OrderBy(p => p.Id).Take(100).ToList();
                if (pallet.Any())
                {
                    var ids = pallet.Select(p => p.Id).Distinct().ToList();
                    var pallethty = _mapper.Map<List<PalletizingHty>>(pallet);
                    if (_pallethtyrepository.AsQueryable().With(SqlWith.NoLock).SplitTable(p => p.Take(2)).Where(p => ids.Contains(p.Id)).Any())
                    {
                        _pallethtyrepository.Context.Deleteable<PalletizingHty>(p => ids.Contains(p.Id)).SplitTable(x => x.Take(2)).ExecuteCommand();
                    }
                    _pallethtyrepository.InsertableSplitTable(pallethty);
                    _palletizrepository.Delete(p => ids.Contains(p.Id));
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            //推送表
            try
            {
                var push = _billPushinforepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddTime < DateTime.Now.AddMonths(-6)).OrderBy(p => p.Id).Take(100).ToList();
                if (push.Any())
                {
                    var ids = push.Select(p => p.Id).Distinct().ToList();
                    var pushthty = _mapper.Map<List<BillPushinfoHty>>(push);
                    if (_pushhtyrepository.AsQueryable().With(SqlWith.NoLock).SplitTable(p => p.Take(2)).Where(p => ids.Contains(p.Id)).Any())
                    {
                        _pushhtyrepository.Context.Deleteable<BillPushinfoHty>(p => ids.Contains(p.Id)).SplitTable(x => x.Take(2)).ExecuteCommand();
                    }
                    _pushhtyrepository.InsertableSplitTable(pushthty);
                    _billPushinforepository.Delete(p => ids.Contains(p.Id));
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            //箱号表
            try
            {
                var boxrule = _boxrulerepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddTime < DateTime.Now.AddMonths(-6) && p.ZXStateCode == 2).OrderBy(p => p.Id).Take(100).ToList();
                if (boxrule.Any())
                {
                    var ids = boxrule.Select(p => p.Id).Distinct().ToList();
                    var boxrulethty = _mapper.Map<List<BillPboxruleHty>>(boxrule);
                    if (_pboxrulehtyrepository.AsQueryable().With(SqlWith.NoLock).SplitTable(p => p.Take(2)).Where(p => ids.Contains(p.Id)).Any())
                    {
                        _pboxrulehtyrepository.Context.Deleteable<BillPboxruleHty>(p => ids.Contains(p.Id)).SplitTable(x => x.Take(2)).ExecuteCommand();
                    }
                    _pboxrulehtyrepository.InsertableSplitTable(boxrulethty);
                    _boxrulerepository.Delete(p => ids.Contains(p.Id));
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            return res;
        }

        /// <summary>
        /// 清理任务数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes RemoveTaskData(PalletizingPackStockOutRequest request)
        {
            var res = new SRes();
            try
            {
                var sysconfcon = int.Parse(_sysconfigrepository.GetFirst(p => p.Code == "TaskRemoveHours").SContent) * (-1);
                var tasklist = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.Type == TaskType.EnterDepot && p.Status == TaskStatus.NewBuild && p.AddTime < DateTime.Now.AddHours(sysconfcon)).Take(100).ToList();
                //var taskold = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddTime < DateTime.Now.AddHours(sysconfcon)).SplitTable(p => p.Take(2)).Take(100).ToList();

                if (tasklist.Any())
                {
                    var ids = tasklist.Select(p => p.ID).ToList();
                    var barlist = tasklist.Select(p => p.BarCode).ToList();

                    _taskrepository.Delete(p => ids.Contains(p.ID));//任务表

                    var tables = _wcstaskoldrepository.Context.SplitHelper<WCS_TaskOld>().GetTables().Take(2);//
                    foreach (var item in tables)
                    {
                        //删除历史任务表
                        _wcstaskoldrepository.Context.Deleteable<WCS_TaskOld>().AS(item.TableName)//使用当前分表名
                                          .Where(p => ids.Contains(p.Id))
                                         .ExecuteCommand();
                    }
                    _billInvinitrepository.Delete(p => barlist.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    _billInvnowrepository.Delete(p => barlist.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

            return res;
        }

        public void WreTimeOutRecord(List<string> contbars, string msg)
        {
            SxPackingHelp.WreTimeOutRecord(contbars, msg, _timeoutrecord, _logger);
        }

        /// <summary>
        ///  码垛工位与对应的机器人的关系
        /// </summary>
        /// <param name="palletequip"></param>
        /// <returns></returns>
        private string DetermineRoot(string palletequip)
        {
            return SxServiceHelp.DetermineRoot(palletequip);
        }

        /// <summary>
        ///  转换为百分比
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private static string ToPercentage(decimal value)
        {
            return (value * 100).ToString("F2") + "%";
        }

        private SRes MoveTask(string code)
        {
            return code.MoveTask(_wcstaskoldrepository, _basewarehouserepository, _billInvnowrepository, _basewarecellrepository,
                                 _taskrepository, _taskdetailrepository, _db, _logger, _mapper, lockerPalletizingPackTask, lockerApplyLoc);
        }
    }
}