ZT-FJ-WMS/wms.service/Service/FJService.cs

using AutoMapper;
using Castle.Core.Internal;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using NPOI.SS.Formula;
using NPOI.SS.Formula.Functions;
using NPOI.SS.Formula.PTG;
using NPOI.XSSF.Model;
using Org.BouncyCastle.Asn1.Ocsp;
using SqlSugar;
using SqlSugar.Extensions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.Entity.fj;
using wms.dataservice.IDataSetvice;
using wms.dto;
using wms.dto.request;
using wms.dto.request.fj;
using wms.dto.request.hj;
using wms.dto.request.share;
using wms.dto.response;
using wms.dto.response.fj;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model;
using wms.sqlsugar.model.fj;
using wms.util.Check;
using wms.util.Ext;
using static NPOI.POIFS.Crypt.CryptoFunctions;
using TaskStatus = wms.dto.TaskStatus;

namespace wms.service.Service
{
    /// <summary>
    ///  分拣服务
    /// </summary>
    public class FJService : IFJService
    {
        private readonly IMapper _mapper;
        private readonly ILogger<FJService> _logger;
        private readonly IFJDataService _IFJDataService;
        private static object lockInOrOut = new object();

        public FJService(IMapper mapper, ILogger<FJService> logger, IFJDataService IFJDataService)
        {
            _mapper = mapper;
            _logger = logger;
            _IFJDataService = IFJDataService;
        }

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

        #region 初始化仓储

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

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

        /// <summary>
        ///  环形库码垛缓存信息
        /// </summary>
        private Repository<BillRingPalletizingInfo> _billRingPalletizingInfo => new Repository<BillRingPalletizingInfo>();

        /// <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<BillSpoolTrans> _billSpoolTransrepository => new Repository<BillSpoolTrans>();

        private RepositoryTask<BaseErrorInfo> _baseErrorInfoRepository => new RepositoryTask<BaseErrorInfo>();

        private Repository<BillBominfo> _billBominfoRepository => new Repository<BillBominfo>();

        /// <summary>
        ///  垛形主表
        /// </summary>
        private Repository<BillBomsetgrp> _BillBomsetgrpRepository => new Repository<BillBomsetgrp>();

        /// <summary>
        ///  垛形信息
        /// </summary>
        private Repository<BillBomsetinfo> _billBomsetinfoRepository => new Repository<BillBomsetinfo>();

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

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

        /// <summary>
        ///  agv任务表
        /// </summary>
        private RepositoryTask<WCS_AgvTaskInfo> _agvTaskInfoRepository => new RepositoryTask<WCS_AgvTaskInfo>();

        /// <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<BillBomsetgrp> _billBomsetgrpRepository => new Repository<BillBomsetgrp>();
        private Repository<fjSysJob> _jobRepository => new Repository<fjSysJob>();
        private Repository<fjSysJobApiRelation> _jobApiRepository => new Repository<fjSysJobApiRelation>();

        #endregion 初始化仓储

        /// <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;
            var sysname = sysconf.Default1; //所属系统mes/erp
            RedisHelper.Set("sys_config" + code, content + "|" + sysname);
            return content;
        }


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

        public fjSysJob GetSysJobEntity(DetailRequest2Str req)
        {
            return _jobRepository.GetFirst(p => p.Id == long.Parse(req.Id));
        }

        public fjSysJob GetSysJobEntityByCode(string Code)
        {
            return _jobRepository.GetSingle(p => p.Code == Code);
        }

        public List<fjSysJobApiRelation> GetSysApiDetail(long Id)
        {
            return _jobApiRepository.GetList(p => p.JobId == Id);
        }

        /// <summary>
        /// 创建货位,用于少数虚拟货位及平库
        /// </summary>
        /// <param name="WarehouseCode">仓库号</param>
        /// <param name="Code">货位号</param>
        /// <returns></returns>
        public SRes CreatWarecell(string WarehouseCode,string Code)
        {
            SRes res = new SRes();
            //找到对应的仓库
            var warehouse = _basewarehouserepository.GetFirst(x => x.Code == WarehouseCode);
            var wareCell = new BaseWarecell()
            {
                WarehouseId = warehouse.Id,
                WarehouseCode = WarehouseCode,
                WareAreaId = 1669154208777113600,
                IsStop = 0,
                Code = Code,
                Name = Code,
                StateNum = FjLocationState.Empty,
                TypeNum = FjLocationType.Virtual,
                Size = 1,
                Row = 1,
                Col = 1,
                Layer = 1,
                Depth = 1,
                Tunnel = 1,
                SCRel = "芯股虚拟货位",
                ContGrpBarCode = "0",
                ContGrpId = 0,
                Shelf = "L",
                AddWho = "Admin",
                AddTime = DateTime.Now,
                EditWho = "Admin",
                EditTime = DateTime.Now,
                Memo = "芯股货架",
                GroupID = 0,
                XYNO = 0
            };
            _db.BeginTran();
            try
            {
                _basewarecellrepository.InsertReturnEntity(wareCell);
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                _logger.LogInformation(e.Message);
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            _db.CommitTran();
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription();
            return res;
        }

        public List<fjSysJob> GetJobList()
        {
            return _jobRepository.GetList();
        }

        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjSysConfig GetSysConfigByExpression(Expression<Func<fjSysConfig, bool>> WhereExpression)
        {
            return _sysconfigrepository.GetSingle(WhereExpression);
        }

        /// <summary>
        /// 获取反馈信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<BillPushinfo> GetBillPushinfoList(Expression<Func<BillPushinfo, bool>> WhereExpression, bool type = false)
        {
            if (type)
            {
                return _billPushinforepository.AsQueryable().Where(WhereExpression).OrderBy(x=>x.AddTime).Take(1).ToList();
            }
            return _billPushinforepository.GetList(WhereExpression);
        }

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

        ///// <summary>
        ///// 获取单据信息
        ///// </summary>
        ///// <param name="code"></param>
        ///// <returns></returns>
        //public fjBillDocument GetBillDocumentList(Expression<Func<fjBillDocument, bool>> WhereExpression)
        //{
        //    return _billdtrepository.Context.Queryable<fjBillDocument, fjSysConfig>((doc, conf) => new object[] {
        //      JoinType.Left, doc.BState == conf.Code
        //    }).Where((doc, conf) => doc.Status == 0)
        //    .Select((bc, bm) => bc).First();
        //}
        /// <summary>
        /// 更新SysConfig表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateSysConfigModelColumns(UpdateModelColumns<fjSysConfig> updateModel)
        {
            return _sysconfigrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        public List<BaseMatinfo> GetBaseMatinfoList(Expression<Func<BaseMatinfo, bool>> WhereExpression)
        {
            return _basematerrepository.GetList(WhereExpression);
        }

        /// <summary>
        /// 更新物料基础信息表
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateMaterModelColumns(UpdateModelColumns<BaseMatinfo> updateModel)
        {
            return _basematerrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        public bool UpdateMaterModel(BaseMatinfo updateModel)
        {
            return _basematerrepository.Update(updateModel);
        }

        /// <summary>
        /// 更新BillPushinfo表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateBillPushinfoModelColumns(UpdateModelColumns<BillPushinfo> updateModel)
        {
            return _billPushinforepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }

        public bool SyncMaterInfo(List<FJSyncMaterInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                item.UpdatedTime = DateTime.Now;
                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="ResData"></param>
        /// <returns></returns>
        public bool SyncMaterInfoLX(List<SxSyncMaterInfoListRequestItem> 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;
        }

        public SRes SyncMachineInfo(SyncMachineInfoRequest req)
        {
            if (_basemachinforepository.IsAny(p => p.MachNo == req.MachineCode))
            {
                _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { Direction = req.VehicleDirection, EditTime = DateTime.Now },
                    p => p.MachNo == req.MachineCode);
            }
            else
            {
                var model = _mapper.Map<BillMachinfo>(req);
                model.AddTime = DateTime.Now;
                model.EditTime = DateTime.Now;
                model.AddWho = "wms";
                model.EditWho = "wms";
                model.AddWho = "wms";
                model.EditWho = "wms";
                model.WarehouseCode = "";
                model.WarehouseId = 0;
                model.WarehouseSort = 0;
                model.Direction = "";
                model.WareAreaId = 0;
                model.IsStop = 0;
                model.GrpCode = "";
                model.Station = "";
                model.BillCode = "";
                model.WorkOrder = "";
                model.SetGrpCode = "";
                model.ProBillCode = "";
                model.ProWorkOrder = "";
                model.ProSetGrpCode = "";
                model.WareDirect = "";
                _basemachinforepository.Insert(model);
            }
            return new SRes();
        }

        /// <summary>
        /// 投料信息接收
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes WetFormulaInfo(WetFormulaInfoRequest reqDto)
        {
            var res = new SRes();

            //保存表Bill_BomInfo
            foreach (var item in reqDto.FeedList)
            {
                var procodelist = _billBominfoRepository.GetList(p => p.MatCode == item.InMaterialCode).Select(p => p.ProCode).Distinct();
                if (procodelist.Any() && procodelist.Count() > 1)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = item.InMaterialCode + "不允许率属于两个投料大类编码，接收失败";
                    return res;
                }

                if (_billBominfoRepository.IsAny(p => p.Code == reqDto.FeedCode && p.ProMatCode == item.OutMaterialCode && p.MatCode == item.InMaterialCode))
                {
                    //var mat = _basematerrepository.GetSingle(p => p.Code == item.InMaterialCode);
                    //_billBominfoRepository.UpdateModelColumns(p => new BillBominfo() { MatCode = item.InMaterialCode, MatId = mat.Id, Name = item.InMaterialCode, HWCountQty = item.Count, EditTime = DateTime.Now },
                    //   p => p.Code == reqDto.FeedCode && p.MatCode == item.InMaterialCode);
                }
                else
                {
                    var procode = string.Join('|', reqDto.FeedList.Where(p => p.OutMaterialCode == item.OutMaterialCode).Select(p => p.InMaterialCode).OrderBy(p => p).ToList());

                    var mat = _basematerrepository.GetSingle(p => p.Code == item.InMaterialCode);
                    if (mat == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = "投入料" + ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                        return res;
                    }
                    var model = new BillBominfo()
                    {
                        ProCode = procode,
                        Code = reqDto.FeedCode,
                        Name = reqDto.FeedName,
                        MatCode = item.InMaterialCode,
                        MatId = mat.Id,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        EditTime = DateTime.Now,
                        EditWho = "wms",
                        IsStop = 0,
                        HWCountQty = item.Count,
                        ProMatCode = item.OutMaterialCode,
                        Memo = reqDto.Remark
                    };
                    model.AddTime = DateTime.Now;
                    _billBominfoRepository.Insert(model);
                }
            }
            return res;
        }

        /// <summary>
        /// 帘线工单信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            var res = new SRes();

            //先判断是否有配方信息和物料基础信息
            var outmat = _basematerrepository.GetSingle(p => p.Code == reqDto.MatCode);
            if (outmat == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = reqDto.MatCode + "不存在该物料基础信息，请先同步基础信息";
                return res;
            }
            var procode = string.Join('|', reqDto.FeedList.Select(p => p.InMaterialCode).OrderBy(p => p).ToList());
            if (reqDto.ProdFlag == 1)
            {
                var bominfo = _billBominfoRepository.GetFirst(p => p.Code == reqDto.FeedCode && p.ProMatCode == reqDto.MatCode);
                if (bominfo == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = string.Format("当前产出为芯股，此芯股投料信息不存在请先同步投料信息，投料编码{0},产出物{1}", reqDto.FeedCode, reqDto.MatCode);
                    return res;
                }
                procode = bominfo.ProCode;
            }
            BillBomsetgrp stack = null; //垛型固定获取最早更新的垛型
            //后续一个配方会有多个垛型
            if (reqDto.MatCode.StartsWith("57")) //是芯股
            {
                stack = _billBomsetgrpRepository.GetList(p => (p.BomCode == procode || procode.Contains(p.BomCode)) && p.ProMaterCode.StartsWith("57") && p.IsStop == 0)
                    .OrderBy(x=>x.EditTime).First();
                if (stack == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = string.Format("{0}该单据配方没有垛型信息，请先配置垛型，bom编码{1},bom大类编码{2}，产出物料{3}", reqDto.BillCode, reqDto.FeedCode, procode, reqDto.MatCode);
                    return res;
                }
            }
            else //不是芯股
            {
               var stackList= _billBomsetgrpRepository.GetList(p => (p.BomCode == procode || procode.Contains(p.BomCode)) && !p.ProMaterCode.StartsWith("57") && p.IsStop == 0).ToList();

                stack = stackList.OrderBy(x => x.EditTime).First() ;

                if (stack == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = string.Format("{0}该单据配方没有垛型信息，请先配置垛型，bom编码{1},bom大类编码{2}，产出物料{3}", reqDto.BillCode, reqDto.FeedCode, procode, reqDto.MatCode);
                    return res;
                }
            }

            string reqjson = JsonConvert.SerializeObject(reqDto);
            if (reqjson.Length > 5000)
            {
                reqjson = "内容量过大,已截取";
            }
            if (reqDto.BillState == CurtainBillState.初始化.GetHashCode().ToString() || reqDto.BillState == CurtainBillState.已合并.GetHashCode().ToString() || reqDto.BillState == CurtainBillState.已排产.GetHashCode().ToString())
            {
                var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
                if (doc == null)
                {
                    doc = new BillDocsinfo();
                    doc.WarehouseId = 0;
                    doc.ReqNo = reqDto.BillCode;
                    doc.DocsNo = reqDto.BillCode;
                    doc.TypeNum = DocType.DocType_FJ_CurtainProduction.GetHashCode();
                    doc.StateNum = DocState.DocState_Create.GetHashCode();
                    doc.JsonContent = reqjson;
                    doc.DownQty = 1;
                    doc.IsStop = 0;
                    doc.BomCode = reqDto.FeedCode;
                    doc.ProMaterCode = reqDto.MatCode;
                    doc.SetGrpCode = stack.Code;
                    doc.WorkOrder = reqDto.WorkOrder;
                    doc.SkuCode = reqDto.SkuCode;
                    doc.PackRule = reqDto.PackRule;
                    var docinsert = _billdocrepository.Insert(doc);
                    if (!docinsert)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                        return res;
                    }
                }
                _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { ProBillCode = reqDto.BillCode, ProWorkOrder = reqDto.WorkOrder, ProSetGrpCode = stack.Code, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
                //箱号处理
                //根据箱号更新装箱信息表
            }
            else if (reqDto.BillState == CurtainBillState.生产中.GetHashCode().ToString())
            {
                var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
                if (doc == null)
                {
                    doc = new BillDocsinfo();
                    doc.WarehouseId = 0;
                    doc.ReqNo = reqDto.BillCode;
                    doc.DocsNo = reqDto.BillCode;
                    doc.TypeNum = DocType.DocType_FJ_CurtainProduction.GetHashCode();
                    doc.StateNum = DocState.DocState_Execute.GetHashCode();
                    doc.JsonContent = reqjson;
                    doc.DownQty = 1;
                    doc.IsStop = 0;
                    doc.BomCode = reqDto.FeedCode;
                    doc.ProMaterCode = reqDto.MatCode;
                    doc.SetGrpCode = stack.Code;
                    doc.WorkOrder = reqDto.WorkOrder;
                    doc.SkuCode = reqDto.SkuCode;
                    doc.PackRule = reqDto.PackRule;
                    var docinsert = _billdocrepository.Insert(doc);
                    if (!docinsert)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                        return res;
                    }
                }
                var state = DocState.DocState_Execute.GetHashCode();
                _billdocrepository.UpdateModelColumns(p => new BillDocsinfo() { StateNum = state, SetGrpCode = stack.Code }, p => p.DocsNo == reqDto.BillCode);
                _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = reqDto.BillCode, WorkOrder = reqDto.WorkOrder, SetGrpCode = stack.Code, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
                //箱号处理
                //根据箱号更新装箱信息表
            }
            else if (reqDto.BillState == CurtainBillState.生产结束.GetHashCode().ToString() || reqDto.BillState == CurtainBillState.计划关闭.GetHashCode().ToString())
            {
                var state = DocState.DocState_Complete.GetHashCode();
                _billdocrepository.UpdateModelColumns(p => new BillDocsinfo() { StateNum = state }, p => p.DocsNo == reqDto.BillCode);
            }
            return res;
        }

        /// <summary>
        /// 湿拉工单启动验证
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainOrderStartCheck(CurtainOrderStartCheckRequest reqDto)
        {
            var res = new SRes();
            var doc = _billdocrepository.GetList(p => p.WorkOrder == reqDto.BillCode);
            if (doc == null || !doc.Any())
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "工单不存在";
                return res;
            }
            if (doc.Any(p => string.IsNullOrEmpty(p.BomCode)))
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "帘线工序工单没有配置垛型信息,请先配置垛型";
                return res;
            }
            //foreach (var item in doc)
            //{
            //    _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = item.DocsNo, WorkOrder = item.WorkOrder, SetGrpCode = item.SetGrpCode, EditTime = DateTime.Now }, p => p.ProBillCode == item.DocsNo);
            //}
            return res;
        }

        public SRes ManualBuildEmptyStock(ManualBuildEmptyStockRequest request)
        {
            var result = new SRes();
            if (string.IsNullOrEmpty(request.ContGrpBarCode))
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return result;
            }
            var mater = _basematerrepository.GetSingle(p => request.ContGrpBarCode.Substring(0, 3) == p.Code);
            if (mater == null)
            {
                result.ResCode = ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetHashCode();
                result.ResMsg = request.ContGrpBarCode.Substring(0, 3) + "托盘类型不存在";
                return result;
            }

            var taskold = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == request.ContGrpBarCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).ToList();
            if (taskold.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                result.ResMsg = request.ContGrpBarCode + ResponseStatusCodeEnum.WcsTaskExist.GetDescription() + "不允许绑定";
                return result;
            }
            var BarCode = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == request.ContGrpBarCode);
            if (BarCode != null && BarCode?.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                result.ResCode = ResponseStatusCodeEnum.BarcodeContainerRepeat.GetHashCode();
                result.ResMsg = request.ContGrpBarCode + ResponseStatusCodeEnum.BarcodeContainerRepeat.GetDescription();
                return result;
            }
            if (BarCode != null && BarCode?.InvStateCode == InvState.InvEcecState_BuildUp.ToString())
            {
                result.ResCode = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetHashCode();
                result.ResMsg = request.ContGrpBarCode + ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetDescription();
                return result;
            }
            if (BarCode != null)
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = request.ContGrpBarCode + "存在库存信息，请先处理遗留的库存信息";
                return result;
            }

            //空托盘
            var code = _baseContinfo.GetSingle(p => p.ContBarCode == request.ContGrpBarCode);
            if (code == null)
            {
                var init = new BaseContinfo()
                {
                    ContBarCode = request.ContGrpBarCode,
                    Name = mater.Name,
                    IsStop = 0,
                    WarehouseId = 0,
                    TypeCode = "1",
                    PrintQty = 1,
                    AddWho = "wms",
                    EditWho = "wms"
                };
                _baseContinfo.Insert(init);
            }
            try
            {
                var nov = new BillInvnow()
                {
                    WarehouseId = 0,
                    ContGrpBarCode = request.ContGrpBarCode,
                    ContGrpId = IdFactory.NewId(),
                    BoxBarCode = "",
                    InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                    ExecStateCode = InvLockState.InvState_Normal.ToString(),
                    MatId = mater.Id,
                    MatCode = mater.Code,
                    MatName = mater.Name,
                    RFIDBarCode = request.ContGrpBarCode,
                    HWBarCode = request.ContGrpBarCode,
                    HWTypeCode = "",
                    InvInOut = FJInvInOutType.In,
                    Size = 2,
                    ContGrpType = FJContGrpType.EmptyCon,
                    LengthQty = request.Count    //存放托盘数量
                };
                _db.BeginTran();
                _billInvnowrepository.Insert(nov);
                _billInvflow.Insert(_mapper.Map<BillInvflow>(nov));
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                result.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                result.ResMsg = request.ContGrpBarCode + ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                return result;
            }

            return result;
        }

        /// <summary>
        /// 获取工字轮流向（江锦调用）
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<string> AllocatedSpoolFlow(AllocatedSpoolFlowRequest reqDto)
        {
            var spoolbar = _billSpoolTransrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.ConBarCode == reqDto.SpoolBarCode).OrderByDescending(x => x.AddTime).First();

            if (spoolbar == null)
            {
                var error = new BaseErrorInfo()
                {
                    BusName = "江景获取流向",
                    Message = $"{reqDto.SpoolBarCode}没有工字轮信息,{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);

                return new SRes<string>()
                {
                    ResMsg = reqDto.SpoolBarCode + "没有工字轮信息",
                    ResData = "",
                    ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode()
                };
            }

            //验证产品等级与下线时间
            var invInt = _billInvinitrepository.AsQueryable().With(SqlWith.NoLock).Single(x => x.HWBarCode == spoolbar.ConBarCode);
            if (invInt == null)
            {
                var error = new BaseErrorInfo()
                {
                    BusName = "江景获取流向",
                    Message = $"{reqDto.SpoolBarCode}没有工字轮信息,{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);
                return new SRes<string>()
                {
                    ResMsg = reqDto.SpoolBarCode + "没有工字轮条码信息",
                    ResData = "",
                    ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode()
                };
            }

            if (invInt.Grade != "A")
            {
                var error = new BaseErrorInfo()
                {
                    BusName = "江景获取流向",
                    Message = $"{reqDto.SpoolBarCode}-{invInt.Grade}质量，进入BC区,{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);
                return new SRes<string>()
                {
                    ResMsg = $"{invInt.Grade}质量，进入BC区",
                    ResData = "",
                    ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode()
                };
            }

            if (invInt.ProductTime < DateTime.Now.AddHours(-12))
            {
                var error = new BaseErrorInfo()
                {
                    BusName = "江景获取流向",
                    Message = $"{reqDto.SpoolBarCode}生产时间超时十二小时,{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);

                return new SRes<string>()
                {
                    ResMsg = "生产时间超时十二小时",
                    ResData = "",
                    ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode()
                };
            }
            return new SRes<string>()
            {
                ResMsg = "成功",
                ResData = spoolbar.Direct,
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode()
            };
        }

        /// <summary>
        ///  人工创建满托入库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CreateMaterialPalletWarehouTask(CreateMaterialPalletWarehouTaskRequest reqDto)
        {
            var res = new SRes(){ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(),ResMsg = "失败"};


            //获取工字轮任务信息
            var taskInfo = _taskrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.BarCode == reqDto.TrayCode&&x.Status< TaskStatus.Finish);
            if (taskInfo != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.TrayCode + "已有任务，请联系智能制造人员进行处理！！！！！！";
                return res;
            }

            //托盘
            var container = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.TrayCode);
            if (container == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.TrayCode,
                    Name = reqDto.TrayCode,
                    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 spoolNr = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.SpoolNr);
            if (spoolNr == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.TrayCode,
                    Name = reqDto.TrayCode,
                    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 mater = _basematerrepository.GetSingle(p => p.Code == reqDto.InMaterialCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }

            //工字轮库存
            var stock = _billInvnowrepository.GetSingle(p => p.HWBarCode == reqDto.SpoolNr);
            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 trayCode = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.TrayCode);
            if (trayCode != null && trayCode.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号已在库中，请检查RFID号是否重复";
                return res;
            }
            if (trayCode != null && trayCode.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
                return res;
            }

            //通过投入物料找到垛型编码
            var stackdetail = _billBomsetinfoRepository.GetFirst(p => p.MatCode == reqDto.InMaterialCode && p.IsStop == 0);
            if (stackdetail == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有对应的垛型信息,物料编码" + reqDto.InMaterialCode;
                return res;
            }
            //获取垛型主表
            var stack = _BillBomsetgrpRepository.GetSingle(p => p.Id == stackdetail.BomSetHdrId && p.IsStop == 0);

            //获取工字轮任务信息
            var task = _taskrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.BarCode == reqDto.SpoolNr);
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有组盘任务，请从新注册" ;
                return res;
            }
            //工字轮条码信息
            var barInfo = _billInvinitrepository.GetFirst(p => p.HWBarCode == reqDto.SpoolNr);
            if (barInfo == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有条码信息";
                return res;
            }

            try
            {
                _db.BeginTran();

                //更新条码信息
                _billInvinitrepository.UpdateModelColumns(p => new BillInvinit()
                {
                    ContGrpBarCode = reqDto.TrayCode,
                    EditTime = DateTime.Now
                }, p => p.HWBarCode == reqDto.SpoolNr);
                //删除因异常导致残留的对应库存信息
                _billInvnowrepository.Delete(x => x.ContGrpBarCode == reqDto.TrayCode || x.HWBarCode == reqDto.SpoolNr);

                barInfo.ContGrpBarCode=reqDto.TrayCode;
                
                //创建库存信息
                //将条码表映射到库存表
                var invnow = _mapper.Map<BillInvnow>(barInfo);
                invnow.IsTorsChk = true;
                invnow.AddTime = DateTime.Now;
                invnow.Id = IdFactory.NewId();

                if (!_billInvnowrepository.Insert(invnow))
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "人工满轮入库存储库存失败";
                    return res;
                }

                //删除这个任务的阻盘记录
                var taskIdList = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.BarCode == reqDto.SpoolNr).Select(x => x.ID).ToList();
                 if (taskIdList != null)
                 {
                     //删除当前任务与更新历史任务
                     _taskrepository.Delete(x => taskIdList.Contains(x.ID));
                     _wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                     {
                         Status = TaskStatus.Cancel,
                         ManualRemarks = "人工满托入库，清除信息"
                     }, x => taskIdList.Contains(x.Id));
                 }

                //创建入库记录
                var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
                {
                    BusType = FJTaskBusType.人工满托入库.GetDescription(),
                    ContGrpBarCode = reqDto.TrayCode,
                    Qty = 1,
                    Floor = 2,
                    MatCode = reqDto.InMaterialCode,
                    EquCode = reqDto.LocCode,
                    Type = TaskType.EnterDepot,
                    DocCode = "",
                    WorkBench = task.WorkBench
                };

                //下发wcs任务 - 分解方法
                var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest, task.Grade, true);
                if (taskRes.ResCode != 200)
                {
                    _db.RollbackTran();
                    res.ResCode = taskRes.ResCode;
                    res.ResMsg = taskRes.ResMsg;
                    return res;
                }
                _db.CommitTran();
              
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.StackTrace;

                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResMsg = ResponseStatusCodeEnum.Sucess.ToString();
            return res;
        }

        /// <summary>
        ///  芯股满托创建库存信息
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CreateMaterialPalletWarehouTask1(CreateMaterialPalletWarehouTask1Request reqDto)
        {
            var res = new SRes() { ResCode = ResponseStatusCodeEnum.Fail.GetHashCode(), ResMsg = "失败" };


            //获取工字轮任务信息
            var taskInfo = _taskrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.BarCode == reqDto.TrayCode && x.Status < TaskStatus.Finish);
            if (taskInfo != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.TrayCode + "已有任务，请联系智能制造人员进行处理！！！！！！";
                return res;
            }

            //托盘
            var container = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.TrayCode);
            if (container == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.TrayCode,
                    Name = reqDto.TrayCode,
                    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 spoolNr = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.SpoolNr);
            if (spoolNr == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.TrayCode,
                    Name = reqDto.TrayCode,
                    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 mater = _basematerrepository.GetSingle(p => p.Code == reqDto.InMaterialCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }

            //工字轮库存
            var stock = _billInvnowrepository.GetSingle(p => p.HWBarCode == reqDto.SpoolNr);
            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 trayCode = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.TrayCode);
            if (trayCode != null && trayCode.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号已在库中，请检查RFID号是否重复";
                return res;
            }
            if (trayCode != null && trayCode.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
                return res;
            }

            //通过投入物料找到垛型编码
            var stackdetail = _billBomsetinfoRepository.GetFirst(p => p.MatCode == reqDto.InMaterialCode && p.IsStop == 0);
            if (stackdetail == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有对应的垛型信息,物料编码" + reqDto.InMaterialCode;
                return res;
            }
            //获取垛型主表
            var stack = _BillBomsetgrpRepository.GetSingle(p => p.Id == stackdetail.BomSetHdrId && p.IsStop == 0);

            //获取工字轮任务信息
            var task = _taskrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.BarCode == reqDto.SpoolNr);
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有组盘任务，请从新注册";
                return res;
            }
            //工字轮条码信息
            var barInfo = _billInvinitrepository.GetFirst(p => p.HWBarCode == reqDto.SpoolNr);
            if (barInfo == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolNr + "没有条码信息";
                return res;
            }

            //对应货位是否存在
            var wareCell = _basewarecellrepository.GetFirst(p => p.Code == reqDto.LocCode);
            if (wareCell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.LocCode + "没有货位信息";
                return res;
            }

            //判断货位是否已经存储
            if (wareCell.StateNum!= FjLocationState.Empty)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"货位{reqDto.LocCode}状态不是空，当前状态位{wareCell.StateNum.GetDescription()}，请联系相关人员进行处理！！！";
                return res;
            }


            try
            {
                _db.BeginTran();

                //更新条码信息
                _billInvinitrepository.UpdateModelColumns(p => new BillInvinit()
                {
                    ContGrpBarCode = reqDto.TrayCode,
                    EditTime = DateTime.Now
                }, p => p.HWBarCode == reqDto.SpoolNr);
                //删除因异常导致残留的对应库存信息
                _billInvnowrepository.Delete(x => x.ContGrpBarCode == reqDto.TrayCode || x.HWBarCode == reqDto.SpoolNr);

                wareCell.ContGrpBarCode = reqDto.TrayCode;

                //创建库存信息
                //将条码表映射到库存表
                var invnow = _mapper.Map<BillInvnow>(barInfo);
                invnow.IsTorsChk = true;
                invnow.AddTime = DateTime.Now;
                invnow.InvStateCode = FJInvState.InvEcecState_In.ToString();
                invnow.ContGrpBarCode = reqDto.TrayCode;
                invnow.Id = IdFactory.NewId();
                invnow.WarehouseId = wareCell.WarehouseId;

                if (!_billInvnowrepository.Insert(invnow))
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "芯股满托存储库存失败";
                    return res;
                }

                //存储进入对应的货位
                //更新条码信息
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                {
                    ContGrpBarCode = reqDto.TrayCode,
                    ContGrpId = invnow.ContGrpId,
                    StateNum = FjLocationState.Full,
                    EditTime = DateTime.Now
                }, p => p.Code == reqDto.LocCode);

                _db.CommitTran();

            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.StackTrace;

                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResMsg = ResponseStatusCodeEnum.Sucess.ToString();
            return res;
        }

        public SRes ManualBuildStockTrans(ManualBuildStockTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        #region 湿拉工字轮/帘线芯股信息初始化

        /// <summary>
        ///  湿拉工字轮/帘线芯股信息初始化
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SpoolMaterialInfoTrans(SpoolMaterialInfoTransRequest reqDto)
        {
            var res = new SRes();
            var dateTime = DateTime.Now.AddHours(-12);
            //清除十二小时小时前的新建数据
            if (_taskrepository.AsQueryable().With(SqlWith.NoLock).Any(x => x.Status == TaskStatus.NewBuild && x.Type == TaskType.SetPlate && x.AddTime < dateTime))
            {
                var taskIdList = _taskrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)")
                    .Where(x => x.Status == TaskStatus.NewBuild && x.Type == TaskType.SetPlate && x.AddTime < dateTime)
                    .ToList();
                var ids = taskIdList.Select(x => x.ID).ToList();
                //有超过十二小时小时的数据，开始清除
                _taskrepository.Delete(x => ids.Contains(x.ID));
                _wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                {
                    Status = TaskStatus.Cancel,
                    ManualRemarks = "产品超时，自动清除任务"
                }, x => ids.Contains(x.Id));
                //清除相关条码、码垛信息
                var barCodes = taskIdList.Select(x => x.BarCode).ToList();
                _billSpoolTransrepository.Delete(x => barCodes.Contains(x.ConBarCode));
                _billInvinitrepository.Delete(x => barCodes.Contains(x.HWBarCode));
            }

           
            //容器
            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 mater = _basematerrepository.GetSingle(p => p.Code == reqDto.MatCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }

            //码垛工字轮
            var billSpoolTrans = new BillSpoolTrans();
            billSpoolTrans.ConBarCode = reqDto.SpoolCode;
            billSpoolTrans.BillCode = reqDto.BillCode;
            billSpoolTrans.WorkOrder = reqDto.WorkOrder;
            billSpoolTrans.MatCode = reqDto.MatCode;
            billSpoolTrans.WarehouseCode = "";
            billSpoolTrans.WarehouseSort = 0;
            billSpoolTrans.LocSort = 0;
            billSpoolTrans.ConveyorSort = 0;
            billSpoolTrans.Direct = "";
            billSpoolTrans.ErrType = 0;
            billSpoolTrans.AddTime = DateTime.Now;
            billSpoolTrans.EditTime = DateTime.Now;
            billSpoolTrans.AddWho = "wms";
            billSpoolTrans.EditWho = "wms";
            //库存
            var stock = _billInvnowrepository.GetSingle(p => p.HWBarCode == reqDto.SpoolCode);
            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 fJPalletType = FJPalletType.Pallet09;
            if (reqDto.SpoolType != "WS09")
            {
                fJPalletType = FJPalletType.PalletNo09;
            }
            var prodate = DateTime.Now;
            if (!string.IsNullOrEmpty(reqDto.ProductDate) && DateTime.TryParse(reqDto.ProductDate, out prodate))
            {
                prodate = DateTime.Parse(reqDto.ProductDate);
            }
            else
            {
                _logger.LogInformation("生产日期格式不对,系统默认使用当前时间");
            }

            //通过订单找到对应的机台信息
            //通过投入物料找到垛型编码
            var stackdetail = _billBomsetinfoRepository.GetFirst(p => p.MatCode == reqDto.MatCode && p.IsStop == 0);
            if (stackdetail == null)
            {
                _logger.LogInformation(reqDto.SpoolCode + "没有对应的垛型信息,物料编码" + reqDto.MatCode);
                _billInvinitrepository.Delete(x => x.ContGrpBarCode == billSpoolTrans.ConBarCode);
                _billInvinitrepository.Delete(x => x.ContGrpBarCode == billSpoolTrans.ConBarCode);
                _billSpoolTransrepository.Delete(x => x.ConBarCode == billSpoolTrans.ConBarCode);
                _logger.LogInformation($"找不到垛形信息时删除缓存信息{billSpoolTrans.ConBarCode}");
                var task = _taskrepository.GetSingle(x => x.BarCode == billSpoolTrans.ConBarCode);
                if (task != null)
                {
                    //删除当前任务与更新历史任务
                    _taskrepository.Delete(x => x.ID == task.ID);
                    _wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                    {
                        Status = TaskStatus.Cancel,
                        ManualRemarks = "产品重新投放，自动覆盖历史信息"
                    }, x => x.Id == task.ID);
                }
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.SpoolCode + "没有对应的垛型信息,物料编码" + reqDto.MatCode;
                var error = new BaseErrorInfo()
                {
                    BusName = "湿拉下盘注册",
                    Message = $"{res.ResMsg},{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);
                return res;
            }

            //机台垛型编码
            var stack = _BillBomsetgrpRepository.GetSingle(p => p.Id == stackdetail.BomSetHdrId && p.IsStop == 0);
            var macList = _basemachinforepository.GetList(p => stack.Code==p.SetGrpCode); //找到垛型对应的机台信息
            //查询出来的垛型没有对应的机台，开始尝试通过产出匹配机台(适配同产出配多个垛型的情况)
            if (macList.Count<=0) 
            {
                //查出当前这个垛型同产出对应的所有启用垛型
                var stacks = _BillBomsetgrpRepository.GetList(p => p.ProMaterCode == stack.ProMaterCode && p.IsStop == 0);
                var stackCodes = stacks.Select(x => x.Code).ToList();
                macList = _basemachinforepository.GetList(p => stackCodes.Contains(p.SetGrpCode));
            }

            //查询机台
            var wareList = macList.Where(x => !x.WarehouseCode.IsNullOrEmpty()).Select(p => p.WarehouseCode).Distinct().OrderBy(v => v); //找到机台对应的仓库信息
            if (!wareList.Any()) //当前订单没有对应仓库信息
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = stack.Code + "垛型没有配置机台信息";
                var error = new BaseErrorInfo()
                {
                    BusName = "湿拉下盘注册",
                    Message = $"{res.ResMsg},{DateTime.Now:yyyyMMddHH}",
                    Count = 1,
                    Memo = "WCS"
                };
                error.UpdataErrorinfo(_baseErrorInfoRepository);
                return res;
            }
            if (wareList.Count() == 1) //当前订单对应一个仓库信息
            {
                var sort = int.Parse(wareList.First().Substring(0, 1));

                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans
                {
                    WarehouseCode = wareList.First(),
                    WarehouseSort = sort,
                    Direct = wareList.First().Substring(1, 1),
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == billSpoolTrans.ConBarCode);
                billSpoolTrans.WarehouseCode = wareList.First();
                billSpoolTrans.WarehouseSort = sort;
                billSpoolTrans.Direct = wareList.First().Substring(1, 1);
            }
            else //当前订单对应多个仓库信息
            {
                //先计算出当前物料在各仓库中应该的占比
                var wareTempList = macList.Where(x => !x.WarehouseCode.IsNullOrEmpty()).Select(p => new { p.WarehouseCode }).Distinct();
                var statTime = DateTime.Now.AddHours(-3);
                var warehouseGoods = _billSpoolTransrepository.GetList(s => s.MatCode == reqDto.MatCode && s.AddTime > statTime).ToList();
                var specificGravity = wareTempList.Select(x =>
                    {
                        decimal currentWarehouseGoodsSum = warehouseGoods.Count(s => s.MatCode == reqDto.MatCode && s.WarehouseCode == x.WarehouseCode);
                        decimal warehouseGoodsSum = warehouseGoods.Count;
                        var a = Convert.ToDecimal(macList.Count(m => m.WarehouseCode == x.WarehouseCode));
                        var b = Convert.ToDecimal(macList.Count);
                        decimal specificGravityValue = b == 0 ? 0 : a / b;
                        decimal currentSpecificGravityValue = warehouseGoodsSum == 0 ? 0 : currentWarehouseGoodsSum / warehouseGoodsSum;
                        return new
                        {
                            x.WarehouseCode,
                            a,
                            b,
                            SpecificGravity = specificGravityValue, //预期比重
                            WarehouseGoods = warehouseGoodsSum, //三个分拣中心实际数量
                            CurrentWarehouseGoods = currentWarehouseGoodsSum, //当前分拣中心实际数量
                            CurrentSpecificGravity = currentSpecificGravityValue, //当前分拣库实际已有货物占比
                            //实际比重与预期比重差值
                            //实际比重大于预期比重的默认排在最后
                            //实际比重减去预期比重，结果值越大应优先送往
                            ProportionGap = currentSpecificGravityValue > specificGravityValue ? 0 : specificGravityValue - currentSpecificGravityValue,
                            Direct = x.WarehouseCode.Substring(1, 1),
                        };
                    }).OrderByDescending(x => x.ProportionGap) //比差越大应当越优先送过去
                    .ThenByDescending(x => x.SpecificGravity); //在各库已有货物实际占比达到预期值时按照预期占比最多的优先分配

                _logger.LogInformation($"SpoolMaterialInfoTrans:{JsonConvert.SerializeObject(specificGravity)}");
                var sort = int.Parse(wareList.First().Substring(0, 1));
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans
                {
                    WarehouseCode = specificGravity.FirstOrDefault().WarehouseCode,
                    WarehouseSort = sort,
                    Direct = specificGravity.FirstOrDefault().Direct,
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == billSpoolTrans.ConBarCode);
                billSpoolTrans.WarehouseCode = specificGravity.FirstOrDefault().WarehouseCode;
                billSpoolTrans.WarehouseSort = sort;
                billSpoolTrans.Direct = specificGravity.FirstOrDefault().Direct;
            }

            var promat = _basematerrepository.GetSingle(p => p.Code == stack.ProMaterCode);
            //创建条码
            var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == billSpoolTrans.WarehouseCode);
            //检查条码
            var barInfo = _billInvinitrepository.GetFirst(p => p.HWBarCode == reqDto.SpoolCode);
            string gra = "";
            if (reqDto.Grade != null && !string.IsNullOrEmpty(reqDto.Grade))
            {
                gra = reqDto.Grade;
            }
            if (barInfo == null) //当前条码无残留信息
            {
                var barinfo = InitInvinitInfo(reqDto, wareHosue, stack, mater, promat, fJPalletType);

                try
                {
                    _db.BeginTran();
                    _billInvinitrepository.InsertReturnEntity(barinfo);
                    _billSpoolTransrepository.InsertReturnEntity(billSpoolTrans);
                    //删除因异常导致残留的对应库存信息
                    _billInvnowrepository.Delete(x => x.ContGrpBarCode == billSpoolTrans.ConBarCode || x.HWBarCode == billSpoolTrans.ConBarCode);

                    //开始生成WCS
                    var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
                    {
                        BusType = FJTaskBusType.二楼组盘.GetDescription(),
                        ContGrpBarCode = reqDto.SpoolCode,
                        Qty = 1,
                        WarehouseCode = billSpoolTrans.WarehouseCode,
                        Floor = 2,
                        MatCode = billSpoolTrans.MatCode,
                        EquCode = "Robot",
                        Type = TaskType.SetPlate,
                        DocCode = billSpoolTrans.WorkOrder,
                        WorkBench = reqDto.WbCode
                    };

                    //下发wcs任务 - 分解方法
                    var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest,gra,true);
                    if (taskRes.ResCode != 200)
                    {
                        _db.RollbackTran();
                        res.ResCode = taskRes.ResCode;
                        res.ResMsg = taskRes.ResMsg;
                        return res;
                    }
                    _db.CommitTran();
                    RedisHelper.Set($"AllocationWarehouseSort:{reqDto.SpoolCode}", JsonConvert.SerializeObject(new MainlineDiversion
                    {
                        TaskId = taskRes.ResData.ID,
                        WarehouseCode = billSpoolTrans.WarehouseCode
                    }));
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ex.StackTrace;
                }
            }
            else //有残留条码信息更新
            {
                try
                {
                    //开始生成WCS
                    var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
                    {
                        BusType = FJTaskBusType.二楼组盘.GetDescription(),
                        ContGrpBarCode = reqDto.SpoolCode,
                        Qty = 1,
                        WarehouseCode = billSpoolTrans.WarehouseCode,
                        Floor = 2,
                        MatCode = billSpoolTrans.MatCode,
                        EquCode = "Robot",
                        Type = TaskType.SetPlate,
                        DocCode = billSpoolTrans.WorkOrder,
                        WorkBench = reqDto.WbCode
                    };
                    var barinfo = InitInvinitInfo(reqDto, wareHosue, stack, mater, promat, fJPalletType);

                    _db.BeginTran();
                    //更新条码信息
                    _billInvinitrepository.Delete(x => x.Id == barInfo.Id);
                    _billInvinitrepository.InsertReturnEntity(barinfo);
                    //更新码垛信息
                    _billSpoolTransrepository.UpdateModelColumns(x => new BillSpoolTrans()
                    {
                        ConBarCode = reqDto.SpoolCode,
                        BillCode = reqDto.BillCode,
                        WorkOrder = reqDto.WorkOrder,
                        MatCode = reqDto.MatCode,
                        WarehouseCode = billSpoolTrans.WarehouseCode,
                        WarehouseSort = billSpoolTrans.WarehouseSort,
                        LocSort = 0,
                        ConveyorSort = 0,
                        Direct = billSpoolTrans.Direct,
                        ErrType = 0,
                        EditTime = DateTime.Now,
                        EditWho = "wms",
                    }, x => x.ConBarCode == billSpoolTrans.ConBarCode);
                    if (!_billSpoolTransrepository.GetList(x => x.ConBarCode == billSpoolTrans.ConBarCode).Any())
                    {
                        _billSpoolTransrepository.InsertReturnEntity(billSpoolTrans);
                    }
                    //删除对应的库存信息
                    _billInvnowrepository.Delete(x => x.ContGrpBarCode == billSpoolTrans.ConBarCode || x.HWBarCode == billSpoolTrans.ConBarCode);

                    var taskIdList = _taskrepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.BarCode == billSpoolTrans.ConBarCode).Select(x => x.ID).ToList();

                    //下发wcs任务 - 分解方法
                    var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest,gra,true);
                    if (taskRes.ResCode != 200)
                    {
                        _db.RollbackTran();
                        res.ResCode = taskRes.ResCode;
                        res.ResMsg = taskRes.ResMsg;
                        return res;
                    }

                    if (taskIdList != null)
                    {
                        //删除当前任务与更新历史任务
                        _taskrepository.Delete(x => taskIdList.Contains(x.ID));
                        _wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                        {
                            Status = TaskStatus.Cancel,
                            ManualRemarks = "产品重新投放，自动覆盖历史信息"
                        }, x => taskIdList.Contains(x.Id));
                    }

                    _db.CommitTran();
                    //RedisHelper.Set($"AllocationWarehouseSort:{reqDto.SpoolCode}", JsonConvert.SerializeObject(new MainlineDiversion
                    //{
                    //    TaskId = taskRes.ResData.ID,
                    //    WarehouseCode = billSpoolTrans.WarehouseCode
                    //}));
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ex.StackTrace;
                }
            }

            return res;
        }

        /// <summary>
        ///  生成条码信息
        /// </summary>
        /// <param name="reqDto">请求实体</param>
        /// <param name="wareHosue">仓库信息</param>
        /// <param name="stack">垛形信息</param>
        /// <param name="mater">物料信息</param>
        /// <param name="promat">帘线物料信息</param>
        /// <param name="fJPalletType">托盘类型</param>
        /// <returns></returns>
        public BillInvinit InitInvinitInfo(SpoolMaterialInfoTransRequest reqDto, BaseWarehouse wareHosue, BillBomsetgrp stack, BaseMatinfo mater, BaseMatinfo promat, FJPalletType fJPalletType)
        {
            var invInit = new BillInvinit();

            invInit.InvBarCode = reqDto.MatBarCode;
            invInit.WarehouseId = wareHosue != null ? wareHosue.Id : 0;
            invInit.ExecStateCode = InvLockState.InvState_Normal.ToString();
            invInit.ExecDocsNo = reqDto.WorkOrder;
            invInit.ExecDocsRowNo = reqDto.MatBarCode;
            invInit.ExecDocsTypeCode = DocType.DocType_FJ_WetStockIn.GetHashCode().ToString();
            invInit.InvInOut = FJInvInOutType.In;
            invInit.ExecWho = "MES";
            invInit.EditTime = DateTime.Now;
            invInit.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
            invInit.InDocsNo = reqDto.BillCode;
            invInit.InDocsRowNo = reqDto.MatBarCode;
            invInit.SuppCode = "";
            invInit.BomDocsNo = stack.BomCode;
            invInit.BomSetId = stack.Id;
            invInit.SetGrpCode = stack.Code;
            invInit.BomMatCode = promat.Code;
            invInit.BomMatId = promat.Id;
            invInit.BomMatName = promat.Name;
            invInit.MatId = mater.Id;
            invInit.MatCode = mater.Code;
            invInit.MatName = mater.Name;
            invInit.LengthQty = reqDto.Length;
            invInit.TareWQty = reqDto.Weight;
            invInit.ProductTime = DateTime.Parse(reqDto.ProductDate);
            invInit.RFIDBarCode = "";
            invInit.ProductLineNo = reqDto.WbCode;
            invInit.Grade = reqDto.Grade;
            invInit.HWBarCode = reqDto.SpoolCode;
            invInit.HWTypeCode = reqDto.SpoolType; //工字轮类型
            invInit.ContGrpBarCode = reqDto.SpoolCode;
            invInit.ContGrpType = FJContGrpType.Material;
            invInit.ContGrpId = IdFactory.NewId();
            invInit.IsFast = reqDto.IsFast;
            invInit.IsRework = false;
            invInit.CLBarCode = reqDto.MatBarCode;
            invInit.Size = 1;
            invInit.AddTime = DateTime.Now;
            invInit.BackReason = "";
            invInit.IsBack = reqDto.IsBack;
            invInit.SilkTypeCode = reqDto.SilkType;
            invInit.IsCore = reqDto.BusType == 1;
            invInit.PalletType = fJPalletType;

            return invInit;
        }

        #endregion 湿拉工字轮/帘线芯股信息初始化

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <returns></returns>
        public bool AllocationWarehouseSort(AllocationWarehouseSortRequest reqDto)
        {
            return true;
        }

        /// <summary>
        /// 二次扫码分配输送地址
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes AllocationConveyorSort(AllocationConveyorSortRequest reqDto)
        {
            var res = new SRes();
            var baritem = _billSpoolTransrepository.GetFirst(p => p.ConBarCode == reqDto.BarCode);
            //判断当前库是否有mix垛型
            //var mixrow = _billBomsetinfoRepository.AsQueryable().Where(p => p.IsMixRow == 1 && p.WarehouseCode == baritem.WarehouseCode);
            //if (mixrow == null || !mixrow.Any())
            //{
            //    var matcodelist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode);
            //    var curmatrate = matcodelist.Where(p => p.MatCode == baritem.MatCode).Count() / matcodelist.Count();
            //    //需要的总量
            //}
            //else
            //{
            //}
            //var translist = _billSpoolTransrepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode).ToList();
            //foreach (var item in translist.GroupBy(p => p.ConveyorSort))
            //{
            //}
            return res;
        }

        /// <summary>
        ///  agv状态同步接口
        /// </summary>
        /// <param name="reqDto">请求信息</param>
        /// <returns></returns>
        public AgvCallbackResponse AgvCallback(AgvCallbackRequest reqDto)
        {
            var res = new AgvCallbackResponse() { code = AgvResponseCode.Error, message = "失败" };
            try
            {
                _db.BeginTran();
                //跟据AGVid找到对应的AGV任务
                var agvTask = _agvTaskInfoRepository.AsQueryable().With(SqlWith.RowLock).SplitTable(tabs => tabs.Take(2))
                    .First(v => v.AgvID == reqDto.taskCode && v.Status < AGVTaskStatus.MissionCompleted);
                if (agvTask == null)
                {
                    _db.RollbackTran();
                    res.code = AgvResponseCode.Fail;
                    res.message = "未找到对应的AGV任务";
                    return res;
                }
                switch (reqDto.method)
                {
                    case "applyContinue": //表示请求巷道
                        agvTask.AgvStatus = AGVTaskStatus.RequestOrPermission1;
                        break;

                    case "outbin": //小车退出取货位
                        agvTask.AgvStatus = AGVTaskStatus.LeaveGet;
                        break;

                    case "applySecurity": //表示请求放货或取货
                        agvTask.AgvStatus = AGVTaskStatus.RequestOrPermission2;
                        break;

                    case "applySecurityPut": //表示请求放货或取货
                        agvTask.AgvStatus = AGVTaskStatus.PutRequestOrPermission;
                        break;

                    case "FJend": //任务完成
                        agvTask.AgvStatus = AGVTaskStatus.MissionCompleted;
                        break;

                    case "cancel": //取消任务
                        if (agvTask.TaskType == AGVTaskType.EnterDepot)
                        {
                            agvTask.AgvStatus = AGVTaskStatus.Cancel;
                        }

                        break;
                }

                //更新agv任务状态
                if (!_agvTaskInfoRepository.UpdateSplitTableModelColumns(x => new WCS_AgvTaskInfo()
                    {
                        AgvStatus = agvTask.AgvStatus
                }, x => x.ID == agvTask.ID && x.AgvID == agvTask.AgvID))
                {
                    _db.RollbackTran();
                    res.code = AgvResponseCode.Fail;
                    res.message = $"agv任务{agvTask.AgvID}更新状态至{agvTask.AgvStatus}失败";
                    return res;
                }
                _db.CommitTran();
                res.code = AgvResponseCode.Success;
                res.message = "成功";
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.code = AgvResponseCode.Error;
                res.message = ex.Message;
            }
            return res;
        }

        /// <summary>
        /// 帘线领料出库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionStockOut(CurtainProductionStockOutRequest reqDto)
        {
            var res = new SRes();

            var agvMaxSm = Convert.ToInt32(_sysconfigrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.Code == "AGVSendsMaxQuantity").SContent);
            var agvMaxFk = Convert.ToInt32(_sysconfigrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.Code == "AGVMaxNumberEmptyRetur").SContent);
            var agvSmNumber = _agvTaskInfoRepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.AgvStatus < AGVTaskStatus.MissionCompleted && x.TaskType == AGVTaskType.CallMaterial).SplitTable(x => x.Take(2)).Count();
            var agvFkNumber = _agvTaskInfoRepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.AgvStatus < AGVTaskStatus.MissionCompleted && x.TaskType == AGVTaskType.EnterDepot).SplitTable(x => x.Take(2)).Count();

            switch (reqDto.Type)
            {
                case "1":
                    if (agvMaxSm<=agvSmNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大送满任务已达{agvSmNumber}";
                        return res;
                    }
                    if (agvMaxFk <= agvFkNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大返空任务已达{agvFkNumber}";
                        return res;
                    }
                    break;
                case "2":
                    if (agvMaxFk <= agvFkNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大返空任务已达{agvFkNumber}";
                        return res;
                    }
                    break;
                case "3":
                    if (agvMaxSm <= agvSmNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大送满任务已达{agvSmNumber}";
                        return res;
                    }
                    break;
            }

            if (reqDto.Type == "1" || reqDto.Type == "3")
            {
                var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
                if (doc == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.BillCode + "工单信息不存在";
                    return res;
                }

                //获取机台信息
                var mach = _basemachinforepository.GetSingle(x => x.MachNo == reqDto.WbCode);
                if (mach == null || string.IsNullOrEmpty(mach.Station))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.WbCode + "机台号没有配置AGV点位坐标";
                    return res;
                }

                //找到所有的立库货位
                var warehouse = _basewarehouserepository.GetList(x => x.TypeNum == FjLocationType.Storage).Select(x => x.Id).ToList();
                var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.WorkBench == mach.Station && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2));
                if (task != null && task.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = mach.Station + "站台号存在进行中的任务，不要重复申请";
                    return res;
                }

                var setGrpCode = reqDto.TypeCode;
                if (setGrpCode.IsNullOrEmpty()) setGrpCode = doc.SetGrpCode;

                //获取所有的立库有货库位信息
                var wareCellList = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                        new object[] { JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode })
                    .Where((loc, inv) => warehouse.Contains(loc.WarehouseId) && loc.IsStop == 0 && loc.StateNum == FjLocationState.Full && inv.InvStateCode == InvState.InvEcecState_In.ToString() && inv.SetGrpCode == setGrpCode && (!inv.Secondary || inv.ProductTime < DateTime.Now.AddHours(-6)))
                    .Where((loc, inv) => inv.IsTorsChk==false)
                    .Select((loc, inv) => new
                    {
                        locId = loc.Id,
                        loc.ContGrpBarCode,
                        loc.WarehouseId,
                        loc.WarehouseCode,
                        loc.Code,
                        loc.Row,
                        loc.Col,
                        loc.Layer,
                        loc.Depth,
                        loc.EditTime,
                        inv.MatCode,
                        inv.SideNum,
                        inv.CLBarCode,
                        inv.ProductTime,
                        invId = inv.Id
                    }).ToList().DistinctBy(x => x.ContGrpBarCode).ToList();
                if (!wareCellList.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.NotEnoughStock.GetDescription();
                    return res;
                }

                var warehouseCodes = new List<string>();
                switch (mach.WarehouseCode)
                {
                    case "1N":
                        warehouseCodes.AddRange(new List<string>() { "1N", "1S", "2N", "2S", "3N", "3S" });
                        break;

                    case "1S":
                        warehouseCodes.AddRange(new List<string>() { "1S", "1N", "2S", "2N", "3S", "3N" });
                        break;

                    case "2N":
                        warehouseCodes.AddRange(new List<string>() { "2N", "2S", "1N", "1S", "3N", "3S" });
                        break;

                    case "2S":
                        warehouseCodes.AddRange(new List<string>() { "2S", "2N", "1S", "1N", "3S", "3N" });
                        break;

                    case "3N":
                        warehouseCodes.AddRange(new List<string>() { "3N", "3S", "2N", "2S", "1N", "1S" });
                        break;

                    case "3S":
                        warehouseCodes.AddRange(new List<string>() { "3S", "3N", "2S", "2N", "1S", "1N" });
                        break;
                }

                var wareCell = wareCellList.OrderBy(x => warehouseCodes.IndexOf(x.WarehouseCode))//按照优先级排序
                    .ThenBy(x => x.ProductTime)
                    .FirstOrDefault();

                try
                {
                    //获取所有的库存信息
                    var sotcks = _billInvnowrepository.GetList(x => x.ContGrpBarCode == wareCell.ContGrpBarCode);
                    var nowTime = DateTime.Now;
                    //创建流水信息
                    var invFlowList = _mapper.Map<List<BillInvflow>>(sotcks);
                    foreach (var invFlow in invFlowList)
                    {
                        invFlow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                        invFlow.AddTime = nowTime;
                        invFlow.Id = IdFactory.NewId();
                    }
                    _db.BeginTran(); //创建事务
                                     //更新货位信息
                    if (!_basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == wareCell.locId && p.StateNum == FjLocationState.Full))
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"请重新叫料，{wareCell.Code}货位货物已被其他机台叫走!";
                        return res;
                    }
                    //跟新库存
                    _billInvnowrepository.UpdateModelColumns(
                        p => new BillInvnow()
                        {
                            InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                            EditTime = nowTime
                        }, p => p.ContGrpBarCode == wareCell.ContGrpBarCode);
                    //新建流水
                    _billInvflow.InsertRange(invFlowList);

                    //添加出库任务
                    RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                    {
                        ContGrpBarCode = wareCell.ContGrpBarCode,
                        CellNo = wareCell.Code,
                        MatCode = wareCell.MatCode,
                        EquCode = "1",
                        Floor = 1,
                        Device = wareCell.WarehouseCode switch
                        {
                            "1N" => "SRM1",
                            "1S" => "SRM2",
                            "2N" => "SRM3",
                            "2S" => "SRM4",
                            "3N" => "SRM5",
                            "3S" => "SRM6",
                            _ => "ERROR"
                        },
                        WorkBench = mach.Station,
                        WarehouseCode = wareCell.WarehouseCode,
                        BusType = FJTaskBusType.车间叫料,
                        LastInteractionPoint = reqDto.Type,
                        MesNo = reqDto.ReqId,
                        EmptyInventory = mach.NearestWarehouseName.IsNullOrEmpty()?wareCell.WarehouseCode:mach.NearestWarehouseName
                    });
                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ex.Message;
                }
            }
            else if (reqDto.Type == "2") //单独取空
            {
                //获取对应机台绑定的仓库
                var mach = _basemachinforepository.GetFirst(x => x.MachNo == reqDto.WbCode);
                if (mach == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"没有对应机台-{reqDto.WbCode}";
                    return res;
                }
                var taskold = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).
                    Where(p => p.WorkBench == mach.Station && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2));
                if (taskold != null && taskold.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = mach.Station + "站台号存在进行中的单独取空任务任务，不要重复申请";
                    return res;
                }
                if (string.IsNullOrEmpty(mach.Station))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.WbCode + "机台号没有配置AGV点位坐标";
                    return res;
                }
                //获取对应仓库
                var warehouse = _basewarehouserepository.GetFirst(x => x.Id == mach.WarehouseId);
                if (warehouse == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"当前机台没有分配对应仓库-{reqDto.WbCode}";
                    return res;
                }

                //创建入库任务
                var wcstask = new WCS_TaskInfo()
                {
                    Type = TaskType.EnterDepot,
                    Status = TaskStatus.NewBuild,
                    Priority = 0,
                    Device = warehouse.Code switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    AddrFrom = reqDto.WbCode,
                    AddrTo = warehouse.Code switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    LastInteractionPoint = reqDto.Type,
                    BarCode = reqDto.WbCode,
                    Floor = 1,
                    Length = 1,
                    AddTime = DateTime.Now,
                    DocID = 0,
                    PalletType = 1,
                    ProdLine = 1,
                    FullQty = 1,
                    AddWho = "WMS",
                    WarehouseCode = warehouse.Code,
                    Enabled = true,
                    WorkBench = mach.Station,
                    GoodsType = 1,
                    BusType = FJTaskBusType.皮盘入库.GetDescription(),
                    MatCode = "",
                    MaterialCode = mach.NearestWarehouseName.IsNullOrEmpty() ? warehouse.Code : mach.NearestWarehouseName
                };

                var wcstaskhis = _mapper.Map<WCS_TaskOld>(wcstask);

                try
                {
                    var task = _taskrepository.InsertReturnEntity(wcstask);
                    wcstaskhis.Id = task.ID;
                    _wcstaskoldrepository.InsertableSplitTable(wcstaskhis);
                    var taskdetail = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = reqDto.WbCode,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = task.ID,
                        Desc = "单独返空任务",
                    };
                    _taskdetailrepository.InsertableSplitTable(taskdetail);
                    res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                }
                catch (Exception ex)
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                    _logger.LogInformation("保存任务异常：" + ex.ToString());
                    return res;
                }
                return res;
            }
            else
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"位置业务类型-{reqDto.Type}";
            }

            return res;
        }

        /// <summary>
        /// 帘线叫料接口(人工码垛托盘/芯股)
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionStockOut1(CurtainProductionStockOutRequest1 reqDto)
        {
            var res = new SRes();

            var agvMaxSm = Convert.ToInt32(_sysconfigrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.Code == "AGVSendsMaxQuantity").SContent);
            var agvMaxFk = Convert.ToInt32(_sysconfigrepository.AsQueryable().With(SqlWith.NoLock).First(x => x.Code == "AGVMaxNumberEmptyRetur").SContent);
            var agvSmNumber = _agvTaskInfoRepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.AgvStatus < AGVTaskStatus.MissionCompleted && x.TaskType == AGVTaskType.CallMaterial).SplitTable(x=>x.Take(2)).Count();
            var agvFkNumber = _agvTaskInfoRepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.AgvStatus < AGVTaskStatus.MissionCompleted && x.TaskType == AGVTaskType.EnterDepot).SplitTable(x => x.Take(2)).Count();

            switch (reqDto.Type)
            {
                case "1":
                    if (agvMaxSm <= agvSmNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大送满任务已达{agvSmNumber}";
                        return res;
                    }
                    if (agvMaxFk <= agvFkNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大返空任务已达{agvFkNumber}";
                        return res;
                    }
                    break;
                case "2":
                    if (agvMaxFk <= agvFkNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大返空任务已达{agvFkNumber}";
                        return res;
                    }
                    break;
                case "3":
                    if (agvMaxSm <= agvSmNumber)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"禁止叫料,最大送满任务已达{agvSmNumber}";
                        return res;
                    }
                    break;
            }

            if (reqDto.Type == "1" || reqDto.Type == "3")
            {
                var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
                if (doc == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.BillCode + "工单信息不存在";
                    return res;
                }

                //获取机台信息
                var mach = _basemachinforepository.GetSingle(x => x.MachNo == reqDto.WbCode);
                if (mach == null || string.IsNullOrEmpty(mach.Station))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.WbCode + "机台号没有配置AGV点位坐标";
                    return res;
                }

                //找到所有的立库/虚拟货位
                var warehouse = _basewarehouserepository.GetList(x => x.TypeNum == FjLocationType.Storage||x.TypeNum==FjLocationType.Virtual).Select(x => x.Id).ToList();
                var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.WorkBench == mach.Station && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2));
                if (task != null && task.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = mach.Station + "站台号存在进行中的任务，不要重复申请";
                    return res;
                }

                //获取所有的立库/虚拟有货库位信息
                var wareCellList = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                        new object[] { JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode })
                    .Where((loc, inv) => warehouse.Contains(loc.WarehouseId) && loc.IsStop == 0 && loc.StateNum == FjLocationState.Full && inv.InvStateCode == InvState.InvEcecState_In.ToString() && inv.MatCode == reqDto.Materialcodecall && (!inv.Secondary || inv.ProductTime < DateTime.Now.AddHours(-6)))
                    .Where((loc, inv) => inv.IsTorsChk == true)
                    .Select((loc, inv) => new
                    {
                        locId = loc.Id,
                        loc.ContGrpBarCode,
                        loc.WarehouseId,
                        loc.WarehouseCode,
                        loc.Code,
                        loc.Row,
                        loc.Col,
                        loc.Layer,
                        loc.Depth,
                        loc.EditTime,
                        loc.TypeNum,
                        inv.MatCode,
                        inv.SideNum,
                        inv.CLBarCode,
                        inv.ProductTime,
                        invId = inv.Id
                    }).ToList().DistinctBy(x => x.ContGrpBarCode).ToList();
                if (!wareCellList.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.NotEnoughStock.GetDescription();
                    return res;
                }

                var warehouseCodes = new List<string>();
                switch (mach.WarehouseCode)
                {
                    case "1N":
                        warehouseCodes.AddRange(new List<string>() { "1N", "1S", "2N", "2S", "3N", "3S" });
                        break;

                    case "1S":
                        warehouseCodes.AddRange(new List<string>() { "1S", "1N", "2S", "2N", "3S", "3N" });
                        break;

                    case "2N":
                        warehouseCodes.AddRange(new List<string>() { "2N", "2S", "1N", "1S", "3N", "3S" });
                        break;

                    case "2S":
                        warehouseCodes.AddRange(new List<string>() { "2S", "2N", "1S", "1N", "3S", "3N" });
                        break;

                    case "3N":
                        warehouseCodes.AddRange(new List<string>() { "3N", "3S", "2N", "2S", "1N", "1S" });
                        break;

                    case "3S":
                        warehouseCodes.AddRange(new List<string>() { "3S", "3N", "2S", "2N", "1S", "1N" });
                        break;
                }

                var wareCell = wareCellList.OrderBy(x => warehouseCodes.IndexOf(x.WarehouseCode))//按照优先级排序
                    .ThenBy(x => x.ProductTime)
                    .FirstOrDefault();

                try
                {
                    //获取所有的库存信息
                    var sotcks = _billInvnowrepository.GetList(x => x.ContGrpBarCode == wareCell.ContGrpBarCode);
                    var nowTime = DateTime.Now;
                    //创建流水信息
                    var invFlowList = _mapper.Map<List<BillInvflow>>(sotcks);
                    foreach (var invFlow in invFlowList)
                    {
                        invFlow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                        invFlow.AddTime = nowTime;
                        invFlow.Id = IdFactory.NewId();
                    }
                    _db.BeginTran(); //创建事务
                    //更新货位信息
                    if (!_basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == wareCell.locId && p.StateNum == FjLocationState.Full))
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"请重新叫料，{wareCell.Code}货位货物已被其他机台叫走!";
                        return res;
                    }
                    //更新库存
                    _billInvnowrepository.UpdateModelColumns(
                        p => new BillInvnow()
                        {
                            InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                            EditTime = nowTime
                        }, p => p.ContGrpBarCode == wareCell.ContGrpBarCode);
                    //新建流水
                    _billInvflow.InsertRange(invFlowList);

                    //添加出库任务
                    RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                    {
                        ContGrpBarCode = wareCell.ContGrpBarCode,
                        CellNo = wareCell.Code,
                        MatCode = wareCell.MatCode,
                        EquCode = wareCell.TypeNum== FjLocationType.Storage? "1":wareCell.Code,
                        Floor = 1,
                        Device = wareCell.WarehouseCode switch
                        {
                            "1N" => "SRM1",
                            "1S" => "SRM2",
                            "2N" => "SRM3",
                            "2S" => "SRM4",
                            "3N" => "SRM5",
                            "3S" => "SRM6",
                            _ => wareCell.WarehouseCode
                        },
                        WorkBench = mach.Station,
                        WarehouseCode = wareCell.TypeNum == FjLocationType.Storage? wareCell.WarehouseCode:mach.WarehouseCode,//如果是芯股的话就使用叫料机台对应的仓库
                        BusType = FJTaskBusType.车间叫料,
                        LastInteractionPoint = reqDto.Type,
                        MesNo = reqDto.ReqId,
                      EmptyInventory  = mach.NearestWarehouseName.IsNullOrEmpty() ? wareCell.WarehouseCode : mach.NearestWarehouseName
                    });

                    //如果是从芯股虚拟机台叫料的话需要记录芯股组盘机台的送空托需求
                    if (wareCell.TypeNum== FjLocationType.Virtual)
                    {
                        //检查对应芯股支架是否有对应的送空托任务
                        var taskList = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock)
                            .Where(p => p.WorkBench == wareCell.Code && p.Type == TaskType.OutDepot
                                                                     && p.BusType==FJTaskBusType.芯股站台送空托.GetDescription() 
                                                                     && p.Status < TaskStatus.Finish)
                            .SplitTable(tabs => tabs.Take(2)).ToList();
                        if (taskList != null && taskList.Any())
                        {
                            _logger.LogInformation(wareCell.Code + "已有执行中的空托输送任务，不要重复申请");
                        }
                        else
                        {
                            //检查是否有对应配置信息
                            var sysConfig = _sysconfigrepository.GetFirst(x => x.Code == $"{wareCell.Code}-EmptyPallet");
                            if (sysConfig == null)
                            {
                                sysConfig = new fjSysConfig()
                                {
                                    Code = $"{wareCell.Code}-EmptyPallet",
                                    Name = $"芯股支架补空托-{wareCell.Code}",
                                    SContent = "0",
                                    SType = "1",
                                    AddWho = "WMS",
                                    EditWho = "WMS",
                                    Default1 = "1",
                                    Default2 = "2",
                                    Default3 = "3",
                                    Memo = "值为0表示不需要补充空托，1表示有空托需求"
                                };
                                _sysconfigrepository.Insert(sysConfig);
                                sysConfig = _sysconfigrepository.GetFirst(x => x.Code == $"{wareCell.Code}-EmptyPallet");
                            }
                            //检查当前站台是否已经有空托需求,无的话改为需要空托盘
                            if (sysConfig.SContent == "0")
                            {
                                //更新库存
                                _sysconfigrepository.UpdateModelColumns(
                                    p => new fjSysConfig()
                                    {
                                        SContent = "1",
                                        EditTime = nowTime
                                    }, p => p.Id == sysConfig.Id);
                            }
                        }
                        

                    }

                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ex.Message;
                }
            }
            else if (reqDto.Type == "2") //单独取空
            {
                //获取对应机台绑定的仓库
                var mach = _basemachinforepository.GetFirst(x => x.MachNo == reqDto.WbCode);
                if (mach == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"没有对应机台-{reqDto.WbCode}";
                    return res;
                }
                var taskold = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).
                    Where(p => p.WorkBench == mach.Station && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2));
                if (taskold != null && taskold.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = mach.Station + "站台号存在进行中的单独取空任务任务，不要重复申请";
                    return res;
                }
                if (string.IsNullOrEmpty(mach.Station))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = reqDto.WbCode + "机台号没有配置AGV点位坐标";
                    return res;
                }
                //获取对应仓库
                var warehouse = _basewarehouserepository.GetFirst(x => x.Id == mach.WarehouseId);
                if (warehouse == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"当前机台没有分配对应仓库-{reqDto.WbCode}";
                    return res;
                }

                //创建入库任务
                var wcstask = new WCS_TaskInfo()
                {
                    Type = TaskType.EnterDepot,
                    Status = TaskStatus.NewBuild,
                    Priority = 0,
                    Device = warehouse.Code switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    AddrFrom = reqDto.WbCode,
                    AddrTo = warehouse.Code switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    LastInteractionPoint = reqDto.Type,
                    BarCode = reqDto.WbCode,
                    Floor = 1,
                    Length = 1,
                    AddTime = DateTime.Now,
                    DocID = 0,
                    PalletType = 1,
                    ProdLine = 1,
                    FullQty = 1,
                    AddWho = "WMS",
                    WarehouseCode = warehouse.Code,
                    Enabled = true,
                    WorkBench = mach.Station,
                    GoodsType = 1,
                    BusType = FJTaskBusType.皮盘入库.GetDescription(),
                    MatCode = "",
                    MaterialCode = mach.NearestWarehouseName.IsNullOrEmpty() ? warehouse.Code : mach.NearestWarehouseName
                };

                var wcstaskhis = _mapper.Map<WCS_TaskOld>(wcstask);

                try
                {
                    var task = _taskrepository.InsertReturnEntity(wcstask);
                    wcstaskhis.Id = task.ID;
                    _wcstaskoldrepository.InsertableSplitTable(wcstaskhis);
                    var taskdetail = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = reqDto.WbCode,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = task.ID,
                        
                        Desc = "单独返空任务",
                    };
                    _taskdetailrepository.InsertableSplitTable(taskdetail);
                    res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                }
                catch (Exception ex)
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                    _logger.LogInformation("保存任务异常：" + ex.ToString());
                    return res;
                }
                return res;
            }
            else
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"位置业务类型-{reqDto.Type}";
            }

            return res;
        }

        /// <summary>
        /// 帘线手动领料出库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes ManualCurtainProductionStockOut(ManualCurtainProductionStockOut reqDto)
        {
            var res = new SRes();

            //获取机台信息
            var mach = _basemachinforepository.GetSingle(x => x.MachNo == reqDto.WbCode);
            if (mach == null || string.IsNullOrEmpty(mach.Station))
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = reqDto.WbCode + "机台号没有配置AGV点位坐标";
                return res;
            }
            var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.AddrTo == mach.Station && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2));
            if (task != null && task.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = mach.Station + "站台号存在进行中的任务，不要重复申请";
                return res;
            }

            //货位信息验证
            var location = _basewarecellrepository.GetSingle(p => p.Code == reqDto.cellCode && p.WarehouseCode == reqDto.wareCode);
            if (location == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = reqDto.cellCode + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (location.StateNum != FjLocationState.Full)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.cellCode + ResponseStatusCodeEnum.Fail.GetDescription() + "货位状态不满足出库条件";
                return res;
            }
            if (location.IsStop == 1)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + reqDto.cellCode + "被禁用";
                return res;
            }

            //库存信息验证
            var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == location.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            if (stock.InvStateCode != InvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = reqDto.cellCode + "组盘状态不是已入库";
                return res;
            }

            try
            {
                //获取所有的库存信息
                var sotcks = _billInvnowrepository.GetList(x => x.ContGrpBarCode == location.ContGrpBarCode);
                var nowTime = DateTime.Now;
                //创建流水信息
                var invFlowList = _mapper.Map<List<BillInvflow>>(sotcks);
                foreach (var invFlow in invFlowList)
                {
                    invFlow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    invFlow.AddTime = nowTime;
                    invFlow.Id = IdFactory.NewId();
                }
                _db.BeginTran(); //创建事务
                //更新货位信息
                if (!_basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == location.Id && p.StateNum == FjLocationState.Full))
                {
                    _db.RollbackTran();
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"请重新叫料，{location.Code}货位货物已被其他机台叫走!";
                    return res;
                }
                //跟新库存
                _billInvnowrepository.UpdateModelColumns(
                    p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = nowTime
                    }, p => p.ContGrpBarCode == location.ContGrpBarCode);
                //新建流水
                _billInvflow.InsertRange(invFlowList);

                //添加出库任务
                RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                {
                    ContGrpBarCode = location.ContGrpBarCode,
                    CellNo = location.Code,
                    MatCode = stock.MatCode,
                    EquCode = "1",
                    Floor = 1,
                    Device = location.WarehouseCode switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    WorkBench = mach.Station,
                    WarehouseCode = location.WarehouseCode,
                    BusType = FJTaskBusType.车间手动叫料,
                });
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
            }
            return res;
        }

        public SRes ProductionBack(FjProductionBackRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        /// <summary>
        ///  变更流向
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes EditorialFlow(FjEditorialFlowRequest reqDto)
        {
            var res = new SRes();
            //获取对应任务信息 
            var taskInfo = _wcstaskoldrepository.AsQueryable().Where(x => x.Id == reqDto.TaskId).SplitTable(tabs => tabs.Take(2)).First();
            if (taskInfo==null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"不存在任务{reqDto.TaskId}";
                return res;
            }
            if (taskInfo.Status > TaskStatus.WaitingToExecute)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"任务状态大于待执行{reqDto.TaskId}";
                return res;
            }

            //库存
            var stock = _billInvnowrepository.GetSingle(p => p.HWBarCode == taskInfo.BarCode);
            if (stock != null )
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号已在库中，请检查RFID号是否重复";
                return res;
            }

            //仓库
            var warehouse = _basewarehouserepository.GetSingle(p => p.Code == reqDto.WareCode);
            if (stock != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "该工字轮条码号已在库中，请检查RFID号是否重复";
                return res;
            }

            #region 变更仓库信息
            try
            {
                _db.BeginTran();
                //变更码垛信息所属仓库
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans
                {
                    WarehouseCode = reqDto.WareCode,
                    WarehouseSort = int.Parse(reqDto.WareCode.Substring(0, 1)),
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == taskInfo.BarCode);

                //变更条码所属仓库信息
                _billInvinitrepository.UpdateModelColumns(x => new BillInvinit()
                {
                    WarehouseId = warehouse.Id
                },x=>x.ContGrpBarCode==taskInfo.BarCode);

                _db.CommitTran();
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = e.StackTrace;
            }

            #endregion




            return res;
        }

        public SRes ProductionLeftFeedBack(string doccode)
        {
            var res = new SRes();
            return res;
        }

        public SRes ErrorMaterialStockOut(FjErrorMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes BGradeMaterialStockOut(BGradeMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes StockChange(FjStockChangeRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes BomInfoTrans(BomInfoTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }

        public SRes FJ1NorthAutoGenerateLocation()
        {
            var res = new SRes();
            var BaseWarearea = new BaseWarehouse()
            {
                Id = IdFactory.NewId(),
                IsStop = 0,
                Code = "1N",
                Name = "分拣库1北",
                AddTime = DateTime.Now,
                AddWho = "admin",
                EditTime = DateTime.Now,
                EditWho = "admin",
                TypeNum = FjLocationType.Storage
            };
            var baseWareareaEntity = _basewarehouserepository.InsertReturnEntity(BaseWarearea);
            var dbBaseWarecellLists = _basewarehouserepository.AsQueryable().ToList();
            var shelfcode = "";
            var list = new List<BaseWarecell>();
            var codes = new List<string>();
            for (var row = 1; row <= 2; row++) //行
            {
                var tunnel = 1;

                //12行 48列9层
                for (var layer = 1; layer <= 10; layer++) //层
                {
                    for (var col = 1; col <= 10; col++) //列
                    {
                        var code = row.ToString().PadLeft(2, '0') + "-" + col.ToString().PadLeft(2, '0') + "-" + layer.ToString().PadLeft(2, '0') + "-" + tunnel;
                        codes.Add(code);
                        var name = row.ToString() + "行" + col.ToString() + "列" + layer.ToString() + "层";
                        list.Add(new BaseWarecell
                        {
                            Id = IdFactory.NewId(),
                            WarehouseId = baseWareareaEntity.Id,
                            WareAreaId = 1669154208777113600,
                            IsStop = 0,
                            Code = code,
                            Name = name,
                            StateNum = FjLocationState.Empty,
                            TypeNum = FjLocationType.Storage,
                            Size = 1,
                            Shelf = tunnel.ToString() + shelfcode,
                            WarehouseCode = BaseWarearea.Code,
                            Row = row,
                            Col = col,
                            Layer = layer,
                            Depth = 1,
                            Tunnel = tunnel,
                            SCRel = "SRM" + tunnel.ToString().PadLeft(2, '0'),
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            Memo = "",
                            AddWho = "admin",
                            AddTime = DateTime.Now,
                            EditWho = "admin",
                            EditTime = DateTime.Now,
                        });
                    }
                }
            }

            _basewarecellrepository.InsertRange(list);
            return res;
        }

        public SRes FJSouthAutoGenerateLocation()
        {
            var res = new SRes();

            var BaseWarearea = new BaseWarehouse()
            {
                Id = IdFactory.NewId(),
                IsStop = 0,
                Code = "1S",
                Name = "分拣库1南",
                AddTime = DateTime.Now,
                AddWho = "admin",
                EditTime = DateTime.Now,
                EditWho = "admin",
                TypeNum = FjLocationType.Storage
            };

            var baseWareareaEntity = _basewarehouserepository.InsertReturnEntity(BaseWarearea);

            var dbBaseWarecellLists = _basewarehouserepository.AsQueryable().ToList();
            var shelfcode = "";
            var list = new List<BaseWarecell>();
            var codes = new List<string>();
            for (var row = 1; row <= 2; row++) //行
            {
                var tunnel = 1;

                //12行 48列9层
                for (var layer = 1; layer <= 10; layer++) //层
                {
                    for (var col = 11; col <= 20; col++) //列
                    {
                        var code = row.ToString().PadLeft(2, '0') + "-" + col.ToString().PadLeft(2, '0') + "-" + layer.ToString().PadLeft(2, '0') + "-" + tunnel;
                        codes.Add(code);
                        var name = row.ToString() + "行" + col.ToString() + "列" + layer.ToString() + "层";
                        list.Add(new BaseWarecell
                        {
                            Id = IdFactory.NewId(),
                            WarehouseId = baseWareareaEntity.Id,
                            WareAreaId = 1669154208777113600,
                            IsStop = 0,
                            Code = code,
                            Name = name,
                            StateNum = FjLocationState.Empty,
                            TypeNum = FjLocationType.Storage,
                            Size = 1,
                            Shelf = tunnel.ToString() + shelfcode,
                            WarehouseCode = BaseWarearea.Code,
                            Row = row,
                            Col = col,
                            Layer = layer,
                            Depth = 1,
                            Tunnel = tunnel,
                            SCRel = "SRM" + 2,
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            Memo = "",
                            AddWho = "admin",
                            AddTime = DateTime.Now,
                            EditWho = "admin",
                            EditTime = DateTime.Now,
                        });
                    }
                }
            }

            _basewarecellrepository.InsertRange(list);
            return res;
        }

        /// <summary>
        ///  获取垛型数组
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public SRes<List<BillBomsetgrp>> FjGetSetGrpList(FjGetSetGrpListRequest req)
        {
            var res = new SRes<List<BillBomsetgrp>>();
            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            res.ResMsg = "失败";
            var setGrps=_BillBomsetgrpRepository.GetList(x => x.ProMaterCode == req.OutMaterialCode && x.IsStop==0);
            if (req.ListmatInfo.Any(v => v == "null"))
            {
                res.ResMsg = $"请重新打开界面";
                return res;
            }

            foreach (var setGrpList in req.ListmatInfo.Select(info => _BillBomsetgrpRepository.GetList(x => (x.BomCode == info || x.BomCode.Contains(info)) && x.IsStop == 0)))
            {
                setGrps.AddRange(setGrpList);
            }

            setGrps = setGrps.DistinctBy(x => x.Id).ToList();
            if (setGrps != null && setGrps.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                res.ResMsg = "成功";
                res.Listinfo = setGrps;
                return res;
            }
            else res.ResMsg = $"{req}没有对应启用垛型";

            return res;
        }

        /// <summary>
        ///  分拣南环形库自动生成库位
        /// </summary>
        /// <returns></returns>
        public SRes RingLibraryAutoGenerateLocation(string WareCode)
        {
            var res = new SRes();
            var wareHouse = _basewarehouserepository.GetSingle(x => x.Code == WareCode);
            var list = new List<BaseWarecell>();
            var codes = new List<string>();
            for (var row = 1; row <= 3; row++) //3行
            {
                for (var layer = 1; layer <= 7; layer++) //7层
                {
                    for (var col = 1; col <= 17; col++) //17列
                    {
                        //行列层深度
                        var code = row.ToString().PadLeft(2, '0') + "-" + col.ToString().PadLeft(2, '0') + "-" + layer.ToString().PadLeft(2, '0') + "-" + row.ToString().PadLeft(2, '0');
                        codes.Add(code);
                        var name = row + "行" + col + "列" + layer + "层" + row + "深";
                        list.Add(new BaseWarecell
                        {
                            Id = IdFactory.NewId(),
                            WarehouseId = wareHouse.Id,
                            WareAreaId = 1669154208777113600,
                            IsStop = 0,
                            Code = code,
                            Name = name,
                            StateNum = FjLocationState.Empty,
                            TypeNum = FjLocationType.RingLibrary,
                            Size = 1,
                            Shelf = "1",
                            WarehouseCode = wareHouse.Code,
                            Row = row,
                            Col = col,
                            Layer = layer,
                            Depth = row,
                            SCRel = "Robot" + 2,
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            Memo = "",
                            AddWho = "admin",
                            AddTime = DateTime.Now,
                            EditWho = "admin",
                            EditTime = DateTime.Now,
                        });
                    }
                }
            }

            _basewarecellrepository.InsertRange(list);
            return res;
        }

        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public GetFJCurStockListResponse GetCurStockList(GetFJCurStockListRequest reqDto)
        {
            var res = new GetFJCurStockListResponse()
            {
                ResData = new List<FJResDataItem>()
                {
                }
            };
            var totalCount = 0;
            var list = _billInvnowrepository.Context.Queryable<BillInvnow>()
                .Where(p => p.InvStateCode == InvState.InvEcecState_In.ToString())
                .WhereIF(!string.IsNullOrEmpty(reqDto.MatCode), p => p.MatCode.Contains(reqDto.MatCode))
                .WhereIF(!string.IsNullOrEmpty(reqDto.MatName), p => p.MatName.Contains(reqDto.MatName))
                .ToPageList(reqDto.PageIndex, reqDto.PageSize, ref totalCount)
                .Select(p => new FJResDataItem
                {
                    MatCode = p.MatCode,
                    MatName = p.MatName,
                    MatBarCode = p.CLBarCode,
                    Describe = "",
                    LocCell = p.PutCol.ToString(),
                    LocLayer = p.PutLayer.ToString(),
                    LocRow = p.PutRow.ToString(),
                    LocCode = p.PutRow.ToString() + p.PutCol.ToString() + p.PutLayer.ToString(),
                    ConBarCode = p.ContGrpBarCode,
                    HWBarCode = p.HWBarCode,
                    UpdatedTime = p.EditTime,
                }
                );
            res.TotalCount = totalCount;
            res.ResData = list.ToList();
            return res;
        }

        /// <summary>
        /// 创建芯股用空托入库任务
        /// </summary>
        /// <returns></returns>
        public void CreateCoreStrandEmptyPalletEnterWarehouse()
        {
            //查询配置最大库存数量
            var sycon = _sysconfigrepository.GetList(x => x.Code.Contains("CoreStrandEmptyPalletMaxNumber"));
            foreach (var config in sycon)
            {
                //获取仓库编号
                var warehouseCode = config.Code.Split("-")[1];
                var warehouse = _basewarehouserepository.GetFirst(x => x.Code == warehouseCode);
                if (warehouse==null)
                {
                    _logger.LogInformation($"找不到仓库{warehouse}");
                    return;
                }

                //判断对应仓库中是否存在指定缓存数量的空托盘
                var invnowCount=_billInvnowrepository.GetList(x=>x.ContGrpType==FJContGrpType.EmptyPal&& x.InvStateCode== InvState.InvEcecState_In.ToString()&&x.WarehouseId==warehouse.Id).Count;
                //获取正在执行中的任务
                var taskInfoCount=_taskrepository.AsQueryable().Count(x=>x.Status<TaskStatus.Finish && x.BusType==FJTaskBusType.芯股用空托盘入库.GetDescription()&&x.WarehouseCode==warehouse.Code);
                //创建对应任务
                var maxNumber = Convert.ToInt32(config.SContent);
                var now = invnowCount + taskInfoCount;
                if (now<maxNumber) //已有任务数量和库存数量小于最大缓存数量
                {
                    _db.BeginTran();
                    //开始生成WCS
                    var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
                    {
                        BusType = FJTaskBusType.芯股用空托盘入库.GetDescription(),
                        Qty = 1,
                        WarehouseCode = warehouse.Code,
                        Floor = 2,
                        MatCode = "",
                        EquCode = "",
                        Type = TaskType.EnterDepot,
                        DocCode = "",
                        WorkBench =""
                    };
                    createStockInWcsTaskReqest.ContGrpBarCode = $"{createStockInWcsTaskReqest.BusType}-{warehouseCode}";
                    //下发wcs任务 - 分解方法
                    var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest);
                    if (taskRes.ResCode != 200)
                    {
                        _db.RollbackTran();
                        _logger.LogInformation($"{taskRes.ResMsg}");
                    }
                    _db.CommitTran();

                }
            }
        }

        /// <summary>
        /// 创建芯股站台用的空托出库任务
        /// </summary>
        /// <returns></returns>
        public SRes CoreStrandSupportReplenishEmptyPallet()
        {
            var res = new SRes(){ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription()};
            //芯股支架补空托,获取需要空托的支架
            var sycon = _sysconfigrepository.GetList(x => x.Code.Contains("EmptyPallet") && x.Name.Contains("芯股支架补空托") && x.SContent=="1");
            var isEnd = false;
            foreach (var config in sycon)
            {
                if (isEnd)continue;
                
                //获取仓库编号
                var wareCellCode = config.Code.Split("-")[0];
                var wareCell = _basewarecellrepository.GetFirst(x => x.Code == wareCellCode);
                if (wareCell == null)
                {
                    _logger.LogInformation($"找不到货位{wareCellCode}");
                    continue;
                }
                var taskInfo = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock)
                    .Where(p => p.WorkBench == wareCell.Code && p.Type == TaskType.OutDepot
                                                             && p.BusType == FJTaskBusType.芯股站台送空托.GetDescription()
                                                             && p.Status < TaskStatus.Finish)
                    .SplitTable(tabs => tabs.Take(2)).First();
                if (taskInfo != null)
                {
                    _logger.LogInformation(wareCell.Code + "已有执行中的空托输送任务，不要重复申请");
                    continue;
                }
                
                //找到所有的立库货位
                var warehouse = _basewarehouserepository.GetList(x => x.TypeNum == FjLocationType.Storage ).Select(x => x.Id).ToList();
                //获取所有的立库有货库位信息
                var wareCellList = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                        new object[] { JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode })
                    .Where((loc, inv) => warehouse.Contains(loc.WarehouseId) && loc.IsStop == 0 && loc.StateNum == FjLocationState.Full && inv.InvStateCode == InvState.InvEcecState_In.ToString() )
                    .Where((loc, inv) =>  inv.ContGrpType== FJContGrpType.EmptyPal)
                    .Select((loc, inv) => new
                    {
                        locId = loc.Id,
                        loc.ContGrpBarCode,
                        loc.WarehouseId,
                        loc.WarehouseCode,
                        loc.Code,
                        loc.Row,
                        loc.Col,
                        loc.Layer,
                        loc.Depth,
                        loc.EditTime,
                        loc.TypeNum,
                        inv.MatCode,
                        inv.SideNum,
                        inv.CLBarCode,
                        inv.OneInTime,
                        invId = inv.Id
                    }).ToList().DistinctBy(x => x.ContGrpBarCode).ToList();
                if (!wareCellList.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                    res.ResMsg = "没有可用空托盘";
                    isEnd = true;
                    continue;
                }

                //TODO:暂时不按照芯股支架的位置进行空托盘的出库

                var wareCellInfo = wareCellList.OrderBy(x => x.OneInTime).First();

                //获取所有的库存信息
                var sotcks = _billInvnowrepository.GetList(x => x.ContGrpBarCode == wareCellInfo.ContGrpBarCode);
                var nowTime = DateTime.Now;
                //创建流水信息
                var invFlowList = _mapper.Map<List<BillInvflow>>(sotcks);
                foreach (var invFlow in invFlowList)
                {
                    invFlow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    invFlow.AddTime = nowTime;
                    invFlow.Id = IdFactory.NewId();
                }
                _db.BeginTran(); //创建事务
                                 //更新货位信息
                if (!_basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == wareCellInfo.locId && p.StateNum == FjLocationState.Full))
                {
                    _db.RollbackTran();
                    _logger.LogInformation($"请重新叫料，{wareCellInfo.Code}货位货物已被其他机台叫走!");
                    continue;
                }
                //更新库存
                _billInvnowrepository.UpdateModelColumns(
                    p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = nowTime
                    }, p => p.ContGrpBarCode == wareCellInfo.ContGrpBarCode);
                //新建流水
                _billInvflow.InsertRange(invFlowList);

                //添加出库任务
                RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                {
                    ContGrpBarCode = wareCellInfo.ContGrpBarCode,
                    CellNo = wareCellInfo.Code,
                    MatCode = wareCellInfo.MatCode,
                    EquCode = wareCellInfo.TypeNum == FjLocationType.Storage ? "1" : wareCellInfo.Code,
                    Floor = 1,
                    Device = wareCellInfo.WarehouseCode switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => wareCellInfo.WarehouseCode
                    },
                    WorkBench = wareCell.Code,
                    WarehouseCode = wareCellInfo.WarehouseCode,//如果是芯股的话就使用叫料机台对应的仓库
                    BusType = FJTaskBusType.芯股站台送空托,
                    LastInteractionPoint = "1"
                });
                _sysconfigrepository.UpdateModelColumns(
                    p => new fjSysConfig()
                    {
                        SContent = "0",
                        EditTime = nowTime
                    }, p => p.Id == config.Id);
                _db.CommitTran();
                isEnd = true;
            }

            return res;
        }

        #region 同WCS交互部分

        #region 满轮主线

        /// <summary>
        ///  工字轮/芯股进入主线扫码
        /// </summary>
        /// <returns></returns>
        public SRes<SRes> EnteMainLine(FJEnteMainLineRequest reqDto)
        {
            var res = new SRes<SRes>();

            return res;
        }

        /// <summary>
        ///  码垛创建异常任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes PalletizingCreateseErrorTasks(PalletizingCreateseErrorTasksRequest reqDto)
        {
            var res = new SRes();
            //异常物料的物料号使用Error + 型号组合而成
            var matCode = "Error" + reqDto.Type;
            //物料
            var mater = _basematerrepository.GetSingle(p => p.Code == matCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }

            //判断任务表中是否有相同物料号、起始地址且未结束的任务
            var wcsTask = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.MatCode == matCode && p.AddrFrom == reqDto.EquNo && p.Status < TaskStatus.Finish).SplitTable(tabs => tabs.Take(2)).First(); ;

            if (wcsTask != null && wcsTask.Status < TaskStatus.FinishOfShunt)// 如果任务状态小于分流结束，表示已有任务，无需重新生成
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"{reqDto.EquNo}已有新建任务，需优先处理任务{wcsTask.Id}";
                return res;
            }

            //生成一个随机条码
            var spoolCode = $"Error{reqDto.Type}{IdFactory.GetInstance().NextId()}";

            //码垛工字轮
            var billSpoolTrans = new BillSpoolTrans();
            billSpoolTrans.ConBarCode = spoolCode;
            billSpoolTrans.BillCode = "";
            billSpoolTrans.WorkOrder = "";
            billSpoolTrans.MatCode = matCode;
            billSpoolTrans.WarehouseCode = reqDto.WarehouseCode;
            billSpoolTrans.WarehouseSort = 0;
            billSpoolTrans.LocSort = 0;
            billSpoolTrans.ConveyorSort = 0;
            billSpoolTrans.Direct = "";
            billSpoolTrans.ErrType = 0;
            billSpoolTrans.AddTime = DateTime.Now;
            billSpoolTrans.EditTime = DateTime.Now;
            billSpoolTrans.AddWho = "wms";
            billSpoolTrans.EditWho = "wms";
            //库存
            var stock = _billInvnowrepository.GetSingle(p => p.HWBarCode == spoolCode);
            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 barstock = _billInvinitrepository.GetFirst(p => p.HWBarCode == spoolCode);
            if (barstock != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = barstock.HWBarCode + "已使用请检查条码是否重复";
                return res;
            }
            //工字轮需要用到的托盘类型
            var fJPalletType = FJPalletType.Pallet09;
            if (reqDto.Type != "9")
            {
                fJPalletType = FJPalletType.PalletNo09;
            }
            var prodate = DateTime.Now;

            //通过投入物料找到垛型编码
            var stackdetail = _billBomsetinfoRepository.GetFirst(p => p.MatCode == matCode);
            if (stackdetail == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"请配置{reqDto.Type}工字轮对应的异常垛形";
                return res;
            }
            var stack = _BillBomsetgrpRepository.GetSingle(p => p.Id == stackdetail.BomSetHdrId);
            var promat = _basematerrepository.GetSingle(p => p.Code == stack.ProMaterCode);
            //创建条码
            var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == billSpoolTrans.WarehouseCode);
            var barinfo = new BillInvinit()
            {
                InvBarCode = "",
                WarehouseId = wareHosue != null ? wareHosue.Id : 0,
                ExecStateCode = InvLockState.InvState_Normal.ToString(),
                ExecDocsNo = "",
                ExecDocsRowNo = "",
                ExecDocsTypeCode = "",
                InvInOut = FJInvInOutType.In,
                ExecWho = "WMS",
                EditTime = DateTime.Now,
                InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                InDocsNo = "",
                InDocsRowNo = "",
                SuppCode = "",
                BomDocsNo = stack.BomCode,
                BomSetId = stack.Id,
                SetGrpCode = stack.Code,
                BomMatCode = promat.Code,
                BomMatId = promat.Id,
                BomMatName = promat.Name,
                MatId = mater.Id,
                MatCode = mater.Code,
                MatName = mater.Name,
                LengthQty = 0,
                TareWQty = 0,
                ProductTime = prodate,
                RFIDBarCode = "",
                ProductLineNo = reqDto.EquNo,
                Grade = "",
                HWBarCode = spoolCode,
                HWTypeCode = reqDto.Type,//工字轮类型
                ContGrpBarCode = spoolCode,
                ContGrpType = FJContGrpType.Material,
                ContGrpId = IdFactory.NewId(),
                IsFast = false,
                IsRework = false,
                CLBarCode = "",
                Size = 1,
                AddTime = DateTime.Now,
                BackReason = "",
                IsBack = false,
                SilkTypeCode = "",
                IsCore = false,
                PalletType = fJPalletType,
            };
            try
            {
                //构造WCS信息
                var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
                {
                    BusType = FJTaskBusType.二楼异常组盘.GetDescription(),
                    ContGrpBarCode = spoolCode,
                    Qty = 1,
                    WarehouseCode = billSpoolTrans.WarehouseCode,
                    Floor = 2,
                    MatCode = billSpoolTrans.MatCode,
                    EquCode = reqDto.EquNo,
                    Type = TaskType.SetPlate,
                    DocCode = billSpoolTrans.WorkOrder,
                    GoodsType = Convert.ToInt32(reqDto.Type)
                };

                _db.BeginTran();
                _billInvinitrepository.InsertReturnEntity(barinfo);
                _billSpoolTransrepository.InsertReturnEntity(billSpoolTrans);

                //下发wcs任务 - 分解方法
                string graMemo = "";
                if (reqDto.errType == 2)
                {
                    graMemo = "南北流错";
                }
                else if (reqDto.errType == 3)
                {
                    graMemo = "BC";
                }
                var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest, graMemo);
                if (taskRes.ResCode != 200)
                {
                    _db.RollbackTran();
                    res.ResCode = taskRes.ResCode;
                    res.ResMsg = taskRes.ResMsg;
                    return res;
                }
                _db.CommitTran();
                RedisHelper.Set($"ErrorTasks:{reqDto.EquNo}:{reqDto.Type}", JsonConvert.SerializeObject(new MainlineDiversion
                {
                    TaskId = taskRes.ResData.ID,
                    WarehouseCode = billSpoolTrans.WarehouseCode
                }));
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.ToString();
            }

            return res;
        }

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <param name="code">工字轮条码</param>
        /// <returns></returns>
        public SRes AllocationWarehouseSort(string code)
        {
            //开始分配分拣库
            var res = new SRes();
            //找到码垛工字轮信息
            var spoolTrans = _billSpoolTransrepository.GetSingle(p => p.ConBarCode == code);
            if (spoolTrans == null)
            {
                //创建容器信息
                var cont = new BillSpoolTrans
                {
                    ConBarCode = code,
                    AddWho = "WMS",
                    AddTime = DateTime.Now,
                    WorkOrder = "20230210",
                    MatCode = "shilatest01"
                };
                //加载新的容器信息
                if (!_billSpoolTransrepository.Insert(cont))
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "RFID载具初始化失败";
                    return res;
                }
                spoolTrans = _billSpoolTransrepository.GetSingle(p => p.ConBarCode == code);
            }
            if (!spoolTrans.WarehouseCode.IsNullOrEmpty())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "已完成分库";
                return res;
            }

            //验证容器是否存在
            res = _mapper.Map<CopperLineResponse>(CheckContinfo(code, FJContainerType.ContainerType_IShapedWheel));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证任务信息
            res = _mapper.Map<CopperLineResponse>(CheckNoFinishTask(code));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证是否条码信息
            var invini = _billInvinitrepository.GetSingle(p => p.HWBarCode == code);
            if (invini != null && invini.InvStateCode == FJInvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号已在库中，请检查托盘号是否重复";
                return res;
            }
            if (invini != null && invini.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号存在出库中任务，请检查上一个任务是否已经完成";
                return res;
            }
            if (invini != null)
            {
                res.ResCode = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetDescription();
                return res;
            }

            //通过订单找到对应的机台信息
            var macList = _basemachinforepository.GetList(p => p.WorkOrder == spoolTrans.WorkOrder);
            var wareList = macList.Select(p => p.WarehouseCode).Distinct().OrderBy(v => v); //找到机台对应的仓库信息
            if (!wareList.Any()) //当前订单没有对应仓库信息
            {
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans
                {
                    ErrType = 1,
                    ErrMsg = "没有配置机台信息",
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == spoolTrans.ConBarCode);
            }
            else if (wareList.Count() == 1) //当前订单对应一个仓库信息
            {
                var sort = int.Parse(wareList.First().Substring(0, 1));
                _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans
                {
                    WarehouseCode = wareList.First(),
                    WarehouseSort = sort,
                    Direct = wareList.First().Substring(1, 1),
                    EditTime = DateTime.Now
                }, p => p.ConBarCode == spoolTrans.ConBarCode);
                spoolTrans.WarehouseCode = wareList.First();
                spoolTrans.WarehouseSort = sort;
                spoolTrans.Direct = wareList.First().Substring(1, 1);
            }
            else //当前订单对应多个仓库信息
            {
                //TODO:怎么计算当前订单在当前仓库需要码多少托，跟据当前仓库已有订单需要的托盘数量计算各订单在可用码垛工位占比，再计算当前托盘该码什么跺
                var wareTempList = macList.Select(p => new { p.WarehouseCode, p.WorkOrder, p.BillCode, }).Distinct();
                var wareHouseList = _basewarehouserepository.GetList().Select(p => p.Id);
                foreach (var warehouse in wareHouseList)
                {
                    //var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p == warehouse);
                    //getMatProport(spoolTrans.MatCode, warehouse);
                }
            }

            //TODO:此处条码号应当使用材料号，测试时使用条码
            var barInfo = _billInvinitrepository.GetSingle(p => p.HWBarCode == code);
            if (barInfo == null)
            {
                var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == spoolTrans.WarehouseCode);
                barInfo = new BillInvinit
                {
                    InvBarCode = code,
                    WarehouseId = wareHosue.Id,
                    HWBarCode = code,
                    ExecStateCode = FJInvLockState.InvState_Normal.GetDescription(),
                    ExecDocsTypeCode = FJDocType.FullWheelPalletizing.GetDescription(),
                    InvInOut = FJInvInOutType.In,
                    ExecWho = "WCS",
                    EditTime = DateTime.Now,
                    InvStateCode = FJInvState.InvEcecState_BuildUp.ToString(),
                    SuppCode = "",
                    Size = 1,
                    MatCode = spoolTrans.MatCode,
                    AddTime = DateTime.Now,
                };
                _billInvinitrepository.InsertReturnEntity(barInfo);
            }

            //开始生成WCS
            var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest
            {
                BusType = FJTaskBusType.二楼组盘.GetDescription(),
                ContGrpBarCode = code,
                Qty = 1,
                WarehouseCode = spoolTrans.WarehouseCode,
                Floor = 2,
                MatCode = spoolTrans.MatCode,
                EquCode = "Robot",
                Type = TaskType.SetPlate,
                DocCode = spoolTrans.WorkOrder
            };

            //下发wcs任务 - 分解方法
            var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest);
            if (taskRes.ResCode != 200)
            {
                res.ResCode = taskRes.ResCode;
                res.ResMsg = taskRes.ResMsg;
                return res;
            }
            RedisHelper.Set($"AllocationWarehouseSort:{code}", JsonConvert.SerializeObject(new MainlineDiversion
            {
                TaskId = taskRes.ResData.ID,
                WarehouseCode = spoolTrans.WarehouseCode
            }));
            return res;
        }

        /// <summary>
        ///  计算物料在该仓库的比例
        /// </summary>
        /// <param name="matcode">物料编号</param>
        /// <param name="warehouseId"></param>
        /// <returns></returns>
        public decimal getMatProport(string matcode, long warehouseId)
        {
            //计算此仓库所有该物料的量 已组盘/已入库
            var stackLisk = _billInvnowrepository.AsQueryable()
                                                 .Count(v => v.WarehouseId == warehouseId
                                                          && v.MatCode == matcode
                                                          && (v.ExecStateCode == FJInvState.InvEcecState_BuildUp.ToString() || v.ExecStateCode == FJInvState.InvEcecState_In.ToString()));

            //每的单子（每盘的数量）
            //var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseId == warehouseId);
            return 0;
        }

        #endregion 满轮主线

        #region 环形库

        #region 环形库申请货位（二深）

        /// <summary>
        ///  环形库申请货位
        /// </summary>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> RingApplyStockInLoc(FJApplyStockInLocRequest reqEntity)
        {
            var res = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };

            try
            {
                #region 任务信息是否正常

                var wcsTask = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqEntity.TaskNum).SplitTable(tabs => tabs.Take(2)).First();

                ;
                if (wcsTask == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    return res;
                }

                if (wcsTask.Type == TaskType.OutDepot)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "该任务是出库任务，不能分配货位；任务号" + wcsTask.Id;
                    return res;
                }

                if (!string.IsNullOrEmpty(wcsTask.AddrTo) && wcsTask.AddrTo != "Robot") //如果目标地址不是机器人
                {
                    res.ResData.CellNo = wcsTask.AddrTo;
                    res.ResData.Row = wcsTask.AddrTo.Split('-')[0] != null ? int.Parse(wcsTask.AddrTo.Split('-')[0]) : 0;
                    res.ResData.Colomn = wcsTask.AddrTo.Split('-')[1] != null ? int.Parse(wcsTask.AddrTo.Split('-')[1]) : 0;
                    res.ResData.Layer = wcsTask.AddrTo.Split('-')[2] != null ? int.Parse(wcsTask.AddrTo.Split('-')[2]) : 0;
                    return res;
                }

                #endregion 任务信息是否正常

                //验证仓库信息
                var wareHouse = _basewarehouserepository.GetFirst(p => p.Code == wcsTask.WarehouseCode);
                if (wareHouse == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                    return res;
                }

                //验证库存
                var stock = _billInvnowrepository.GetFirst(p => p.HWBarCode == wcsTask.BarCode);
                if (stock == null)
                {
                    //获取条码表相关信息
                    var billInvinit = _billInvinitrepository.GetList(x => x.HWBarCode == wcsTask.BarCode).OrderByDescending(x => x.AddTime).FirstOrDefault();
                    if (billInvinit == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = "无条码信息";
                        return res;
                    }

                    //将条码表映射到库存表
                    stock = _mapper.Map<BillInvnow>(billInvinit);
                    stock.AddTime = DateTime.Now;
                    stock.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
                    stock.Id = IdFactory.NewId();
                    if (!_billInvnowrepository.Insert(stock))
                    {
                        res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                        res.ResMsg = "满轮库存信息存储失败";
                        return res;
                    }
                }
                if (stock.InvStateCode != InvState.InvEcecState_BuildUp.ToString())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"工字轮{wcsTask.BarCode}库存状态异常，不是已组盘,请检查相关任务信息";
                    return res;
                }

                //获取包含当前物料、计划个数大于已有个数、未出库
                var ringPalletizingInfoList = _billRingPalletizingInfo.GetList(x => x.WareHouseId == wareHouse.Id && x.BomCode.Contains(wcsTask.MatCode) && x.HWCountQty > x.HaveQty && !x.Out).OrderBy(x => x.AddTime);
                BillRingPalletizingInfo ringPalletizingInfo = null;
                if (ringPalletizingInfoList.Any())
                {
                    foreach (var ringPalletizing in ringPalletizingInfoList)
                    {
                        if (ringPalletizingInfo != null) continue;
                        //取当前任务SKU在货位中已有的信息
                        var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                                new object[]
                                {
                                    JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
                                }).Where((loc, inv) => loc.GroupID == ringPalletizing.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
                            .Select((loc, inv) => new
                            {
                                loc.GroupID,
                                inv.MatCode,
                                loc.XYNO
                            }).ToList().Where(x => x.MatCode == wcsTask.MatCode && x.GroupID == ringPalletizing.Id);
                        var bomSetInfo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizing.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
                        if (cells.Count() == bomSetInfo.Count)
                        {
                            res.Memo2 = $"[{ringPalletizing.Id}]-同规格产品已满足需求，任务[{wcsTask.Id}]创建了新的码垛信息";
                            ringPalletizingInfo = null;
                        }
                        else ringPalletizingInfo = ringPalletizing;
                    }
                }

                if (ringPalletizingInfo != null)
                {
                    //取当前任务SKU在货位中已有的信息
                    var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                            new object[]
                            {
                                JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
                            }).Where((loc, inv) => loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
                        .Select((loc, inv) => new
                        {
                            loc.GroupID,
                            inv.MatCode,
                            loc.XYNO
                        }).ToList().Where(x => x.MatCode == wcsTask.MatCode && x.GroupID == ringPalletizingInfo.Id);
                    var bomSetInfo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
                    if (cells.Count() == bomSetInfo.Count)
                    {
                        res.Memo2 = $"[{ringPalletizingInfo.Id}]-同规格产品已满足需求，任务[{wcsTask.Id}]创建了新的码垛信息";
                        ringPalletizingInfo = null;
                    }
                }

                if (ringPalletizingInfo == null) //如果没有码垛信息
                {
                    var bomsetGrp = _billBomsetgrpRepository.GetFirst(x => x.IsStop == 0 && x.BomCode.Contains(wcsTask.MatCode));
                    var xyNo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == bomsetGrp.Id && x.IsEmpty == 0).ToList().Select(x => Convert.ToInt32(x.XYNo)).OrderByDescending(x => x).First();
                    //跟据垛形信息生成
                    ringPalletizingInfo = new BillRingPalletizingInfo
                    {
                        Id = IdFactory.NewId(),
                        WareHouseId = wareHouse.Id,
                        BomSetGrpId = bomsetGrp.Id,
                        HWCountQty = bomsetGrp.HWCountQty,
                        BomCode = bomsetGrp.BomCode,
                        HaveQty = 0,
                        Out = false,
                        LastXYNO = wareHouse.Code.Contains("N") ? xyNo + 1 : 0
                    };

                    if (!_billRingPalletizingInfo.Insert(ringPalletizingInfo))
                    {
                        res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                        res.ResMsg = "环形库满轮码垛信息存储失败";
                        return res;
                    }
                    res.Memo3 = $"[{wcsTask.MatCode}]，任务[{wcsTask.Id}]创建了新的码垛信息";
                }

                //获取所有可用货位
                var emptyLocList = _basewarecellrepository.Context
                    .Queryable<BaseWarecell, BillInvnow, BaseWarecell, BillInvnow>(
                        (loc1, inv1, loc2, inv2) => new object[]
                        {
                            JoinType.Left, loc1.ContGrpBarCode == inv1.ContGrpBarCode,
                            JoinType.Left, loc2.Col == loc1.Col && loc2.Layer == loc1.Layer,
                            JoinType.Left, loc2.ContGrpBarCode == inv2.ContGrpBarCode
                        })
                    .Where((loc1, inv1, loc2, inv2) => loc1.WarehouseId == wareHouse.Id && loc2.WarehouseId == wareHouse.Id) //保证三个深度都是同一个从仓库的
                    .Where((loc1, inv1, loc2, inv2) => loc1.IsStop == 0 && loc2.IsStop == 0)
                    .Where((loc1, inv1, loc2, inv2) => loc2.Size == loc1.Size)
                    .Where((loc1, inv1, loc2, inv2) => wcsTask.GoodsType == 34 || (wcsTask.GoodsType != 34 && loc1.Layer != 6))
                    .Where((loc1, inv1, loc2, inv2) => loc1.Depth == 1 && loc2.Depth == 2) //保证三个深度与字段对应
                    .Where((loc1, inv1, loc2, inv2) => loc2.GroupID == ringPalletizingInfo.Id) //三深货位的绑定ID是码垛缓存信息的ID
                    .Where((loc1, inv1, loc2, inv2) =>
                        (loc1.StateNum == FjLocationState.Empty && (loc2.StateNum == FjLocationState.Full || loc2.StateNum == FjLocationState.StockIn)) //1空、2有/入锁、3有
                        || (loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty) //1空、2空、3有/入锁
                        || (loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty)
                    ) //1空、2空、3空
                    .Where((loc1, inv1, loc2, inv2) =>
                        loc2.StateNum == FjLocationState.Empty || ((loc2.StateNum == FjLocationState.Full || loc2.StateNum == FjLocationState.StockIn) && inv2.MatCode == wcsTask.MatCode)
                    )
                    .Select((loc1, inv1, loc2, inv2) => new
                    {
                        Loc1Code = loc1.Code,
                        Loc1Id = loc1.Id,
                        Loc1Row = loc1.Row,
                        Loc1Col = loc1.Col,
                        Loc1Layer = loc1.Layer,
                        Loc1Depth = loc1.Depth,
                        Loc1Size = loc1.Size,
                        Loc1StateNum = loc1.StateNum,
                        Loc1ContGrpBarCode = loc1.ContGrpBarCode,
                        Inv1MatCode = inv1.MatCode,
                        Loc2Code = loc2.Code,
                        Loc2Id = loc2.Id,
                        Loc2Row = loc2.Row,
                        Loc2Col = loc2.Col,
                        Loc2Layer = loc2.Layer,
                        Loc2Depth = loc2.Depth,
                        Loc2Size = loc2.Size,
                        Loc2StateNum = loc2.StateNum,
                        Loc2ContGrpBarCode = loc2.ContGrpBarCode,
                        Inv2MatCode = inv2.MatCode,
                    }).ToList();

                if (emptyLocList.Any()) //有货位
                {
                    var emptyLoc = emptyLocList.OrderByDescending(x => x.Loc2StateNum)
                        .ThenByDescending(x => x.Loc1StateNum)
                        .First();
                  
                    if (emptyLoc.Loc2StateNum == FjLocationState.Empty) //次2
                    {
                        res.ResData.CellNo = emptyLoc.Loc2Code;
                        res.ResData.Row = emptyLoc.Loc2Row;
                        res.ResData.Colomn = emptyLoc.Loc2Col;
                        res.ResData.Layer = emptyLoc.Loc2Layer;
                        res.ResData.Depth = emptyLoc.Loc2Depth;
                    }
                    else if (emptyLoc.Loc1StateNum == FjLocationState.Empty) //再次1
                    {
                        res.ResData.CellNo = emptyLoc.Loc1Code;
                        res.ResData.Row = emptyLoc.Loc1Row;
                        res.ResData.Colomn = emptyLoc.Loc1Col;
                        res.ResData.Layer = emptyLoc.Loc1Layer;
                        res.ResData.Depth = emptyLoc.Loc1Depth;
                    }
                }
                else //找不到对应货位当前缓存信息对应的货位,找到三个全是同一货位的信息
                {
                    var emptyLocList1 = _basewarecellrepository.Context
                        .Queryable<BaseWarecell, BaseWarecell>(
                            (loc1, loc2) => new object[]
                            {
                                JoinType.Left, loc2.Col == loc1.Col && loc2.Layer == loc1.Layer
                            })
                        .Where((loc1, loc2) => loc1.WarehouseId == wareHouse.Id && loc2.WarehouseId == wareHouse.Id) //保证三个深度都是同一个从仓库的
                        .Where((loc1, loc2) => loc1.IsStop == 0 && loc2.IsStop == 0)
                        .Where((loc1, loc2) => loc2.Size == loc1.Size)
                        .Where((loc1, loc2) => wcsTask.GoodsType == 34 || (wcsTask.GoodsType != 34 && loc1.Layer != 6))
                        .Where((loc1, loc2) => loc1.Depth == 1 && loc2.Depth == 2) //保证三个深度与字段对应
                        .Where((loc1, loc2) => loc1.GroupID == 0 && loc2.GroupID == 0) //获取三个货位都是没有绑定缓存信息的
                        .Where((loc1, loc2) => loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty) //1空、2空、3空
                        .Select((loc1, loc2) => new
                        {
                            Loc1Code = loc1.Code,
                            Loc1Id = loc1.Id,
                            Loc1Row = loc1.Row,
                            Loc1Col = loc1.Col,
                            Loc1Layer = loc1.Layer,
                            Loc1Depth = loc1.Depth,
                            Loc1Size = loc1.Size,
                            Loc1StateNum = loc1.StateNum,
                            Loc1ContGrpBarCode = loc1.ContGrpBarCode,
                            Loc2Code = loc2.Code,
                            Loc2Id = loc2.Id,
                            Loc2Row = loc2.Row,
                            Loc2Col = loc2.Col,
                            Loc2Layer = loc2.Layer,
                            Loc2Depth = loc2.Depth,
                            Loc2Size = loc2.Size,
                            Loc2StateNum = loc2.StateNum,
                            Loc2ContGrpBarCode = loc2.ContGrpBarCode,
                        }).ToList();

                    if (emptyLocList1.Any())
                    {
                        var emptyLoc = emptyLocList1.OrderBy(x => x.Loc2Layer).ThenBy(x => x.Loc2Col).First();
                        res.ResData.CellNo = emptyLoc.Loc2Code;
                        res.ResData.Row = emptyLoc.Loc2Row;
                        res.ResData.Colomn = emptyLoc.Loc2Col;
                        res.ResData.Layer = emptyLoc.Loc2Layer;
                        res.ResData.Depth = emptyLoc.Loc2Depth;
                    }
                }

                if (string.IsNullOrEmpty(res.ResData.CellNo)) //没有分配货位
                {
                    res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                    res.ResMsg = "有空货位单无可用货位";
                    return res;
                }

                List<BillBomsetinfo> bomSetInfos = new List<BillBomsetinfo>();

                //分配当前轮子在垛形中的位置
                if (wareHouse.Code.Contains("N")) //北侧由大到小，出的时候刚好可用反过来;
                {
                    //取当前任务SKU在货位中已有的信息
                    var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                            new object[]
                            {
                                JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
                            }).Where((loc, inv) => loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
                        .Select((loc, inv) => new
                        {
                            loc.GroupID,
                            inv.MatCode,
                            loc.XYNO
                        }).ToList();
                    if (cells.Count != ringPalletizingInfo.HaveQty)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"码垛信息组【{ringPalletizingInfo.Id}】记录已有【{ringPalletizingInfo.HaveQty}】个轮子，但对应的库存信息只有【{cells.Count}】，请在WMS检查对应的库存信息";
                        return res;
                    }
                    var cellMatCodeList = cells.Where(x => x.MatCode == wcsTask.MatCode);
                    //取当前SKU在垛形明细中所有的信息
                     bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
                    //取当前SKU在垛形明细中最大的一个坐标号，初始化时默认取第一个
                    var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).OrderByDescending(x => x).First());
                    if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最小数,最小数表示最近入库的
                    {
                        lastXYNO = cellMatCodeList.OrderBy(x => x.XYNO).First().XYNO;
                        var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x < lastXYNO).OrderByDescending(x => x).First();
                        ringPalletizingInfo.LastXYNO = xyNo;
                    }
                    else ringPalletizingInfo.LastXYNO = lastXYNO;
                }
                else //南侧小到大，出的时候刚好可用反过来;
                {
                    //取当前任务SKU在货位中已有的信息
                    var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
                            new object[]
                            {
                                JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
                            }).Where((loc, inv) =>
                            loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
                        .Select((loc, inv) => new
                        {
                            loc.GroupID,
                            inv.MatCode,
                            loc.XYNO
                        }).ToList();
                    if (cells.Count != ringPalletizingInfo.HaveQty)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"码垛信息组【{ringPalletizingInfo.Id}】记录已有【{ringPalletizingInfo.HaveQty}】个轮子，但对应的库存信息只有【{cells.Count}】，请在WMS检查对应的库存信息";
                        return res;
                    }
                    var cellMatCodeList = cells.Where(x => x.MatCode == wcsTask.MatCode);
                    //取当前SKU在垛形明细中所有的信息
                     bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
                    //取当前SKU在垛形明细中最小的一个坐标号 ,初始化时默认取第一个
                    var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).OrderBy(x => x).First());
                    if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最大数 最大数表示最近入库的
                    {
                        lastXYNO = cellMatCodeList.OrderByDescending(x => x.XYNO).First().XYNO;
                        var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x > lastXYNO).OrderBy(x => x).First();
                        ringPalletizingInfo.LastXYNO = xyNo;
                    }
                    else ringPalletizingInfo.LastXYNO = lastXYNO;
                }

                if (_basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Any(x => x.GroupID == ringPalletizingInfo.Id && x.XYNO == ringPalletizingInfo.LastXYNO))
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"当前位置已经被分配过了，请检查异常码垛信息{ringPalletizingInfo.Id}-{ringPalletizingInfo.LastXYNO}";
                    return res;
                }

                try
                {
                    _db.BeginTran();
                    var task = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqEntity.TaskNum)
                        .SplitTable(x => x.Take(2)).First();
                    if (task == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                        return res;
                    }
                    if (task.Type == TaskType.OutDepot)
                    {
                        res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        res.ResMsg = "该任务是出库任务，不能分配货位；任务号" + task.Id;
                        return res;
                    }

                    var outTime = ringPalletizingInfo.AddTime;
                    if (stock.ProductTime < ringPalletizingInfo.AddTime) outTime = stock.ProductTime;
                  
                    //更新目标缓存信息
                    if (!_billRingPalletizingInfo.UpdateModelColumns(p => new BillRingPalletizingInfo() { HaveQty = ringPalletizingInfo.HaveQty + 1, LastXYNO = ringPalletizingInfo.LastXYNO,AddTime = outTime }, p => p.Id == ringPalletizingInfo.Id))
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"货位{res.ResData.CellNo}被锁定";
                        return res;
                    }

                    //更新目标货位
                    if (!_basewarecellrepository.UpdateModelColumns(
                            p => new BaseWarecell()
                            {
                                StateNum = FjLocationState.StockIn,
                                ContGrpBarCode = task.BarCode,
                                ContGrpId = stock.ContGrpId,
                                GroupID = ringPalletizingInfo.Id,
                                EditTime = DateTime.Now,
                                XYNO = ringPalletizingInfo.LastXYNO
                            },
                            p => p.WarehouseId == wareHouse.Id && p.Code == res.ResData.CellNo && p.StateNum == FjLocationState.Empty))
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"货位{res.ResData.CellNo}被锁定";
                        return res;
                    }

                    //更新货位信息至历史表，防止WCS重复请求，导致信息异常
                    if (!_wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                    {
                        AddrTo = res.ResData.CellNo
                    }, x => x.Id == wcsTask.Id && x.AddrTo == "Robot"))
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"货位{res.ResData.CellNo}更新货位至任务历史表失败";
                        return res;
                    }

                    var bomSetInfo = bomSetInfos.First(x => x.XYNo == ringPalletizingInfo.LastXYNO.ToString());
                    //更新库存货物大小信息
                    _billInvnowrepository.UpdateModelColumns(x => new BillInvnow() { Size = reqEntity.Height, SideNum=bomSetInfo.SideNum }, x => x.Id == stock.Id);

                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    _logger.LogInformation(ex.ToString());
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ex.Message;
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message + ex.StackTrace;
            }

            return res;
        }

        #endregion

        //#region 环形库货位申请（三深）
        //public SRes<FJApplyStockInLocResponse> RingApplyStockInLoc(FJApplyStockInLocRequest reqEntity)
        //{
        //    var res = new SRes<FJApplyStockInLocResponse>()
        //    {
        //        ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
        //        ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
        //        ResData = new FJApplyStockInLocResponse()
        //    };

        //    try
        //    {
        //        #region 任务信息是否正常

        //        var wcsTask = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqEntity.TaskNum).SplitTable(tabs => tabs.Take(2)).First();

        //        ;
        //        if (wcsTask == null)
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
        //            res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
        //            return res;
        //        }

        //        if (wcsTask.Type == TaskType.OutDepot)
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
        //            res.ResMsg = "该任务是出库任务，不能分配货位；任务号" + wcsTask.Id;
        //            return res;
        //        }

        //        if (!string.IsNullOrEmpty(wcsTask.AddrTo) && wcsTask.AddrTo != "Robot") //如果目标地址不是机器人
        //        {
        //            res.ResData.CellNo = wcsTask.AddrTo;
        //            res.ResData.Row = wcsTask.AddrTo.Split('-')[0] != null ? int.Parse(wcsTask.AddrTo.Split('-')[0]) : 0;
        //            res.ResData.Colomn = wcsTask.AddrTo.Split('-')[1] != null ? int.Parse(wcsTask.AddrTo.Split('-')[1]) : 0;
        //            res.ResData.Layer = wcsTask.AddrTo.Split('-')[2] != null ? int.Parse(wcsTask.AddrTo.Split('-')[2]) : 0;
        //            return res;
        //        }

        //        #endregion 任务信息是否正常

        //        //验证仓库信息
        //        var wareHouse = _basewarehouserepository.GetFirst(p => p.Code == wcsTask.WarehouseCode);
        //        if (wareHouse == null)
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
        //            res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
        //            return res;
        //        }

        //        //验证库存
        //        var stock = _billInvnowrepository.GetFirst(p => p.HWBarCode == wcsTask.BarCode);
        //        if (stock == null)
        //        {
        //            //获取条码表相关信息
        //            var billInvinit = _billInvinitrepository.GetList(x => x.HWBarCode == wcsTask.BarCode).OrderByDescending(x => x.AddTime).FirstOrDefault();
        //            if (billInvinit == null)
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = "无条码信息";
        //                return res;
        //            }

        //            //将条码表映射到库存表
        //            stock = _mapper.Map<BillInvnow>(billInvinit);
        //            stock.AddTime = DateTime.Now;
        //            stock.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
        //            stock.Id = IdFactory.NewId();
        //            if (!_billInvnowrepository.Insert(stock))
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
        //                res.ResMsg = "满轮库存信息存储失败";
        //                return res;
        //            }
        //        }
        //        if (stock.InvStateCode != InvState.InvEcecState_BuildUp.ToString())
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //            res.ResMsg = $"工字轮{wcsTask.BarCode}库存状态异常，不是已组盘,请检查相关任务信息";
        //            return res;
        //        }

        //        //获取包含当前物料、计划个数大于已有个数、未出库
        //        var ringPalletizingInfoList = _billRingPalletizingInfo.GetList(x => x.WareHouseId == wareHouse.Id && x.BomCode.Contains(wcsTask.MatCode) && x.HWCountQty > x.HaveQty && !x.Out).OrderBy(x => x.AddTime);
        //        BillRingPalletizingInfo ringPalletizingInfo = null;
        //        if (ringPalletizingInfoList.Any())
        //        {
        //            foreach (var ringPalletizing in ringPalletizingInfoList)
        //            {
        //                if (ringPalletizingInfo != null) continue;
        //                //取当前任务SKU在货位中已有的信息
        //                var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
        //                        new object[]
        //                        {
        //                            JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
        //                        }).Where((loc, inv) => loc.GroupID == ringPalletizing.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
        //                    .Select((loc, inv) => new
        //                    {
        //                        loc.GroupID,
        //                        inv.MatCode,
        //                        loc.XYNO
        //                    }).ToList().Where(x => x.MatCode == wcsTask.MatCode && x.GroupID == ringPalletizing.Id);
        //                var bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizing.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
        //                if (cells.Count() == bomSetInfos.Count)
        //                {
        //                    res.Memo2 = $"[{ringPalletizing.Id}]-同规格产品已满足需求，任务[{wcsTask.Id}]创建了新的码垛信息";
        //                    ringPalletizingInfo = null;
        //                }
        //                else ringPalletizingInfo = ringPalletizing;
        //            }
        //        }

        //        if (ringPalletizingInfo != null)
        //        {
        //            //取当前任务SKU在货位中已有的信息
        //            var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
        //                    new object[]
        //                    {
        //                        JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
        //                    }).Where((loc, inv) => loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
        //                .Select((loc, inv) => new
        //                {
        //                    loc.GroupID,
        //                    inv.MatCode,
        //                    loc.XYNO
        //                }).ToList().Where(x => x.MatCode == wcsTask.MatCode && x.GroupID == ringPalletizingInfo.Id);
        //            var bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
        //            if (cells.Count() == bomSetInfos.Count)
        //            {
        //                res.Memo2 = $"[{ringPalletizingInfo.Id}]-同规格产品已满足需求，任务[{wcsTask.Id}]创建了新的码垛信息";
        //                ringPalletizingInfo = null;
        //            }
        //        }

        //        if (ringPalletizingInfo == null) //如果没有码垛信息
        //        {
        //            var bomsetGrp = _billBomsetgrpRepository.GetFirst(x => x.IsStop == 0 && x.BomCode.Contains(wcsTask.MatCode));
        //            var xyNo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == bomsetGrp.Id && x.IsEmpty == 0).ToList().Select(x => Convert.ToInt32(x.XYNo)).OrderByDescending(x => x).First();
        //            //跟据垛形信息生成
        //            ringPalletizingInfo = new BillRingPalletizingInfo
        //            {
        //                Id = IdFactory.NewId(),
        //                WareHouseId = wareHouse.Id,
        //                BomSetGrpId = bomsetGrp.Id,
        //                HWCountQty = bomsetGrp.HWCountQty,
        //                BomCode = bomsetGrp.BomCode,
        //                HaveQty = 0,
        //                Out = false,
        //                LastXYNO = wareHouse.Code.Contains("N") ? xyNo + 1 : 0
        //            };

        //            if (!_billRingPalletizingInfo.Insert(ringPalletizingInfo))
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
        //                res.ResMsg = "环形库满轮码垛信息存储失败";
        //                return res;
        //            }
        //            res.Memo3 = $"[{wcsTask.MatCode}]，任务[{wcsTask.Id}]创建了新的码垛信息";
        //        }

        //        //获取所有可用货位
        //        var emptyLocList = _basewarecellrepository.Context
        //            .Queryable<BaseWarecell, BillInvnow, BaseWarecell, BillInvnow, BaseWarecell, BillInvnow>(
        //                (loc1, inv1, loc2, inv2, loc3, inv3) => new object[]
        //                {
        //                    JoinType.Left, loc1.ContGrpBarCode == inv1.ContGrpBarCode,
        //                    JoinType.Left, loc2.Col == loc1.Col && loc2.Layer == loc1.Layer,
        //                    JoinType.Left, loc2.ContGrpBarCode == inv2.ContGrpBarCode,
        //                    JoinType.Left, loc3.Col == loc2.Col && loc3.Layer == loc2.Layer,
        //                    JoinType.Left, loc3.ContGrpBarCode == inv3.ContGrpBarCode
        //                })
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => loc1.WarehouseId == wareHouse.Id && loc2.WarehouseId == wareHouse.Id && loc3.WarehouseId == wareHouse.Id) //保证三个深度都是同一个从仓库的
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => loc1.IsStop == 0 && loc2.IsStop == 0 && loc3.IsStop == 0)
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => loc2.Size == loc1.Size && loc3.Size == loc1.Size)
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => wcsTask.GoodsType == 34 || (wcsTask.GoodsType != 34 && loc1.Layer != 6))
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => loc1.Depth == 1 && loc2.Depth == 2 && loc3.Depth == 3) //保证三个深度与字段对应
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) => loc3.GroupID == ringPalletizingInfo.Id) //三深货位的绑定ID是码垛缓存信息的ID
        //            .Where((loc1, inv1, loc2, inv2, loc3, inv3) =>
        //                (loc1.StateNum == FjLocationState.Empty && (loc2.StateNum == FjLocationState.Full || loc2.StateNum == FjLocationState.StockIn) && loc3.StateNum == FjLocationState.Full) //1空、2有/入锁、3有
        //                || (loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty && (loc3.StateNum == FjLocationState.Full || loc3.StateNum == FjLocationState.StockIn)) //1空、2空、3有/入锁
        //            || (loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty && loc3.StateNum == FjLocationState.Empty)
        //        ) //1空、2空、3空
        //        .Where((loc1, inv1, loc2, inv2, loc3, inv3) =>
        //                loc3.StateNum == FjLocationState.Empty || ((loc3.StateNum == FjLocationState.Full || loc3.StateNum == FjLocationState.StockIn) && inv3.MatCode == wcsTask.MatCode))
        //        .Select((loc1, inv1, loc2, inv2, loc3, inv3) => new
        //        {
        //            Loc1Code = loc1.Code,
        //            Loc1Id = loc1.Id,
        //            Loc1Row = loc1.Row,
        //            Loc1Col = loc1.Col,
        //            Loc1Layer = loc1.Layer,
        //            Loc1Depth = loc1.Depth,
        //            Loc1Size = loc1.Size,
        //            Loc1StateNum = loc1.StateNum,
        //            Loc1ContGrpBarCode = loc1.ContGrpBarCode,
        //            Inv1MatCode = inv1.MatCode,
        //            Loc2Code = loc2.Code,
        //            Loc2Id = loc2.Id,
        //            Loc2Row = loc2.Row,
        //            Loc2Col = loc2.Col,
        //            Loc2Layer = loc2.Layer,
        //            Loc2Depth = loc2.Depth,
        //            Loc2Size = loc2.Size,
        //            Loc2StateNum = loc2.StateNum,
        //            Loc2ContGrpBarCode = loc2.ContGrpBarCode,
        //            Inv2MatCode = inv2.MatCode,
        //            Loc3Code = loc3.Code,
        //            Loc3Id = loc3.Id,
        //            Loc3Row = loc3.Row,
        //            Loc3Col = loc3.Col,
        //            Loc3Layer = loc3.Layer,
        //            Loc3Depth = loc3.Depth,
        //            Loc3Size = loc3.Size,
        //            Loc3StateNum = loc3.StateNum,
        //            Loc3ContGrpBarCode = loc3.ContGrpBarCode,
        //            Inv3MatCode = inv3.MatCode,
        //        }).ToList();

        //        if (emptyLocList.Any()) //有货位
        //        {
        //            var emptyLoc = emptyLocList.OrderByDescending(x => x.Loc3StateNum)
        //            .ThenByDescending(x => x.Loc2StateNum)
        //            .ThenByDescending(x => x.Loc1StateNum)
        //            .First();
        //            if (emptyLoc.Loc3StateNum == FjLocationState.Empty) //优先3
        //            {
        //                res.ResData.CellNo = emptyLoc.Loc3Code;
        //                res.ResData.Row = emptyLoc.Loc3Row;
        //                res.ResData.Colomn = emptyLoc.Loc3Col;
        //                res.ResData.Layer = emptyLoc.Loc3Layer;
        //                res.ResData.Depth = emptyLoc.Loc3Depth;
        //            }
        //            else if (emptyLoc.Loc2StateNum == FjLocationState.Empty) //次2
        //            {
        //                res.ResData.CellNo = emptyLoc.Loc2Code;
        //                res.ResData.Row = emptyLoc.Loc2Row;
        //                res.ResData.Colomn = emptyLoc.Loc2Col;
        //                res.ResData.Layer = emptyLoc.Loc2Layer;
        //                res.ResData.Depth = emptyLoc.Loc2Depth;
        //            }
        //            else if (emptyLoc.Loc1StateNum == FjLocationState.Empty) //再次1
        //            {
        //                res.ResData.CellNo = emptyLoc.Loc1Code;
        //                res.ResData.Row = emptyLoc.Loc1Row;
        //                res.ResData.Colomn = emptyLoc.Loc1Col;
        //                res.ResData.Layer = emptyLoc.Loc1Layer;
        //                res.ResData.Depth = emptyLoc.Loc1Depth;
        //            }
        //        }
        //        else //找不到对应货位当前缓存信息对应的货位,找到三个全是同一货位的信息
        //        {
        //            var emptyLocList1 = _basewarecellrepository.Context
        //               .Queryable<BaseWarecell, BaseWarecell, BaseWarecell>(
        //                   (loc1, loc2, loc3) => new object[]
        //                   {
        //                    JoinType.Left, loc2.Col == loc1.Col && loc2.Layer == loc1.Layer,
        //                    JoinType.Left, loc3.Col == loc2.Col && loc3.Layer == loc2.Layer,
        //                   })
        //               .Where((loc1, loc2, loc3) => loc1.WarehouseId == wareHouse.Id && loc2.WarehouseId == wareHouse.Id && loc3.WarehouseId == wareHouse.Id) //保证三个深度都是同一个从仓库的
        //               .Where((loc1, loc2, loc3) => loc1.IsStop == 0 && loc2.IsStop == 0 && loc3.IsStop == 0)
        //               .Where((loc1, loc2, loc3) => loc2.Size == loc1.Size && loc3.Size == loc1.Size)
        //               .Where((loc1, loc2, loc3) => wcsTask.GoodsType == 34 || (wcsTask.GoodsType != 34 && loc1.Layer != 6))
        //               .Where((loc1, loc2, loc3) => loc1.Depth == 1 && loc2.Depth == 2 && loc3.Depth == 3) //保证三个深度与字段对应
        //               .Where((loc1, loc2, loc3) => loc1.GroupID == 0 && loc2.GroupID == 0 && loc3.GroupID == 0) //获取三个货位都是没有绑定缓存信息的
        //               .Where((loc1, loc2, loc3) => loc1.StateNum == FjLocationState.Empty && loc2.StateNum == FjLocationState.Empty && loc3.StateNum == FjLocationState.Empty) //1空、2空、3空
        //               .Select((loc1, loc2, loc3) => new
        //               {
        //                   Loc1Code = loc1.Code,
        //                   Loc1Id = loc1.Id,
        //                   Loc1Row = loc1.Row,
        //                   Loc1Col = loc1.Col,
        //                   Loc1Layer = loc1.Layer,
        //                   Loc1Depth = loc1.Depth,
        //                   Loc1Size = loc1.Size,
        //                   Loc1StateNum = loc1.StateNum,
        //                   Loc1ContGrpBarCode = loc1.ContGrpBarCode,
        //                   Loc2Code = loc2.Code,
        //                   Loc2Id = loc2.Id,
        //                   Loc2Row = loc2.Row,
        //                   Loc2Col = loc2.Col,
        //                   Loc2Layer = loc2.Layer,
        //                   Loc2Depth = loc2.Depth,
        //                   Loc2Size = loc2.Size,
        //                   Loc2StateNum = loc2.StateNum,
        //                   Loc2ContGrpBarCode = loc2.ContGrpBarCode,
        //                   Loc3Code = loc3.Code,
        //                   Loc3Id = loc3.Id,
        //                   Loc3Row = loc3.Row,
        //                   Loc3Col = loc3.Col,
        //                   Loc3Layer = loc3.Layer,
        //                   Loc3Depth = loc3.Depth,
        //                   Loc3Size = loc3.Size,
        //                   Loc3StateNum = loc3.StateNum,
        //                   Loc3ContGrpBarCode = loc3.ContGrpBarCode,
        //               }).ToList();

        //            if (emptyLocList1.Any())
        //            {
        //                var emptyLoc = emptyLocList1.OrderBy(x => x.Loc3Layer).ThenBy(x => x.Loc3Col).First();
        //                res.ResData.CellNo = emptyLoc.Loc3Code;
        //                res.ResData.Row = emptyLoc.Loc3Row;
        //                res.ResData.Colomn = emptyLoc.Loc3Col;
        //                res.ResData.Layer = emptyLoc.Loc3Layer;
        //                res.ResData.Depth = emptyLoc.Loc3Depth;
        //            }
        //        }

        //        if (string.IsNullOrEmpty(res.ResData.CellNo)) //没有分配货位
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
        //            res.ResMsg = "有空货位单无可用货位";
        //            return res;
        //        }

        //        //分配当前轮子在垛形中的位置
        //        if (wareHouse.Code.Contains("N")) //北侧由大到小，出的时候刚好可用反过来;
        //        {
        //            //取当前任务SKU在货位中已有的信息
        //            var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
        //                    new object[]
        //                    {
        //                        JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
        //                    }).Where((loc, inv) => loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
        //                .Select((loc, inv) => new
        //                {
        //                    loc.GroupID,
        //                    inv.MatCode,
        //                    loc.XYNO
        //                }).ToList();
        //            if (cells.Count != ringPalletizingInfo.HaveQty)
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = $"码垛信息组【{ringPalletizingInfo.Id}】记录已有【{ringPalletizingInfo.HaveQty}】个轮子，但对应的库存信息只有【{cells.Count}】，请在WMS检查对应的库存信息";
        //                return res;
        //            }
        //            var cellMatCodeList = cells.Where(x => x.MatCode == wcsTask.MatCode);
        //            //取当前SKU在垛形明细中所有的信息
        //            var bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
        //            //取当前SKU在垛形明细中最大的一个坐标号，初始化时默认取第一个
        //            var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).OrderByDescending(x => x).First());
        //            if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最小数,最小数表示最近入库的
        //            {
        //                lastXYNO = cellMatCodeList.OrderBy(x => x.XYNO).First().XYNO;
        //                var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x < lastXYNO).OrderByDescending(x => x).First();
        //                ringPalletizingInfo.LastXYNO = xyNo;
        //            }
        //            else ringPalletizingInfo.LastXYNO = lastXYNO;
        //        }
        //        else //南侧小到大，出的时候刚好可用反过来;
        //        {
        //            //取当前任务SKU在货位中已有的信息
        //            var cells = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) =>
        //                    new object[]
        //                    {
        //                        JoinType.Inner, loc.ContGrpBarCode == inv.ContGrpBarCode
        //                    }).Where((loc, inv) =>
        //                    loc.GroupID == ringPalletizingInfo.Id && (loc.StateNum == FjLocationState.Full || loc.StateNum == FjLocationState.StockIn))
        //                .Select((loc, inv) => new
        //                {
        //                    loc.GroupID,
        //                    inv.MatCode,
        //                    loc.XYNO
        //                }).ToList();
        //            if (cells.Count != ringPalletizingInfo.HaveQty)
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = $"码垛信息组【{ringPalletizingInfo.Id}】记录已有【{ringPalletizingInfo.HaveQty}】个轮子，但对应的库存信息只有【{cells.Count}】，请在WMS检查对应的库存信息";
        //                return res;
        //            }
        //            var cellMatCodeList = cells.Where(x => x.MatCode == wcsTask.MatCode);
        //            //取当前SKU在垛形明细中所有的信息
        //            var bomSetInfos = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == ringPalletizingInfo.BomSetGrpId && x.IsEmpty == 0 && x.MatCode == wcsTask.MatCode).ToList();
        //            //取当前SKU在垛形明细中最小的一个坐标号 ,初始化时默认取第一个
        //            var lastXYNO = Convert.ToInt32(bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).OrderBy(x => x).First());
        //            if (cellMatCodeList.Any()) //货位中已有当前SKU的产品，取最大数 最大数表示最近入库的
        //            {
        //                lastXYNO = cellMatCodeList.OrderByDescending(x => x.XYNO).First().XYNO;
        //                var xyNo = bomSetInfos.Select(x => Convert.ToInt32(x.XYNo)).Where(x => x > lastXYNO).OrderBy(x => x).First();
        //                ringPalletizingInfo.LastXYNO = xyNo;
        //            }
        //            else ringPalletizingInfo.LastXYNO = lastXYNO;
        //        }

        //        if (_basewarecellrepository.AsQueryable().With(SqlWith.NoLock).Any(x => x.GroupID == ringPalletizingInfo.Id && x.XYNO == ringPalletizingInfo.LastXYNO))
        //        {
        //            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //            res.ResMsg = $"当前位置已经被分配过了，请检查异常码垛信息{ringPalletizingInfo.Id}-{ringPalletizingInfo.LastXYNO}";
        //            return res;
        //        }

        //        try
        //        {
        //            _db.BeginTran();
        //            var task = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqEntity.TaskNum)
        //                .SplitTable(x => x.Take(2)).First();
        //            if (task == null)
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
        //                res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
        //                return res;
        //            }
        //            if (task.Type == TaskType.OutDepot)
        //            {
        //                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
        //                res.ResMsg = "该任务是出库任务，不能分配货位；任务号" + task.Id;
        //                return res;
        //            }
        //            //更新目标缓存信息
        //            if (!_billRingPalletizingInfo.UpdateModelColumns(p => new BillRingPalletizingInfo() { HaveQty = ringPalletizingInfo.HaveQty + 1, LastXYNO = ringPalletizingInfo.LastXYNO }, p => p.Id == ringPalletizingInfo.Id))
        //            {
        //                _db.RollbackTran();
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = $"货位{res.ResData.CellNo}被锁定";
        //                return res;
        //            }

        //            //更新目标货位
        //            if (!_basewarecellrepository.UpdateModelColumns(
        //                    p => new BaseWarecell()
        //                    {
        //                        StateNum = FjLocationState.StockIn,
        //                        ContGrpBarCode = task.BarCode,
        //                        ContGrpId = stock.ContGrpId,
        //                        GroupID = ringPalletizingInfo.Id,
        //                        EditTime = DateTime.Now,
        //                        XYNO = ringPalletizingInfo.LastXYNO
        //                    },
        //                    p => p.WarehouseId == wareHouse.Id && p.Code == res.ResData.CellNo && p.StateNum == FjLocationState.Empty))
        //            {
        //                _db.RollbackTran();
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = $"货位{res.ResData.CellNo}被锁定";
        //                return res;
        //            }

        //            //更新货位信息至历史表，防止WCS重复请求，导致信息异常
        //            if (!_wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
        //            {
        //                AddrTo = res.ResData.CellNo
        //            }, x => x.Id == wcsTask.Id && x.AddrTo == "Robot"))
        //            {
        //                _db.RollbackTran();
        //                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //                res.ResMsg = $"货位{res.ResData.CellNo}更新货位至任务历史表失败";
        //                return res;
        //            }

        //            //更新库存货物大小信息
        //            _billInvnowrepository.UpdateModelColumns(x => new BillInvnow() { Size = reqEntity.Height }, x => x.Id == stock.Id);

        //            _db.CommitTran();
        //        }
        //        catch (Exception ex)
        //        {
        //            _db.RollbackTran();
        //            _logger.LogInformation(ex.ToString());
        //            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //            res.ResMsg = ex.Message;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
        //        res.ResMsg = ex.Message + ex.StackTrace;
        //    }

        //    return res;
        //}
        //#endregion

        /// <summary>
        ///  WCS申请码垛出库
        /// </summary>
        public SRes ApplyPalletizingStockOut(RingApplyPalletizingStockOutRequest req)
        {
            var res = new SRes()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
            };

            //验证仓库信息
            var wareHouse = _basewarehouserepository.GetFirst(p => p.Code == req.WareHouseCode);
            if (wareHouse == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }

            #region 获取已经成组的码垛信息

            var matInfoList = _basematerrepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.TimeOut != 0).ToList();
            var defaultOutTime = _sysconfigrepository.GetFirst(x => x.Code == "DefaultOutTime");
            if (defaultOutTime==null)
            {
                defaultOutTime = new fjSysConfig() { SContent = "12" };
            }

            var ringPalletizingInfo = _billRingPalletizingInfo.GetList(x => x.WareHouseId == wareHouse.Id && x.HaveQty > 0 && !x.Out).ToList().OrderBy(x => x.AddTime)
                .FirstOrDefault(x =>
                {
                    var outTime = Convert.ToInt32(defaultOutTime.SContent);
                    if (matInfoList.Any(m=>x.BomCode.Contains(m.Code)))
                    {
                        outTime = matInfoList.Where(m => x.BomCode.Contains(m.Code)).Min(m => m.TimeOut);
                    }
                    return  x.HaveQty == x.HWCountQty || x.AddTime < DateTime.Now.AddHours(-outTime);
                });
            if (ringPalletizingInfo == null)
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                res.ResMsg = $"无满跺码垛信息";
                return res;
            }

            #endregion

            var wareCellList = _basewarecellrepository.Context.Queryable<BaseWarecell, BillInvnow>((loc, inv) => new object[] { JoinType.Inner, loc.ContGrpBarCode == inv.HWBarCode })
                .Where((loc, inv) => loc.WarehouseCode == req.WareHouseCode && loc.StateNum == FjLocationState.Full && ringPalletizingInfo.Id == loc.GroupID)
                .Select((loc, inv) => new CellInfo
                {
                    Id = loc.Id,
                    ContGrpBarCode = loc.ContGrpBarCode,
                    WarehouseId = loc.WarehouseId,
                    WarehouseCode = loc.WarehouseCode,
                    Code = loc.Code,
                    Row = loc.Row,
                    Col = loc.Col,
                    Layer = loc.Layer,
                    Depth = loc.Depth,
                    EditTime = loc.EditTime,
                    MatCode = inv.MatCode,
                    SideNum = inv.SideNum,
                    CLBarCode = inv.CLBarCode,
                    XYNo = loc.XYNO,
                    BomDocsNo = inv.BomDocsNo
                }).ToList();
            if (ringPalletizingInfo.HaveQty != wareCellList.Count)
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                res.ResMsg = $"库存不足{ringPalletizingInfo.Id}";
                return res;
            }

            if (ringPalletizingInfo.HaveQty != wareCellList.DistinctBy(x => x.XYNo).Count())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"码垛信息组XYNo存在重复情况，请查看环形库码垛信息找出是哪一个位置出现重复";
                return res;
            }

            try
            {
                //找到当前库存信息中可以使用的垛形信息
                var bomDocsNos = wareCellList.Select(x => x.BomDocsNo).Distinct().ToList();
                var bomSetGrpList = _BillBomsetgrpRepository.GetList(x => bomDocsNos.Contains(x.BomCode));

                if (!bomSetGrpList.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"{JsonConvert.SerializeObject(bomDocsNos.Distinct())}未找到对应的垛形信息";
                    return res;
                }

                #region 分区计算

                

                #endregion
                foreach (var doc in bomSetGrpList)
                {
                    //找到对应的垛形信息
                    var bomSetGrp = _BillBomsetgrpRepository.GetSingle(x => doc.Id == x.Id);
                    //var bomSetGrpInfo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == bomSetGrp.Id && x.IsEmpty == 0).OrderBy(x => x.XYNo.ObjToInt());

                    ////南侧需要反转
                    //if (wareHouse.Code.Contains("S"))
                    //{
                    //    bomSetGrpInfo = bomSetGrpInfo.OrderByDescending(x => x.XYNo.ObjToInt());
                    //}

                    //是否可以码垛，默认可以码垛
                    var isPalletize = true;

                    if (isPalletize) //开始计算出库任务
                    {
                        //开始为各种物料生成对应的出库任务
                        try
                        {
                            //开始更新相关数据

                            _db.BeginTran(); //创建事务

                            _billRingPalletizingInfo.UpdateModelColumns(p => new BillRingPalletizingInfo() { Out = true }, p => p.Id == ringPalletizingInfo.Id);
                            foreach (var cell in wareCellList)
                            {
                                //更新货位信息
                                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == cell.Id && p.StateNum == FjLocationState.Full);

                                //更新库存信息
                                var sotck = _billInvnowrepository.GetSingle(x => x.ContGrpBarCode == cell.ContGrpBarCode && x.HWBarCode == cell.ContGrpBarCode && x.PutCol == cell.Col && x.PutLayer == cell.Layer && x.PutRow == cell.Row);
                                if (sotck == null)
                                {
                                    _db.RollbackTran(); //回滚事务
                                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                                    res.ResMsg = $"未找到库存信息{cell.ContGrpBarCode}";
                                    return res;
                                }
                                _billInvnowrepository.UpdateModelColumns(
                                    p => new BillInvnow()
                                    {
                                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                                        EditTime = DateTime.Now
                                    }, p => p.HWBarCode == cell.ContGrpBarCode);

                                //更新流水信息
                                var invFlow = _mapper.Map<BillInvflow>(sotck);
                                invFlow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                                invFlow.AddTime = DateTime.Now;
                                invFlow.Id = IdFactory.NewId();
                                invFlow.Memo = "出库码垛";
                                _billInvflow.Insert(invFlow);

                                //添加出库任务
                                var task = RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                                {
                                    ContGrpBarCode = cell.ContGrpBarCode,
                                    CellNo = cell.Code,
                                    MatCode = cell.MatCode,
                                    EquCode = req.EquCode,
                                    Floor = 2,
                                    ProdLine = Convert.ToInt16(cell.XYNo),
                                    PalletType = bomSetGrp.ShortCode,
                                    FullQty = (short)ringPalletizingInfo.HaveQty,
                                    Device = req.Device,
                                    WarehouseCode = cell.WarehouseCode,
                                    BusType = FJTaskBusType.环形库出库码垛任务,
                                    GoodsType = sotck.Size
                                });
                                if (task.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                                {
                                    _db.RollbackTran(); //回滚事务
                                    res = task;
                                    return res;
                                }

                                wareCellList = wareCellList.Where(x => x.Id != cell.Id).ToList();
                            }

                            _db.CommitTran(); //提交事务
                            break;
                        }
                        catch (Exception e)
                        {
                            _db.RollbackTran(); //回滚事务
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            _logger.LogInformation(e.ToString());
                            res.ResMsg = e.StackTrace;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                _logger.LogInformation(e.ToString());
                res.ResMsg = e.Message;
            };
            return res;
        }

        /// <summary>
        ///  计算出库任务
        /// </summary>
        public void CalculateOutBoundTasks()
        {
            //获取所有的环形库有货库位信息
            var wareCellList = _basewarecellrepository.GetList(x => x.WarehouseCode.Contains("R") && x.StateNum == FjLocationState.Full).GroupBy(x => x.WarehouseId);

            foreach (var wareCells in wareCellList)
            {
                //获取当前仓库对应的订单所有的订单
                var docs = _billdocrepository.GetList(x => x.IsStop == 0 && wareCells.Key == x.WarehouseId);
                foreach (var doc in docs) //开始处理当前仓库每个订单相关信息
                {
                    //找到对应的垛形信息
                    var bomSetGrp = _BillBomsetgrpRepository.GetSingle(x => doc.SetGrpCode == x.Code);
                    var bomSetGrpInfo = _billBomsetinfoRepository.GetList(x => x.BomSetHdrId == bomSetGrp.Id);

                    //是否可以码垛，默认可以码垛
                    var isPalletize = true;

                    #region 计算当前垛形需要的货物是否已满足数量

                    var bomSetGrpMatCodes = bomSetGrpInfo.Select(x => x.MatCode).ToList();
                    foreach (var matCode in bomSetGrpMatCodes)
                    {
                        var wareCellSum = wareCells.Count(x => matCode == x.ContGrpBarCode);
                        if (wareCellSum == bomSetGrpInfo.Count(x => x.MatCode == matCode)) continue;
                        isPalletize = false;
                        //TODO:暂时未计算物料超时处理方案
                        break;
                    }

                    #endregion 计算当前垛形需要的货物是否已满足数量

                    //开始计算出库任务
                    if (isPalletize)
                    {
                        //TODO：货物序号暂不做处理直接使用累计数值
                        short index = 1;
                        //开始为各种物料生成对应的出库任务
                        try
                        {
                            _db.BeginTran();

                            foreach (var matCode in bomSetGrpMatCodes)
                            {
                                #region 生成这种物料所需要的出库任务信息

                                var sum = bomSetGrpInfo.Count(x => x.MatCode == matCode);
                                var cells = wareCells.Where(x => x.ContGrpBarCode == matCode)
                                    .OrderBy(x => x.Col)
                                    .ThenBy(x => x.Layer)
                                    .ThenBy(x => x.Depth)
                                    .Take(sum);
                                foreach (var cell in cells)
                                {
                                    //更新货位信息
                                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == cell.Id);
                                    //更新库存信息
                                    var sotck = _billInvnowrepository.GetSingle(x => x.ContGrpBarCode == cell.ContGrpBarCode);
                                    _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { InvStateCode = InvState.InvEcecState_OutGoing.ToString(), EditTime = DateTime.Now }, p => p.HWBarCode == cell.ContGrpBarCode);
                                    //更新流水信息
                                    var invflow = _mapper.Map<BillInvflow>(sotck);
                                    invflow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                                    invflow.AddTime = DateTime.Now;
                                    invflow.Id = IdFactory.NewId();
                                    _billInvflow.Insert(invflow);
                                    //添加出库任务
                                    RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                                    {
                                        ContGrpBarCode = cell.ContGrpBarCode,
                                        CellNo = cell.Code,
                                        EquCode = "",
                                        Floor = 2,
                                        ProdLine = index,
                                        //Qty = sotck.LengthQty,
                                        //Tunnel = temploc.Tunnel.ToString(),
                                        WarehouseCode = cell.WarehouseCode,
                                        BusType = FJTaskBusType.环形库出库码垛任务
                                    });
                                    index++;
                                }

                                #endregion 生成这种物料所需要的出库任务信息
                            }
                        }
                        catch (Exception e)
                        {
                            _db.CommitTran();
                        }
                    }
                }
            }
        }

        /// <summary>
        ///  环形库创建WCS出库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<WCS_TaskInfo> RingCreateStockOutWcsTask(FJCreateStockOutWcsTaskRequest reqDto)
        {
            var res = new SRes<WCS_TaskInfo>();
            var bus = reqDto.BusType.GetDescription();
            var wcstask = new WCS_TaskInfo()
            {
                Type = TaskType.OutDepot,
                Status = TaskStatus.NewBuild,
                Priority = 0,
                Device = reqDto.Device,
                SrmStation = reqDto.EquCode,
                AddrFrom = reqDto.CellNo,
                AddrTo = reqDto.EquCode,
                LastInteractionPoint = reqDto.LastInteractionPoint,
                BarCode = reqDto.ContGrpBarCode,
                Floor = reqDto.Floor,
                Length = reqDto.Qty,
                AddTime = DateTime.Now,
                DocID = 0,
                PalletType = reqDto.PalletType,
                ProdLine = reqDto.ProdLine,
                FullQty = reqDto.FullQty,
                AddWho = "WMS",
                WarehouseCode = reqDto.WarehouseCode,
                Enabled = true,
                WorkBench = reqDto.WorkBench,
                GoodsType = reqDto.GoodsType,
                BusType = bus,
                MatCode = reqDto.MatCode,
                WorkOrder = reqDto.MesNo,
                MaterialCode=reqDto.EmptyInventory
            };

            var wcstaskhis = _mapper.Map<WCS_TaskOld>(wcstask);

            try
            {
                var task = _taskrepository.InsertReturnEntity(wcstask);
                wcstaskhis.Id = task.ID;
                _wcstaskoldrepository.InsertableSplitTable(wcstaskhis);
                var taskdetail = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.CellNo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = "创建出库任务",
                };
                _taskdetailrepository.InsertableSplitTable(taskdetail);
                res.ResData = task;
                res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                _logger.LogInformation("保存任务异常：" + ex.ToString());
                return res;
            }
            return res;
        }

        #endregion 环形库

        #region 码垛

        /// <summary>
        ///  生成组盘任务，空托盘
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes GroupTask(FJBuildEmptyPalletsStockDto reqDto)
        {
            var res = new SRes();
            var BusType = reqDto.BusType;

            //验证业务类型
            if (reqDto.BusType != FJTaskBusType.组盘_托盘)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "指令类型" + reqDto.BusType + ResponseStatusCodeEnum.ErrParam.GetDescription();
                return res;
            }

            ////验证是否有空余货位
            //res = _mapper.Map<CopperLineResponse>(IsThereAnySpaceVacancy());
            //if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //检查仓库是否存在
            res = _mapper.Map<CopperLineResponse>(CheckWareCode(reqDto.WareCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证容器是否存在
            res = _mapper.Map<CopperLineResponse>(CheckContinfo(reqDto.PalletCode, FJContainerType.ContainerType_Pallet));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证托盘是否有未结束的任务
            res = _mapper.Map<CopperLineResponse>(CheckNoFinishTask(reqDto.PalletCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
            {
                BusType = BusType.GetDescription(),
                ContGrpBarCode = reqDto.PalletCode,
                Qty = reqDto.PalletNum.ObjToDecimal(),
                EquCode = reqDto.StartLoc,
                WarehouseCode = reqDto.WareCode,
                Floor = reqDto.Floor,
                Type = TaskType.SetPlate
            };

            //下发wcs任务 - 分解方法
            var taskres = CreateStockInWcsTask(createStockInWcsTaskReqest);
            if (taskres.ResCode != 200)
            {
                res.ResCode = taskres.ResCode;
                res.ResMsg = taskres.ResMsg;
                return res;
            }

            return res;
        }

        /// <summary>
        ///  绑定托盘与工字轮
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes BingPallet(FJBingPalletDto reqDto)
        {
            var res = new SRes();
            reqDto.PalletCode = Regex.Replace(reqDto.PalletCode.Trim(), @"[\r\n]", "");
            //检查仓库是否存在
            res = _mapper.Map<CopperLineResponse>(CheckWareCode(reqDto.WarehouseCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            #region 检查托盘任务是否有效

            //容器信息
            var palletContainer = _baseContinfo.GetSingle(x => x.ContBarCode == reqDto.PalletCode);
            if (palletContainer == null)
            {
                //创建容器信息
                var cont = new BaseContinfo
                {
                    ContBarCode = reqDto.PalletCode,
                    Name = reqDto.PalletCode,
                    TypeCode = FJContainerType.ContainerType_Pallet.ToString(),
                    PrintQty = 1,
                    IsStop = 0,
                    WarehouseId = 0,
                    AddWho = "WMS",
                    AddTime = DateTime.Now
                };
                //加载新的容器信息
                if (!_baseContinfo.Insert(cont))
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "载具初始化失败";
                    return res;
                }
            }
            else if (palletContainer.IsStop != 0)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "容器已停用";
                return res;
            }

            #endregion 检查托盘任务是否有效

            if (reqDto.IsFinish)
            {
                if (reqDto.IsItHalf)
                {
                    _db.BeginTran();

                    var invnow = _billInvnowrepository.GetList(x => reqDto.PalletCode == x.ContGrpBarCode);

                    var invnowIds = invnow.Select(x => x.Id);
                    _billInvnowrepository.UpdateModelColumns(x => new BillInvnow()
                    {
                        IsFail = reqDto.IsFail,
                        FailReason = reqDto.FailReason,
                        Secondary = true
                    }, x => invnowIds.Contains(x.Id));

                    //开始生成WCS
                    var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
                    {
                        BusType = FJTaskBusType.码垛入库.GetDescription(),
                        ContGrpBarCode = reqDto.PalletCode,
                        Qty = 1,
                        WarehouseCode = reqDto.WarehouseCode,
                        Floor = 2,
                        EquCode = reqDto.loc,
                        Height = 1, //带料托盘默认为小货位
                        Type = TaskType.EnterDepot,
                    };

                    //下发wcs任务 - 分解方法
                    var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest);
                    if (taskRes.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        _db.RollbackTran(); //回滚事务
                        res = taskRes;
                        return res;
                    }
                    _db.CommitTran();
                }
                else
                {
                    _db.BeginTran();

                    var invnow = _billInvnowrepository.GetList(x => reqDto.PalletCode == x.ContGrpBarCode);
                    if (invnow.Count <= 0)
                    {
                        _db.RollbackTran(); //回滚事务
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"无法结盘，当前托盘条码无对应绑盘库存信息请检查当前码垛工位是否完成绑定动作";
                        return res;
                    }

                    if (!reqDto.IsFail)
                    {
                        if (invnow.Count != reqDto.TaskCode.Count)
                        {
                            _db.RollbackTran(); //回滚事务
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            res.ResMsg = $"实有库存信息数量与应有库存信息数量不匹配;实有{invnow.Count}--应有{reqDto.TaskCode.Count}";
                            return res;
                        }
                    }

                    var invnowIds = invnow.Select(x => x.Id);
                    _billInvnowrepository.UpdateModelColumns(x => new BillInvnow()
                    {
                        IsFail = reqDto.IsFail,
                        FailReason = reqDto.FailReason,
                        Secondary = false
                    }, x => invnowIds.Contains(x.Id));

                    //开始生成WCS
                    var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
                    {
                        BusType = FJTaskBusType.码垛入库.GetDescription(),
                        ContGrpBarCode = reqDto.PalletCode,
                        Qty = 1,
                        WarehouseCode = reqDto.WarehouseCode,
                        Floor = 2,
                        EquCode = reqDto.loc,
                        Height = 1, //带料托盘默认为小货位
                        Type = TaskType.EnterDepot,
                    };

                    //下发wcs任务 - 分解方法
                    var taskRes = CreateStockInWcsTask(createStockInWcsTaskReqest);
                    if (taskRes.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                    {
                        _db.RollbackTran(); //回滚事务
                        res = taskRes;
                        return res;
                    }
                    _db.CommitTran();
                }
                return res;
            }

            #region 检查工字轮任务是否有效

            var wareHosue = _basewarehouserepository.GetSingle(p => p.Code == reqDto.WarehouseCode);

            //无论是桁架还是环形库绑盘都要验证条码信息
            foreach (var code in from code in reqDto.TaskCode let billInvinit = _billInvinitrepository.GetFirst(x => x.HWBarCode == code) where billInvinit == null select code)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"条码{code}无条码信息";
                return res;
            }

            if (wareHosue.TypeNum == FjLocationType.RingLibrary) //环形库需要验证一下库存信息
            {
                foreach (var code in reqDto.TaskCode)
                {
                    var billInvnow = _billInvnowrepository.GetSingle(x => x.HWBarCode == code);
                    if (billInvnow == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"工字轮{code}无库存信息";
                        return res;
                    }

                    if (billInvnow.InvStateCode != FJInvState.InvEcecState_BuildUp.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"工字轮{code}库存状态错误";
                        return res;
                    }
                }
            }

            #endregion 检查工字轮任务是否有效

            try
            {
                _db.BeginTran();

                var contGrpId = IdFactory.NewId();
                //开始更新条码信息
                foreach (var code in reqDto.TaskCode)
                {
                    //无论桁架码垛还是环形库都能找到条码信息,因上方已经验证过条码信息是否存在，所以不再二次验证
                    var billInv = _billInvinitrepository.GetFirst(x => x.HWBarCode == code);
                    if (billInv == null)
                    {
                        _db.RollbackTran();
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = $"{code}未找到条码信息";
                        return res;
                    }
                    var stock = _billInvnowrepository.GetSingle(x => x.HWBarCode == billInv.HWBarCode);

                    switch (wareHosue.TypeNum)
                    {
                        case FjLocationType.RingLibrary:
                            if (stock == null)
                            {
                                _db.RollbackTran();
                                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                                res.ResMsg = $"{code}未找到库存信息";
                                return res;
                            }
                            //更新库存信息
                            _billInvnowrepository.UpdateModelColumns(
                                x => new BillInvnow()
                                {
                                    WarehouseId = wareHosue.Id,
                                    ContGrpId = contGrpId,
                                    ContGrpType = FJContGrpType.Material,
                                    ContGrpBarCode = reqDto.PalletCode,
                                    IsFail = reqDto.IsFail,
                                    FailReason = reqDto.FailReason
                                },
                                x => x.Id == stock.Id && x.InvStateCode == FJInvState.InvEcecState_BuildUp.ToString());
                            break;

                        case FjLocationType.Storage:
                            if (stock != null)
                            {
                                _db.RollbackTran();
                                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                                res.ResMsg = $"{code}已有库存信息";
                                return res;
                            }

                            //将条码表映射到库存表
                            stock = _mapper.Map<BillInvnow>(billInv);
                            stock.AddTime = DateTime.Now;
                            stock.Id = IdFactory.NewId();
                            stock.ContGrpId = contGrpId;
                            stock.ContGrpType = FJContGrpType.Material;
                            stock.ContGrpBarCode = reqDto.PalletCode;
                            stock.WarehouseId = wareHosue.Id;
                            stock.IsFail = reqDto.IsFail;
                            stock.FailReason = reqDto.FailReason;
                            stock.InvStateCode = InvState.InvEcecState_BuildUp.ToString();

                            if (!_billInvnowrepository.Insert(stock))
                            {
                                _db.RollbackTran();
                                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                                res.ResMsg = "库存信息存储失败";
                                return res;
                            }

                            break;

                        case FjLocationType.Pingku:
                            _db.RollbackTran();
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            res.ResMsg = "无效仓库类型";
                            return res;

                        case FjLocationType.Virtual:
                            _db.RollbackTran();
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            res.ResMsg = "无效仓库类型";
                            return res;

                        default:
                            _db.RollbackTran();
                            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                            res.ResMsg = "无效仓库类型";
                            return res;
                    }

                    //增加流水信息
                    var depotstocklist = _billInvnowrepository.GetList(p =>
                        p.ContGrpBarCode == reqDto.PalletCode &&
                        p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    foreach (var item in depotstocklist)
                    {
                        item.Id = IdFactory.NewId();
                        item.AddTime = DateTime.Now;
                        item.Memo = "整托入库组盘";
                    }

                    _billInvflow.InsertRange(_mapper.Map<List<BillInvflow>>(depotstocklist));
                }

                _db.CommitTran();
            }
            catch (Exception e)
            {
                _db.RollbackTran(); ;
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = e.Message;
            }
            return res;
        }

        public SRes<int> GetTwoPallet(FJGetTwoPalletDto reqDto)
        {
            var res = new SRes<int>();

            res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            res.ResMsg = "暂停";
            return res;
            //检查仓库是否存在
            var warehosue = _basewarehouserepository.GetSingle(p => p.Code == reqDto.WarehouseCode);
            if (warehosue == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }

            //通过任务号在历史任务中找到对应货位号
            var task = _wcstaskoldrepository.AsQueryable().Where(p => p.Id == reqDto.TaskId).SplitTable(tabs => tabs.Take(2)).First();

            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            if (task.Type != TaskType.EnterDepot)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "不是入库任务，无法获取出库货位；任务号" + task.Id;
                return res;
            }

            var cell = _basewarecellrepository.GetSingle(x => x.ContGrpBarCode == task.BarCode && x.WarehouseCode == reqDto.WarehouseCode);
            if (cell == null || cell.StateNum != FjLocationState.Full)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "当前货物以超时出库" + task.Id;
                return res;
            }

            try
            {
                _db.BeginTran();

                _basewarecellrepository.UpdateModelColumns(x => new BaseWarecell()
                {
                    StateNum = FjLocationState.StockOut,
                    EditTime = DateTime.Now,
                    EditWho = "WMS"
                }, x => x.Id == cell.Id);

                //添加出库任务
                var resTask = RingCreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                {
                    ContGrpBarCode = cell.ContGrpBarCode,
                    CellNo = cell.Code,
                    EquCode = cell.WarehouseCode switch
                    {
                        "1N" => "1605",
                        "1S" => "1615",
                        "2N" => "1625",
                        "2S" => "1635",
                        "3N" => "1645",
                        "3S" => "1655",
                        _ => "ERROR"
                    },
                    Floor = 2,
                    Device = cell.WarehouseCode switch
                    {
                        "1N" => "SRM1",
                        "1S" => "SRM2",
                        "2N" => "SRM3",
                        "2S" => "SRM4",
                        "3N" => "SRM5",
                        "3S" => "SRM6",
                        _ => "ERROR"
                    },
                    WorkBench = "",
                    WarehouseCode = cell.WarehouseCode,
                    BusType = FJTaskBusType.二楼二次码垛出库,
                });

                _db.CommitTran();
                res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                res.ResMsg = "成功";
                res.ResData = resTask.ResData.ID;
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = e.Message;
            }

            return res;
        }

        #endregion 码垛

        #region 立库

        /// <summary>
        ///  一楼空托盘人工入库任务创建
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes OneFloorWorkerBuildEmptyPalletsStock(FJBuildEmptyPalletsStockRequest reqDto)
        {
            var res = new SRes();

            reqDto.PalletCode = Regex.Replace(reqDto.PalletCode.Trim(), @"[\r\n]", ""); ;
            //判断时候存在组盘信息
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.PalletCode);
            if (stock != null && stock.InvStateCode != InvState.InvEcecState_BuildUp.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.StockStateFail.GetHashCode();
                res.ResMsg = reqDto.PalletCode + ResponseStatusCodeEnum.StockStateFail.GetDescription();
                return res;
            }
            if (stock == null)
            {
                var req = _mapper.Map<FJBuildEmptyPalletsStockDto>(reqDto);
                req.Floor = 1;
                req.BusType = FJTaskBusType.OneLayerManualPallets;
                req.PalletType = req.PalletCode.StartsWith("TPA") ? FJPalletType.Pallet09 : FJPalletType.PalletNo09;
                req.PalletNum = "5";
                res = FJEmptyPalletsStockIn(req);
            }
            else
            {
                //后续补充
            }
            return res;
        }

        /// <summary>
        /// 分拣库空托盘入库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes FJEmptyPalletsStockIn(FJBuildEmptyPalletsStockDto reqDto)
        {
            var res = new CopperLineResponse();

            var BusType = reqDto.BusType;

            //验证业务类型
            if (reqDto.BusType <= FJTaskBusType.def || reqDto.BusType > FJTaskBusType.OneLayerAutoPallets)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "指令类型" + reqDto.BusType + ResponseStatusCodeEnum.ErrParam.GetDescription();
                return res;
            }

            //验证是否有空余货位
            res = _mapper.Map<CopperLineResponse>(IsThereAnySpaceVacancy());
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //检查仓库是否存在
            res = _mapper.Map<CopperLineResponse>(CheckWareCode(reqDto.WareCode));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            //验证容器是否存在
            res = _mapper.Map<CopperLineResponse>(CheckContinfo(reqDto.PalletCode, FJContainerType.ContainerType_Pallet));
            if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

            if (reqDto.PalletCode != "TPA" && reqDto.PalletCode != "TPB")
            {
                //验证托盘是否有未结束的任务
                res = _mapper.Map<CopperLineResponse>(CheckNoFinishTask(reqDto.PalletCode));
                if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;

                //验证是否存在库存信息
                res = _mapper.Map<CopperLineResponse>(CheckInvnow(reqDto.PalletCode));
                if (res.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode()) return res;
            }
            else
            {
                reqDto.PalletCode = reqDto.PalletCode + IdFactory.GetInstance().NextId();
            }

            //保存条码信息 空托盘条码即条码表条码
            var barinfo = _billInvinitrepository.GetSingle(p => p.InvBarCode == reqDto.PalletCode);
            if (barinfo == null)
            {
                var warehosue = _basewarehouserepository.GetSingle(p => p.Code == reqDto.WareCode);
                var mat = _basematerrepository.GetSingle(p => p.Code == reqDto.PalletCode.Substring(0, 3));
                barinfo = new BillInvinit()
                {
                    InvBarCode = reqDto.PalletCode,
                    CLBarCode = reqDto.PalletCode,
                    WarehouseId = warehosue.Id,
                    ContGrpId = IdFactory.NewId(),
                    ContGrpBarCode = reqDto.PalletCode,
                    ExecStateCode = FJInvLockState.InvState_Normal.ToString(),
                    ExecDocsTypeCode = FJDocType.DocType_FJ_EmptyPalletsStockIn.GetHashCode().ToString(),
                    ContGrpType = FJContGrpType.EmptyCon,
                    InvInOut = FJInvInOutType.In,
                    ExecWho = "WCS",
                    EditTime = DateTime.Now,
                    InvStateCode = FJInvState.InvEcecState_BuildUp.ToString(),
                    SuppCode = "",
                    Size = 2,
                    MatCode = mat.Code,
                    MatId = mat.Id,
                    MatName = mat.Name,
                    AddTime = DateTime.Now,
                    PalletType = reqDto.PalletType
                };

                barinfo = _billInvinitrepository.InsertReturnEntity(barinfo);
            }

            try
            {
                _db.BeginTran();
                //生成库存信息-分解方法
                var createStockRes = CreateStock(new List<BillInvinit>() { barinfo }, reqDto.PalletCode);
                if (createStockRes.ResCode != 200)
                {
                    _db.RollbackTran();
                    res.ResCode = createStockRes.ResCode;
                    res.ResMsg = createStockRes.ResMsg;
                    return res;
                }
                //生成流水数据-分解方法
                var createInvFlowRes = CreateInvFlow(createStockRes.ResDataList);
                if (createInvFlowRes.ResCode != 200)
                {
                    _db.RollbackTran();
                    res.ResCode = createInvFlowRes.ResCode;
                    res.ResMsg = createInvFlowRes.ResMsg;
                    return res;
                }
                var createStockInWcsTaskReqest = new FJCreateStockInWcsTaskRequest()
                {
                    BusType = BusType.GetDescription(),
                    ContGrpBarCode = reqDto.PalletCode,
                    ContGrpId = createStockRes.ResDataList.First().ContGrpId,
                    Qty = reqDto.PalletNum.ObjToDecimal(),
                    EquCode = reqDto.StartLoc,
                    WarehouseCode = reqDto.WareCode,
                    Floor = reqDto.Floor,
                    Type = TaskType.EnterDepot
                };

                //下发wcs任务 - 分解方法
                var taskres = CreateStockInWcsTask(createStockInWcsTaskReqest);
                if (taskres.ResCode != 200)
                {
                    _db.RollbackTran();
                    res.ResCode = taskres.ResCode;
                    res.ResMsg = taskres.ResMsg;
                    return res;
                }

                _db.CommitTran();
            }
            catch (Exception e)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = e.Message;
            }

            return res;
        }

        #endregion 立库

        #region 巷道及货位分配

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyStockInLoc(FJApplyStockInLocRequest reqEntity)
        {
            var res = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };
            res = ApplyStockInLocTemp(reqEntity);
            if (string.IsNullOrEmpty(res.ResData.CellNo)) return res;
            try
            {
                _db.BeginTran();
                var task = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(x => x.Id == reqEntity.TaskNum).SplitTable(x => x.Take(2)).First();
                if (task == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                    return res;
                }
                if (task.Type == TaskType.OutDepot)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "该任务是出库任务，不能分配货位；任务号" + task.Id;
                    return res;
                }

                var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());

                //更新货位
                _basewarecellrepository.UpdateModelColumns(
                    p => new BaseWarecell()
                    {
                        StateNum = FjLocationState.StockIn,
                        ContGrpBarCode = "",
                        ContGrpId = 0,
                        EditTime = DateTime.Now
                    },
                    p => p.Code == res.ResData.CellNo && res.ResData.WarehuoseId == p.WarehouseId);
                _wcstaskoldrepository.UpdateSplitTableModelColumns(x => new WCS_TaskOld()
                {
                    AddrTo = res.ResData.CellNo
                }, x => x.Id == task.Id);

                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
            }

            return res;
        }

        /// <summary>
        /// 分配货位
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyStockInLocTemp(FJApplyStockInLocRequest reqEntity)
        {
            var result = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };
            //检擦任务是否异常
            var wcstask = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqEntity.TaskNum).SplitTable(tabs => tabs.Take(2)).First(); ;
            if (wcstask == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            if (wcstask.Type == TaskType.OutDepot)
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                result.ResMsg = "该任务是出库任务，不能分配货位；任务号" + wcstask.Id;
                return result;
            }
            if (!string.IsNullOrEmpty(wcstask.AddrTo) && wcstask.AddrTo != "SRM")//如果目标地址不是堆垛机
            {
                result.ResData.TunnelNum = wcstask.Tunnel;
                result.ResData.CellNo = wcstask.AddrTo;
                result.ResData.Row = wcstask.AddrTo.Split('-')[0] != null ? int.Parse(wcstask.AddrTo.Split('-')[0]) : 0;
                result.ResData.Colomn = wcstask.AddrTo.Split('-')[1] != null ? int.Parse(wcstask.AddrTo.Split('-')[1]) : 0;
                result.ResData.Layer = wcstask.AddrTo.Split('-')[2] != null ? int.Parse(wcstask.AddrTo.Split('-')[2]) : 0;
                return result;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                result.ResCode = ResponseStatusCodeEnum.NotTunnelNum.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.NotTunnelNum.GetDescription();
                return result;
            }
            //验证仓库信息
            var warehouse = _basewarehouserepository.GetFirst(p => p.Code == wcstask.WarehouseCode);
            if (warehouse == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }
            //验证库存
            var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == wcstask.BarCode.Trim() && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
            if (stock == null)
            {
                if (wcstask.BusType== FJTaskBusType.芯股用空托盘入库.GetDescription())
                {
                    var nov = new BillInvnow()
                    {
                        WarehouseId = warehouse.Id,
                        ContGrpBarCode = wcstask.BarCode,
                        ContGrpId = IdFactory.NewId(),
                        BoxBarCode = "",
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        ExecStateCode = InvLockState.InvState_Normal.ToString(),
                        MatId = default,
                        MatCode = "",
                        MatName = "",
                        RFIDBarCode = wcstask.BarCode,
                        HWBarCode = wcstask.BarCode,
                        HWTypeCode = "",
                        InvInOut = FJInvInOutType.In,
                        Size = 1,
                        ContGrpType = FJContGrpType.EmptyPal,
                        LengthQty = 1    //存放托盘数量
                    };
                    _db.BeginTran();
                    _billInvnowrepository.Insert(nov);
                    _billInvflow.Insert(_mapper.Map<BillInvflow>(nov));
                    _db.CommitTran();
                    
                }
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return result;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                result.ResMsg = "没有传巷道值";
                return result;
            }

            return ApplyLoc(new FJApplyLocRequest()
            {
                MaterialId = stock.MatId,
                MaterialCode = stock.MatCode,
                Size = reqEntity.Height,
                TunnelNum = reqEntity.TunnelNum,
                WarehuoseId = warehouse.Id,
                IsMove = wcstask.Type == TaskType.TransferDepot
            });
        }

        /// <summary>
        ///  分配货位
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        public SRes<FJApplyStockInLocResponse> ApplyLoc(FJApplyLocRequest reqEntity)
        {
            var result = new SRes<FJApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new FJApplyStockInLocResponse()
            };

            //预留货位数量
            var emptyLoc = _basewarecellrepository.GetList(p => p.IsStop == 0
                                                                && p.StateNum == FjLocationState.Empty
                                                                && p.TypeNum == FjLocationType.Storage
                                                                && p.Tunnel == reqEntity.TunnelNum
                                                                && p.WarehouseId == reqEntity.WarehuoseId
                                                                && p.Size == reqEntity.Size);

            //判断是否移库
            if (!reqEntity.IsMove && (emptyLoc == null || emptyLoc.Count < 2))
            {
                result.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return result;
            }

            //找到可用货位
            var loc1ist = _basewarecellrepository.Context
                         .Queryable<BaseWarecell>()
                         .Where((loc1) => loc1.IsStop == 0
                                            && loc1.StateNum == FjLocationState.Empty
                                            && loc1.TypeNum == FjLocationType.Storage
                                            && loc1.Tunnel == reqEntity.TunnelNum
                                            && loc1.WarehouseId == reqEntity.WarehuoseId
                                            && loc1.Size == reqEntity.Size
                                            && loc1.Depth == 1)
                         .Where((loc1) => loc1.Tunnel == reqEntity.TunnelNum)
                         .Select((loc1) => new
                         {
                             loc1.Code,
                             loc1.Id,
                             loc1.Row,
                             loc1.Col,
                             loc1.Layer,
                             loc1.Tunnel,
                         }).ToList();

            if (loc1ist.Any())
            {
                var resloc = loc1ist.ToList().OrderBy(p => p.Layer).ThenBy(p => p.Col).ThenBy(p => p.Row).First();
                result.ResData.TunnelNum = resloc.Tunnel.ToString();
                result.ResData.WarehuoseId = reqEntity.WarehuoseId;
                result.ResData.CellNo = resloc.Code;
                result.ResData.Row = resloc.Row;
                result.ResData.Colomn = resloc.Col;
                result.ResData.Layer = resloc.Layer;
                return result;
            }
            result.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
            result.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
            return result;
        }

        #endregion 巷道及货位分配

        #region 二楼申请空托盘组出库

        /// <summary>
        ///  申请空托盘组出库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes ApplyEmptyPalletGroupOutStorage(FjApplyEmptyPalletGroupOutStorageRequest reqDto)
        {
            var res = new SRes();

            ////获取所有未被禁用的巷道
            //var tunnel = _sysconfigrepository.AsQueryable().Where(p => p.SType == "OutStop" && string.IsNullOrEmpty(p.SContent)).ToList();
            //if (!tunnel.Any())
            //{
            //    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            //    res.ResMsg = +"没有可用巷道";
            //    return res;
            //}

            //检查对应目标地址是否有出库任务
            var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.Status < TaskStatus.Finish && x.AddrTo == reqDto.AddTo).SplitTable(v => v.Take(2));
            if (task.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = $"拆盘机{reqDto.AddTo}已存在未结束任务";
                return res;
            }

            //计算巷道剩余空托盘数量
            //TODO:跟据客户要救，暂时屏蔽调关于托盘类型的判断
            var locationlist = from loc in _basewarecellrepository.GetList(p => p.IsStop == 0 && p.StateNum == FjLocationState.Full)
                               join stock in _billInvnowrepository.GetList(p => p.ContGrpType == FJContGrpType.EmptyCon && p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString() && /*p.PalletType == reqDto.FJPalletType &&*/ p.ContGrpType == FJContGrpType.EmptyCon)
                               on loc.ContGrpBarCode equals stock.ContGrpBarCode
                               orderby stock.AddTime
                               select new
                               {
                                   stock.MatCode,
                                   stock.InvBarCode,
                                   stock.RFIDBarCode,
                                   stock.IsFast,
                                   stock.Grade,
                                   stock.IsSurplus,
                                   stock.IsRework,
                                   stock.InvStateCode,
                                   stock.ProductTime,
                                   loc.Col,
                                   loc.Layer,
                                   loc.Shelf,
                                   loc.Depth,
                                   loc.Code,
                                   loc.Tunnel,
                                   loc.WarehouseCode,
                                   loc.ContGrpBarCode,
                                   loc.Id,
                                   loc.StateNum,
                               };

            locationlist = locationlist.Where(p => p.Tunnel == reqDto.Tunnel);

            if (locationlist == null || !locationlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughStock.GetHashCode();
                res.ResMsg = reqDto.FJPalletType.GetDescription() + ResponseStatusCodeEnum.NotEnoughStock.GetDescription();
                return res;
            }

            locationlist = locationlist.OrderBy(p => p.ProductTime);
            //出库任务
            var temploc = locationlist.First();

            var sotck = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == temploc.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
            try
            {
                _db.BeginTran();
                //货位表
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.StockOut }, p => p.Id == temploc.Id);
                //库存表
                _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { InvStateCode = InvState.InvEcecState_OutGoing.ToString(), EditTime = DateTime.Now }, p => p.Id == sotck.Id);
                var invflow = _mapper.Map<BillInvflow>(sotck);

                invflow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                invflow.AddTime = DateTime.Now;
                invflow.Id = IdFactory.NewId();
                invflow.Memo = "空托出库";
                _billInvflow.Insert(invflow);
                //添加出库任务
                CreateStockOutWcsTask(new FJCreateStockOutWcsTaskRequest()
                {
                    ContGrpBarCode = temploc.ContGrpBarCode,
                    CellNo = temploc.Code,
                    EquCode = reqDto.AddTo,
                    Floor = 2,
                    Qty = sotck.LengthQty,
                    Tunnel = temploc.Tunnel.ToString(),
                    WarehouseCode = temploc.WarehouseCode,
                    BusType = FJTaskBusType.二楼空托盘组出库
                });
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                return res;
            }
            return res;
        }

        /// <summary>
        ///  创建WCS出库任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<WCS_TaskInfo> CreateStockOutWcsTask(FJCreateStockOutWcsTaskRequest reqDto)
        {
            var res = new SRes<WCS_TaskInfo>();
            var bus = reqDto.BusType.GetDescription();
            var wcstask = new WCS_TaskInfo()
            {
                Type = TaskType.OutDepot,
                Status = TaskStatus.NewBuild,
                Priority = 0,
                Device = "SRM" + reqDto.Tunnel,
                AddrFrom = reqDto.CellNo,
                AddrTo = reqDto.EquCode,
                LastInteractionPoint = "",
                BarCode = reqDto.ContGrpBarCode,
                Floor = reqDto.Floor,
                Length = reqDto.Qty,
                AddTime = DateTime.Now,
                StartTime = DateTime.Now,
                DocID = 0,
                PalletType = 1,
                ProdLine = 0,
                AddWho = "wms",
                WarehouseCode = reqDto.WarehouseCode,
                Enabled = true,
                WorkBench = reqDto.WorkBench,
                Tunnel = reqDto.Tunnel,
                BusType = bus,
            };

            var wcstaskhis = _mapper.Map<WCS_TaskOld>(wcstask);

            try
            {
                _db.BeginTran();
                var task = _taskrepository.InsertReturnEntity(wcstask);
                wcstaskhis.Id = task.ID;
                _wcstaskoldrepository.InsertableSplitTable(wcstaskhis);
                var taskdetail = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.CellNo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = reqDto.EquCode + "分拣空托盘组备料",
                };
                _taskdetailrepository.InsertableSplitTable(taskdetail);
                _db.CommitTran();
                res.ResData = task;
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                _logger.LogInformation("保存任务异常：" + ex.ToString());
                return res;
            }
            return res;
        }

        #endregion 二楼申请空托盘组出库

        #region 容器、物料、条码、库存检测及创建，创建流水信息

        /// <summary>
        ///  检查容器是否存在，不存在则创建
        /// </summary>
        /// <param name="contBarCode">容器条码</param>
        /// <param name="fjContainerType">容器类型</param>
        /// <returns></returns>
        public SRes CheckContinfo(string contBarCode, FJContainerType fjContainerType)
        {
            var res = new SRes();
            var container = _baseContinfo.GetSingle(x => x.ContBarCode == contBarCode);
            if (container == null)
            {
                //创建容器信息
                var cont = new BaseContinfo
                {
                    ContBarCode = contBarCode,
                    Name = contBarCode,
                    TypeCode = fjContainerType.ToString(),
                    PrintQty = 1,
                    IsStop = 0,
                    WarehouseId = 0,
                    AddWho = "WMS",
                    AddTime = DateTime.Now
                };
                //加载新的容器信息
                if (!_baseContinfo.Insert(cont))
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = "托盘初始化失败";
                    return res;
                }
            }
            else if (container.IsStop != 0)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "容器已停用";
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  跟据库存信息创建流水信息
        /// </summary>
        /// <param name="barlist">库存信息</param>
        /// <returns></returns>
        public SRes CreateInvFlow(List<BillInvnow> barlist)
        {
            var res = new SRes();
            var listflow = _mapper.Map<List<BillInvflow>>(barlist);
            foreach (var item in listflow)
            {
                item.AddTime = DateTime.Now;
                item.Id = IdFactory.NewId();
            }
            _billInvflow.InsertRange(listflow);
            return res;
        }

        /// <summary>
        ///  跟据库存信息创建流水信息
        /// </summary>
        /// <param name="bar">库存信息</param>
        /// <returns></returns>
        public SRes CreateInvFlow(BillInvnow bar)
        {
            var res = new SRes();
            var flow = _mapper.Map<BillInvflow>(bar);
            flow.AddTime = DateTime.Now;
            flow.Id = IdFactory.NewId();
            _billInvflow.Insert(flow);
            return res;
        }

        /// <summary>
        ///  是否有空余货位
        /// </summary>
        /// <returns></returns>
        public SRes IsThereAnySpaceVacancy()
        {
            var res = new SRes();
            //验证有剩余货位
            if (_basewarecellrepository.GetList(p => p.IsStop == 0 && p.StateNum == FjLocationState.Empty && p.Size == 2).Count() < 2)
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        /// 检查传入的仓库是否存在
        /// </summary>
        /// <param name="wareCode">仓库编号</param>
        /// <returns></returns>
        public SRes CheckWareCode(string wareCode)
        {
            var res = new SRes();
            //验证是否有对应仓库
            var warehosue = _basewarehouserepository.GetSingle(p => p.Code == wareCode);
            if (warehosue == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  验证空托盘是否有未结束的任务
        /// </summary>
        /// <param name="PalletCode"></param>
        /// <returns></returns>
        public SRes CheckNoFinishTask(string PalletCode)
        {
            var res = new SRes();
            //验证当前托盘是否有未结束的任务
            var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == PalletCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task != null && task.Id > 0)
            {
                switch (task.Type)
                {
                    case TaskType.SetPlate:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号组盘任务还未完成，请先完成组盘任务";
                        return res;

                    case TaskType.EnterDepot:
                        if (task.Status > TaskStatus.WaitingToExecute && task.Status < TaskStatus.Finish)
                        {
                            res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                            res.ResMsg = PalletCode + "已有进行中任务，请检查托盘条码是否重复";
                            return res;
                        }
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "任务已创建，请勿重复申请";
                        return res;

                    case TaskType.OutDepot:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号出库任务还未完成，请先完成出库任务";
                        return res;

                    case TaskType.TransferDepot:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号移库任务还未完成，请先完成移库任务";
                        return res;

                    case TaskType.Delivery:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号输送任务还未完成，请先完成输送任务";
                        return res;

                    case TaskType.EmptyInit:
                        res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                        res.ResMsg = PalletCode + "该号空轮初始化任务还未完成，请先完成空轮初始化任务";
                        return res;
                }
            }
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  检查是否存在库存信息
        /// </summary>
        /// <param name="code">编码</param>
        /// <returns></returns>
        public SRes CheckInvnow(string code)
        {
            var res = new SRes();

            //验证是否没有库存信息
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == code);
            if (stock != null && stock.InvStateCode == FJInvState.InvEcecState_In.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号已在库中，请检查托盘号是否重复";
                return res;
            }
            else if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = code + "该托盘号存在出库中任务，请检查上一个任务是否已经完成";
                return res;
            }
            //else if (stock != null)
            //{
            //    res.ResCode = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetHashCode();
            //    res.ResMsg = ResponseStatusCodeEnum.GroupStockDetailMaterialBarCodeExist.GetDescription();
            //    return res;
            //}
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            return res;
        }

        /// <summary>
        ///  创建库存信息
        ///  不验证容器是否存在
        ///  不验证容器是否有未结束的任务
        ///  不验条码信息是否存在
        /// </summary>
        /// <param name="barList">条码集合</param>
        /// <param name="containerBarcode">容器编号</param>
        /// <param name="containerType">容器类型</param>
        /// <returns></returns>
        public SRes<BillInvnow> CreateStock(List<BillInvinit> barList, string containerBarcode)
        {
            var res = new SRes<BillInvnow>();
            if (string.IsNullOrEmpty(containerBarcode))
            {
                res.ResCode = ResponseStatusCodeEnum.ContainerCodeNotEmpty.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ContainerCodeNotEmpty.GetDescription();
                return res;
            }

            //将条码表映射到库存表
            var stocklist = _mapper.Map<List<BillInvnow>>(barList);
            foreach (var item in stocklist)
            {
                item.AddTime = DateTime.Now;
                item.Id = IdFactory.NewId();
            }

            if (!_billInvnowrepository.InsertRange(stocklist))
            {
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = "托盘库存信息存储失败";
                return res;
            }

            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            res.ResDataList = stocklist;
            return res;
        }

        /// <summary>
        ///  创建WCS任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<WCS_TaskInfo> CreateStockInWcsTask(FJCreateStockInWcsTaskRequest reqDto,string gra = "",bool isBench=false)
        {
            var res = new SRes<WCS_TaskInfo>();
            var wcsTask = new WCS_TaskInfo()
            {
                Type = reqDto.Type,
                Status = TaskStatus.NewBuild,
                Priority = 0,
                Device = "",
                SrmStation = "",
                AddrFrom = reqDto.EquCode,
                AddrTo = "SRM",
                LastInteractionPoint = "",
                BarCode = reqDto.ContGrpBarCode,
                Floor = reqDto.Floor,
                Length = reqDto.Qty,
                AddTime = DateTime.Now,
                StartTime = DateTime.Now,
                DocID = 0,
                WorkOrder = reqDto.DocCode,
                PalletType = 1,
                ProdLine = 0,
                AddWho = "WMS",
                WarehouseCode = reqDto.WarehouseCode,
                Enabled = true,
                Height = reqDto.Height,
                Grade = gra,
                //WorkBench = reqDto.EquCode,
                //MaterialCode = reqDto.MaterialCode,
                MatCode = reqDto.MatCode,
                BusType = reqDto.BusType,
                GoodsType = reqDto.GoodsType
            };
            if (isBench) wcsTask.WorkBench = reqDto.EquCode;

            var wcsTaskHis = _mapper.Map<WCS_TaskOld>(wcsTask);

            try
            {
                var task = _taskrepository.InsertReturnEntity(wcsTask);
                wcsTaskHis.Id = task.ID;
                _wcstaskoldrepository.InsertableSplitTable(wcsTaskHis);
                var taskDetail = new WCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.EquCode,
                    AddTime = DateTime.Now,
                    AddWho = "WMS",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = reqDto.EquCode + "任务生成",
                };
                _taskdetailrepository.InsertableSplitTable(taskDetail);
                res.ResData = task;
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                _logger.LogInformation("保存任务异常：" + ex);
                return res;
            }
            return res;
        }

        #endregion 容器、物料、条码、库存检测及创建，创建流水信息

        /// <summary>
        ///  手动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public string ManualTask(FJManualTaskRequest request)
        {
            var res = new SRes();

            //必须要有货位信息
            if (!request.Location.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "货位" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res.ToCamelCaseString();
            }
            try
            {
                foreach (var item in request.Location)
                {
                    //货位信息验证
                    var location = _basewarecellrepository.GetSingle(p => p.Code == item && p.WarehouseCode == request.WarehouseCode);
                    if (location == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                        return res.ToCamelCaseString();
                    }
                    if (location.StateNum != FjLocationState.Full)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.Fail.GetDescription() + "货位状态不满足出库条件";
                        return res.ToCamelCaseString();
                    }
                    if (location.IsStop == 1)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + item + "被禁用";
                        return res.ToCamelCaseString();
                    }

                    //库存信息验证
                    var stock = _billInvnowrepository.GetFirst(p => p.ContGrpBarCode == location.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res.ToCamelCaseString();
                    }
                    if (stock.InvStateCode != InvState.InvEcecState_In.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + "组盘状态不是已入库";
                        return res.ToCamelCaseString();
                    }

                    var billTask = new WCS_TaskInfo();
                    billTask.Status = TaskStatus.NewBuild;
                    billTask.Type = TaskType.OutDepot;
                    billTask.Priority = 0;
                    billTask.Device = "SRM" + location.Tunnel;
                    billTask.AddrFrom = item;
                    billTask.AddrTo = request.AddTo;
                    billTask.BarCode = stock.ContGrpBarCode;
                    billTask.StartTime = DateTime.Now;
                    billTask.AddTime = DateTime.Now;
                    billTask.EditTime = DateTime.Now;
                    billTask.AddWho = "WMS";
                    billTask.WarehouseCode = location.WarehouseCode;
                    billTask.Enabled = true;
                    billTask.Floor = 2;
                    billTask.Tunnel = location.Tunnel.ToString();
                    billTask.PalletType = 1;
                    billTask.Length = stock.LengthQty;
                    billTask.MaterialCode = stock.MatCode;
                    billTask.OutType = OutTypeEnum.全自动手动出库任务;
                    billTask.BusType = FJTaskBusType.TaskBusType_FJ_ManualOut.GetDescription();

                    _db.BeginTran();

                    _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                    {
                        StateNum = FjLocationState.StockOut,
                        EditTime = DateTime.Now
                    }, p => p.Code == item && p.WarehouseCode == request.WarehouseCode);
                    _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == stock.ContGrpBarCode);

                    var flow = _mapper.Map<BillInvflow>(stock);
                    flow.Id = IdFactory.NewId();
                    flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    flow.EditTime = DateTime.Now;
                    _billInvflow.Insert(flow);
                    var wcs = _taskrepository.InsertReturnEntity(billTask);
                    var wcshistory = _mapper.Map<WCS_TaskOld>(wcs);
                    _wcstaskoldrepository.InsertableSplitTable(wcshistory);
                    var taskdetail = new WCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = item,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcs.ID,
                        Desc = wcs.OutType.ToString(),
                    };
                    _taskdetailrepository.InsertableSplitTable(taskdetail);
                    _db.CommitTran();
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation("手动出库异常：" + ex.Message);
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
                return res.ToCamelCaseString();
            }
            return res.ToCamelCaseString();
        }

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

            var wcstask = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).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.OutDepot)
            {
                result.ResCode = ResponseStatusCodeEnum.OnlyStockOutAvil.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.OnlyStockOutAvil.GetDescription();
                return result;
            }
            if (wcstask.Status >= TaskStatus.Finish)
            {
                result.ResCode = ResponseStatusCodeEnum.StateNotUpdate.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.StateNotUpdate.GetDescription();
                return result;
            }
            try
            {
                var well = _basewarecellrepository.GetSingle(x => x.ContGrpBarCode == wcstask.BarCode && x.Code.Contains(wcstask.AddrFrom) && x.WarehouseCode == wcstask.WarehouseCode);
                if (well == null)
                {
                    result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                    result.ResMsg = reqDto.TaskNum + "任务已结束";
                    return result;
                }
                var wareHouse = _basewarehouserepository.GetSingle(x => x.Id == well.WarehouseId);
                _db.BeginTran();

                switch (wareHouse.TypeNum)
                {
                    case FjLocationType.Storage:
                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { PutRow = 0, PutCol = 0, PutLayer = 0 }, p => p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && p.ContGrpBarCode == wcstask.BarCode);
                        break;
                    case FjLocationType.Virtual:
                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { PutRow = 0, PutCol = 0, PutLayer = 0 }, p => p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && p.ContGrpBarCode == wcstask.BarCode);
                        break;

                    case FjLocationType.RingLibrary:
                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow() { PutRow = 0, PutCol = 0, PutLayer = 0, InvStateCode = FJInvState.InvEcecState_BuildUp.ToString() },
                            p => p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && (p.ContGrpBarCode == wcstask.BarCode || p.HWBarCode == wcstask.BarCode));
                        break;
                }

                var stocklist = _billInvnowrepository.GetList(p => (p.ContGrpBarCode == wcstask.BarCode || p.HWBarCode == wcstask.BarCode) && (p.InvStateCode == InvState.InvEcecState_BuildUp.ToString() || p.InvStateCode == InvState.InvEcecState_OutGoing.ToString()));
                if (stocklist == null || !stocklist.Any())
                {
                    result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                    return result;
                }
                var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
                foreach (var item in flowlist)
                {
                    item.Id = IdFactory.NewId();
                    item.AddTime = DateTime.Now;
                    item.Memo = "设备出库放货完成";
                }
                //货位
                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell() { StateNum = FjLocationState.Empty, ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now, GroupID = 0, XYNO = 0 },
                         p => p.ContGrpBarCode == wcstask.BarCode && p.Code.Contains(wcstask.AddrFrom) && p.WarehouseCode == wcstask.WarehouseCode);
                _billInvflow.InsertRange(flowlist);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
                result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                result.ResMsg = wcstask.Id + "设备出库放货完成异常";
            }

            return result;
        }

        /// <summary>
        ///  完成任务
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes<int> CompleteTask(CompleteTaskRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = reqDto.TaskNum
            };

            //检查历史任务表是否有任务
            var task = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqDto.TaskNum).SplitTable(tabs => tabs.Take(2)).First();
            if (task == null)
            {
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }

            switch (task.Type)
            {
                case TaskType.SetPlate:
                    try
                    {
                        //检擦库存信息是否正确
                        var stock = _billInvnowrepository.GetFirst(p => (p.ContGrpBarCode == task.BarCode || p.HWBarCode == task.BarCode));
                        if (stock == null)
                        {
                            result.ResMsg = task.BarCode + "没有库存信息";
                            return result;
                        }

                        var wareCell = _basewarecellrepository.GetFirst(x => x.ContGrpBarCode == stock.ContGrpBarCode && x.WarehouseId == stock.WarehouseId);
                        if (stock.InvStateCode == InvState.InvEcecState_In.ToString() && wareCell.StateNum == FjLocationState.Full) //如果库存状态是入库，货位状态是有货直接返回成功，避免WCS重复调用造成出库异常
                        {
                            return result;
                        }
                        if (stock.InvStateCode != InvState.InvEcecState_BuildUp.ToString())
                        {
                            result.ResMsg = task.BarCode + $"库存状态错误{stock.InvStateCode}";
                            return result;
                        }

                        var warehouse = _basewarehouserepository.GetSingle(p => p.Code == task.WarehouseCode);
                        _db.BeginTran();
                        var row = int.Parse(task.AddrTo.Split('-')[0]);
                        var col = int.Parse(task.AddrTo.Split('-')[1]);
                        var layer = int.Parse(task.AddrTo.Split('-')[2]);

                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                        {
                            WarehouseId = warehouse.Id,
                            InvStateCode = InvState.InvEcecState_In.ToString(),
                            PutRow = row,
                            PutCol = col,
                            PutLayer = layer,
                            OneInTime = DateTime.Now,
                            EditTime = DateTime.Now
                        }, p => p.HWBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());

                        //更新货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = FjLocationState.Full,
                            ContGrpBarCode = stock.HWBarCode,
                            ContGrpId = stock.ContGrpId,
                            EditTime = DateTime.Now
                        }, p => p.Code == task.AddrTo && p.WarehouseId == warehouse.Id);

                        //增加流水信息
                        var enterDepotstocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        foreach (var item in enterDepotstocklist)
                        {
                            item.Id = IdFactory.NewId();
                            item.AddTime = DateTime.Now;
                        }
                        _billInvflow.InsertRange(_mapper.Map<List<BillInvflow>>(enterDepotstocklist));

                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResMsg = task.Id + "完成任务异常";
                        _logger.LogInformation("完成任务异常" + ex.ToString());
                    }
                    break;

                case TaskType.EnterDepot:

                    try
                    {
                        //检擦库存信息是否正确
                        var stock = _billInvnowrepository.GetFirst(p => (p.ContGrpBarCode == task.BarCode || p.HWBarCode == task.BarCode)
                                                                                                       && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                        if (stock == null)
                        {
                            result.ResMsg = task.BarCode + "没有已组盘的信息";
                            return result;
                        }

                        var warehouse = _basewarehouserepository.GetSingle(p => p.Code == task.WarehouseCode);
                        _db.BeginTran();
                        var row = int.Parse(task.AddrTo.Split('-')[0]);
                        var col = int.Parse(task.AddrTo.Split('-')[1]);
                        var layer = int.Parse(task.AddrTo.Split('-')[2]);

                        //更新库存
                        _billInvnowrepository.UpdateModelColumns(p => new BillInvnow()
                        {
                            InvStateCode = InvState.InvEcecState_In.ToString(),
                            WarehouseId = warehouse.Id,
                            PutRow = row,
                            PutCol = col,
                            PutLayer = layer,
                            OneInTime = DateTime.Now,
                            EditTime = DateTime.Now
                        }, p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());

                        //更新货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = FjLocationState.Full,
                            ContGrpBarCode = stock.ContGrpBarCode,
                            ContGrpId = stock.ContGrpId,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(task.AddrTo) && p.WarehouseId == warehouse.Id);

                        //增加流水信息
                        var enterDepotstocklist = _billInvnowrepository.GetList(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                        foreach (var item in enterDepotstocklist)
                        {
                            item.Id = IdFactory.NewId();
                            item.AddTime = DateTime.Now;
                        }
                        _billInvflow.InsertRange(_mapper.Map<List<BillInvflow>>(enterDepotstocklist));

                        //添加反馈信息

                        var pushtype = fjFackbeekType.InterfaceType_FJ_StockIn.ToString();
                        var list = new List<BillPushinfo>();
                        foreach (var item in enterDepotstocklist)
                        {
                            list.Add(new BillPushinfo
                            {
                                DocsNo = stock.ExecDocsNo,
                                TypeCode = pushtype,
                                RFIDBarCode = stock.ContGrpBarCode,
                                HWBarCode = item.HWBarCode,
                                CLBarCode = item.CLBarCode,
                                WarehouseId = warehouse.Id,
                                WarehouseCode = warehouse.Code,
                                WareCellId = 0,
                                WareCellCode = task.AddrTo,
                                MatId = item.MatId,
                                MatCode = item.MatCode,
                                MatName = item.MatName,
                                TolWQty = item.TolWQty,
                                NetWQty = item.NetWQty,
                                TareWQty = item.TareWQty,
                                ReqNo = Guid.NewGuid().ToString()
                            });
                        }
                        if (stock.ContGrpType == FJContGrpType.Material)
                        {
                            _billPushinforepository.InsertRange(list);
                        }
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResMsg = task.Id + "完成任务异常";
                        _logger.LogInformation("完成任务异常" + ex.ToString());
                    }

                    break;

                case TaskType.OutDepot:
                    //验证库存信息
                    var stocklist = _billInvnowrepository.GetList(p => (p.ContGrpBarCode == task.BarCode || p.HWBarCode == task.BarCode) && (p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() || p.InvStateCode == InvState.InvEcecState_BuildUp.ToString()));
                    if (stocklist == null || !stocklist.Any())
                    {
                        result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        
                    }
                    var flowlist = _mapper.Map<List<BillInvflow>>(stocklist);
                    foreach (var item in flowlist)
                    {
                        item.Id = IdFactory.NewId();
                        item.InvStateCode = InvState.InvEcecState_Out.ToString();
                        item.AddTime = DateTime.Now;
                        item.Memo = "任务完成";
                    }

                    try
                    {
                        _db.BeginTran();
                        //删除库存及条码信息
                        var wareHouse = _basewarehouserepository.GetSingle(x => x.Id == stocklist.First().WarehouseId);

                        switch (wareHouse.TypeNum)
                        {
                            case FjLocationType.Storage: //立库出库需要删除库存信息
                                _billInvnowrepository.Delete(p => stocklist.Select(p => p.Id).ToList().Contains(p.Id));
                                var hWBarCode = stocklist.Select(p => p.HWBarCode).ToList();
                                _billInvinitrepository.Delete(p => hWBarCode.Contains(p.HWBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                                var contGrpBarCode = stocklist.Select(p => p.ContGrpBarCode).ToList();
                                _billInvinitrepository.Delete(p => contGrpBarCode.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                                _billSpoolTransrepository.Delete(p => stocklist.Select(p => p.HWBarCode).ToList().Contains(p.ConBarCode));
                                _logger.LogInformation($"删除缓存信息{JsonConvert.SerializeObject(stocklist.Select(x => x.HWBarCode).ToList())}");
                                //更新货位信息
                                _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                                {
                                    StateNum = FjLocationState.Empty,
                                    ContGrpBarCode = "",
                                    ContGrpId = 0,
                                    EditTime = DateTime.Now
                                }, p => p.StateNum == FjLocationState.StockOut && p.ContGrpBarCode == task.BarCode && p.Code.Contains(task.AddrFrom) && p.WarehouseCode == task.WarehouseCode);

                                //更新流水信息
                                _billInvflow.InsertRange(flowlist);
                                //添加反馈信息
                                var pushtype = fjFackbeekType.InterfaceType_FJ_StockOut.ToString();
                                var list = new List<BillPushinfo>();
                                foreach (var item in stocklist)
                                {
                                    list.Add(new BillPushinfo
                                    {
                                        DocsNo = item.ExecDocsNo,
                                        TypeCode = pushtype,
                                        RFIDBarCode = item.ContGrpBarCode,
                                        HWBarCode = item.HWBarCode,
                                        CLBarCode = item.CLBarCode,
                                        WarehouseId = wareHouse.Id,
                                        WarehouseCode = wareHouse.Code,
                                        WareCellId = 0,
                                        WareCellCode = task.AddrTo,
                                        MatId = item.MatId,
                                        MatCode = item.MatCode,
                                        MatName = item.MatName,
                                        TolWQty = item.TolWQty,
                                        NetWQty = item.NetWQty,
                                        TareWQty = item.TareWQty,
                                        ReqNo = Guid.NewGuid().ToString()
                                    });
                                }
                                if (stocklist.First().ContGrpType == FJContGrpType.Material)
                                {
                                    _billPushinforepository.InsertRange(list);
                                }
                                _db.CommitTran();
                                break;

                            case FjLocationType.RingLibrary: //环形库的库存信息变更是在SrmPickOutCompleted
                                break;

                            case FjLocationType.Pingku:
                                result.ResMsg = task.Id + "没有平库";
                                break;

                            case FjLocationType.Virtual:
                                _billInvnowrepository.Delete(p => stocklist.Select(p => p.Id).ToList().Contains(p.Id));
                                 hWBarCode = stocklist.Select(p => p.HWBarCode).ToList();
                                _billInvinitrepository.Delete(p => hWBarCode.Contains(p.HWBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                                 contGrpBarCode = stocklist.Select(p => p.ContGrpBarCode).ToList();
                                _billInvinitrepository.Delete(p => contGrpBarCode.Contains(p.ContGrpBarCode) && p.InvStateCode == InvState.InvEcecState_OutGoing.ToString());
                                _billSpoolTransrepository.Delete(p => stocklist.Select(p => p.HWBarCode).ToList().Contains(p.ConBarCode));
                                _logger.LogInformation($"删除缓存信息{JsonConvert.SerializeObject(stocklist.Select(x => x.HWBarCode).ToList())}");
                                if (task.BusType== FJTaskBusType.车间叫料.ToString()&&task.AddrFrom.Contains("NSTJ"))
                                {
                                    //更新货位信息
                                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                                    {
                                        StateNum = FjLocationState.Empty,
                                        ContGrpBarCode = "",
                                        ContGrpId = 0,
                                        EditTime = DateTime.Now
                                    }, p => p.StateNum == FjLocationState.StockOut && p.ContGrpBarCode == task.BarCode && p.Code.Contains(task.AddrFrom) && p.WarehouseCode == "FJXG");
                                }
                                else
                                {
                                    //更新货位信息
                                    _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                                    {
                                        StateNum = FjLocationState.Empty,
                                        ContGrpBarCode = "",
                                        ContGrpId = 0,
                                        EditTime = DateTime.Now
                                    }, p => p.StateNum == FjLocationState.StockOut && p.ContGrpBarCode == task.BarCode && p.Code.Contains(task.AddrFrom) && p.WarehouseCode == task.WarehouseCode);
                                }
                               

                                //更新流水信息
                                _billInvflow.InsertRange(flowlist);
                                //添加反馈信息
                                 pushtype = fjFackbeekType.InterfaceType_FJ_StockOut.ToString();
                                 list = new List<BillPushinfo>();
                                foreach (var item in stocklist)
                                {
                                    list.Add(new BillPushinfo
                                    {
                                        DocsNo = item.ExecDocsNo,
                                        TypeCode = pushtype,
                                        RFIDBarCode = item.ContGrpBarCode,
                                        HWBarCode = item.HWBarCode,
                                        CLBarCode = item.CLBarCode,
                                        WarehouseId = wareHouse.Id,
                                        WarehouseCode = wareHouse.Code,
                                        WareCellId = 0,
                                        WareCellCode = task.AddrTo,
                                        MatId = item.MatId,
                                        MatCode = item.MatCode,
                                        MatName = item.MatName,
                                        TolWQty = item.TolWQty,
                                        NetWQty = item.NetWQty,
                                        TareWQty = item.TareWQty,
                                        ReqNo = Guid.NewGuid().ToString()
                                    });
                                }
                                if (stocklist.First().ContGrpType == FJContGrpType.Material)
                                {
                                    _billPushinforepository.InsertRange(list);
                                }
                                _db.CommitTran();
                                break;

                            default:
                                throw new ArgumentOutOfRangeException();
                        }
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        _logger.LogInformation(ex.ToString());
                        result.ResMsg = task.Id + "完成任务异常";
                    }
                    break;

                case TaskType.TransferDepot:

                    var fromcell = _basewarecellrepository.GetFirst(p => p.Code == task.AddrFrom && task.WarehouseCode == p.WarehouseCode);
                    var grcontid = fromcell.ContGrpId;
                    var grcontcode = fromcell.ContGrpBarCode;
                    var fromcellno = fromcell.Code;
                    var tocellno = task.AddrTo;

                    try
                    {
                        _db.BeginTran();
                        //更新货位信息
                        //起始货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = FjLocationState.Empty,
                            ContGrpBarCode = "",
                            ContGrpId = 0,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(fromcellno) && p.WarehouseCode == task.WarehouseCode);
                        //目标货位
                        _basewarecellrepository.UpdateModelColumns(p => new BaseWarecell()
                        {
                            StateNum = FjLocationState.Full,
                            ContGrpBarCode = grcontcode,
                            ContGrpId = grcontid,
                            EditTime = DateTime.Now
                        }, p => p.Code.Contains(tocellno));

                        //更新库存信息
                        var row = int.Parse(tocellno.Split('-')[0]);
                        var col = int.Parse(tocellno.Split('-')[1]);
                        var 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());

                        //更新流水信息
                        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.Memo = grcontcode + "移库(" + fromcellno + "至" + tocellno + ")";
                        _billInvflow.Insert(flow);
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        result.ResMsg = task.Id + "完成任务异常";
                        _logger.LogInformation("完成任务异常" + ex.ToString());
                    }
                    break;

                case TaskType.Delivery:
                    break;

                case TaskType.EmptyInit:
                    break;

                default:
                    result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.Fail.GetDescription();
                    return result;
            }

            return result;
        }

        public SRes<int> CancelTask(CompleteTaskRequest reqDto)
        {
            var res = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription()
            };

            var task = _wcstaskoldrepository.AsQueryable().With("WITH(READPAST,ROWLOCK)").Where(p => p.Id == reqDto.TaskNum).SplitTable(tabs => tabs.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }

            try
            {
                if (task.Type == TaskType.EnterDepot)
                {
                    //验证组盘状态
                    
                }
                else if (task.Type == TaskType.OutDepot && (task.BusType == "车间叫料" || task.BusType == "芯股站台送空托"))
                {
                    //验证库存信息
                    var stocklist = _billInvnowrepository.GetList(p => (p.ContGrpBarCode == task.BarCode || p.HWBarCode == task.BarCode) && (p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() || p.InvStateCode == InvState.InvEcecState_BuildUp.ToString()));
                    if (stocklist == null || !stocklist.Any())
                    {
                        res.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var wareHouse = _basewarehouserepository.GetSingle(x => x.Id == stocklist.First().WarehouseId);
                    switch (wareHouse.TypeNum)
                    {
                        case FjLocationType.Storage:
                            //验证
                            //var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                            //if (stock == null)
                            //{
                            //    res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                            //    res.ResMsg = "库存信息不存在";//ResponseStatusCodeEnum.StockNotExist.GetDescription();
                            //    return res;
                            //}
                            var cell = _basewarecellrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode && p.WarehouseCode == task.WarehouseCode);
                            if (cell == null)
                            {
                                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                                res.ResMsg = task.BarCode + ResponseStatusCodeEnum.Fail.GetDescription() + "堆垛机已放货完成，不允许取消";
                                return res;
                            }
                            
                            _db.BeginTran();
                            _basewarecellrepository.UpdateSetColumnsTrue(p => new BaseWarecell()
                            {
                                StateNum = FjLocationState.Full,
                                EditTime = DateTime.Now
                            }, p => p.ContGrpBarCode == task.BarCode && p.WarehouseCode == task.WarehouseCode && p.Code.Contains(task.AddrFrom) && p.StateNum == FjLocationState.StockOut);
                            _billInvnowrepository.UpdateSetColumnsTrue(p => new BillInvnow()
                            {
                                InvStateCode = InvState.InvEcecState_In.ToString(),
                                EditTime = DateTime.Now
                            }, p => p.ContGrpBarCode == task.BarCode && p.WarehouseId == cell.WarehouseId);
                            
                            _db.CommitTran();
                            break;

                        case FjLocationType.RingLibrary: //环形库的库存信息变更是在SrmPickOutCompleted
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                    }
                }
                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;
        }

        /// <summary>
        /// 查询任务  通过条码查询任务
        /// </summary>
        /// <param name="barCode">条码</param>
        /// <returns></returns>
        public SRes<WCS_TaskOld> GetTaskInfo(FJGetTaskInfoRequest dto)
        {
            var res = new SRes<WCS_TaskOld>();
            res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            var task = _wcstaskoldrepository.AsQueryable().With(SqlWith.NoLock).Where(x => x.BarCode == dto.BarCode).SplitTable(x => x.Take(2)).OrderByDescending(x => x.AddTime).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "当前条码不存在任务";
                return res;
            }

            res.ResData = task;
            return res;
        }

        /// <summary>
        ///  获取环形库第一深度为空，第二深度有货的货位信息
        /// </summary>
        /// <param name="wareHouseId">仓库信息主键</param>
        /// <param name="depth">第一深度</param>
        /// <param name="size"></param>
        /// <returns></returns>
        public ISugarQueryable<BaseWarecell, BaseWarecell, BillInvnow> RingGetEmptyCell(long wareHouseId, int depth, long size) => GetEmptyCell(wareHouseId, depth, FjLocationType.RingLibrary, size);

        /// <summary>
        ///  获取第一深度为空，第二深度有货的货位信息
        /// </summary>
        /// <param name="wareHouseId">仓库信息主键</param>
        /// <param name="depth">第一深度</param>
        /// <param name="type">仓库类型</param>
        /// <param name="size">大小货位</param>
        /// <returns></returns>
        public ISugarQueryable<BaseWarecell, BaseWarecell, BillInvnow> GetEmptyCell(long wareHouseId, int depth, FjLocationType type, long size)
        {
            var nextDepth = depth + 1;
            return _basewarecellrepository.Context.Queryable<BaseWarecell, BaseWarecell, BillInvnow>((loc1, loc2, inv)
                    => new object[]
                    {
                        JoinType.Inner,loc1.Shelf == loc2.Shelf && loc1.Col == loc2.Col && loc1.Layer == loc2.Layer ,
                        JoinType.Inner, loc2.ContGrpBarCode == inv.ContGrpBarCode||loc2.ContGrpBarCode == inv.HWBarCode,
                    })
                .Where((loc1, loc2, inv) => loc1.WarehouseId == wareHouseId && loc1.TypeNum == type && loc1.Depth == depth && loc1.StateNum == FjLocationState.Empty && loc1.IsStop == 0 && loc1.Size == size)
                .Where((loc1, loc2, inv) => (loc2.StateNum == FjLocationState.Full || loc2.StateNum == FjLocationState.StockIn) && loc2.Depth == nextDepth && loc2.IsStop == 0 && loc2.Size == size)
                .Where((loc1, loc2, inv) => inv.InvStateCode == InvState.InvEcecState_In.ToString() || inv.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
        }

        /// <summary>
        ///  获取环形库第一深度为空，第二深度有货的货位信息
        /// </summary>
        /// <param name="wareHouseId">仓库信息主键</param>
        /// <param name="depth">第一深度</param>
        /// <param name="size"></param>
        /// <returns></returns>
        public ISugarQueryable<BaseWarecell, BaseWarecell, BillInvnow> RingGetFullCell(long wareHouseId, int depth, long size) => GetEmptyCell(wareHouseId, depth, FjLocationType.RingLibrary, size);

        /// <summary>
        ///  获取第一深度为空，第二深度有货的货位信息
        /// </summary>
        /// <param name="wareHouseId">仓库信息主键</param>
        /// <param name="depth">第一深度</param>
        /// <param name="type">仓库类型</param>
        /// <param name="size">大小货位</param>
        /// <returns></returns>
        public ISugarQueryable<BaseWarecell, BaseWarecell, BillInvnow> GetFullCell(long wareHouseId, int depth, FjLocationType type, long size)
        {
            var nextDepth = depth + 1;
            return _basewarecellrepository.Context.Queryable<BaseWarecell, BaseWarecell, BillInvnow>((loc1, loc2, inv)
                    => new object[]
                    {
                        JoinType.Inner,loc1.Shelf == loc2.Shelf && loc1.Col == loc2.Col && loc1.Layer == loc2.Layer ,
                        JoinType.Inner, loc2.ContGrpBarCode == inv.ContGrpBarCode||loc2.ContGrpBarCode == inv.HWBarCode,
                    })
                .Where((loc1, loc2, inv) => loc1.WarehouseId == wareHouseId && loc1.TypeNum == type && loc1.Depth == depth && loc1.StateNum == FjLocationState.Empty && loc1.IsStop == 0 && loc1.Size == size)
                .Where((loc1, loc2, inv) => (loc2.StateNum == FjLocationState.Full || loc2.StateNum == FjLocationState.StockIn) && loc2.Depth == nextDepth && loc2.IsStop == 0 && loc2.Size == size)
                .Where((loc1, loc2, inv) => inv.InvStateCode == InvState.InvEcecState_In.ToString() || inv.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
        }

        /// <summary>
        ///  获取前置深位为空的货位信息
        /// </summary>
        /// <param name="emptyLoc">可用深位集合</param>
        /// <param name="depth">前置深位</param>
        /// <returns></returns>
        public IEnumerable<string> GetEmptyCell(List<BaseWarecell> emptyLoc, int depth)
        {
            var nextDepth = depth + 1;
            return _basewarecellrepository.GetList(p => p.TypeNum == FjLocationType.RingLibrary && p.Depth == depth)
                   .Join(emptyLoc.Where(p => p.Depth == nextDepth), loc1 => new { loc1.Col, loc1.Layer, loc1.Shelf }, loc2 => new { loc2.Col, loc2.Layer, loc2.Shelf }, (loc1, loc2) => loc2)
                   .ToList().Select(x => x.Code);
        }

        /// <summary>
        ///  执行并发锁
        ///  指定redis
        /// </summary>
        /// <param name="lockKey">并发锁key</param>
        /// <exception cref="Exception"></exception>
        public static SRes RedisExists(string lockKey, Action act)
        {
            lock (lockInOrOut)
            {
                lockKey = "ConcurrentLock:" + lockKey;
                var res = new SRes()
                {
                    ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                    ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                };
                try
                {
                    if (RedisHelper.Exists(lockKey)) throw new Exception($"调用冲突:{lockKey}");
                    RedisHelper.Expire(lockKey, 60);
                    act();
                }
                catch (Exception ex)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = $"{ex.Message}";
                }
                finally
                {
                    RedisHelper.Del(lockKey);
                }

                return res;
            }
        }
    }

    public static class TaslEx
    {
        public static void UpdataErrorinfo(this BaseErrorInfo error, RepositoryTask<BaseErrorInfo> db)
        {
            var errorinfoWcs =db.AsQueryable().With(SqlWith.NoLock).Where(v => v.BusName == error.BusName && v.Message == error.Message).First();
            if (errorinfoWcs != null)
            {
                errorinfoWcs.Count += 1;
                db.Context.Updateable(errorinfoWcs).ExecuteCommand();
            }
            else
            {
                db.Context.Insertable(error).ExecuteCommand();
            }
        }
    }

  

    /// <summary>
    ///  主线分流
    /// </summary>
    public class MainlineDiversion
    {
        /// <summary>
        ///  任务号
        /// </summary>
        public int TaskId { get; set; }

        /// <summary>
        ///  仓库号
        /// </summary>
        public string WarehouseCode { get; set; }
    }

    /// <summary>
    ///  申请空托盘组出库请求体
    /// </summary>
    public class FjApplyEmptyPalletGroupOutStorageRequest : BaseRequest
    {
        /// <summary>
        ///  托盘类型
        /// </summary>
        public FJPalletType FJPalletType { get; set; }

        /// <summary>
        ///  巷道
        /// </summary>
        public int Tunnel { get; set; }

        /// <summary>
        ///  目标位置
        /// </summary>
        public string AddTo { get; set; }
    }

    /// <summary>
    ///  创建WCS出库任务
    /// </summary>
    public class FJCreateStockOutWcsTaskRequest
    {
        /// <summary>
        /// 容器条码
        /// </summary>
        public string ContGrpBarCode { get; set; }

        /// <summary>
        /// 主盘主表ID
        /// </summary>
        public long ContGrpId { get; set; }

        /// <summary>
        /// 仓库编码
        /// </summary>
        public string WarehouseCode { get; set; }

        public decimal Qty { get; set; }

        /// <summary>
        /// 设备编号
        /// </summary>
        public string EquCode { get; set; }

        /// <summary>
        /// 业务类型
        /// </summary>
        public FJTaskBusType BusType { get; set; }

        public int Floor { get; set; }
        public string Tunnel { get; set; }
        public string CellNo { get; set; }

        public short ProdLine { get; set; }

        public string WorkBench { get; set; }

        public int GoodsType { get; set; }

        public string Device { get; set; }

        /// <summary>
        ///  物料号
        /// </summary>
        public string MatCode { get; set; }

        /// <summary>
        ///  码垛托盘类型
        /// </summary>
        public short PalletType { get; set; }

        /// <summary>
        /// 满盘数量
        /// </summary>
        public short FullQty { get; set; }

        public string LastInteractionPoint { get; set; }

        /// <summary>
        /// MES任务号
        /// </summary>
        [SugarColumn(ColumnDescription = "MES任务号")]
        public string MesNo { get; set; }

        /// <summary>
        /// 空盘库
        /// </summary>
        [SugarColumn(ColumnDescription = "空盘库")]
        public string EmptyInventory { get; set; }
    }

    public class FJBingPalletDto : BaseRequest
    {
        /// <summary>
        ///  仓库号
        /// </summary>
        public string WarehouseCode { get; set; }

        /// <summary>
        ///  托盘条码
        /// </summary>
        public string PalletCode { get; set; }

        /// <summary>
        ///  工字轮任务号集合
        /// </summary>
        public List<string> TaskCode { get; set; }

        /// <summary>
        ///  业务类型
        /// </summary>
        public FJTaskBusType BusType { get; set; }

        /// <summary>
        ///  任务申请设备
        /// </summary>
        public string loc { get; set; }

        /// <summary>
        ///  是否异常
        /// </summary>
        public bool IsFail { get; set; }

        /// <summary>
        ///  异常原因
        /// </summary>
        public string FailReason { get; set; }

        /// <summary>
        ///  是否结束
        /// </summary>
        public bool IsFinish { get; set; }

        /// <summary>
        ///  是否为半跺入库
        /// </summary>
        public bool IsItHalf { get; set; }
    }

    public class FJGetTwoPalletDto : BaseRequest
    {
        /// <summary>
        ///  仓库号
        /// </summary>
        public string WarehouseCode { get; set; }

        /// <summary>
        ///  仓库号
        /// </summary>
        public int TaskId { get; set; }
    }

    public class CellInfo
    {
        public long Id { get; set; }
        public string ContGrpBarCode { get; set; }
        public long WarehouseId { get; set; }
        public string WarehouseCode { get; set; }
        public string Code { get; set; }
        public int Row { get; set; }
        public int Col { get; set; }
        public int Layer { get; set; }
        public int Depth { get; set; }
        public string MatCode { get; set; }
        public int SideNum { get; set; }

        public string CLBarCode { get; set; }

        public int XYNo { get; set; }

        public DateTime EditTime { get; set; }

        /// <summary>
        ///  Bom单号 关联投料单 帘线工序工单号 BillCode
        /// </summary>
        public string BomDocsNo { get; set; }
    }

    public class FjGetSetGrpListRequest
    {
        /// <summary>
        ///  帘线产出物料编码
        /// </summary>
        public string OutMaterialCode { get; set; }

        /// <summary>
        /// 投入物料
        /// </summary>
        public List<string> ListmatInfo { get; set; }
    }
}

#endregion 同WCS交互部分