using AutoMapper;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using wms.dto;
using wms.dto.response;
using wms.dto.response.pt;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model;
using wms.sqlsugar.model.pt;
using wms.util.Check;
using wms.util.Ext;
using System.Linq;
using Newtonsoft.Json;
using Microsoft.Extensions.Logging;
using wms.util;
using wms.dto.request.pt;
using wms.dataservice.IDataSetvice;
using wms.dto.request.pt.dto;
using wms.dto.response.pt.dto;
using wms.util.Http;
using wms.dto.request;
using wms.dto.request.share;
using Org.BouncyCastle.Asn1.Ocsp;
using Org.BouncyCastle.Ocsp;
using wms.dto.request.hj.dto;
using wms.dto.request.hj;
using NPOI.SS.Formula.Functions;
using System.Threading.Tasks;
using TaskStatus = wms.dto.TaskStatus;
using static NPOI.HSSF.Util.HSSFColor;

namespace wms.service.Service
{
    public class PTService : IPTService
    {
        private readonly IMapper _mapper;
        private readonly ILogger<PTService> _logger;
        private readonly IPTDataService _iptDataService;

        private static readonly List<TunnelSrmTemp> TunnelSrmRel = new List<TunnelSrmTemp>() {
          new TunnelSrmTemp(){ Tunnel = "1",Srm = "Srm1" },
          new TunnelSrmTemp(){ Tunnel = "2",Srm = "Srm1" },
          new TunnelSrmTemp(){ Tunnel = "3",Srm = "Srm2" },
          new TunnelSrmTemp(){ Tunnel = "4",Srm = "Srm2" },
          new TunnelSrmTemp(){ Tunnel = "5",Srm = "Srm3" },
          new TunnelSrmTemp(){ Tunnel = "6",Srm = "Srm3" },
          new TunnelSrmTemp(){ Tunnel = "7",Srm = "Srm4" },
          new TunnelSrmTemp(){ Tunnel = "8",Srm = "Srm4" },
        };

        public PTService(IMapper mapper, ILogger<PTService> logger, IPTDataService iptDataService)
        {
            _mapper = mapper;
            _logger = logger;
            _iptDataService = iptDataService;
        }

        private Repository<ptBaseContainer> _ptbaseContInfo => new Repository<ptBaseContainer>();
        private Repository<ptSysConfig> _sysconfigrepository => new Repository<ptSysConfig>();
        private Repository<ptBaseMater> _materrepository => new Repository<ptBaseMater>();
        private RepositoryTask<ptWCS_TaskInfo> _ptwcsTaskinfo => new RepositoryTask<ptWCS_TaskInfo>();
        private Repository<ptBaseWarehouse> _baseWareHouserepository => new Repository<ptBaseWarehouse>();
        private Repository<ptBaseWareLocation> _baseWareLocationrepository => new Repository<ptBaseWareLocation>();
        private Repository<ptBillDocsinfo> _docrepository => new Repository<ptBillDocsinfo>();
        private Repository<ptBillPushinfo> _ptbillPushinfo => new Repository<ptBillPushinfo>();
        private RepositoryTask<ptWCS_TaskOld> _ptwcsTaskold => new RepositoryTask<ptWCS_TaskOld>();
        private Repository<ptSysJob> _sysJobrepository => new Repository<ptSysJob>();
        private Repository<ptSysJobApiRelation> _sysJobApirepository => new Repository<ptSysJobApiRelation>();
        private Repository<ptBillInvFlow> _ptBillInvFlow => new Repository<ptBillInvFlow>();
        private Repository<ptBillInvnow> _ptbillInvnow => new Repository<ptBillInvnow>();
        private Repository<ptBillInvinit> _ptbillInvinit => new Repository<ptBillInvinit>();
        private RepositoryTask<ptWCS_TaskDtl> _ptwcsTaskdtl => new RepositoryTask<ptWCS_TaskDtl>();
        private Repository<ptBillMesmiddle> _ptbillmes => new Repository<ptBillMesmiddle>();
        private RepositoryTask<Bill_InvflowHty> _flowhtyrepository => new RepositoryTask<Bill_InvflowHty>();
        private RepositoryTask<BillPushinfoHty> _pushhtyrepository => new RepositoryTask<BillPushinfoHty>();

        //Repository<ptBillPboxrule> _ptBillLocationMap => new Repository<ptBillPboxrule>();
        private ITenant _db => SqlSugarHelper.Db;//处理事务

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

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

        /// <summary>
        /// 获取物料信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public ptBaseMater GetBaseMaterByExpression(Expression<Func<ptBaseMater, bool>> WhereExpression)
        {
            return _materrepository.GetSingle(WhereExpression);
        }

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

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

        /// <summary>
        /// 获取反馈信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<ptBillPushinfo> GetBillFeedbackList(string type)
        {
            return _ptbillPushinfo.GetList(p => p.PostResult != 1 && p.PostQty <= 5 && (p.TypeCode == type)).OrderBy(p => p.AddTime).Take(10).ToList();
        }

        public List<ptBillPushinfo> GetProductionFeedBack()
        {
            return _ptbillPushinfo.GetList(p => p.PostResult != 1 && p.PostQty <= 5 && (p.TypeCode == PtFackbeekType.PickMat.ToString() || p.TypeCode == PtFackbeekType.ReturnMat.ToString() || p.TypeCode == "Manual")).OrderBy(p => p.AddTime).Take(10).ToList();
        }

        public bool UpdatePuchinfoModelColumns(UpdateModelColumns<ptBillPushinfo> updateModel)
        {
            return _ptbillPushinfo.Update(updateModel.Columns, updateModel.WhereExpression);
        }

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

        public bool SyncMaterInfo(List<PTSyncMaterInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_materrepository.IsAny(p => p.Code == item.MatCode))
                {
                    _materrepository.UpdateModelColumns(p => new ptBaseMater() { IsHold = item.IsHold, HoldDuration = item.HoldDuration },
                       p => p.Code == item.MatCode);
                }
                else
                {
                    var model = _mapper.Map<ptBaseMater>(item);
                    _materrepository.Insert(model);
                }
            }
            return true;
        }

        public SRes PurchaseBillTrans(PurchaseBillTransReqest request)
        {
            var result = new SRes();
            if (string.IsNullOrEmpty(request.BillCode))
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                result.ResMsg = "单号" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return result;
            }
            if (!request.ListInfo.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return result;
            }

            var warehouse = _baseWareHouserepository.GetSingle(p => p.Code == request.WareCode);
            if (warehouse == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }
            //存单据
            var doc = _docrepository.GetSingle(p => p.DocsNo == request.BillCode);
            if (doc == null)
            {
                var docsinfo = new ptBillDocsinfo()
                {
                    DocsNo = request.BillCode,
                    WarehouseId = warehouse.Id,
                    ReqNo = request.ReqId,
                    Type = request.BillType,
                    StateNum = DocState.DocState_Create.GetHashCode(),
                    IsStop = 0,
                    JsonContent = JsonConvert.SerializeObject(request.ListInfo),
                    DownQty = request.ListInfo.Count,
                    AddWho = "wms",
                    EditWho = "wms"
                };
                _docrepository.Insert(docsinfo);
            }
            else
            {
                //_docrepository.UpdateModelColumns(p => new ptBillDocsinfo()
                //{
                //    JsonContent = JsonConvert.SerializeObject(request.ListInfo),
                //    EditTime = DateTime.Now
                //}, p => p.DocsNo == request.BillCode);
            }
            result = InsertBillInvinit(request, warehouse);

            return result;
        }

        public SRes InsertBillInvinitCheck(PurchaseBillTransReqestCheck request)
        {
            var result = new SRes();

            if (!request.ListInfo.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return result;
            }
            //明细存条码表
            foreach (var item in request.ListInfo)
            {
                if (_ptbillInvnow.IsAny(p => p.ContGrpBarCode == item.RFID))
                {
                    var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == item.RFID);
                    var init = _ptbillInvinit.GetSingle(p => p.ContGrpBarCode == item.RFID);
                    if (init != null)
                    {
                        if (stock.CLBarCode != init.CLBarCode || stock.CLBarCode != item.MatBarCode || init.CLBarCode != item.MatBarCode)
                        {
                            result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认,分别绑定了{1}和{2}", item.RFID, init.CLBarCode, item.MatBarCode);
                            return result;
                        }
                    }

                    result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                    result.ResMsg = string.Format("{0}已经有绑定信息,请确认,盘条条码是{1}", item.RFID, item.MatBarCode);
                    return result;
                }
                if (_ptbillInvnow.IsAny(p => p.CLBarCode == item.MatBarCode))
                {
                    result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                    result.ResMsg = string.Format("{0}已经有绑定信息,请确认,绑定的RFID是{1}", item.MatBarCode, item.RFID);
                    return result;
                }
                if (!_ptbillInvinit.IsAny(p => p.CLBarCode == item.MatBarCode))
                {
                }
                else
                {
                    var init = _ptbillInvinit.GetSingle(p => p.CLBarCode == item.MatBarCode);
                    if (init.ContGrpBarCode != item.RFID)
                    {
                        result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID);
                        return result;
                    }
                    if (_ptbillInvnow.IsAny(p => p.CLBarCode == item.MatBarCode))
                    {
                        var sto = _ptbillInvnow.GetSingle(p => p.CLBarCode == item.MatBarCode);
                        if (sto.ContGrpBarCode != init.ContGrpBarCode || sto.ContGrpBarCode != item.RFID || init.ContGrpBarCode != item.RFID)
                        {
                            result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID);
                            return result;
                        }
                    }
                }

                var taskvi = _ptwcsTaskold.AsQueryable().Where(p => p.BarCode == item.RFID && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                if (taskvi != null)
                {
                    result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    result.ResMsg = string.Format("{0}已经存在未完成任务，不允许绑定", item.RFID);
                    return result;
                }
            }

            return result;
        }

        public SRes PurchaseRFIDCheck(PurchaseRFIDCheckReqest request)
        {
            var result = new SRes();

            if (_ptbillInvnow.IsAny(p => p.ContGrpBarCode == request.RFID))
            {
                var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == request.RFID);
                var init = _ptbillInvinit.GetSingle(p => p.ContGrpBarCode == request.RFID);
                if (init != null)
                {
                    if (stock.CLBarCode != init.CLBarCode)
                    {
                        result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认,分别绑定了{1}和{2}", request.RFID, init.CLBarCode, stock.CLBarCode);
                        return result;
                    }
                }

                result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                result.ResMsg = string.Format("{0}已经有绑定信息,请确认,盘条条码是{1}", request.RFID, stock.CLBarCode);
                return result;
            }

            var taskvi = _ptwcsTaskold.AsQueryable().Where(p => p.BarCode == request.RFID && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (taskvi != null)
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                result.ResMsg = string.Format("{0}已经存在未完成任务，不允许绑定", request.RFID);
                return result;
            }
            return result;
        }

        private SRes InsertBillInvinit(PurchaseBillTransReqest request, ptBaseWarehouse warehouse)
        {
            var result = new SRes();
            List<ptBillInvinit> invlist = new List<ptBillInvinit>();
            //明细存条码表
            foreach (var item in request.ListInfo)
            {
                var mater = _materrepository.GetSingle(p => p.Code == item.MatCode);
                if (mater == null)
                {
                    //result.ResCode = ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetHashCode();
                    //result.ResMsg = item.MatCode + ResponseStatusCodeEnum.BaseMaterCodeNotExist.GetDescription();
                    //return result;
                    _materrepository.Insert(new ptBaseMater()
                    {
                        Id = IdFactory.NewId(),
                        WarehouseId = warehouse.Id,
                        Code = item.MatCode,
                        Name = item.MatCode,
                        ShortDesc = item.MatCode,
                        MatGrpId = 0,
                        Leafcode = "",
                        LeafName = "",
                        MidCode = item.Brand,
                        MidName = "",
                        Description = item.Describe,
                        SpoolType = "",
                        SpoolCode = "",
                        PackGrpId = "0",
                        Qty = 0,
                        IsHold = false,
                        HoldDuration = 0,
                        Memo = "根据采购盘条同步",
                        AddTime = DateTime.Now,
                        EditTime = DateTime.Now,
                        AddWho = "wms",
                        EditWho = "wms"
                    });
                }

                if (_ptbillInvnow.IsAny(p => p.ContGrpBarCode == item.RFID))
                {
                    var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == item.RFID);
                    var init = _ptbillInvinit.GetSingle(p => p.ContGrpBarCode == item.RFID);
                    if (stock.CLBarCode != init.CLBarCode || stock.CLBarCode != item.MatBarCode || init.CLBarCode != item.MatBarCode)
                    {
                        result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID);
                        _logger.LogInformation(string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID));
                        return result;
                    }

                    if (stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString() && !_ptwcsTaskold.AsQueryable().Where(p => p.BarCode == stock.ContGrpBarCode && p.Status < TaskStatus.Finish).SplitTable(tas => tas.Take(2)).Any())
                    {
                        _ptbillInvnow.Delete(p => p.Id == stock.Id);
                        _ptbillInvinit.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    }
                    else
                    {
                        //result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                        //result.ResMsg = string.Format("{0}已经有组盘信息，不用重复提交,盘条条码是{1}", item.RFID, item.MatBarCode);
                        //_logger.LogInformation(string.Format("{0}已经有组盘信息，不允许修改,盘条条码是{1}", item.RFID, item.MatBarCode));
                        //return result;
                    }
                }
                if (!_ptbillInvinit.IsAny(p => p.CLBarCode == item.MatBarCode))
                {
                    var invinit = new ptBillInvinit()
                    {
                        WarehouseId = warehouse.Id,
                        ContGrpBarCode = item.RFID,
                        ContGrpId = GetId(),
                        BoxBarCode = item.RFID,
                        BoilerNo = item.BoilerNo,
                        PackNo = item.PackNo,
                        BatchNo = item.Batch,
                        RodBarCode = item.RodBar,
                        CLBarCode = item.MatBarCode,
                        CaQty = item.Carbon,
                        ProductTime = item.ProductDate,
                        BrandNo = item.Brand,
                        ExecStd = item.ExecStandard,
                        LicenceCode = item.Licence,
                        TolWQty = item.Weight,
                        HoldDuration = item.HoldDuration,
                        Describe = item.Describe,
                        InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                        InvBarCode = item.MatBarCode,
                        ExecStateCode = InvLockState.InvState_Lock.ToString(),
                        InDocsNo = request.BillCode,
                        InDocsRowNo = request.BillCode,
                        MatId = mater.Id,
                        MatCode = item.MatCode,
                        RFIDBarCode = item.RFID,
                        HWTypeCode = "",
                        ExecDocsNo = request.BillCode,
                        ExecDocsRowNo = request.BillCode,
                        ExecDocsTypeCode = request.BillType,
                        HWBarCode = item.RFID,
                        InvInOut = 1,
                        ExecWho = "",
                        MatName = mater.Name,
                        Size = 1,
                        SuppCode = request.SupCode,
                        SuppName = request.SupName
                    };
                    invlist.Add(_mapper.Map<ptBillInvinit>(invinit));
                }
                else
                {
                    var init = _ptbillInvinit.GetSingle(p => p.CLBarCode == item.MatBarCode);
                    if (init.ContGrpBarCode != item.RFID)
                    {
                        result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID);
                        _logger.LogInformation(string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID));
                        return result;
                    }
                    if (_ptbillInvnow.IsAny(p => p.CLBarCode == item.MatBarCode))
                    {
                        var sto = _ptbillInvnow.GetSingle(p => p.CLBarCode == item.MatBarCode);
                        if (sto.ContGrpBarCode != init.ContGrpBarCode || sto.ContGrpBarCode != item.RFID || init.ContGrpBarCode != item.RFID)
                        {
                            result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                            result.ResMsg = string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID);
                            _logger.LogInformation(string.Format("{0}绑定的标牌，条码管理与库存管理中不一致，请确认", item.RFID));
                            return result;
                        }
                    }
                    _ptbillInvinit.UpdateModelColumns(p => new ptBillInvinit() { RFIDBarCode = item.RFID, ContGrpBarCode = item.RFID, BoxBarCode = item.RFID, HWBarCode = item.RFID, EditTime = DateTime.Now }, p => p.CLBarCode == item.MatBarCode);
                }
            }
            if (invlist.Any())
            {
                _ptbillInvinit.InsertRange(invlist);
            }

            return result;
        }

        public SRes PurchaseBillTransFeedBack(PurchaseBillTransFeedBackRequest reqDto)
        {
            var result = new SRes();

            return result;
        }

        /// <summary>
        /// 放行单传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public ErpUnlockStockResponse ErpUnlockStock(ErpUnlockStockRequest reqDto)
        {
            var result = new ErpUnlockStockResponse() { ListInfo = new List<ErpUnlockStockResponseItem>() };
            if (!reqDto.ListInfo.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                result.ResMsg = reqDto.BillCode + ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return result;
            }
            var inv = _ptbillInvnow.GetList(p => p.ExecStateCode == InvLockState.InvState_Lock.ToString() && p.InvStateCode == InvState.InvEcecState_In.ToString());
            if (!inv.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = reqDto.BillCode + "不存在库存明细或者已经放行";
                return result;
            }
            foreach (var item in reqDto.ListInfo)
            {
                if (inv.Where(p => p.ContGrpBarCode == item.RFID && p.CLBarCode == item.MatBarCode).Any())
                {
                    var stock = inv.Where(p => p.ContGrpBarCode == item.RFID && p.CLBarCode == item.MatBarCode).First();
                    var flow = _mapper.Map<ptBillInvFlow>(stock);
                    flow.Id = GetId();
                    flow.ExecStateCode = item.State == "Normal" ? InvLockState.InvState_Normal.ToString() : InvLockState.InvState_Lock.ToString();
                    flow.EditTime = DateTime.Now;
                    flow.AddTime = DateTime.Now;
                    flow.Memo = "ERP放行" + item.State;
                    try
                    {
                        _db.BeginTran();
                        _ptbillInvnow.UpdateSetColumnsTrue(p => new ptBillInvnow()
                        {
                            ExecStateCode = item.State == "Normal" ? InvLockState.InvState_Normal.ToString() : InvLockState.InvState_Lock.ToString(),
                            EditTime = DateTime.Now
                        }, p => p.ContGrpBarCode == item.RFID && p.CLBarCode == item.MatBarCode);
                        _ptBillInvFlow.Insert(flow);
                        _db.CommitTran();
                        var erpUnlockStock = new ErpUnlockStockResponseItem()
                        {
                            RFID = item.RFID,
                            MatBarCode = item.MatBarCode,
                            ResState = "S",
                            ResDesc = ""
                        };
                        result.ListInfo.Add(_mapper.Map<ErpUnlockStockResponseItem>(erpUnlockStock));
                    }
                    catch (Exception ex)
                    {
                        _db.RollbackTran();
                        var erpUnlockStock = new ErpUnlockStockResponseItem()
                        {
                            RFID = item.RFID,
                            MatBarCode = item.MatBarCode,
                            ResState = "E",
                            ResDesc = "放行失败"
                        };
                        result.ListInfo.Add(_mapper.Map<ErpUnlockStockResponseItem>(erpUnlockStock));
                    }
                }
                else
                {
                    var unlockStock = new ErpUnlockStockResponseItem()
                    {
                        RFID = item.RFID,
                        MatBarCode = item.MatBarCode,
                        ResState = "E",
                        ResDesc = "未找到该RFID条码"
                    };
                    result.ListInfo.Add(_mapper.Map<ErpUnlockStockResponseItem>(unlockStock));
                    continue;
                }
            }
            return result;
        }

        /// <summary>
        /// 车间自动叫料出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes WcsProductionOutRequest(WcsProductionOutRequest request)
        {
            var result = new SRes();
            //var sys = _sysconfigrepository.GetSingle(p => p.Code == "" && p.Default1 == "ProductPinKu"); 预留光电
            //if (sys != null)
            //{
            //    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
            //    {
            //        Default3 = ""
            //    }, p => p.Code == sys.Code);
            //}
            var mesRequest = _ptbillmes.GetList(p => p.State != DocState.DocState_Complete.GetHashCode() && p.State != DocState.DocState_Stop.GetHashCode());
            if (!mesRequest.Any())
            {
                //result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //result.ResMsg = "没有进行中的叫料单据，请重新推送单据";
                RedisHelper.Set("Pt:WMSErrorInfo:1", new RedisErrorInfo() { Equip = "1", Con = "没有进行中的叫料单据，无法出库领料", Time = DateTime.Now });
                return result;
            }
            //判断是否有可用点位
            if (!_sysconfigrepository.IsAny(p => p.Default1 == Const.ProductType && p.SContent == "1"))
            {
                result.ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode();
                result.ResMsg = "领料区没有可用的空余点位，无法出库";
                RedisHelper.Set("Pt:WMSErrorInfo:2", new RedisErrorInfo() { Equip = "2", Con = "领料区没有可用的空余点位，无法出库", Time = DateTime.Now });
                return result;
            }
            foreach (var item in mesRequest)
            {
                var doc = RedisHelper.Get("Pt:DocNo" + item.BillCode);
                if (!string.IsNullOrEmpty(doc))
                {
                    ProductionStockOut(new ProductionStockOutRequest()
                    {
                        BillCode = item.BillCode,
                        WareCode = item.WareCode,
                        PackNo = item.PackNo,
                        BoilerNo = doc.Split('|')[1],
                        MatCode = new List<string>() { doc.Split('|')[0] },
                        MatBarCode = item.MatBarCode
                    });
                }
                else
                {
                    if (string.IsNullOrEmpty(item.MatCode))
                    {
                        _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
                        {
                            State = DocState.DocState_Complete.GetHashCode(),
                            EditTime = DateTime.Now
                        }, p => p.BillCode == item.BillCode);
                        _docrepository.UpdateSetColumnsTrue(p => new ptBillDocsinfo()
                        {
                            StateNum = DocState.DocState_Complete.GetHashCode(),
                            EditTime = DateTime.Now
                        }, p => p.DocsNo == item.BillCode);
                        continue;
                    }
                    List<string> list = new List<string>();
                    foreach (var item1 in item.MatCode.Split(','))
                    {
                        list.Add(item1);
                    }
                    ProductionStockOut(new ProductionStockOutRequest()
                    {
                        BillCode = item.BillCode,
                        WareCode = item.WareCode,
                        PackNo = item.PackNo,
                        BoilerNo = item.BoilerNo,
                        MatCode = list,
                        MatBarCode = item.MatBarCode
                    });
                }
            }
            return result;
        }

        /// <summary>
        /// 车间自动叫料出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes WcsProductionOutRequest2(WcsProductionOutRequest request)
        {
            var result = new SRes();
            //判断是否有可用点位
            if (!_sysconfigrepository.IsAny(p => p.Default1 == Const.ProductType && p.SContent == "1"))
            {
                result.ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode();
                result.ResMsg = "领料区没有可用的空余点位，无法出库";
                RedisHelper.Set("Pt:WMSErrorInfo:2", new RedisErrorInfo() { Equip = "2", Con = "领料区没有可用的空余点位，无法出库", Time = DateTime.Now });
                return result;
            }
            var list = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && p.SContent == "1" && !string.IsNullOrEmpty(p.Default5) && !string.IsNullOrEmpty(p.Default2));
            foreach (var item in list)
            {
                ApplyProductionStockOutNew(new ProductionStockOutRequest()
                {
                    BoilerNo = item.Default5,
                    WareCode = "pthouse",
                    MatCode = item.Default2.Split(',').ToList()
                });
            }
            return result;
        }

        /// <summary>
        /// 生产领料出库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes ProductionStockOut(ProductionStockOutRequest reqDto)
        {
            var result = new SRes();
            var ware = _baseWareHouserepository.GetSingle(p => p.Code == reqDto.WareCode);
            if (ware == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = reqDto.WareCode + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                RedisHelper.Set("Pt:WMSErrorInfo:3", new RedisErrorInfo() { Equip = "3", Con = reqDto.WareCode + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription(), Time = DateTime.Now });
                return result;
            }
            if (string.IsNullOrEmpty(reqDto.BillCode) || !reqDto.MatCode.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                result.ResMsg = "单号与物料编码不可为空";
                RedisHelper.Set("Pt:WMSErrorInfo:4", new RedisErrorInfo() { Equip = "4", Con = "单号与物料编码不可为空", Time = DateTime.Now });
                return result;
            }
            var mes = _ptbillmes.GetSingle(p => p.BillCode == reqDto.BillCode);
            if (mes == null)
            {
                List<string> list = new List<string>();
                foreach (var mat in reqDto.MatCode)
                {
                    list.Add(mat);
                }
                var mesRequest = new ptBillMesmiddle()
                {
                    BillCode = reqDto.BillCode,
                    PackNo = reqDto.PackNo,
                    MatCode = string.Join(",", list),
                    MatBarCode = reqDto.MatBarCode,
                    BoilerNo = reqDto.BoilerNo,
                    WareCode = reqDto.WareCode,
                    State = DocState.DocState_Create.GetHashCode()
                };
                _ptbillmes.Insert(mesRequest);
            }
            //添加单据
            var doc = _docrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
            if (doc == null)
            {
                var docsinfo = new ptBillDocsinfo()
                {
                    DocsNo = reqDto.BillCode,
                    WarehouseId = ware.Id,
                    ReqNo = GetId().ToString(),
                    Type = PtDocType.DocType_PT_ProductionStockOut.ToString(),
                    StateNum = DocState.DocState_Create.GetHashCode(),
                    IsStop = 0,
                    JsonContent = JsonConvert.SerializeObject(reqDto),
                    AddWho = "wms",
                    EditWho = "wms"
                };
                _docrepository.Insert(docsinfo);
            }

            var sys = GetPinkuMater();
            reqDto.MatCode = sys.Distinct().Intersect(reqDto.MatCode).ToList();

            //申请出库
            result = ApplyProductionStockOut(reqDto);
            return result;
        }

        /// <summary>
        /// 申请出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private SRes ApplyProductionStockOut(ProductionStockOutRequest request)
        {
            var res = new SRes();
            //考虑巷道剩余空轮数量
            var locationlist = from loc in _baseWareLocationrepository.GetList(p => p.IsStop == 0 && p.StateNum == LocationState.LocationState_Full.GetHashCode())
                               join stock in _ptbillInvnow.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString())
                               on loc.ContGrpBarCode equals stock.ContGrpBarCode
                               orderby stock.ProductTime
                               select new
                               {
                                   stock.MatCode,
                                   stock.InvBarCode,
                                   stock.BoilerNo,
                                   stock.RodBarCode,
                                   stock.Grade,
                                   stock.PackNo,
                                   stock.InvStateCode,
                                   stock.ProductTime,
                                   loc.Col,
                                   loc.Layer,
                                   loc.Shelf,
                                   loc.Depth,
                                   loc.Code,
                                   loc.Tunnel,
                                   loc.WarehouseCode,
                                   loc.ContGrpBarCode,
                                   loc.Id,
                                   loc.StateNum,
                               };
            if (!string.IsNullOrEmpty(request.BoilerNo))
            {
                locationlist = locationlist.Where(p => p.BoilerNo == request.BoilerNo);
            }
            if (locationlist == null || !locationlist.Any())
            {
                //该炉号没有料之后调用mes回调通知接口
                _sysconfigrepository.UpdateModelColumns(p => new ptSysConfig() { Default6 = "0" }, p => p.Default5 == request.BoilerNo);
            }
            if (request.MatCode.Any())
            {
                locationlist = locationlist.Where(p => request.MatCode.Contains(p.MatCode));
            }
            if (!string.IsNullOrEmpty(request.MatBarCode))
            {
                locationlist = locationlist.Where(p => p.InvBarCode == request.MatBarCode);
            }
            if (!string.IsNullOrEmpty(request.PackNo))
            {
                locationlist = locationlist.Where(p => p.PackNo == request.PackNo);
            }

            //过滤已禁用的巷道
            var tunlist = _sysconfigrepository.GetList(p => !string.IsNullOrEmpty(p.SContent) && p.SType == "OutStop");
            if (tunlist.Any())
            {
                var tun = tunlist.Select(p => p.Default1).ToList();
                locationlist = locationlist.Where(p => !tun.Contains(p.Tunnel.ToString()));
            }

            if (locationlist == null || !locationlist.Any())
            {
                var pp = RedisHelper.Get("Pt:DocNo" + request.BillCode);
                if (string.IsNullOrEmpty(pp))
                {
                    _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
                    {
                        State = DocState.DocState_Complete.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.BillCode == request.BillCode);
                    _docrepository.UpdateSetColumnsTrue(p => new ptBillDocsinfo()
                    {
                        StateNum = DocState.DocState_Complete.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.DocsNo == request.BillCode);
                    _logger.LogInformation("库存不足，单号：" + request.BillCode + "物料编码：" + request.MatCode);
                    var msg = RedisHelper.Get("Pt:WMSErrorInfo:5");
                    if (!string.IsNullOrEmpty(msg))
                    {
                        var msgdto = JsonConvert.DeserializeObject<BusinessDto2>(msg);
                        if (!msg.Contains(request.BillCode))
                        {
                            RedisHelper.Set("Pt:WMSErrorInfo:5", new RedisErrorInfo() { Equip = "5", Con = msgdto.Con + "；单号：" + request.BillCode + "，物料编码：" + string.Join(',', request.MatCode), Time = DateTime.Now });
                        }
                        else
                        {
                            RedisHelper.Set("Pt:WMSErrorInfo:5", new RedisErrorInfo() { Equip = "5", Con = msgdto.Con, Time = DateTime.Now });
                        }
                    }
                    else
                    {
                        RedisHelper.Set("Pt:WMSErrorInfo:5", new RedisErrorInfo() { Equip = "5", Con = "库存不足，单号：" + request.BillCode + "，物料编码：" + string.Join(',', request.MatCode), Time = DateTime.Now });
                    }

                    RedisHelper.Del("Pt:DocNo" + request.BillCode);
                }
                else
                {
                    var mes = _ptbillmes.GetSingle(p => p.BillCode == request.BillCode);
                    var code = mes.MatCode.Split(',').ToList().Except(new List<string>() { pp.Split('|')[0] });

                    _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
                    {
                        MatCode = string.Join(",", code),
                        Count = mes.Count + 1
                    }, p => p.BillCode == request.BillCode);
                    RedisHelper.Set("Pt:DocNo" + request.BillCode, "");
                }
                return res;
            }

            if (string.IsNullOrEmpty(request.BoilerNo))
            {
                //多个炉号业务处理
                var boilernum = locationlist.Select(p => new { p.BoilerNo, p.ProductTime }).Distinct().OrderBy(p => p.ProductTime).ToList();
                if (boilernum.Count() > 1)
                {
                    List<string> boils = new List<string>();
                    for (int i = 0; i < boilernum.Count(); i++)
                    {
                        var boil = boilernum;
                        foreach (var item in boil)
                        {
                            if (item.BoilerNo == boilernum[i].BoilerNo)
                            {
                                continue;
                            }
                            if (DateTime.Equals(boilernum[i].ProductTime, item.ProductTime))
                            {
                                boils.Add(item.BoilerNo);
                            }
                        }
                    }
                    boils = boils.Distinct().ToList();
                    if (boils.Any())
                    {
                        //多个炉号的生产时间在同一天的
                        locationlist = locationlist.Where(p => boils.Contains(p.BoilerNo)).GroupBy(p => p.BoilerNo).OrderBy(p => p.Count()).First();
                    }
                    else
                    {
                        var loca = locationlist.OrderBy(p => p.ProductTime).First();
                        locationlist = locationlist.Where(p => p.BoilerNo == loca.BoilerNo).OrderBy(p => p.PackNo);
                    }
                }
            }
            if (!locationlist.Any())
            {
                var pp = RedisHelper.Get("Pt:DocNo" + request.BillCode);
                if (string.IsNullOrEmpty(pp))
                {
                    _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
                    {
                        State = DocState.DocState_Complete.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.BillCode == request.BillCode);
                    _docrepository.UpdateSetColumnsTrue(p => new ptBillDocsinfo()
                    {
                        StateNum = DocState.DocState_Complete.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.DocsNo == request.BillCode);
                    RedisHelper.Del("Pt:DocNo" + request.BillCode);
                }
                else
                {
                    var mes = _ptbillmes.GetSingle(p => p.BillCode == request.BillCode);
                    var code = mes.MatCode.Split(',').ToList().Except(new List<string>() { pp.Split('|')[0] });

                    _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
                    {
                        MatCode = string.Join(",", code),
                        Count = mes.Count + 1
                    }, p => p.BillCode == request.BillCode);
                    RedisHelper.Set("Pt:DocNo" + request.BillCode, "");
                }
                return res;
            }
            //出库任务
            //出库按巷道任务执行情况分配
            var existtunnellist = locationlist.GroupBy(p => p.Tunnel).Select(p => p.Key.ToString()).Distinct().ToList();
            var tunneltask = _ptwcsTaskold.AsQueryable().Where(p => p.Type == TaskType.OutDepot && p.Status < dto.TaskStatus.Finish && existtunnellist.Contains(p.Tunnel)).SplitTable(p => p.Take(2)).ToList().Select(p => p.Tunnel);
            var outtunnelgroup = new List<TunnelCountTemp>();
            if (tunneltask != null && tunneltask.Any())
            {
                outtunnelgroup = tunneltask.ToList().GroupBy(p => p).Select(p => new TunnelCountTemp { Tunnel = p.Key, Count = p.Count() }).ToList();
            }
            foreach (var item in existtunnellist)
            {
                if (!outtunnelgroup.Where(p => p.Tunnel == item.ToString()).Any())
                {
                    outtunnelgroup.Add(new TunnelCountTemp
                    {
                        Tunnel = item.ToString(),
                        Count = 0,
                        StockCount = locationlist.Where(p => p.Tunnel.ToString() == item).Count()
                    });
                }
            }
            var curtunnel = int.Parse(outtunnelgroup.OrderBy(p => p.Count).ThenByDescending(p => p.StockCount).First().Tunnel);

            //找出领料点位的所有空位置的炉号
            var boilerNoList = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && !string.IsNullOrEmpty(p.Default5) && p.SContent == "1");
            if (boilerNoList.Any())
            {
                var list = boilerNoList.Select(p => p.Default5).Distinct().ToList();
                locationlist = locationlist.Where(p => list.Contains(p.BoilerNo));
            }
            if (locationlist == null || !locationlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "请确认领料位置绑定炉号是否正确";
                return res;
            }
            var temploc = locationlist.Where(p => p.Tunnel == curtunnel).OrderBy(p => p.ProductTime).ThenBy(p => p.PackNo).First();
            //直接判断点位有没有绑定炉号，有的则出，没得则返回
            var syslist = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && !string.IsNullOrEmpty(p.Default2) && p.SContent == "1");
            var equip = "";
            if (!syslist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "已没有可用点位，请稍后请求";
                return res;
            }
            foreach (var item in syslist)
            {
                var dd = item.Default2.Split(',');
                //if (dd.Contains(temploc.MatCode))
                //{
                //    equip = item.Code;
                //    break;
                //}
                if (dd.Contains(temploc.MatCode) && item.Default5 == temploc.BoilerNo)
                {
                    equip = item.Code;
                    break;
                }
            }
            if (string.IsNullOrEmpty(equip))
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有找到可用的目标地址，请稍后请求";
                return res;
            }
            var sotck = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == temploc.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString());
            try
            {
                _db.BeginTran();
                //_sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                //{
                //    SContent = "2",
                //    EditTime = DateTime.Now
                //}, p => p.Code == outstation);
                //货位表
                _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_StockOut.GetHashCode() }, p => p.Id == temploc.Id);
                //库存表
                _ptbillInvnow.UpdateModelColumns(p => new ptBillInvnow() { InvStateCode = InvState.InvEcecState_OutGoing.ToString(), EditTime = DateTime.Now }, p => p.Id == sotck.Id);
                var invflow = _mapper.Map<ptBillInvFlow>(sotck);

                invflow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                invflow.AddTime = DateTime.Now;
                invflow.EditTime = DateTime.Now;
                invflow.Id = IdFactory.NewId();
                invflow.Memo = "领料出库任务下发";
                _ptBillInvFlow.Insert(invflow);
                //添加出库任务
                CreateStockOutTask(new PtCreateStockOutTaskRequest()
                {
                    ContGrpBarCode = temploc.ContGrpBarCode,
                    CellNo = temploc.Code,
                    EquCode = equip,
                    Qty = sotck.LengthQty,
                    Tunnel = temploc.Tunnel.ToString(),
                    WarehouseCode = temploc.WarehouseCode,
                    MatCode = sotck.MatCode,
                    InvBarCode = request.MatBarCode,
                    BusType = PtTaskBusType.TaskBusType_PT_ProductionStockOut.GetDescription(),
                    DocNo = request.BillCode
                });
                //更新单据物料编码和炉号
                RedisHelper.Set("Pt:DocNo" + request.BillCode, sotck.MatCode + "|" + sotck.BoilerNo);
                _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>
        /// 申请出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private SRes ApplyProductionStockOutNew(ProductionStockOutRequest request)
        {
            var res = new SRes();
            var locationlist = from loc in _baseWareLocationrepository.GetList(p => p.IsStop == 0 && p.StateNum == LocationState.LocationState_Full.GetHashCode())
                               join stock in _ptbillInvnow.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString())
                               on loc.ContGrpBarCode equals stock.ContGrpBarCode
                               orderby stock.ProductTime
                               select new
                               {
                                   stock.MatCode,
                                   stock.InvBarCode,
                                   stock.BoilerNo,
                                   stock.RodBarCode,
                                   stock.Grade,
                                   stock.PackNo,
                                   stock.InvStateCode,
                                   stock.ProductTime,
                                   loc.Col,
                                   loc.Layer,
                                   loc.Shelf,
                                   loc.Depth,
                                   loc.Code,
                                   loc.Tunnel,
                                   loc.WarehouseCode,
                                   loc.ContGrpBarCode,
                                   loc.Id,
                                   loc.StateNum,
                               };
            if (!string.IsNullOrEmpty(request.BoilerNo))
            {
                locationlist = locationlist.Where(p => p.BoilerNo == request.BoilerNo);
            }
            if (locationlist == null || !locationlist.Any())
            {
                _logger.LogInformation("炉号更新标记埋点：" + request.BoilerNo + (locationlist == null).ToString() + (!locationlist.Any()).ToString());
                //该炉号没有料之后调用mes回调通知接口
                _sysconfigrepository.UpdateModelColumns(p => new ptSysConfig() { Default6 = "0", Default7 = request.BoilerNo }, p => p.Default5 == request.BoilerNo);
            }
            if (request.MatCode.Any())
            {
                locationlist = locationlist.Where(p => request.MatCode.Contains(p.MatCode));
            }
            if (!string.IsNullOrEmpty(request.MatBarCode))
            {
                locationlist = locationlist.Where(p => p.InvBarCode == request.MatBarCode);
            }
            if (!string.IsNullOrEmpty(request.PackNo))
            {
                locationlist = locationlist.Where(p => p.PackNo == request.PackNo);
            }

            //过滤已禁用的巷道
            var tunlist = _sysconfigrepository.GetList(p => !string.IsNullOrEmpty(p.SContent) && p.SType == "OutStop");
            if (tunlist.Any())
            {
                var tun = tunlist.Select(p => p.Default1).ToList();
                locationlist = locationlist.Where(p => !tun.Contains(p.Tunnel.ToString()));
            }

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

            //出库任务
            //出库按巷道任务执行情况分配
            var existtunnellist = locationlist.GroupBy(p => p.Tunnel).Select(p => p.Key.ToString()).Distinct().ToList();
            var tunneltask = _ptwcsTaskold.AsQueryable().Where(p => p.Type == TaskType.OutDepot && p.Status < dto.TaskStatus.Finish && existtunnellist.Contains(p.Tunnel)).SplitTable(p => p.Take(2)).ToList().Select(p => p.Tunnel);
            var outtunnelgroup = new List<TunnelCountTemp>();
            if (tunneltask != null && tunneltask.Any())
            {
                outtunnelgroup = tunneltask.ToList().GroupBy(p => p).Select(p => new TunnelCountTemp { Tunnel = p.Key, Count = p.Count() }).ToList();
            }
            //获取堆垛机所在巷道
            var equlist = HttpUtil.GetRequest("http://10.30.35.1:8080/api/Wcs/GetDeviceInfo?name=SrmCurTun");
            var srmtunlist = JsonConvert.DeserializeObject<List<DeviceInfo>>(equlist);
            var curtunlist = srmtunlist.Select(p => p.CurTunnel).ToList();
            foreach (var item in existtunnellist)
            {
                if (!outtunnelgroup.Where(p => p.Tunnel == item.ToString()).Any())
                {
                    outtunnelgroup.Add(new TunnelCountTemp
                    {
                        Tunnel = item.ToString(),
                        Count = 0,
                        StockCount = locationlist.Where(p => p.Tunnel.ToString() == item).Count(),
                        IsSrmCurTunel = curtunlist.Contains(item) ? 1 : 0
                    });
                }
            }
            //按任务数分配
            var curtunnel = int.Parse(outtunnelgroup.OrderBy(p => p.Count).ThenByDescending(p => p.StockCount).First().Tunnel);

            //优先出所在巷道的料
            //var curtunnel = int.Parse(outtunnelgroup.OrderByDescending(p => p.IsSrmCurTunel).ThenBy(p => p.Count).ThenByDescending(p => p.StockCount).First().Tunnel);
            //按照每个巷道出一定数量之后换巷道
            //int abcou = int.Parse(wms.util.AppSettings.GetConfig("DiffVal"));
            //var curtunnel = int.Parse(outtunnelgroup.OrderByDescending(p => p.IsSrmCurTunel).First().Tunnel);
            //var mattunnel = curtunnel % 2 == 0 ? curtunnel - 1 : curtunnel + 1;
            //if (outtunnelgroup.Where(p => p.Tunnel == mattunnel.ToString()).Any() && outtunnelgroup.Where(p => p.Tunnel == mattunnel.ToString()).First().StockCount > abcou)//相邻巷道有料
            //{
            //    if (Math.Abs(outtunnelgroup.Where(p => p.Tunnel == curtunnel.ToString()).First().StockCount - outtunnelgroup.Where(p => p.Tunnel == mattunnel.ToString()).First().StockCount) > 0 &&
            //      outtunnelgroup.Where(p => p.Tunnel == curtunnel.ToString()).First().StockCount < outtunnelgroup.Where(p => p.Tunnel == mattunnel.ToString()).First().StockCount)
            //    {
            //        curtunnel = mattunnel;
            //    }
            //}

            //找出领料点位的所有空位置的炉号
            var boilerNoList = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && !string.IsNullOrEmpty(p.Default5) && !string.IsNullOrEmpty(p.Default2) && p.SContent == "1");
            if (boilerNoList.Any())
            {
                var list = boilerNoList.Select(p => p.Default5).Distinct().ToList();
                locationlist = locationlist.Where(p => list.Contains(p.BoilerNo));
            }
            if (locationlist == null || !locationlist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "请确认领料位置绑定炉号是否正确";
                return res;
            }
            var temploc = locationlist.Where(p => p.Tunnel == curtunnel).OrderBy(p => p.ProductTime).ThenBy(p => p.PackNo).First();
            //直接判断点位有没有绑定炉号，有的则出，没得则返回
            var syslist = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && !string.IsNullOrEmpty(p.Default2) && !string.IsNullOrEmpty(p.Default5) && p.SContent == "1");
            var equip = "";
            if (!syslist.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "已没有可用点位，请稍后请求";
                return res;
            }
            foreach (var item in syslist)
            {
                var dd = item.Default2.Split(',');
                //if (dd.Contains(temploc.MatCode))
                //{
                //    equip = item.Code;
                //    break;
                //}
                if (dd.Contains(temploc.MatCode) && item.Default5 == temploc.BoilerNo)
                {
                    equip = item.Code;
                    break;
                }
            }
            if (string.IsNullOrEmpty(equip))
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = "没有找到可用的目标地址，请稍后请求";
                return res;
            }
            var sotck = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == temploc.ContGrpBarCode && p.InvStateCode == InvState.InvEcecState_In.ToString() && p.ExecStateCode == InvLockState.InvState_Normal.ToString());
            try
            {
                _db.BeginTran();

                //货位表
                _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_StockOut.GetHashCode() }, p => p.Id == temploc.Id);
                //库存表
                _ptbillInvnow.UpdateModelColumns(p => new ptBillInvnow() { InvStateCode = InvState.InvEcecState_OutGoing.ToString(), EditTime = DateTime.Now }, p => p.Id == sotck.Id);
                var invflow = _mapper.Map<ptBillInvFlow>(sotck);

                invflow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                invflow.AddTime = DateTime.Now;
                invflow.EditTime = DateTime.Now;
                invflow.Id = IdFactory.NewId();
                invflow.Memo = "领料出库任务下发";
                _ptBillInvFlow.Insert(invflow);
                //添加出库任务
                CreateStockOutTask(new PtCreateStockOutTaskRequest()
                {
                    ContGrpBarCode = temploc.ContGrpBarCode,
                    CellNo = temploc.Code,
                    EquCode = equip,
                    Qty = sotck.LengthQty,
                    Tunnel = temploc.Tunnel.ToString(),
                    WarehouseCode = temploc.WarehouseCode,
                    MatCode = sotck.MatCode,
                    InvBarCode = request.MatBarCode,
                    BusType = PtTaskBusType.TaskBusType_PT_ProductionStockOut.GetDescription(),
                    DocNo = request.BillCode
                });

                _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;
        }

        public SRes UpdateDocState(UpdateDocStateReqest req)
        {
            if (_docrepository.GetSingle(p => p.DocsNo == req.DocCode) == null)
            {
                return new SRes()
                {
                    ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode(),
                    ResMsg = "单据不存在"
                };
            }
            _ptbillmes.UpdateSetColumnsTrue(p => new ptBillMesmiddle()
            {
                State = req.DocState.GetHashCode(),
                EditTime = DateTime.Now
            }, p => p.BillCode == req.DocCode);
            _docrepository.UpdateSetColumnsTrue(p => new ptBillDocsinfo()
            {
                StateNum = req.DocState.GetHashCode(),
                EditTime = DateTime.Now
            }, p => p.DocsNo == req.DocCode);
            return new SRes();
        }

        private SRes<ptWCS_TaskInfo> CreateStockOutTask(PtCreateStockOutTaskRequest reqDto)
        {
            var res = new SRes<ptWCS_TaskInfo>();
            string srm = "";
            switch (reqDto.Tunnel)
            {
                case "1":
                    srm = "1";
                    break;

                case "2":
                    srm = "1";
                    break;

                case "3":
                    srm = "2";
                    break;

                case "4":
                    srm = "2";
                    break;

                case "5":
                    srm = "3";
                    break;

                case "6":
                    srm = "3";
                    break;

                case "7":
                    srm = "4";
                    break;

                case "8":
                    srm = "4";
                    break;

                default:
                    break;
            }
            var wcstask = new ptWCS_TaskInfo()
            {
                Type = TaskType.OutDepot,
                Status = TaskStatus.NewBuild,
                Priority = 0,
                Device = "SRM" + srm,
                SrmStation = "",
                AddrFrom = reqDto.CellNo,
                AddrTo = reqDto.EquCode,
                LastInteractionPoint = "",
                BarCode = reqDto.ContGrpBarCode,
                Length = reqDto.Qty,
                PalletType = 1,
                AddWho = "wms",
                WarehouseCode = reqDto.WarehouseCode,
                Enabled = true,
                Tunnel = reqDto.Tunnel,
                BusType = reqDto.BusType,
                MatCode = reqDto.MatCode,
                MaterialCode = reqDto.MatCode,
                InvBarCode = reqDto.InvBarCode,
                TaskGroupKey = reqDto.DocNo,  //单号
                OutType = OutTypeEnum.自动出库任务
            };

            try
            {
                _db.BeginTran();
                var task = _ptwcsTaskinfo.InsertReturnEntity(wcstask);
                var taskold = _mapper.Map<ptWCS_TaskOld>(task);
                _ptwcsTaskold.InsertableSplitTable(taskold);
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = reqDto.CellNo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = reqDto.CellNo + "生产领料出库",
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    Default3 = task.ID.ToString(),
                    SContent = "3",
                    EditTime = DateTime.Now
                }, p => p.Code == reqDto.EquCode);
                _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;
        }

        public SRes ProductionFeedBack(ProductionFeedBackRequest reqDto)
        {
            var result = new SRes();

            return result;
        }

        public SRes<StockChangeResItem> StockChange(PtStockChangeRequest reqDto)
        {
            var result = new SRes<StockChangeResItem>() { ResDataList = new List<StockChangeResItem>() };
            if (!reqDto.ListInfo.Any())
            {
                result.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return result;
            }
            var ware = _baseWareHouserepository.GetSingle(p => p.Code == "pthouse");
            if (ware == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }

            foreach (var item in reqDto.ListInfo)
            {
                //var puch = new ptBillPushinfo()
                //{
                //    DocsNo = "",
                //    TypeCode = PtFackbeekType.StateTrans.ToString(),
                //    RFIDBarCode = item.RFID,
                //    HWBarCode = item.RFID,
                //    CLBarCode = item.MatBarCode,
                //    WarehouseId = ware.Id,
                //    WarehouseCode = ware.Code,
                //    ReqNo = Guid.NewGuid().ToString(),
                //    BoilerNo = item.BoilerNo,
                //    PackNo = item.PackNo
                //};
                var stock = _ptbillInvnow.GetSingle(p => p.CLBarCode == item.MatBarCode);
                if (stock == null)
                {
                    result.ResDataList.Add(new StockChangeResItem()
                    {
                        MatBarCode = item.MatBarCode,
                        StateRes = "F",
                        Reason = "没有查询到库存信息"
                    });
                }
                else
                {
                    if (stock.InvStateCode == InvState.InvEcecState_In.ToString() || stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString())
                    {
                        if (item.State.ToUpper() == "LOCK" || item.State.ToUpper() == "NORMAL")
                        {
                            var it = _ptbillInvnow.UpdateSetColumnsTrue(p => new ptBillInvnow()
                            {
                                ExecStateCode = item.State.ToUpper() == "LOCK" ? InvLockState.InvState_Lock.ToString() : InvLockState.InvState_Normal.ToString(),
                                EditTime = DateTime.Now,
                                Memo = item.Reason
                            }, p => p.CLBarCode == item.MatBarCode);
                            var nov = _ptbillInvnow.GetSingle(p => p.CLBarCode == item.MatBarCode);
                            var flow = _mapper.Map<ptBillInvFlow>(nov);
                            flow.Id = GetId();
                            flow.AddTime = DateTime.Now;
                            flow.EditTime = DateTime.Now;
                            _ptBillInvFlow.Insert(flow);
                            result.ResDataList.Add(new StockChangeResItem()
                            {
                                MatBarCode = item.MatBarCode,
                                StateRes = "S",
                                Reason = "成功"
                            });
                            continue;
                        }
                        else
                        {
                            result.ResDataList.Add(new StockChangeResItem()
                            {
                                MatBarCode = item.MatBarCode,
                                StateRes = "F",
                                Reason = "改判状态传参有误"
                            });
                            continue;
                        }
                    }
                    else
                    {
                        result.ResDataList.Add(new StockChangeResItem()
                        {
                            MatBarCode = item.MatBarCode,
                            StateRes = "F",
                            Reason = "该库存状态出库中不允许改判"
                        });
                        continue;
                    }
                }
            }
            return result;
        }

        public SRes ProductionBack(ProductionBackRequest reqDto)
        {
            var result = new SRes();
            if (!reqDto.ListInfo.Any() || string.IsNullOrEmpty(reqDto.BillCode) || string.IsNullOrEmpty(reqDto.WareCode))
            {
                result.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return result;
            }
            var ware = _baseWareHouserepository.GetSingle(p => p.Code == reqDto.WareCode);
            if (ware == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }
            var doc = _docrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
            if (doc == null)
            {
                var docno = new ptBillDocsinfo()
                {
                    DocsNo = reqDto.BillCode,
                    IsStop = 0,
                    WarehouseId = ware.Id,
                    ReqNo = reqDto.BillCode,
                    Type = PtDocType.DocType_PT_ProductionBackStockIn.ToString(),
                    StateNum = DocState.DocState_Create.GetHashCode(),
                    JsonContent = JsonConvert.SerializeObject(reqDto.ListInfo),
                    AddWho = "mes",
                    EditWho = "mes"
                };
                _docrepository.Insert(docno);
            }
            foreach (var item in reqDto.ListInfo)
            {
                var mater = _materrepository.GetSingle(p => p.Code == item.MatCode);
                if (mater == null)
                {
                    result.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                    result.ResMsg = item.MatCode + ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                    return result;
                }
                var nov = new ptBillInvnow()
                {
                    WarehouseId = ware.Id,
                    ContGrpBarCode = item.RFID,
                    ContGrpId = GetId(),
                    BoxBarCode = item.RFID,
                    BoilerNo = item.BoilerNo,
                    PackNo = item.PackNo,
                    CLBarCode = item.MatBarCode,
                    InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                    InvBarCode = item.MatBarCode,
                    ExecStateCode = item.State == "Lock" ? InvLockState.InvState_Lock.ToString() : InvLockState.InvState_Normal.ToString(),
                    InDocsNo = reqDto.BillCode,
                    InDocsRowNo = reqDto.BillCode,
                    MatId = mater.Id,
                    MatCode = mater.Code,
                    RFIDBarCode = item.RFID,
                    HWTypeCode = mater.SpoolType,
                    ExecDocsNo = reqDto.BillCode,
                    ExecDocsRowNo = reqDto.BillCode,
                    ExecDocsTypeCode = PtDocType.DocType_PT_ProductionBackStockIn.ToString(),
                    HWBarCode = item.RFID,
                    RodBarCode = item.RFID,
                    InvInOut = 1,
                    MatName = mater.Name,
                    Size = 1,
                    IsBack = true
                };
                var task = new ptWCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = item.LocCode,
                    SrmStation = item.LocCode,
                    AddrFrom = item.LocCode,
                    BarCode = item.RFID,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = ware.Code,
                    WorkBench = item.LocCode,
                    AddrTo = "",
                    Tunnel = "",
                    PalletType = 1,
                    MaterialCode = mater.Code,
                    MatCode = mater.Code,
                    BusType = PtTaskBusType.TaskBusType_PT_ProductionBackStockIn.GetDescription()
                };
                var sys = _sysconfigrepository.GetSingle(p => p.Code == item.LocCode && p.SType == Const.PtPinKuhouseType && p.Default1 == Const.ProductType && p.SContent == "2");
                if (sys == null)
                {
                    result.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                    result.ResMsg = item.LocCode + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                    return result;
                }
                try
                {
                    _db.BeginTran();
                    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    {
                        SContent = "3",
                        EditTime = DateTime.Now
                    }, p => p.Code == sys.Code);
                    _ptbillInvnow.Insert(nov);
                    _ptBillInvFlow.Insert(_mapper.Map<ptBillInvFlow>(nov));
                    var wcs = _ptwcsTaskinfo.InsertReturnEntity(task);
                    var wcsold = _mapper.Map<ptWCS_TaskOld>(wcs);
                    _ptwcsTaskold.InsertableSplitTable(wcsold);
                    var taskdetail = new ptWCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = item.LocCode,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcs.ID,
                        Desc = wcs.BusType
                    };
                    _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    result.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                    return result;
                }
            }
            return result;
        }

        public PTGetCurStockListResponse GetCurStockList(PtGetCurStockListRequest reqDto)
        {
            var result = new PTGetCurStockListResponse() { list = new List<PtResDataItem>() };
            int count = 0;
            var stock = _ptbillInvnow.Context.Queryable<ptBillInvnow, ptBaseMater>((inv, mater) => new object[]
                        {
                            JoinType.Left, inv.MatCode == mater.Code
                        })
                        .Where((inv, mater) => inv.InvStateCode == InvState.InvEcecState_In.ToString())
                        .WhereIF(string.IsNullOrEmpty(reqDto.MatCode), (inv, mater) => inv.MatCode.Contains(reqDto.MatCode))
                        .WhereIF(string.IsNullOrEmpty(reqDto.MatName), (inv, mater) => inv.MatName.Contains(reqDto.MatName))
                        .WhereIF(string.IsNullOrEmpty(reqDto.BoilerNo), (inv, mater) => inv.BoilerNo.Contains(reqDto.BoilerNo))
                        .WhereIF(string.IsNullOrEmpty(reqDto.RFID), (inv, mater) => inv.ContGrpBarCode.Contains(reqDto.RFID))
                        .WhereIF(string.IsNullOrEmpty(reqDto.MatBarCode), (inv, mater) => inv.InvBarCode.Contains(reqDto.MatBarCode))
                        .WhereIF(string.IsNullOrEmpty(reqDto.Batch), (inv, mater) => inv.BatchNo.Contains(reqDto.Batch))
                        .Select((inv, mater) => new PtResDataItem()
                        {
                            RFID = inv.ContGrpBarCode,
                            RodBar = inv.RodBarCode,
                            BoilerNo = inv.BoilerNo,
                            MatBarCode = inv.InvBarCode,
                            PackNo = inv.PackNo,
                            Batch = inv.BatchNo,
                            Carbon = inv.CaQty,
                            ProductDate = inv.ProductTime,
                            Brand = inv.BrandNo,
                            Describe = inv.Describe,
                            ExecStandard = inv.ExecStd,
                            Licence = inv.LicenceCode,
                            PackWeight = inv.TolWQty,
                            FigureNo = mater.FigureNo,
                            ComCode = mater.ComCode,
                            ComName = mater.ComName,
                            CalcUnit = mater.CalcUnit,
                            StockUnit = mater.StockUnit,
                            Weight = mater.Weight,
                            WeightUnit = mater.WeightUnit,
                            IsHold = mater.IsHold,
                            HoldDuration = inv.HoldDuration,
                            LocCell = inv.PutCol.ToString(),
                            LocLayer = inv.PutLayer.ToString(),
                            LocRow = inv.PutRow.ToString(),
                            LocCode = inv.PutRow.ToString() + inv.PutCol.ToString() + inv.PutLayer.ToString(),
                            WareCode = "pthouse"
                        })
                        .ToPageList(reqDto.PageIndex, reqDto.PageSize, ref count);

            result.TotalCount = stock.Count();
            result.list = stock;
            return result;
        }

        /// <summary>
        /// 采购入库任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PtPurchaseTask(PtPurchaseTaskReqest request)
        {
            var result = new SRes();
            try
            {
                var sys = _sysconfigrepository.GetSingle(p => p.Code == request.Equip && p.SType == Const.PtPinKuhouseType && p.Default1 == Const.PinKu_22Type);
                if (request.Equip != "2999")
                {
                    if (sys == null)
                    {
                        result.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                        result.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                        return result;
                    }
                    if (sys.SContent == "1")
                    {
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = request.Equip + "没有空架子，不允许提交";
                        return result;
                    }
                    else if (sys.SContent == "3")
                    {
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = request.Equip + "已经有入库任务锁住，不允许提交";
                        return result;
                    }
                    else if (sys.SContent == "4")
                    {
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = request.Equip + "已经有出库任务锁住，不允许提交";
                        return result;
                    }
                }

                var stock = new ptBillInvnow()
                {
                    WarehouseId = 1685164446336552960,
                    ContGrpBarCode = "Test" + DateTime.Now.ToString("hhmmssfff"),
                    ContGrpId = GetId(),
                    InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                    ExecStateCode = InvLockState.InvState_Lock.ToString()
                };
                if (!string.IsNullOrEmpty(request.ConBarCode))
                {
                    var bar = _ptbillInvinit.AsQueryable().Where(x => x.ContGrpBarCode == request.ConBarCode).OrderByDescending(x => x.AddTime).First(p => p.ContGrpBarCode == request.ConBarCode);
                    if (bar == null)
                    {
                        result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        result.ResMsg = request.ConBarCode + "没有条码信息";
                        return result;
                    }
                    var taskvi = _ptwcsTaskold.AsQueryable().Where(p => p.BarCode == request.ConBarCode && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                    if (taskvi != null && taskvi.Id > 0)
                    {
                        if (taskvi.Type == TaskType.OutDepot)
                        {
                            result.ResCode = 0;
                            result.ResMsg = request.ConBarCode + "该码出库任务还未完成，请先完成出库任务";
                            return result;
                        }
                        else if (taskvi.Type == TaskType.EnterDepot)
                        {
                            result.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
                            result.ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription();
                            //result.ResMsg = request.ConBarCode + "任务已创建，请勿重复申请";
                            return result;
                        }
                    }

                    var stockvi = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == request.ConBarCode);
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_In.ToString())
                    {
                        result.ResCode = 0;
                        result.ResMsg = request.ConBarCode + "该码已在库中，请检查码是否重复";
                        return result;
                    }
                    if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
                    {
                        result.ResCode = 0;
                        result.ResMsg = request.ConBarCode + "该码存在出库中任务，请检查上一个任务是否已经完成";
                        return result;
                    }

                    //条码验证
                    var barstock = _ptbillInvnow.GetSingle(p => p.InvBarCode == request.MatBarCode);
                    if (barstock != null && barstock.InvStateCode == InvState.InvEcecState_In.ToString())
                    {
                        result.ResCode = 0;
                        result.ResMsg = request.MatBarCode + "该材料号已在库中，请检查是否重复";
                        return result;
                    }
                    if (barstock != null && barstock.ContGrpBarCode != request.ConBarCode)
                    {
                        result.ResCode = 0;
                        result.ResMsg = request.MatBarCode + "该材料号已经绑定" + barstock.ContGrpBarCode + "，请检查是否重复";
                        return result;
                    }

                    stock = _mapper.Map<ptBillInvnow>(bar);
                    stock.ExecStateCode = InvLockState.InvState_Lock.ToString();
                }
                var task = new ptWCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = request.Equip,
                    AddrFrom = request.Equip,
                    BarCode = stock.ContGrpBarCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = "",
                    Tunnel = "",
                    PalletType = 1,
                    MaterialCode = "",
                    BusType = PtTaskBusType.TaskBusType_PT_PurchaseStockIn.GetDescription(),
                    ManualRemarks = stock.ContGrpBarCode
                };
                _db.BeginTran();

                _ptbillInvnow.Insert(stock);
                var wcs = _ptwcsTaskinfo.InsertReturnEntity(task);
                var wcsold = _mapper.Map<ptWCS_TaskOld>(wcs);
                _ptwcsTaskold.InsertableSplitTable(wcsold);
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = request.Equip,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcs.ID,
                    Desc = wcs.BusType
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                if (request.Equip != "2999")
                {
                    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    {
                        SContent = "4",  //1空；2满；3入；4出
                        EditTime = DateTime.Now,
                        Default3 = wcs.ID.ToString()
                    }, p => p.Code == sys.Code);
                }
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                result.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription() + ex.Message;
                return result;
            }
            return result;
        }

        /// <summary>
        /// 生成库存
        /// </summary>
        /// <returns></returns>
        public SRes InsertStockInfo(string code, int TaskNum)
        {
            var result = new SRes();
            if (_ptbillInvinit.Count(p => p.ContGrpBarCode == code) > 1)
            {
                result.ResCode = ResponseStatusCodeEnum.BaseBarcodeNotExist.GetHashCode();
                result.ResMsg = code + "绑定的条码数据有多条，请确认是否重复绑定";
                return result;
            }
            //查询条码表
            var barcode = _ptbillInvinit.GetSingle(p => p.ContGrpBarCode == code);
            if (barcode == null)
            {
                result.ResCode = ResponseStatusCodeEnum.BaseBarcodeNotExist.GetHashCode();
                result.ResMsg = code + ResponseStatusCodeEnum.BaseBarcodeNotExist.GetDescription();
                return result;
            }
            var oldwcstask = _ptwcsTaskold.AsQueryable().Where(p => p.Id == TaskNum).SplitTable(p => p.Take(2)).First();
            if (oldwcstask == null)
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = TaskNum + "历史任务表" + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            var orginbarcode = oldwcstask.ManualRemarks;//固定存放最初生成的条码，不更新
            var invs = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == code && orginbarcode != p.BomDocsNo);
            if (invs != null)
            {
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = code + ResponseStatusCodeEnum.StockInfoExist.GetDescription();
                return result;
            }

            if (_ptbillInvnow.Count(p => p.ContGrpBarCode == code && orginbarcode == p.BomDocsNo) == 1)
            {
                return result;
            }

            var inv = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == orginbarcode);
            if (inv == null)
            {
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = orginbarcode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return result;
            }
            if (_ptbillInvnow.IsAny(p => p.CLBarCode == barcode.CLBarCode && p.ContGrpBarCode != code))
            {
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = barcode.CLBarCode + "材料号已经存在组盘信息，并且和当前扫码RFID(" + code + ")不一致，请人工核对";
                return result;
            }

            var stock = _mapper.Map<ptBillInvnow>(barcode);
            stock.AddTime = DateTime.Now;
            stock.EditTime = DateTime.Now;
            stock.BomDocsNo = orginbarcode;//暂时使用BomDocsNo字段存原始随机条码
            try
            {
                _db.BeginTran();
                _ptwcsTaskold.AsUpdateable().SetColumns(p => new ptWCS_TaskOld()
                {
                    BarCode = code,
                    ManualRemarks = orginbarcode
                }).Where(p => p.Id == TaskNum).SplitTable(p => p.Take(2)).ExecuteCommand();
                _ptbillInvnow.DeleteById(inv.Id);
                _ptbillInvnow.Insert(stock);
                var flow = _mapper.Map<ptBillInvFlow>(stock);
                //flow.AddTime = DateTime.Now;
                flow.Id = IdFactory.NewId();
                _ptBillInvFlow.Insert(flow);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                result.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return result;
            }
            return result;
        }

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

        public SRes<int> Unbounding(PtUnboundRequest request)
        {
            var res = new SRes<int>() { ResCode = 500 };
            var task = _ptwcsTaskinfo.GetList(p => p.AddrFrom == request.Equip && p.Status < TaskStatus.Finish);
            if (task.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.IsTaskNotUnbounding.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.IsTaskNotUnbounding.GetDescription();
                return res;
            }
            var equip = _baseWareLocationrepository.GetSingle(p => p.Code == request.Equip);
            if (equip == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            var stock = _iptDataService.GetStockByEquip(request.Equip);
            if (stock.Any())
            {
                _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
                {
                    ContGrpId = Const.Zero,
                    ContGrpBarCode = "",
                    EditTime = DateTime.Now
                }, p => request.Equip == p.Code);
                _ptbillInvnow.UpdateSetColumnsTrue(p => new ptBillInvnow()
                {
                    InvStateCode = InvState.InvEcecState_Out.ToString(),
                    EditTime = DateTime.Now
                }, p => stock.Contains(p.HWBarCode));
                res.ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode();
            }
            else
            {
                res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
            }
            return res;
        }

        public SRes<PtDocumentsdetailList> GetDocumentDetailListByDocsNo(PtDocumentsRequest request)
        {
            var res = new SRes<PtDocumentsdetailList>() { ResDataList = new List<PtDocumentsdetailList>() };
            var list = _iptDataService.GetDocumentDetailListByDocsNo(request);
            res.ResDataList = list.Item1;
            res.ToCount = list.Item2;
            res.PageIndex = request.PageIndex;
            res.PageSize = request.PageSize;
            res.PageNumber = Math.Ceiling((decimal)res.ToCount / res.PageSize);
            return res;
        }

        public SRes<PtDocumentsResponse> GetPageDocumentsList(PtDocumentsRequest request)
        {
            var res = new SRes<PtDocumentsResponse>() { ResDataList = new List<PtDocumentsResponse>() };
            if (request.TypeCode == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "单据类型" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            var list = _iptDataService.GetPageDocumentsList(request);
            res.ResDataList = list.Item1;
            res.ToCount = list.Item2;
            res.PageIndex = request.PageIndex;
            res.PageSize = request.PageSize;
            res.PageNumber = Math.Ceiling((decimal)res.ToCount / res.PageSize);
            return res;
        }

        public string ManualTask(PtManualTaskRequest request)
        {
            var res = new SRes();
            if (!request.Location.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = "货位" + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res.ToCamelCaseString();
            }
            var sys = _sysconfigrepository.GetSingle(p => p.Code == request.EndPoint && p.SType == Const.PtPinKuhouseType);
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.EndPoint + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res.ToCamelCaseString();
            }
            if (sys.SContent != "1")
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.EndPoint + "不是空置状态，不允许下任务";
                return res.ToCamelCaseString();
            }
            try
            {
                foreach (var item in request.Location)
                {
                    var location = _baseWareLocationrepository.GetSingle(p => p.Code == item);
                    if (location == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                        return res.ToCamelCaseString();
                    }
                    if (location.StateNum != LocationState.LocationState_Full.GetHashCode())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + ResponseStatusCodeEnum.Fail.GetDescription() + "货位状态不满足出库条件";
                        return res.ToCamelCaseString();
                    }
                    if (location.IsStop != Const.Zero)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + item + "被禁用";
                        return res.ToCamelCaseString();
                    }
                    var stock = _ptbillInvnow.GetSingle(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.ExecStateCode != InvLockState.InvState_Normal.ToString())
                    //{
                    //    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    //    res.ResMsg =  stock.ContGrpBarCode + "状态已被锁定，不允许出库";
                    //    return res.ToCamelCaseString();
                    //}
                    if (stock.InvStateCode != InvState.InvEcecState_In.ToString())
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = item + "组盘状态不是已入库";
                        return res.ToCamelCaseString();
                    }
                    string srm = "";
                    if (location.Tunnel == 1 || location.Tunnel == 2)
                    {
                        srm = "1";
                    }
                    else if (location.Tunnel == 3 || location.Tunnel == 4)
                    {
                        srm = "2";
                    }
                    else if (location.Tunnel == 5 || location.Tunnel == 6)
                    {
                        srm = "3";
                    }
                    else if (location.Tunnel == 7 || location.Tunnel == 8)
                    {
                        srm = "4";
                    }

                    ptWCS_TaskInfo ptwcsTask = new ptWCS_TaskInfo();
                    ptwcsTask.Status = TaskStatus.NewBuild;
                    ptwcsTask.Type = TaskType.OutDepot;
                    ptwcsTask.Priority = 0;
                    ptwcsTask.Device = "SRM" + srm;
                    ptwcsTask.SrmStation = "";
                    ptwcsTask.AddrFrom = item;
                    ptwcsTask.BarCode = stock.ContGrpBarCode;
                    ptwcsTask.AddWho = "wms";
                    ptwcsTask.WarehouseCode = location.WarehouseCode;
                    ptwcsTask.Enabled = true;
                    ptwcsTask.WorkBench = request.EndPoint;
                    ptwcsTask.AddrTo = request.EndPoint;
                    ptwcsTask.Tunnel = location.Tunnel.ToString();
                    ptwcsTask.PalletType = 1;
                    ptwcsTask.Length = stock.LengthQty;
                    ptwcsTask.MaterialCode = stock.MatCode;
                    ptwcsTask.OutType = OutTypeEnum.全自动手动出库任务;
                    ptwcsTask.BusType = request.BusType;
                    _db.BeginTran();

                    var wcs = _ptwcsTaskinfo.InsertReturnEntity(ptwcsTask);
                    var wcstaskold = _mapper.Map<ptWCS_TaskOld>(wcs);
                    _ptwcsTaskold.InsertableSplitTable(wcstaskold);
                    var taskdtl = new ptWCS_TaskDtl()
                    {
                        ID = Guid.NewGuid(),
                        CurPoint = item,
                        AddTime = DateTime.Now,
                        AddWho = "wms",
                        Enabled = true,
                        ParentTaskCode = wcs.ID,
                        Desc = wcs.OutType.ToString(),
                    };
                    _ptwcsTaskdtl.InsertableSplitTable(taskdtl);
                    _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
                    {
                        StateNum = LocationState.LocationState_StockOut.GetHashCode(),
                        EditTime = DateTime.Now
                    }, p => p.Code == item);
                    _ptbillInvnow.UpdateSetColumnsTrue(p => new ptBillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_OutGoing.ToString(),
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    var flow = _mapper.Map<ptBillInvFlow>(stock);
                    flow.Id = IdFactory.NewId();
                    flow.InvStateCode = InvState.InvEcecState_OutGoing.ToString();
                    flow.EditTime = DateTime.Now;
                    _ptBillInvFlow.Insert(flow);
                    if (sys.Default1 == Const.ProductType)
                    {
                        _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                        {
                            SContent = "3",
                            Default3 = wcs.ID.ToString(),
                            EditTime = DateTime.Now
                        }, p => p.Code == sys.Code);
                    }
                    else
                    {
                        _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                        {
                            SContent = "3",
                            Default3 = wcs.ID.ToString(),
                            EditTime = DateTime.Now
                        }, p => p.Code == sys.Code);
                    }

                    _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();
        }

        public SRes WareCellInit(int row, int col, int deot, int rowcount, int tun)
        {
            var res = new SRes();
            for (int i = 0; i < row; i++)
            {
                string shlf = tun.ToString();
                if (row == 2)
                {
                    if (i == 0)
                    {
                        shlf = shlf + "L";
                    }
                    else
                    {
                        shlf = shlf + "R";
                    }
                }
                for (int j = 0; j < deot; j++)
                {
                    for (int k = 0; k < col; k++)
                    {
                        var code = new ptBaseWareLocation()
                        {
                            Code = (rowcount + i).ToString() + "-" + (k + 1).ToString() + "-" + (j + 1).ToString() + "-" + shlf + "-" + "01",
                            Tunnel = tun,
                            IsStop = 0,
                            Name = (rowcount + i).ToString() + "行" + (k + 1).ToString() + "列" + (j + 1).ToString() + "层" + shlf + "货架" + 1 + "深度",
                            WarehouseId = 1685164446336552960,
                            WarehouseCode = "pthouse",
                            WareAreaId = 1685164446352102710,
                            StateNum = 1,
                            TypeNum = 1,
                            Size = 1,
                            Row = (rowcount + i),
                            Col = (k + 1),
                            Layer = (j + 1),
                            Depth = 1,
                            SCRel = "",
                            ContGrpId = 0,
                            ContGrpBarCode = "",
                            AddWho = "wms",
                            EditWho = "wms",
                            Shelf = shlf,
                            Sort = j * col + (k + 1),
                        };
                        _baseWareLocationrepository.Insert(code);
                    }
                }
            }
            return res;
        }

        public SRes PdaInsterInTask(PtGroupInTaskRequest request)
        {
            var res = new SRes();

            if (string.IsNullOrEmpty(request.Rfid))
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParamNotNull.GetHashCode();
                res.ResMsg = request.Rfid + ResponseStatusCodeEnum.ErrParamNotNull.GetDescription();
                return res;
            }
            try
            {
                var wcstask = _ptwcsTaskold.AsQueryable().Where(p => p.BarCode == request.Rfid && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
                if (wcstask != null)
                {
                    res.ResCode = ResponseStatusCodeEnum.WcsTaskExist.GetHashCode();
                    res.ResMsg = request.Rfid + ResponseStatusCodeEnum.WcsTaskExist.GetDescription();
                    return res;
                }
                var sys = _sysconfigrepository.GetSingle(p => p.Code == request.Equip);
                if (sys == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                    res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                    return res;
                }

                if (sys.SContent == "1")
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "点位状态是空，不允许提交";
                    return res;
                }
                else if (sys.SContent == "3")
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "已经有入库任务锁住，不允许提交";
                    return res;
                }
                else if (sys.SContent == "4")
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "已经有出库任务锁住，不允许提交";
                    return res;
                }

                var flow = _ptBillInvFlow.AsQueryable().Where(p => p.ContGrpBarCode == request.Rfid && p.InvStateCode == InvState.InvEcecState_Out.ToString()).OrderByDescending(p => p.EditTime).ToList();
                if (!flow.Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Rfid + "没有找到最新的出库信息，不允许入库";
                    return res;
                }
                var inv = _mapper.Map<ptBillInvnow>(flow.First());
                inv.Id = GetId();
                inv.ContGrpId = GetId();
                //inv.ExecStateCode = InvLockState.InvState_Lock.ToString();
                inv.AddTime = DateTime.Now;
                inv.EditTime = DateTime.Now;
                inv.InvStateCode = InvState.InvEcecState_BuildUp.ToString();
                inv.Memo = "手动入库";
                _db.BeginTran();
                _ptbillInvnow.Insert(inv);
                _ptBillInvFlow.Insert(_mapper.Map<ptBillInvFlow>(inv));
                var wcs = new ptWCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.EnterDepot,
                    Priority = 0,
                    Device = "",
                    SrmStation = request.Equip,
                    AddrFrom = request.Equip,
                    BarCode = request.Rfid,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = "",
                    Tunnel = "",
                    PalletType = 1,
                    MaterialCode = inv.MatCode,
                    MatCode = inv.MatCode,
                    BusType = PtTaskBusType.TaskBusType_PT_ManaelStockIn.GetDescription()
                };
                var task = _ptwcsTaskinfo.InsertReturnEntity(wcs);
                _ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(task));
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = request.Equip,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = task.BusType
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    SContent = "4",
                    Default3 = task.ID.ToString(),
                    EditTime = DateTime.Now
                }, p => p.Code == request.Equip);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation("任务下发失败：" + ex.Message);
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            return res;
        }

        /// <summary>
        /// 分配巷道
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        public SRes<string> GetPtTunnelPriorityList(GetTunnelPriorityListRequest reqEntity)
        {
            var result = new SRes<string>();
            var wcstask = _ptwcsTaskold.AsQueryable().Where(p => p.Id == reqEntity.TaskNum && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (wcstask == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = reqEntity.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            //先处理库存
            if (!string.IsNullOrEmpty(reqEntity.Memo1))
            {
                if (_ptwcsTaskold.AsQueryable().Where(p => p.BarCode == reqEntity.Memo1 && p.Id != reqEntity.TaskNum && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).Any())
                {
                    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    result.ResMsg = reqEntity.Memo1 + "和对应任务不匹配，请确认是否误扫";
                    return result;
                }
                if (_ptbillInvnow.AsQueryable().Where(p => p.ContGrpBarCode == reqEntity.Memo1 && p.InvStateCode != InvState.InvEcecState_BuildUp.ToString()).Any())
                {
                    result.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    result.ResMsg = reqEntity.Memo1 + "组盘信息已经存在，请确认是否误扫，任务号：" + wcstask.Id;
                    return result;
                }

                var p = InsertStockInfo(reqEntity.Memo1, reqEntity.TaskNum);
                if (p.ResCode != ResponseStatusCodeEnum.Sucess.GetHashCode())
                {
                    result.ResCode = p.ResCode;
                    result.ResMsg = p.ResMsg;
                    return result;
                }
                //var sys = _sysconfigrepository.GetSingle(p => p.Code == wcstask.AddrFrom);
                //if (sys != null && sys.SContent != "1")
                //{
                //    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                //    {
                //        SContent = "1",
                //        EditTime = DateTime.Now
                //    }, p => p.Code == wcstask.AddrFrom);
                //}
            }
            else
            {
                reqEntity.Memo1 = wcstask.BarCode;
            }
            var curinv = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == reqEntity.Memo1 && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
            if (curinv == null)
            {
                result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                result.ResMsg = wcstask.BarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return result;
            }
            //else
            //{
            //var sys = _sysconfigrepository.GetSingle(p => p.Code == wcstask.AddrFrom && p.Default1 == Const.ProductType);
            //if (sys != null)
            //{
            //    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
            //    {
            //        SContent = "1",
            //        Default3 = ""
            //    }, p => p.Code == sys.Code);
            //}
            //}

            //获取任务数占用最少的
            //var wcstasks = _ptwcsTaskold.AsQueryable().Where(p => p.WarehouseCode == wcstask.WarehouseCode && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish &&
            //p.Tunnel != "0" && p.Tunnel != "" && p.Tunnel != null).SplitTable(p => p.Take(2)).ToList();

            var wcstasks = _ptwcsTaskinfo.AsQueryable().With(SqlWith.NoLock).Where(p => p.WarehouseCode == wcstask.WarehouseCode && p.Type == TaskType.EnterDepot && p.Status < TaskStatus.Finish &&
           p.Tunnel != "0" && p.Tunnel != "" && p.Tunnel != null).ToList();
            var tunnelcountlist = new List<TunnelCountTemp>();
            var runningtasks = wcstasks;
            if (runningtasks.Any())
            {
                tunnelcountlist = (from task in runningtasks.GroupBy(p => p.Tunnel)
                                   select new TunnelCountTemp
                                   {
                                       Tunnel = task.Key,
                                       Count = task.Count()
                                   }).ToList();
            }

            //获取库位所有巷道列表
            var alltunnels = _baseWareLocationrepository.GetList().Select(p => p.Tunnel).Distinct();
            foreach (var item in alltunnels)
            {
                if (!tunnelcountlist.Where(p => p.Tunnel == item.ToString()).Any())
                {
                    tunnelcountlist.Add(new TunnelCountTemp()
                    {
                        Tunnel = item.ToString(),
                        Count = 0
                    });
                }
            }
            var tasktunnelcountlist = tunnelcountlist.OrderBy(p => p.Count).ToList();
            var warehouse = _baseWareHouserepository.GetSingle(p => p.Code == wcstask.WarehouseCode);
            //获取已占用库位最少的货架
            var threshold = 5; //int.Parse(ConfigUtil.GetConfiguration["Threshold"]);//阈值
            //获取所有有货的货位
            //var locationsreturn = _baseWareLocationrepository.GetList(p => p.WarehouseId == warehouse.Id && p.StateNum == LocationState.LocationState_Full.GetHashCode());
            var locationsreturn = from loc in _baseWareLocationrepository.GetList(p => p.WarehouseId == warehouse.Id && p.StateNum == LocationState.LocationState_Full.GetHashCode() && p.IsStop == 0)
                                  join inv in _ptbillInvnow.GetList(p => p.InvStateCode == InvState.InvEcecState_In.ToString()) on loc.ContGrpId equals inv.ContGrpId
                                  where inv.MatId == curinv.MatId && inv.BoilerNo == curinv.BoilerNo
                                  select loc;

            //获取所有可用货位的数量
            var shelflocationcount = _baseWareLocationrepository.GetList(p => p.WarehouseCode == wcstask.WarehouseCode && p.TypeNum == LocationType.LocationType_StorageLocation.GetHashCode() && p.IsStop == 0).GroupBy(p => new { p.Tunnel, p.Shelf }).Select(p => new { Tunnel = p.Key.Tunnel, Shelf = p.Key.Shelf, LocationCount = p.Select(q => q.Id).Count() });
            if (locationsreturn == null || !locationsreturn.Any())
            {
                result.ResData = string.Join(",", tasktunnelcountlist.OrderBy(p => p.Count).Select(p => p.Tunnel));
            }
            else
            {
                var grouplocationtunnels = (from location in locationsreturn.GroupBy(p => p.Tunnel)
                                            select new TunnelCountTemp
                                            {
                                                Tunnel = location.Key.ToString(),
                                                Count = location.Count(),
                                                Proportion = location.Count() / (shelflocationcount.Where(p => p.Tunnel == location.Key).Any() ? decimal.Parse(shelflocationcount.Where(p => p.Tunnel == location.Key).Sum(p => p.LocationCount).ToString()) : 1)
                                            }).ToList().OrderBy(p => p.Count).ToList();

                foreach (var item in alltunnels)
                {
                    if (!grouplocationtunnels.Where(p => p.Tunnel == item.ToString()).Any())
                    {
                        grouplocationtunnels.Add(new TunnelCountTemp()
                        {
                            Tunnel = item.ToString(),
                            Count = 0,
                            Proportion = 0
                        });
                    }
                }

                grouplocationtunnels = grouplocationtunnels.OrderBy(p => p.Proportion).ToList();
                var sorttunnels = grouplocationtunnels.OrderBy(p => p.Proportion).Select(p => p.Tunnel).ToList();
                for (var i = 0; i < grouplocationtunnels.Count - 1; i++)
                {
                    if (tasktunnelcountlist.Where(p => p.Tunnel == grouplocationtunnels[i].Tunnel).First().Count - threshold > tasktunnelcountlist.Where(p => p.Tunnel == grouplocationtunnels[i + 1].Tunnel).First().Count)
                    {
                        sorttunnels[i] = grouplocationtunnels[i + 1].Tunnel;
                        sorttunnels[i + 1] = grouplocationtunnels[i].Tunnel;
                        i++;
                    }
                    else
                    {
                        sorttunnels[i] = grouplocationtunnels[i].Tunnel;
                    }
                }
                result.ResData = string.Join(",", sorttunnels);
            }
            //删除没有空闲货位的货架
            var arrresultTunnels = result.ResData.Split(',');
            //获取可分配货位的数
            var emptylocationsreturn = _baseWareLocationrepository.GetList(p => p.WarehouseCode == wcstask.WarehouseCode && p.StateNum == LocationState.LocationState_Empty.GetHashCode() && p.IsStop == 0);
            var resultTunenls = new List<string>();
            foreach (var sorttunnel in arrresultTunnels)
            {
                var tunneltaskcount = wcstasks.Where(p => p.Tunnel == sorttunnel).Count();
                int left = 0;

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

            //考虑根据物料的分布情况


            //获取不可用堆垛机所在巷道
            var equlist = HttpUtil.GetRequest("http://10.30.35.1:8080/api/Wcs/GetAvaiableStations?name=Station");
            var srmtunlist = JsonConvert.DeserializeObject<List<string>>(equlist);
            var tunlist = srmtunlist.Select(p => p).ToList();
            if (tunlist != null)
            {
                var resultTunenlsNew = new List<string>();
                var resultTunenlsTemp = result.ResData.Split(',');
                foreach (var tun in resultTunenlsTemp)
                {
                    if (!tunlist.Select(p => p).Contains(tun))
                    {
                        resultTunenlsNew.Add(tun);
                    }
                }
                result.ResData = string.Join(",", resultTunenlsNew);
            }


            //根据配置过滤禁用的巷道
            var disabletunnels = _sysconfigrepository.GetList(p => p.SType == "InStop" && !string.IsNullOrEmpty(p.SContent));
            if (disabletunnels != null && disabletunnels.Any())
            {
                var resultTunenlsNew = new List<string>();
                var resultTunenlsTemp = result.ResData.Split(',');
                foreach (var tun in resultTunenlsTemp)
                {
                    if (!disabletunnels.Select(p => p.Default1).Contains(tun))
                    {
                        resultTunenlsNew.Add(tun);
                    }
                }
                result.ResData = string.Join(",", resultTunenlsNew);
            }
            //按照堆垛机间隔开
            if (!string.IsNullOrEmpty(result.ResData))
            {
                var list = result.ResData.Split(',');
                var preStr = new List<string>();
                var afterStr = new List<string>();
                foreach (var tun in list)
                {
                    var presrmlist = TunnelSrmRel.Where(p => preStr.Contains(p.Tunnel)).ToList();
                    var cursrm = TunnelSrmRel.Where(p => p.Tunnel == tun).First().Srm;
                    if (!presrmlist.Where(p => p.Srm == cursrm).Any())
                    {
                        preStr.Add(tun);
                    }
                    else
                    {
                        afterStr.Add(tun);
                    }
                }
                preStr.AddRange(afterStr);
                result.ResData = string.Join(",", preStr);
            }
            return result;
        }

        public SRes<PtApplyStockInLocResponse> PtApplyStockInLoc(PtApplyStockInLocRequest reqEntity)
        {
            var res = ApplyStockInLocTemp(reqEntity);
            if (string.IsNullOrEmpty(res.ResData.CellNo))
            {
                return res;
            }

            try
            {
                _db.BeginTran();
                //更新货位
                _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_StockIn.GetHashCode(), ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                       p => p.Code == res.ResData.CellNo);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
            }
            return res;
        }

        private SRes<PtApplyStockInLocResponse> ApplyStockInLocTemp(PtApplyStockInLocRequest reqEntity)
        {
            var res = new SRes<PtApplyStockInLocResponse>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = new PtApplyStockInLocResponse()
            };
            var wcstask = _ptwcsTaskold.AsQueryable().Where(p => p.Id == reqEntity.TaskNum).SplitTable(tabs => tabs.Take(2)).First(); ;
            if (wcstask == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = reqEntity.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            if (wcstask.Type == TaskType.OutDepot)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = "该任务是出库任务，不能分配货位；wms任务号" + wcstask.Id;
                return res;
            }
            if (!string.IsNullOrEmpty(wcstask.AddrTo) && wcstask.AddrTo != "srm")
            {
                res.ResData.TunnelNum = wcstask.Tunnel;
                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;
            }
            if (reqEntity.TunnelNum <= 0)
            {
                res.ResCode = ResponseStatusCodeEnum.NotTunnelNum.GetHashCode();
                res.ResMsg = reqEntity.TaskNum + ResponseStatusCodeEnum.NotTunnelNum.GetDescription();
                return res;
            }
            var warehouse = _baseWareHouserepository.GetFirst(p => p.Code == wcstask.WarehouseCode);
            if (warehouse == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = wcstask.WarehouseCode + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            //验证库存
            var stock = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == wcstask.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = wcstask.BarCode + ResponseStatusCodeEnum.StockNotExist.GetDescription() + "，请确认是否已经入库或没有绑定";
                return res;
            }
            var locell = ApplyStockInLoc(new PtApplyLocRequest()
            {
                MaterialId = stock.MatId,
                MaterialCode = stock.MatCode,
                //Size = stock.Size,
                TunnelNum = reqEntity.TunnelNum,
                WarehuoseId = warehouse.Id,
                IsMove = false,
            });
            if (!locell.ResDataList.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                res.ResMsg = reqEntity.TunnelNum + ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return res;
            }
            //预留货位数量
            //var emptyLoc = _baseWareLocationrepository.AsQueryable().Where(p => p.IsStop == 0
            //&& p.StateNum == LocationState.LocationState_Empty.GetHashCode()
            //&& p.TypeNum == LocationType.LocationType_StorageLocation.GetHashCode()
            //&& p.Tunnel == locell.TunnelNum
            //&& p.WarehouseId == locell.WarehuoseId
            //&& p.Size == locell.Size
            //).OrderBy(p => p.Sort).ToList();

            //if (!emptyLoc.Any())
            //{
            //    res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
            //    res.ResMsg = reqEntity.TunnelNum + ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
            //    return res;
            //}
            ////移库预留货位
            //if (!locell.IsMove && emptyLoc.Count <= int.Parse(AppSettings.GetConfig("IsMoveCellCount")))
            //{
            //    res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
            //    res.ResMsg = reqEntity.TunnelNum + "巷道的可用货位数" + emptyLoc.Count + ",禁止分配货位，预留移库使用";
            //    return res;
            //}

            var loc = locell.ResDataList.First();
            res.ResData.TunnelNum = loc.Tunnel.ToString();
            res.ResData.CellNo = loc.Code;
            res.ResData.Row = loc.Row;
            res.ResData.Colomn = loc.Col;
            res.ResData.Layer = loc.Layer;
            return res;
        }

        private SRes<ptBaseWareLocation> ApplyStockInLoc(PtApplyLocRequest request)
        {
            var res = new SRes<ptBaseWareLocation>() { ResDataList = new List<ptBaseWareLocation>() };
            var emptyLoc = _baseWareLocationrepository.AsQueryable().Where(p => p.IsStop == 0
            && p.StateNum == LocationState.LocationState_Empty.GetHashCode()
            && p.TypeNum == LocationType.LocationType_StorageLocation.GetHashCode()
            && p.Tunnel == request.TunnelNum
            && p.WarehouseId == request.WarehuoseId
            //&& p.Size == request.Size
            ).OrderBy(p => p.Sort).ToList();

            var filterstr = _sysconfigrepository.GetSingle(p => p.Code == "FilterMat").SContent;
            if (!string.IsNullOrEmpty(filterstr) && filterstr.Contains(request.MaterialCode))
            {
                emptyLoc = emptyLoc.Where(p => p.IsFilter == 0).ToList();
            }

            if (!emptyLoc.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                res.ResMsg = request.TunnelNum + ResponseStatusCodeEnum.NotEnoughLocation.GetDescription();
                return res;
            }
            //移库预留货位
            if (!request.IsMove && emptyLoc.Count <= int.Parse(AppSettings.GetConfig("IsMoveCellCount")))
            {
                res.ResCode = ResponseStatusCodeEnum.NotEnoughLocation.GetHashCode();
                res.ResMsg = request.TunnelNum + "巷道的可用货位数" + emptyLoc.Count + ",禁止分配货位，预留移库使用";
                return res;
            }

            res.ResDataList = emptyLoc;
            return res;
        }

        public SRes<int> PtCompleteTask(CompleteTaskRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = reqDto.TaskNum
            };
            var task = _ptwcsTaskold.AsQueryable().Where(p => p.Id == reqDto.TaskNum).SplitTable(tabs => tabs.Take(2)).First();
            if (task == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return result;
            }
            if (task.AddrFrom == "2999")
            {
                result.Memo3 = "1";
            }
            var warehouse = _baseWareHouserepository.GetSingle(p => p.Code == task.WarehouseCode);
            if (warehouse == null)
            {
                result.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                result.ResMsg = task.WarehouseCode + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return result;
            }
            if (task.Type == TaskType.EnterDepot)
            {
                //库存,货位
                try
                {
                    if (task.TaskGroupKey == "1")//异常任务情况
                    {
                        _ptbillInvnow.Delete(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                        _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                        {
                            SContent = "2",
                            EditTime = DateTime.Now,
                            Memo = "空架"
                        }, p => p.Code == task.AddrFrom);
                        return result;
                    }

                    var stock = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    if (stock == null)
                    {
                        result.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        result.ResMsg = task.BarCode + "没有已组盘的信息";
                        return result;
                    }
                    if (string.IsNullOrEmpty(task.AddrTo) || task.AddrTo == "srm")
                    {
                        task.AddrTo = _ptwcsTaskinfo.GetSingle(p => p.ID == reqDto.TaskNum).AddrTo;
                    }

                    int row = int.Parse(task.AddrTo.Split('-')[0]);
                    int col = int.Parse(task.AddrTo.Split('-')[1]);
                    int layer = int.Parse(task.AddrTo.Split('-')[2]);
                    var cell = _baseWareLocationrepository.GetSingle(p => p.Row == row && p.Col == col && p.Layer == layer);
                    if (cell.StateNum != LocationState.LocationState_StockIn.GetHashCode())
                    {
                        result.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                        result.ResMsg = cell.Code + "货位状态不是入库中，不能完成任务";
                        return result;
                    }

                    var sys = _sysconfigrepository.GetSingle(p => p.Code == task.AddrFrom && p.SType == Const.PtPinKuhouseType && p.Default3 == task.Id.ToString() && p.SContent == "4");
                    if (sys != null)
                    {
                        _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                        {
                            SContent = "1",  //1空；2满；3入库锁；4出库锁
                            Default3 = "",
                            EditTime = DateTime.Now,
                            Memo = "",
                        }, p => p.Code == sys.Code);
                    }
                    _db.BeginTran();
                    //更新库存
                    _ptbillInvnow.UpdateModelColumns(p => new ptBillInvnow() { InvStateCode = InvState.InvEcecState_In.ToString(), PutRow = row, PutCol = col, PutLayer = layer, OneInTime = DateTime.Now, EditTime = DateTime.Now, ExecStateCode = InvLockState.InvState_Lock.ToString() },
                           p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_BuildUp.ToString());
                    //_ptbillInvinit.Delete(p => p.ContGrpBarCode == stock.ContGrpBarCode);
                    //更新货位
                    _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_Full.GetHashCode(), ContGrpBarCode = stock.ContGrpBarCode, ContGrpId = stock.ContGrpId, EditTime = DateTime.Now },
                           p => p.Row == row && p.Col == col && p.Layer == layer);
                    var stocklist = _ptbillInvnow.GetList(p => p.ContGrpBarCode == task.BarCode && p.InvStateCode == InvState.InvEcecState_In.ToString());
                    foreach (var item in stocklist)
                    {
                        item.Id = IdFactory.NewId();
                        item.AddTime = DateTime.Now;
                        item.EditTime = DateTime.Now;
                        item.Memo = "入库任务完成";
                    }
                    _ptBillInvFlow.InsertRange(_mapper.Map<List<ptBillInvFlow>>(stocklist));
                    var list = new List<ptBillPushinfo>();

                    string pushtype = "";
                    if (task.BusType == PtTaskBusType.TaskBusType_PT_PurchaseStockIn.GetDescription())
                    {
                        pushtype = PtFackbeekType.InterfaceType_PT_PurchaseStockIn.ToString();
                    }
                    else if (task.BusType == PtTaskBusType.TaskBusType_PT_ProductionBackStockIn.GetDescription())
                    {
                        pushtype = PtFackbeekType.ReturnMat.ToString();
                    }

                    //回调数据
                    foreach (var item in stocklist)
                    {
                        list.Add(new ptBillPushinfo
                        {
                            DocsNo = stock.InDocsNo,
                            TypeCode = pushtype,
                            RFIDBarCode = stock.ContGrpBarCode,
                            HWBarCode = stock.RodBarCode,
                            CLBarCode = item.CLBarCode,
                            WarehouseId = warehouse.Id,
                            WarehouseCode = warehouse.Code,
                            WareCellId = 0,
                            WareCellCode = task.AddrTo,
                            MatId = item.MatId,
                            MatCode = item.MatCode,
                            MatName = item.MatName,
                            ReqNo = Guid.NewGuid().ToString()
                        });
                    }
                    _ptbillPushinfo.InsertRange(list);
                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = task.Id + "完成任务异常";
                    _logger.LogInformation("完成任务异常" + ex.ToString());
                }
            }
            else if (task.Type == TaskType.OutDepot)
            {
                //库存删除
                var stocklist = _ptbillInvnow.GetList(p => p.ContGrpBarCode == task.BarCode && 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<ptBillInvFlow>>(stocklist);
                foreach (var item in flowlist)
                {
                    item.Id = IdFactory.NewId();
                    item.InvStateCode = InvState.InvEcecState_Out.ToString();
                    item.AddTime = DateTime.Now;
                    item.EditTime = DateTime.Now;
                    item.Memo = "出库任务完成,至" + task.AddrTo;
                }
                var list = new List<ptBillPushinfo>();
                string pushtype = "";
                if (task.BusType == PtTaskBusType.TaskBusType_PT_ProductionStockOut.GetDescription())
                {
                    pushtype = PtFackbeekType.PickMat.ToString();
                    //回调数据
                    foreach (var item in stocklist)
                    {
                        list.Add(new ptBillPushinfo
                        {
                            DocsNo = task.TaskGroupKey,
                            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,
                            ReqNo = Guid.NewGuid().ToString()
                        });
                    }
                }
                else if (task.BusType == "手动出库")
                {
                    //回调数据
                    foreach (var item in stocklist)
                    {
                        list.Add(new ptBillPushinfo
                        {
                            DocsNo = task.TaskGroupKey,
                            TypeCode = "Manual",
                            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,
                            ReqNo = Guid.NewGuid().ToString()
                        });
                    }
                }
                var sys = _sysconfigrepository.GetSingle(p => p.Code == task.AddrTo && p.SType == Const.PtPinKuhouseType && (p.Default1 == Const.PinKu_22Type || p.Default1 == Const.ProductType));
                try
                {
                    _db.BeginTran();
                    _ptbillInvnow.Delete(p => stocklist.Select(p => p.Id).ToList().Contains(p.Id));
                    _ptbillInvinit.Delete(p => p.ContGrpBarCode == task.BarCode);
                    if (sys != null)
                    {
                        _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                        {
                            SContent = "2",
                            EditTime = DateTime.Now,
                            Memo = "满架"
                        }, p => p.Code == sys.Code);
                    }

                    _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_Empty.GetHashCode(), ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                        p => p.StateNum == LocationState.LocationState_StockOut.GetHashCode() && p.ContGrpId == flowlist.First().ContGrpId && p.Code.Contains(task.AddrFrom));
                    if (task.BusType == PtTaskBusType.TaskBusType_PT_ProductionStockOut.GetDescription() || task.BusType == "手动出库")
                    {
                        _ptbillPushinfo.InsertRange(list);
                    }
                    _ptBillInvFlow.InsertRange(flowlist);

                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    _logger.LogInformation(ex.ToString());
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = task.Id + "完成任务异常";
                }
            }
            else if (task.Type == TaskType.TransferDepot)
            {
                var fromcell = _baseWareLocationrepository.GetFirst(p => p.Code == task.AddrFrom);
                var grcontid = fromcell.ContGrpId;
                var grcontcode = fromcell.ContGrpBarCode;
                var fromcellno = fromcell.Code;
                var tocellno = task.AddrTo;

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

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

                    //流水表
                    var flow = _mapper.Map<ptBillInvFlow>(stock);
                    flow.Id = IdFactory.NewId();
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    flow.Memo = grcontcode + "移库(" + fromcellno + "至" + tocellno + ")";
                    _ptBillInvFlow.Insert(flow);
                    //推送表
                    _db.CommitTran();
                }
                catch (Exception ex)
                {
                    _db.RollbackTran();
                    result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                    result.ResMsg = task.Id + "完成任务异常";
                    _logger.LogInformation("完成任务异常" + ex.ToString());
                }
            }
            else if (task.Type == TaskType.Delivery)
            {
                var sys = _sysconfigrepository.GetSingle(p => p.Code == task.AddrTo && p.Default1 != "OutPinKu" && p.Default1 != "InPinKu");
                if (sys != null)
                {
                    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    {
                        SContent = "2",
                        EditTime = DateTime.Now,
                        Memo = "空架"
                    }, p => p.Code == task.AddrTo);
                }
                //_sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                //{
                //    SContent = "1",
                //    Default3 = "",
                //    EditTime = DateTime.Now,
                //    Default4 = task.Id.ToString()
                //}, p => p.Code == task.AddrFrom && p.Default1 != "OutPinKu" && p.Default1 != "InPinKu");
            }
            return result;
        }

        public SRes<int> PtSrmPickOutCompleted(PtSrmPickOutCompletedRequest reqDto)
        {
            var result = new SRes<int>()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription(),
                ResData = reqDto.TaskNum
            };
            var wcstask = _ptwcsTaskold.AsQueryable().Where(p => p.Id == reqDto.TaskNum).SplitTable(tabs => tabs.Take(2)).First();
            if (wcstask == null)
            {
                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.WcsTaskStateIsComplete.GetHashCode();
                result.ResMsg = reqDto.TaskNum + ResponseStatusCodeEnum.WcsTaskStateIsComplete.GetDescription();
                return result;
            }
            try
            {
                _db.BeginTran();
                //更新库存
                _ptbillInvnow.UpdateModelColumns(p => new ptBillInvnow() { PutRow = 0, PutCol = 0, PutLayer = 0 }, p => p.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && p.ContGrpBarCode == wcstask.BarCode);
                var stocklist = _ptbillInvnow.GetList(p => p.ContGrpBarCode == wcstask.BarCode && 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<ptBillInvFlow>>(stocklist);
                foreach (var item in flowlist)
                {
                    item.Id = IdFactory.NewId();
                    item.AddTime = DateTime.Now;
                    item.EditTime = DateTime.Now;
                    item.Memo = "堆垛机出库放货完成";
                }
                //货位
                _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { StateNum = LocationState.LocationState_Empty.GetHashCode(), ContGrpBarCode = "", ContGrpId = 0, EditTime = DateTime.Now },
                         p => p.ContGrpBarCode == wcstask.BarCode && p.Code.Contains(wcstask.AddrFrom));
                _ptBillInvFlow.InsertRange(flowlist);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                _logger.LogInformation(ex.ToString());
                result.ResCode = ResponseStatusCodeEnum.InnerServerErr.GetHashCode();
                result.ResMsg = wcstask.Id + "堆垛机出库放货完成异常";
            }

            return result;
        }

        public SRes GetSyncMaterInfo(PtSyncMaterInfoListRequest ResData)
        {
            var res = new SRes();
            if (!string.IsNullOrEmpty(ResData.MatCode))
            {
                ResData.UpdatedTime = DateTime.Now.ToString();
                if (_materrepository.IsAny(p => p.Code == ResData.MatCode))
                {
                    _materrepository.UpdateModelColumns(p => new ptBaseMater() { IsHold = ResData.IsHold, HoldDuration = ResData.HoldDuration, Name = ResData.MatName, EditTime = DateTime.Now, Description = ResData.Describe },
                       p => p.Code == ResData.MatCode);
                }
                else
                {
                    var model = _mapper.Map<ptBaseMater>(ResData);
                    model.AddTime = DateTime.Now;
                    model.WarehouseId = 1685164446336552960;
                    _materrepository.Insert(model);
                }
            }
            return res;
        }

        public SRes PinkuInfoManagement(PtSrmPickOutCompletedRequest request)
        {
            var res = new SRes();

            var task = _ptwcsTaskold.AsQueryable().Where(p => p.Id == request.TaskNum && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            if (task.Type == TaskType.EnterDepot)
            {
                var sys = _sysconfigrepository.GetSingle(p => p.Code == task.AddrFrom && p.SType == Const.PtPinKuhouseType);
                if (sys.SContent == "1")
                {
                    return res;
                }
                else
                {
                    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    {
                        SContent = "1",  //1空；2满；3入库锁；4出库锁
                        Default3 = "",
                        EditTime = DateTime.Now,
                        Memo = "",
                    }, p => p.Code == sys.Code);
                }
            }
            else if (task.Type == TaskType.Delivery)
            {
                var sys = _sysconfigrepository.GetSingle(p => p.Code == task.AddrFrom && p.SType == Const.PtPinKuhouseType && p.Default1 != "InPinKu" && p.Default1 != "OutPinKu");
                if (sys != null)
                {
                    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    {
                        SContent = "1",  //1空；2满；3入库锁；4出库锁
                        Default3 = "",
                        EditTime = DateTime.Now,
                        Memo = "",
                    }, p => p.Code == sys.Code);
                }
            }
            return res;
        }

        /// <summary>
        /// 堆垛机入库站台请求搬运任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PinKuCarryInTask(PinkucarryTaskRequest request)
        {
            var res = new SRes();
            var syslist = _sysconfigrepository.GetList(p => p.SType == Const.PtPinKuhouseType);
            var sys = syslist.Where(p => p.Code == request.Equip && (p.Default1 == "InPinKu" || p.Default1 == Const.ProductType)).First();
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            var taskold = _ptwcsTaskold.AsQueryable().Where(p => p.AddrFrom == request.Equip && p.Type == TaskType.Delivery && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (taskold != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Equip + "已存在自动补空架子任务，请稍后再试";
                return res;
            }
            try
            {
                var sysCode = syslist.Where(p => p.Default1 == Const.PinKu_22Type && p.SContent == "1").First();
                if (sysCode == null)
                {
                    //查找生产交接区的6个缓存位
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "已没有可用的平库点位，请先发起入库任务";
                    return res;
                }
                var wcs = new ptWCS_TaskInfo()
                {
                    BarCode = "",
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.Delivery,
                    Priority = 0,
                    Device = sysCode.Code,
                    SrmStation = sysCode.Code,
                    AddrFrom = request.Equip,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = sysCode.Code,
                    Tunnel = "",
                    PalletType = 1,
                    BusType = PtTaskBusType.TaskBusType_PT_AotuShelf.GetDescription()
                };
                _db.BeginTran();

                var task = _ptwcsTaskinfo.InsertReturnEntity(wcs);
                _ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(task));
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = task.AddrFrom + "搬运至" + task.AddrTo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = task.BusType
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    SContent = "3",
                    EditTime = DateTime.Now,
                    Default3 = task.ID.ToString()
                }, p => p.Code == sysCode.Code);
                _db.CommitTran();
                res.Memo1 = task.AddrFrom + "搬运至" + task.AddrTo;
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }

            return res;
        }

        /// <summary>
        /// 堆垛机出库站台请求搬运任务
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public SRes PinKuCarryOutTask(PinkucarryTaskRequest request)
        {
            var res = new SRes();
            var syslist = _sysconfigrepository.GetList(p => p.SType == Const.PtPinKuhouseType);
            var sys = syslist.Where(p => p.Code == request.Equip && p.Default1 == "OutPinKu").First();
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            var taskold = _ptwcsTaskold.AsQueryable().Where(p => p.AddrTo == request.Equip && p.Type == TaskType.Delivery && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (taskold != null)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Equip + "已存在自动补空架子任务，请稍后再试";
                return res;
            }
            try
            {
                string sysCode = "";
                //if (syslist.Where(p => p.Default1 == "ProductPinKu" && p.SContent == "2").Any())
                //{
                //    sysCode = syslist.Where(p => p.Default1 == "ProductPinKu" && p.SContent == "2").First().Code;
                //}
                //else
                //{
                //    if (syslist.Where(p => p.Default1 == "22PinKu" && p.SContent == "2").Any())
                //    {
                //        sysCode = syslist.Where(p => p.Default1 == "22PinKu" && p.SContent == "2").First().Code;
                //    }
                //    else
                //    {
                //        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //        res.ResMsg = "没有可用的架子用于出库站台";
                //        return res;
                //    }
                //}
                if (syslist.Where(p => p.Default1 == Const.ProductType && p.SContent == "2" && p.Memo == "空架").Any())
                {
                    sysCode = syslist.Where(p => p.Default1 == Const.ProductType && p.SContent == "2" && p.Memo == "空架").First().Code;
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = "交接区没有可用的架子用于出库站台" + request.Equip;
                    return res;
                }
                var wcs = new ptWCS_TaskInfo()
                {
                    BarCode = "",
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.Delivery,
                    Priority = 0,
                    Device = request.Equip,
                    SrmStation = request.Equip,
                    AddrFrom = sysCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = request.Equip,
                    Tunnel = "",
                    PalletType = 1,
                    BusType = PtTaskBusType.TaskBusType_PT_AotuShelf.GetDescription()
                };
                _db.BeginTran();
                var task = _ptwcsTaskinfo.InsertReturnEntity(wcs);
                _ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(task));
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = task.AddrFrom + "搬运至" + task.AddrTo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = task.BusType
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    SContent = "4",
                    EditTime = DateTime.Now,
                    Default3 = task.ID.ToString()
                }, p => p.Code == sysCode);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            return res;
        }

        public SRes ProductMaterInfo(ProductMaterInfoRequest request)
        {
            var res = new SRes();
            var sys = _sysconfigrepository.GetSingle(p => p.Code == request.Equip && p.Default1 == Const.ProductType);
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
            {
                Default2 = string.Join(",", request.Code),
                EditTime = DateTime.Now,
                Default5 = request.BoilerNo
            }, p => p.Code == request.Equip);
            return res;
        }

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

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

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

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

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

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

        private SRes CancelTask(CompleteTaskRequest request)
        {
            var res = new SRes()
            {
                ResCode = ResponseStatusCodeEnum.Sucess.GetHashCode(),
                ResMsg = ResponseStatusCodeEnum.Sucess.GetDescription()
            };

            var task = _ptwcsTaskold.AsQueryable().Where(p => p.Id == request.TaskNum && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNum + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            try
            {
                if (task.Type == TaskType.EnterDepot)
                {
                    //验证组盘状态
                    var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var flow = _mapper.Map<ptBillInvFlow>(stock);
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_Out.ToString();
                    flow.Memo = "WCS取消任务";
                    flow.EditTime = DateTime.Now;
                    _db.BeginTran();
                    _ptbillInvnow.DeleteById(stock.Id);
                    _ptbillInvinit.Delete(p => p.ContGrpBarCode == task.BarCode);
                    _ptBillInvFlow.Insert(flow);
                    var conf = _sysconfigrepository.GetSingle(p => p.Code == task.AddrFrom);
                    if (conf.SContent == "4" && conf.Default3 == task.Id.ToString())
                    {
                        _sysconfigrepository.UpdateModelColumns(p => new ptSysConfig() { SContent = "2" }, p => p.Code == task.AddrFrom && p.SType == "Pinku");
                    }
                    _db.CommitTran();
                }
                else if (task.Type == TaskType.OutDepot)
                {
                    //验证组盘状态
                    var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (stock == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                        res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                        return res;
                    }
                    var cell = _baseWareLocationrepository.GetSingle(p => p.ContGrpBarCode == task.BarCode);
                    if (cell == null)
                    {
                        res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                        res.ResMsg = task.BarCode + ResponseStatusCodeEnum.Fail.GetDescription() + "堆垛机已放货完成，不允许取消";
                        return res;
                    }
                    var flow = _mapper.Map<ptBillInvFlow>(stock);
                    flow.Id = GetId();
                    flow.InvStateCode = InvState.InvEcecState_In.ToString();
                    flow.Memo = "WCS取消任务";
                    flow.AddTime = DateTime.Now;
                    flow.EditTime = DateTime.Now;
                    _db.BeginTran();
                    _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
                    {
                        StateNum = 2,
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == task.BarCode);
                    _ptbillInvnow.UpdateSetColumnsTrue(p => new ptBillInvnow()
                    {
                        InvStateCode = InvState.InvEcecState_In.ToString(),
                        PutRow = cell.Row,
                        PutCol = cell.Col,
                        PutLayer = cell.Layer,
                        EditTime = DateTime.Now
                    }, p => p.ContGrpBarCode == task.BarCode);
                    //取消任务不再修改架子状态，现场人员一直搞不清楚，让他们手动修改2024-4-28
                    //_sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    //{
                    //    SContent = "1",
                    //    EditTime = DateTime.Now,
                    //    Memo = "手动取消出库任务"
                    //}, p => p.Code == task.AddrTo);
                    _ptBillInvFlow.Insert(flow);
                    _db.CommitTran();
                }
                else if (task.Type == TaskType.Delivery)
                {
                    //取消任务不再修改架子状态，现场人员一直搞不清楚，让他们手动修改2024-4-28
                    //var sysTo = _sysconfigrepository.GetSingle(p => p.Code == task.AddrTo && p.Default1 != "OutPinKu" && p.Default1 != "InPinKu");
                    //if (sysTo != null)
                    //{
                    //    _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    //    {
                    //        SContent = "1",
                    //        EditTime = DateTime.Now,
                    //        Memo = ""
                    //    }, p => p.Code == task.AddrTo);
                    //}
                    //_sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                    //{
                    //    SContent = "2",
                    //    Default3 = "",
                    //    Memo = "空架",
                    //    EditTime = DateTime.Now,
                    //    Default4 = task.Id.ToString()
                    //}, p => p.Code == task.AddrFrom && p.Default3 == task.Id.ToString() && p.Default1 != "OutPinKu" && p.Default1 != "InPinKu");

                    return res;
                }
                else
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + "该任务类型不允许取消";
                    return res;
                }
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = task.Id + ResponseStatusCodeEnum.Fail.GetDescription();
                _logger.LogInformation("任务取消失败,任务号：" + task.Id + ex.Message);
                return res;
            }

            return res;
        }

        public SRes MoveTaskInfo(MoveTaskRequest request)
        {
            var res = new SRes();
            var cell = _baseWareLocationrepository.GetSingle(p => p.Code == request.Cell);
            if (cell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.Cell + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }

            if (cell.Tunnel == 1 || cell.Tunnel == 2)
            {
                if (request.Tunnel != 1 && request.Tunnel != 2)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = cell.Tunnel + "巷道不能移" + request.Tunnel + "巷道，不是相邻巷道";
                    return res;
                }
            }
            else if (cell.Tunnel == 3 || cell.Tunnel == 4)
            {
                if (request.Tunnel != 3 && request.Tunnel != 4)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = cell.Tunnel + "巷道不能移" + request.Tunnel + "巷道，不是相邻巷道";
                    return res;
                }
            }
            else if (cell.Tunnel == 5 || cell.Tunnel == 6)
            {
                if (request.Tunnel != 5 && request.Tunnel != 6)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = cell.Tunnel + "巷道不能移" + request.Tunnel + "巷道，不是相邻巷道";
                    return res;
                }
            }
            else if (cell.Tunnel == 7 || cell.Tunnel == 8)
            {
                if (request.Tunnel != 7 && request.Tunnel != 8)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = cell.Tunnel + "巷道不能移" + request.Tunnel + "巷道，不是相邻巷道";
                    return res;
                }
            }

            var stock = _ptbillInvnow.GetSingle(p => p.ContGrpBarCode == cell.ContGrpBarCode);
            if (stock == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.StockNotExist.GetDescription();
                return res;
            }
            string srm = "";
            switch (request.Tunnel)
            {
                case 1:
                    srm = "1";
                    break;

                case 2:
                    srm = "1";
                    break;

                case 3:
                    srm = "2";
                    break;

                case 4:
                    srm = "2";
                    break;

                case 5:
                    srm = "3";
                    break;

                case 6:
                    srm = "3";
                    break;

                case 7:
                    srm = "4";
                    break;

                case 8:
                    srm = "4";
                    break;

                default:
                    break;
            }
            var toCell = ApplyStockInLoc(new PtApplyLocRequest()
            {
                TunnelNum = request.Tunnel,
                Size = 1,
                IsMove = true,
                WarehuoseId = cell.WarehouseId
            });
            if (!toCell.ResDataList.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Tunnel + "移库目标货位获取失败，已没有可用货位";
                return res;
            }
            var cell1 = toCell.ResDataList.First();
            try
            {
                _db.BeginTran();
                _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
                {
                    StateNum = LocationState.LocationState_StockMove.GetHashCode(),
                    EditTime = DateTime.Now
                }, p => p.Code == cell1.Code);
                _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
                {
                    StateNum = LocationState.LocationState_StockMove.GetHashCode(),
                    EditTime = DateTime.Now
                }, p => p.Code == cell.Code);
                var task = new ptWCS_TaskInfo()
                {
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.TransferDepot,
                    Priority = 0,
                    Device = "SRM" + srm,
                    SrmStation = "",
                    AddrFrom = cell.Code,
                    BarCode = cell.ContGrpBarCode,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = cell1.Code,
                    Tunnel = request.Tunnel.ToString(),
                    PalletType = 1,
                    MaterialCode = stock.MatCode,
                    BusType = PtTaskBusType.TaskBusType_PT_Move.GetDescription()
                };
                var wcs = _ptwcsTaskinfo.InsertReturnEntity(task);
                _ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(wcs));
                var wcsdtl = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = wcs.AddrFrom,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = wcs.ID,
                    Desc = wcs.AddrFrom + "移库至" + wcs.AddrTo,
                };
                _ptwcsTaskdtl.InsertableSplitTable(wcsdtl);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes ForceCancelTask(ErrorTaskRequest request)
        {
            var res = new SRes();
            if (string.IsNullOrEmpty(request.TaskNo))
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription();
                return res;
            }
            if (request.WareHouse != Const.PtWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var task = _ptwcsTaskold.AsQueryable().Where(p => p.Id == int.Parse(request.TaskNo) && p.Status < TaskStatus.Finish).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = request.TaskNo + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                _ptwcsTaskold.AsUpdateable().SetColumns(p => new ptWCS_TaskOld() { Status = TaskStatus.Cancel, ManualRemarks = "强制取消任务", EditTime = DateTime.Now }).Where(p => p.Id == int.Parse(request.TaskNo)).SplitTable(p => p.Take(2)).ExecuteCommand();
                return res;
            }
            if (_ptwcsTaskinfo.Delete(p => p.ID == int.Parse(request.TaskNo)))
            {
                _ptwcsTaskold.AsUpdateable().SetColumns(p => new ptWCS_TaskOld() { Status = TaskStatus.Cancel, ManualRemarks = "强制取消任务", EditTime = DateTime.Now }).Where(p => p.Id == task.Id).SplitTable(p => p.Take(2)).ExecuteCommand();
            }
            return res;
        }

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

        public SRes DeleteBarCodeInfo(DetailCodeStrRequest request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.PtWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var barcode = _ptbillInvinit.GetSingle(p => p.CLBarCode == request.Code);
            if (barcode == null)
            {
                res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.BaseBarcodeNotExist.GetDescription();
                return res;
            }
            else
            {
                var stock = _ptbillInvnow.GetSingle(p => p.CLBarCode == request.Code);
                if (stock != null)
                {
                    res.ResCode = ResponseStatusCodeEnum.StockNotExist.GetHashCode();
                    res.ResMsg = request.Code + "存在库存信息，不允许直接删除条码";
                    return res;
                }

                _ptbillInvinit.Delete(p => p.CLBarCode == request.Code);
                var flow = _mapper.Map<ptBillInvFlow>(barcode);
                flow.Id = GetId();
                flow.AddTime = DateTime.Now;
                flow.EditTime = DateTime.Now;
                flow.Memo = "手动删除条码信息";
                _ptBillInvFlow.Insert(flow);
            }
            return res;
        }

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

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

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

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

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

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

            return res;
        }

        public SRes UpdateCellState(DetailCodeStr1Requestdto request)
        {
            var res = new SRes();
            if (request.WareHouse != Const.PtWareHouse)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = request.WareHouse + ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var cell = _baseWareLocationrepository.GetSingle(p => p.Code == request.Code);
            if (cell == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WareLocationCodeNotExist.GetHashCode();
                res.ResMsg = request.Code + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            _baseWareLocationrepository.UpdateSetColumnsTrue(p => new ptBaseWareLocation()
            {
                StateNum = request.State,
                EditTime = DateTime.Now
            }, p => p.Code == request.Code);

            return res;
        }

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

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

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

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

        public ptSysJob GetJobEntityByCode(string Code)
        {
            return _sysJobrepository.GetSingle(p => p.Code == Code);
        }

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

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

        private List<string> GetPinkuMater()
        {
            var materlist = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && !string.IsNullOrEmpty(p.Default2));
            List<string> list = new List<string>();
            if (materlist.Any())
            {
                foreach (var item in materlist)
                {
                    var mater = item.Default2.Split(',');
                    for (int i = 0; i < mater.Length; i++)
                    {
                        list.Add(mater[i]);
                    }
                }
            }
            return list;
        }

        public SRes PdaProductRequisition(PtUnboundRequest request)
        {
            var res = new SRes();
            request.Equip = request.Equip.Substring(0, 4);
            var sys = _sysconfigrepository.GetSingle(p => p.Default1 == Const.ProductType && p.Code == request.Equip);
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            if (sys.SContent == "1")
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Equip + "当前叫料位是空状态，不需要手持机操作";
                return res;
            }
            else if (sys.SContent == "3" || sys.SContent == "4")
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Equip + "当前叫料位有任务进行中，请确认当前任务中是否存在该点位任务";
                return res;
            }

            //else if (sys.Memo == "空架")
            //{
            //    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
            //    res.ResMsg = request.Equip + "请不要重复操作";
            //    return res;
            //}
            //先判断22个位置有没有空位，有的话直接送走
            var toEquip = _sysconfigrepository.GetFirst(p => p.SType == Const.PtPinKuhouseType && p.Default1 == Const.PinKu_22Type && p.SContent == "1");
            if (toEquip != null)
            {
                return PdaProductRequisition2(request);
            }

            try
            {
                //var toEquip = _sysconfigrepository.GetFirst(p => p.SType == Const.PtPinKuhouseType && p.Default1 == Const.PinKu_22Type && p.SContent == "1");
                //if (toEquip == null)
                //{
                //    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                //    res.ResMsg = request.Equip + "库前没有可用的目前点位";
                //    return res;
                //}
                //var wcs = new ptWCS_TaskInfo()
                //{
                //    BarCode = "",
                //    Status = TaskStatus.NewBuild,
                //    Type = TaskType.Delivery,
                //    Priority = 0,
                //    Device = toEquip.Code,
                //    SrmStation = toEquip.Code,
                //    AddrFrom = request.Equip,
                //    AddWho = "wms",
                //    EditWho = "wms",
                //    WarehouseCode = Const.PtWareHouse,
                //    AddrTo = toEquip.Code,
                //    Tunnel = "",
                //    PalletType = 1,
                //    BusType = PtTaskBusType.TaskBusType_PT_AotuShelf.GetDescription()
                //};
                _db.BeginTran();
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    Memo = "空架",
                    EditTime = DateTime.Now
                }, p => p.Code == request.Equip);
                //_sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                //{
                //    SContent = "4",
                //}, p => p.Code == toEquip.Code);
                //var task = _ptwcsTaskinfo.InsertReturnEntity(wcs);
                //_ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(task));
                //var taskdetail = new ptWCS_TaskDtl()
                //{
                //    ID = Guid.NewGuid(),
                //    CurPoint = task.AddrFrom + "搬运至" + task.AddrTo,
                //    AddTime = DateTime.Now,
                //    AddWho = "wms",
                //    Enabled = true,
                //    ParentTaskCode = task.ID,
                //    Desc = task.BusType
                //};
                //_ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes PdaProductRequisition2(PtUnboundRequest request)
        {
            var res = new SRes();
            request.Equip = request.Equip.Substring(0, 4);
            var sys = _sysconfigrepository.GetSingle(p => p.Default1 == Const.ProductType && p.Code == request.Equip);
            if (sys == null)
            {
                res.ResCode = ResponseStatusCodeEnum.EquipInfoNotExist.GetHashCode();
                res.ResMsg = request.Equip + ResponseStatusCodeEnum.EquipInfoNotExist.GetDescription();
                return res;
            }
            if (sys.SContent != "2")
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = request.Equip + "当前叫料位不是有货状态";
                return res;
            }
            try
            {
                var toEquip = _sysconfigrepository.GetFirst(p => p.SType == Const.PtPinKuhouseType && p.Default1 == Const.PinKu_22Type && p.SContent == "1");
                if (toEquip == null)
                {
                    res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                    res.ResMsg = request.Equip + "库前没有可用的目前点位";
                    return res;
                }
                var wcs = new ptWCS_TaskInfo()
                {
                    BarCode = "",
                    Status = TaskStatus.NewBuild,
                    Type = TaskType.Delivery,
                    Priority = 0,
                    Device = toEquip.Code,
                    SrmStation = toEquip.Code,
                    AddrFrom = request.Equip,
                    AddWho = "wms",
                    EditWho = "wms",
                    WarehouseCode = Const.PtWareHouse,
                    AddrTo = toEquip.Code,
                    Tunnel = "",
                    PalletType = 1,
                    BusType = PtTaskBusType.TaskBusType_PT_AotuShelf.GetDescription()
                };
                _db.BeginTran();
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    Memo = "空架",
                    SContent = "4",
                    EditTime = DateTime.Now
                }, p => p.Code == request.Equip);
                _sysconfigrepository.UpdateSetColumnsTrue(p => new ptSysConfig()
                {
                    SContent = "3",
                }, p => p.Code == toEquip.Code);
                var task = _ptwcsTaskinfo.InsertReturnEntity(wcs);
                _ptwcsTaskold.InsertableSplitTable(_mapper.Map<ptWCS_TaskOld>(task));
                var taskdetail = new ptWCS_TaskDtl()
                {
                    ID = Guid.NewGuid(),
                    CurPoint = task.AddrFrom + "搬运至" + task.AddrTo,
                    AddTime = DateTime.Now,
                    AddWho = "wms",
                    Enabled = true,
                    ParentTaskCode = task.ID,
                    Desc = task.BusType
                };
                _ptwcsTaskdtl.InsertableSplitTable(taskdetail);
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.Fail.GetDescription() + ex.Message;
                return res;
            }
            return res;
        }

        public SRes MoniterEmptCon(PtUnboundRequest request)
        {
            var res = new SRes();

            var sysconflst = _sysconfigrepository.GetList(p => p.Default1 == Const.ProductType && p.SContent == "2" && p.Memo == "空架");
            if (sysconflst != null && sysconflst.Any())
            {
                foreach (var item in sysconflst)
                {
                    var toEquip = _sysconfigrepository.GetFirst(p => p.SType == Const.PtPinKuhouseType && p.Default1 == Const.PinKu_22Type && p.SContent == "1");
                    if (toEquip != null)
                    {
                        PdaProductRequisition2(new PtUnboundRequest() { Equip = item.Code });
                    }
                }
            }
            return res;
        }

        public SRes HandErrTask(DetailRequest2Str request)
        {
            var res = new SRes();
            try
            {
                if (!_ptwcsTaskold.AsQueryable().Where(p => p.Id == int.Parse(request.Id)).SplitTable(p => p.Take(2)).Any())
                {
                    res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                    res.ResMsg = request.Id + "任务不存在";
                    return res;
                }

                _db.BeginTran();
                _ptwcsTaskinfo.AsUpdateable().SetColumns(p => new ptWCS_TaskInfo()
                {
                    TaskGroupKey = "1"
                }).Where(p => p.ID == int.Parse(request.Id)).ExecuteCommand();
                _ptwcsTaskold.AsUpdateable().SetColumns(p => new ptWCS_TaskOld()
                {
                    TaskGroupKey = "1"
                }).Where(p => p.Id == int.Parse(request.Id)).SplitTable(p => p.Take(2)).ExecuteCommand();
                _db.CommitTran();
            }
            catch (Exception ex)
            {
                _db.RollbackTran();
                res.ResCode = ResponseStatusCodeEnum.DataSaveErr.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DataSaveErr.GetDescription();
            }

            return res;
        }

        //修改任务RFID
        public SRes UpdateTaskCont(UpdateTaskContRequest req)
        {
            var res = new SRes();
            var task = _ptwcsTaskinfo.GetSingle(p => p.ID == req.TaskCode);
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WcsTaskNotExist.GetHashCode();
                res.ResMsg = req.TaskCode + ResponseStatusCodeEnum.WcsTaskNotExist.GetDescription();
                return res;
            }
            if (req.BarCode == task.BarCode)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = req.TaskCode + "当前任务RFID已是" + task.BarCode;
                return res;
            }
            if (_ptwcsTaskinfo.IsAny(p => p.BarCode == req.BarCode && p.ID != req.TaskCode))
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = string.Format("{0}RFID号已经存在任务，请到当前任务列表确认", req.BarCode);
                return res;
            }
            if (!string.IsNullOrEmpty(task.AddrTo))
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = string.Format("当前任务{0}已经分配货位，不允许修改RFID", req.TaskCode);
                return res;
            }
            _ptwcsTaskinfo.AsUpdateable().SetColumns(p => new ptWCS_TaskInfo()
            {
                BarCode = req.BarCode
            }).Where(p => p.ID == req.TaskCode).ExecuteCommand();
            _ptwcsTaskold.AsUpdateable().SetColumns(p => new ptWCS_TaskOld()
            {
                BarCode = req.BarCode
            }).Where(p => p.Id == req.TaskCode).SplitTable(p => p.Take(2)).ExecuteCommand();
            return res;
        }

        //修改货位RFID
        public SRes UpdateLocationContGrpBarCode(UpdateLocationContGrpBarCode req)
        {
            var res = new SRes();
            var loc = _baseWareLocationrepository.GetSingle(p => p.Code == req.LocCode);
            if (loc == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = req.LocCode + ResponseStatusCodeEnum.WareLocationCodeNotExist.GetDescription();
                return res;
            }
            if (_ptwcsTaskold.AsQueryable().Where(p => p.BarCode == req.ContGrpBarCode && p.Status < TaskStatus.Finish).SplitTable(tas => tas.Take(2)).Any())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = string.Format("当前RFID{0}存在进行中任务，不允许修改", req.ContGrpBarCode);
                return res;
            }
            if (loc.StateNum != LocationState.LocationState_Full.GetHashCode())
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = string.Format("当前货位{0}不是满料状态，不允许修改", req.LocCode);
                return res;
            }
            _baseWareLocationrepository.UpdateModelColumns(p => new ptBaseWareLocation() { ContGrpBarCode = req.ContGrpBarCode }, p => p.Code == req.LocCode);

            return res;
        }

        /// <summary>
        /// 添加组盘信息
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public SRes AddStock(UpdateTaskContRequest req)
        {
            var res = new SRes();
            var bar = _ptbillInvinit.GetSingle(p => p.ContGrpBarCode == req.BarCode);
            if (bar == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                return res;
            }
            var stock = _mapper.Map<ptBillInvnow>(bar);
            stock.Id = IdFactory.NewId();
            stock.AddTime = DateTime.Now;
            stock.EditTime = DateTime.Now;
            _ptbillInvnow.Insert(stock);
            return res;
        }

        public SRes<int> MonitorLeftStock(WebErrorRequest request)
        {
            var res = new SRes<int>() { ResDataList = new List<int>() };
            var histasklist = _ptwcsTaskold.AsQueryable().SplitTable(tabs => tabs.Take(2)).Where(p => p.Status == TaskStatus.Finish && p.EndTime > DateTime.Now.AddHours(-1)).ToList();
            if (histasklist != null && histasklist.Any())
            {
                foreach (var histask in histasklist)
                {
                    var stock = _ptbillInvnow.GetFirst(p => p.ContGrpBarCode == histask.BarCode);
                    if (stock != null)
                    {
                        if (histask.Type == TaskType.EnterDepot && stock.InvStateCode == InvState.InvEcecState_BuildUp.ToString() && histask.AddTime.Date == stock.AddTime.Date)
                        {
                            PtCompleteTask(new CompleteTaskRequest()
                            {
                                TaskNum = histask.Id,
                                OperationType = 2,
                                WCSUpdateName = "监控处理残留",
                                Memo1 = "监控处理残留",
                                Memo2 = "监控处理残留"
                            });
                        }
                        else if (histask.Type == TaskType.OutDepot && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString() && histask.AddTime.Date == stock.EditTime.Date)
                        {
                            PtCompleteTask(new CompleteTaskRequest()
                            {
                                TaskNum = histask.Id,
                                OperationType = 2,
                                WCSUpdateName = "监控处理残留",
                                Memo1 = "监控处理残留",
                                Memo2 = "监控处理残留"
                            });
                        }
                        //else if (histask.Type == TaskType.Delivery)
                        //{
                        //    if (_baseWareLocationrepository.GetSingle(p => p.Code == histask.AddrFrom).StateNum == LocationState.LocationState_StockMove.GetHashCode())
                        //    {
                        //        PtCompleteTask(new CompleteTaskRequest()
                        //        {
                        //            TaskNum = histask.Id,
                        //            OperationType = 2,
                        //            WCSUpdateName = "监控处理残留",
                        //            Memo1 = "监控处理残留",
                        //            Memo2 = "监控处理残留"
                        //        });
                        //    }
                        //}
                    }
                }
            }
            return res;
        }

        public SRes<int> GetTaskNum(string rfid)
        {
            var res = new SRes<int>();
            var task = _ptwcsTaskold.AsQueryable().With(SqlWith.NoLock).Where(p => p.BarCode == rfid && p.Status < TaskStatus.Finish && p.AddrFrom == "2999").SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = rfid + "该rfid没有找到任务";
                return res;
            }
            res.ResData = task.Id;
            return res;
        }

        public SRes<ptWCS_TaskOld> GetTask(int tasknum)
        {
            var res = new SRes<ptWCS_TaskOld>();
            var task = _ptwcsTaskold.AsQueryable().With(SqlWith.NoLock).Where(p => p.Id == tasknum).SplitTable(p => p.Take(2)).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = tasknum + "没有找到任务";
                return res;
            }
            res.ResData = task;
            return res;
        }

        public SRes<ptWCS_TaskInfo> GetCurTask(int tasknum)
        {
            var res = new SRes<ptWCS_TaskInfo>();
            var task = _ptwcsTaskinfo.AsQueryable().With(SqlWith.NoLock).Where(p => p.ID == tasknum).First();
            if (task == null)
            {
                res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                res.ResMsg = tasknum + "没有找到任务";
                return res;
            }
            res.ResData = task;
            return res;
        }

        /// <summary>
        /// 更新任务表当前点位
        /// </summary>
        /// <param name="tasknum"></param>
        /// <param name="curpoint"></param>
        /// <returns></returns>
        public SRes<bool> UpdateTask(int tasknum, string curpoint, string srm, string tunnel)
        {
            var res = new SRes<bool>();

            //var task = _ptwcsTaskold.AsQueryable().With(SqlWith.NoLock).Where(p => p.Id == tasknum).SplitTable(p => p.Take(2)).First();
            res.ResData = _ptwcsTaskinfo.UpdateModelColumns(p => new ptWCS_TaskInfo() { SrmStation = curpoint, Device = srm, Tunnel = tunnel, AddrNext = "TY" + tunnel }, p => p.ID == tasknum);
            return res;
        }

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

                    _ptBillInvFlow.Delete(p => ids.Contains(p.Id));
                }
            }
            catch (Exception ex)
            {
                res.ResCode = ResponseStatusCodeEnum.Fail.GetHashCode();
                res.ResMsg = ex.Message;
                return res;
            }

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

            return res;
        }
    }
}