using Model.InterFaceModel;
using Model.ModelVm;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Utility.Tools;
using WMS.BLL.Logic;
using WMS.BLL.LogServer;
using WMS.DAL;
using WMS.Entity.BllAsnEntity;
using WMS.Entity.BllQualityEntity;
using WMS.Entity.BllSoEntity;
using WMS.Entity.Context;
using WMS.Entity.DataEntity;
using WMS.Entity.LogEntity;
using WMS.Entity.SysEntity;
using WMS.IBLL;

namespace WMS.BLL
{
    public class HttpServer:IHttpServer
    {
        private static readonly SqlSugarScope Db = DataContext.Db;
        public HttpServer() { }

        /// <summary>
        /// 申请储位  （立体库）
        /// </summary>
        /// <param name="palletNo"></param>
        /// <param name="houseNo"></param>
        /// <param name="ceng"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public OutCommandDto RequestLocation(string palletNo, string houseNo,string ceng)
        {
            try
            {
                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
                    throw new Exception("请输入要申请的托盘条码");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(houseNo))
                {
                    throw new Exception("请选择所属仓库");
                }
                //验证是否为平库入库
                var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);//获取仓库类型
                //验证是否为立体库入库
                if (houseType.Type != "1")
                {
                    throw new Exception("仓库类型错误，请选择立体库仓库");
                }

                OutCommandDto comDto;//返回wcs的入库命令

                var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息

                //判断托盘条码是否有效
                if (stock == null)
                    throw new Exception("托盘条码不受WMS管理，不可入库！");

                #region 
                
                
                var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
                //物料类别信息
                var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();

                var skuNo = ""; //入库物料 
                var starLocate = ""; // 起始储位
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
                //验证物料是否有成品
                foreach (var item in stockDetail)
                {
                    var skuItem = skuList.First(m => m.SkuNo == item.SkuNo);
                    if (skuItem.Type == "2")
                    {
                        throw new Exception("成品物料请入成品库");
                    }
                }
                var upShelfOldList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1")).ToList();
                if (upShelfOldList.Count != 0) //查询到入库信息
                {
                    var upShelfOld = upShelfOldList.First();
                    var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == upShelfOld.TaskNo);
                    if (beingTask == null)
                    {
                        throw new Exception("该托盘正在入库，但未查询到任务信息");
                    }
                    if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
                    {
                        comDto = new OutCommandDto()
                        {
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型 
                            PalletNo = palletNo,//托盘号

                            StartRoadway = beingTask.StartRoadway, // 起始巷道
                            StartLocate = beingTask.StartLocat, // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway,                           //  目标巷道
                            
                            Order = 999,
                            Type = PLCTypeEnum.AGV
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                        }
                        beingTask.Status = "1";
                        Db.Updateable(beingTask).ExecuteCommand();

                        foreach (var item in upShelfOldList)
                        {
                            if (item.Status == "0")
                            {
                                upShelfOld.Status = "1";
                                Db.Updateable(upShelfOld).ExecuteCommand();
                            }
                        }
                        
                        return comDto;
                    }
                    else
                    {
                        throw new Exception("查询到任务但目的储位为空");
                    }
                }
                else //申请入库
                {
                    if (stockDetail.Count == 0)
                    {
                        throw new Exception($"{palletNo}托盘条码不具有箱码信息，不可入库！");
                    }
                    if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) == 0)
                    {
                        throw new Exception("当前托盘没有在平库储位上，请核实");
                    }
                    starLocate = stockDetail.First().LocatNo;

                    var pingAreaStr = Db.Queryable<SysStorageArea>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W04" && m.AreaNo != "B06" && m.AreaNo != "B07").Select(m => m.AreaNo).ToList();
                    var pingLocateInfo = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == starLocate && pingAreaStr.Contains(m.AreaNo) && m.IsDel == "0");
                    if (pingLocateInfo == null)
                    {
                        throw new Exception("当前托盘所在的储位没有在系统中找到信息");
                    }
                    if (pingLocateInfo.Status != "1")
                    {
                        throw new Exception("当前托盘所在的储位状态错误，不是空储位");
                    }
                    skuNo = stockDetail.First().SkuNo;

                    var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0"
                    && (m.Status == "0" || m.Status == "1") && m.PalletNo == palletNo && m.Type == "0");
                    if (beingTask != null)
                    {
                        if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
                        {
                            comDto = new OutCommandDto()
                            {
                                PalletNo = palletNo,//托盘号
                                StartRoadway = beingTask.StartRoadway, // 起始巷道
                                StartLocate = beingTask.StartLocat, // 起始位置
                                EndLocate = beingTask.EndLocat, // 目标位置
                                EndRoadway = beingTask.EndRoadway,                           //  目标巷道
                                TaskNo = beingTask.TaskNo, // 任务号
                                TaskType = "0",// 任务类型 (出库)
                                OutMode = "",  //目标地址
                                Order = 1,
                                Type = PLCTypeEnum.AGV
                            };
                            if (beingTask.IsSuccess == 0)
                            {
                                beingTask.IsSuccess = 1;
                               
                            }
                            beingTask.Status = "1";
                            Db.Updateable(beingTask).ExecuteCommand();
                            return comDto;
                        }
                        else
                        {
                            throw new Exception("查询到任务但目的储位为空");
                        }
                    }

                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
                    #region 托盘回库规则

                    if (function != null)
                    {
                        //拣货完成后允许托盘回库
                        if (function.SetValue == "CompletePick")
                        {
                            var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);

                            //验证拣货明细是否存在
                            if (allot != null)
                            {
                                //验证当前托盘拣货信息是否已完成
                                if (allot.Status != "5")
                                {
                                    throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
                                }
                            }
                        }
                    }
                    #endregion
                }

                var allotLocate = new AllotLocation();

                #region 申请储位

                SysStorageLocat locate;
                                var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
                if (sku == null)
                {
                    throw new Exception("物料信息中未查询到入库单明细包含的物料信息，不可入库");
                }
                //判断物料是否含有类别信息
                if (string.IsNullOrWhiteSpace(sku.CategoryNo))
                {
                    throw new Exception($"物料：{sku.SkuNo}未查询到类别信息");
                }

                var skuCategory = skuCategoryList.FirstOrDefault(m => m.CategoryNo == sku.CategoryNo);
                if (skuCategory == null)
                {
                    throw new Exception($"未在类别信息中查询到物料：{sku.SkuNo}包含的类别");
                }

                var areaStr = skuCategory.AreaNo.Split(",");
                var areaList = new List<string>();
                foreach (var item in areaStr)
                {
                    areaList.Add(item);
                }

                locate = allotLocate.GetSuiTableLocate(houseNo, areaList, "",ceng);
                

                #endregion

                Db.BeginTran();
                try
                {

                    
                    //添加巷道使用记录
                    var log = new SysRoadwayUseLog
                    {
                        RoadwayNo = locate.RoadwayNo,
                        WareHouseNo = houseNo,
                        Row = 0,
                        Column = 0,
                        Layer = 0,
                    };
                    Db.Insertable(log).ExecuteCommand();
                    var taskNo = new Common().GetMaxNo("TK");
                    var inTask = new LogTask    //入库任务
                    {
                        TaskNo = taskNo,
                        Sender = "WMS",
                        Receiver = "WCS",
                        IsSuccess = 1, //是否下发成功 0失败 1成功
                        SendDate = DateTime.Now,  //发送时间
                        BackDate = DateTime.Now,  //返回时间
                        StartRoadway = "",            // 起始巷道
                        StartLocat = starLocate,//起始位置
                        EndLocat = locate.LocatNo,//目标位置
                        EndRoadway = locate.RoadwayNo,  // 目标巷道
                        PalletNo = palletNo,//托盘码
                        IsSend = 1,//是否可再次下发
                        IsCancel = 1,//是否可取消
                        IsFinish = 1,//是否可完成
                        Type = "0",//任务类型 0 入库任务 1 出库任务  2 移库任务
                        Status = "1",//任务状态0：等待执行1正在执行2执行完成
                        OrderType = "0",//0 入库单 1 出库单  2 盘点单  3 移库单
                        Msg = "入库口到=>>" + locate.LocatNo + "的入库任务", //关键信息

                    };
                    Db.Insertable(inTask).ExecuteCommand();
                    var asnNo = "";
                    // 添加托盘绑定表托盘入库任务号 liudl
                    foreach (DataStockDetail stockModel in stockDetail)
                    {
                        var bindModel = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.Status == "2"
                        && m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo).OrderByDescending(m=>m.CreateTime).First();
                        if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
                        {
                            bindModel.TaskNo = taskNo;
                            bindModel.WareHouseNo = locate.WareHouseNo;
                            bindModel.RoadwayNo = locate.RoadwayNo;
                            bindModel.LocatNo = locate.LocatNo;
                            Db.Updateable(bindModel).ExecuteCommand();
                            asnNo = stockModel.ASNNo;
                        }
                    }
                    foreach (DataStockDetail stockModel in stockDetail)
                    {
                        //添加托盘上架记录
                        var upShelf = new BllPalletUpShelf()
                        {
                            TaskNo = inTask.TaskNo,
                            TraceNo = asnNo,
                            PalletNo = palletNo,
                            SkuNo = stockModel.SkuNo,
                            SkuName = stockModel.SkuName,
                            LotNo = stockModel.LotNo,
                            Status = "1",

                            WareHouseNo = houseNo,
                            RoadwayNo = locate.RoadwayNo,
                            AreaNo = locate.AreaNo,
                            LocatNo = locate.LocatNo,

                            CreateUser = 0,
                        };
                        Db.Insertable(upShelf).ExecuteCommand();
                    }
                     
                    
                    locate.Status = "2";
                    Db.Updateable(locate).ExecuteCommand();
                     
                    Db.CommitTran();
                    comDto = new OutCommandDto()
                    {
                        TaskNo = taskNo, // 任务号
                        TaskType = "0",// 任务类型
                        PalletNo = palletNo,//托盘号

                        StartRoadway = inTask.StartRoadway,
                        StartLocate = inTask.StartLocat, // 起始位置
                        EndLocate = inTask.EndLocat, // 目标位置 
                        EndRoadway = inTask.EndRoadway,   // 目标巷道
                        
                        Order = 999,
                        Type = PLCTypeEnum.AGV
                    };

                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
                #endregion


                return comDto;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 申请巷道(密集库)
        /// </summary>
        /// <param name="palletNo"></param>
        /// <param name="houseNo"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public OutCommandDto RequestMiJiRoadWay(string palletNo, string houseNo)
        {
            try
            {
                #region 验证托盘合法性
                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
                    throw new Exception("请输入要申请的托盘条码");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(houseNo))
                {
                    throw new Exception("请选择所属仓库");
                }
                //获取仓库类型
                var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);
                //验证是否为密集库
                if (houseType.Type != "3")
                {
                    throw new Exception("仓库不是密集库");
                }

                var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息
                //判断托盘条码是否有效
                if (stock == null)
                {
                    throw new Exception("托盘条码不受WMS管理，不可入库！");
                }
                #endregion

                OutCommandDto comDto;//返回wcs的入库命令
                
                #region 代码块

                //查询托盘绑定信息(状态为等待入库/正在执行的)
                
                var skuNo = ""; //入库物料
                var lotNo = ""; //入库批次
                
                //物料信息
                var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
                //物料类别信息
                var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();
                //托盘库存信息
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
                //验证物料是否有成品
                foreach (var item in stockDetail)
                {
                    var skuItem = skuList.First(m => m.SkuNo == item.SkuNo);
                    if (skuItem.SkuNo == "100099")
                    {
                        continue;
                    }
                    if (skuItem.Type != "2")
                    {
                        throw new Exception("托盘上有不是成品的物料");
                    }
                }
                var upShelfOld = Db.Queryable<BllPalletUpShelf>().First(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1"));

                if (upShelfOld != null) //正常入库
                {
                    var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == upShelfOld.TaskNo);
                    if (beingTask == null)
                    {
                        throw new Exception("该托盘正在入库，但未查询到任务信息");
                    }
                    if (!string.IsNullOrWhiteSpace(beingTask.EndRoadway))
                    {
                        comDto = new OutCommandDto()
                        {
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型
                            PalletNo = palletNo,//托盘号

                            StartRoadway = beingTask.StartRoadway, // 起始巷道
                            StartLocate = beingTask.StartLocat, // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway, //  目标巷道

                            Order = 999,
                            Type = PLCTypeEnum.ConveyorLine
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                        }
                        beingTask.Status = "1";
                        Db.Updateable(beingTask).ExecuteCommand();
                        if (upShelfOld.Status == "0")
                        {
                            upShelfOld.Status = "1";
                            Db.Updateable(upShelfOld).ExecuteCommand();
                        }
                        return comDto;
                    }
                    else
                    {
                        throw new Exception("查询到任务但目的巷道为空");
                    }
                }
                else //申请入库
                {
                    if (stockDetail.Count == 0)
                    {
                        throw new Exception($"{palletNo}托盘不存在库存信息，不可入库！");
                    }
                    if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
                    {
                        throw new Exception("当前托盘已在库内，请核实");
                    }
                    skuNo = stockDetail.First().SkuNo;
                    lotNo = stockDetail.First().LotNo;

                    #region 判断该托盘，是否符合回库功能设定的回库规则
                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0"&& a.FunSetNo == "Fun041" && a.IsEnable == "NO");
                    if (function != null)
                    {
                        //拣货完成后允许托盘回库
                        var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0"&& a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);

                        //验证拣货明细是否存在
                        if (allot != null)
                        {
                            //验证当前托盘拣货信息是否已完成
                            if (allot.Status != "5")
                            {
                                throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
                            }
                        }
                    }
                    #endregion
                }

                var allotLocate = new AllotLocation();
                
                #region 根据sku确认区域划分

                //物料信息
                var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == skuNo);
                if (sku == null)
                {
                    throw new Exception("物料编码不存在，不可入库");
                }
                //判断物料是否含有类别信息
                if (string.IsNullOrWhiteSpace(sku.CategoryNo))
                {
                    throw new Exception($"物料：{sku.SkuNo}未设置类别,不可入库");
                }
                //物料类别信息
                var skuCategory = Db.Queryable<SysMaterialCategory>().First(m => m.IsDel == "0" && m.CategoryNo == sku.CategoryNo);
                if (skuCategory == null)
                {
                    throw new Exception($"{sku.SkuNo}物料类别不存在，不可入库");
                }
                //整理区域信息
                var areaStr = skuCategory.AreaNo.Split(",");
                var areaList = new List<string>();
                foreach (var item in areaStr)
                {
                    areaList.Add(item);
                }

                //巷道组信息
                var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo) && !string.IsNullOrWhiteSpace(m.RoadwayNo))
                    .GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();

                #endregion

                //获取申请的密集库巷道
                var roadNo = allotLocate.GetMiJiSuiTableRoad(houseNo, roadList, areaList, skuNo, lotNo);

                if (string.IsNullOrWhiteSpace(roadNo))
                {
                    throw new Exception("未查询到存在空储位巷道");
                }

                Db.BeginTran();
                try
                {
                    //添加巷道使用记录
                    var log = new SysRoadwayUseLog
                    {
                        RoadwayNo = roadNo,
                        WareHouseNo = houseNo,
                        Row = 0,
                        Column = 0,
                        Layer = 0,
                    };
                    Db.Insertable(log).ExecuteCommand();

                    // 添加入库日志记录
                    var taskNo = new Common().GetMaxNo("TK");
                    var inTask = new LogTask    //入库任务
                    {
                        TaskNo = taskNo,
                        Sender = "WMS",
                        Receiver = "WCS",
                        IsSuccess = 0, //是否下发成功 0失败 1成功
                        SendDate = DateTime.Now,  //发送时间
                        BackDate = DateTime.Now,  //返回时间
                        StartRoadway = "",            // 起始巷道
                        StartLocat = "",//起始位置
                        EndLocat = "",//目标位置
                        EndRoadway = roadNo,  // 目标巷道
                        PalletNo = palletNo,//托盘码
                        IsSend = 1,//是否可再次下发
                        IsCancel = 1,//是否可取消
                        IsFinish = 1,//是否可完成
                        Type = "0",//任务类型 0 入库任务 1 出库任务  2 移库任务
                        Status = "1",//任务状态0：等待执行1正在执行2执行完成
                        OrderType = "0",//0 入库单 1 出库单  2 盘点单  3 移库单
                        Msg = "入库口到=>>" + roadNo + "巷道的入库任务", //关键信息

                    };
                    Db.Insertable(inTask).ExecuteCommand();

                    var asnNo = "";
                    // 添加托盘绑定表托盘入库任务号  liudl
                    
                    foreach (DataStockDetail stockModel in stockDetail)
                    {
                        var bindModel = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.Status == "2"
                        && m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo).OrderByDescending(m=>m.CreateTime).First();
                        if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
                        {
                            bindModel.TaskNo = taskNo;
                            bindModel.WareHouseNo = houseNo;
                            bindModel.RoadwayNo = roadNo;
                            Db.Updateable(bindModel).ExecuteCommand();
                            asnNo = stockModel.ASNNo;
                        }

                    }
                    
                    foreach (DataStockDetail stockModel in stockDetail)
                    {
                        //添加托盘上架记录
                        var upShelf = new BllPalletUpShelf()
                        {
                            TaskNo = inTask.TaskNo,
                            TraceNo = asnNo,
                            PalletNo = palletNo,
                            SkuNo = stockModel.SkuNo,
                            SkuName = stockModel.SkuName,
                            LotNo = stockModel.LotNo,
                            Status = "1",

                            WareHouseNo = houseNo,
                            RoadwayNo = roadNo,
                            AreaNo = "",
                            LocatNo = "",

                            CreateUser = 0,
                        };
                        Db.Insertable(upShelf).ExecuteCommand();
                    }

                    Db.CommitTran();

                    comDto = new OutCommandDto()
                    {
                        TaskNo = taskNo, // 任务号
                        TaskType = "0",// 任务类型:入库任务
                        PalletNo = palletNo,//托盘号

                        StartRoadway = inTask.StartRoadway,// 起始巷道
                        StartLocate = inTask.StartLocat, // 起始位置
                        EndLocate = inTask.EndLocat, // 目标位置 
                        EndRoadway = inTask.EndRoadway,   // 目标巷道
                       
                        Order = 999,
                        Type = PLCTypeEnum.ConveyorLine
                    };
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
                #endregion

                return comDto;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 1 申请储位 （申请巷道后 再申请储位储位 ）
        /// </summary>
        /// <param name="palletNo"></param>
        /// <param name="houseNo"></param>
        /// <param name="roadwayNo"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public OutCommandDto RequestMiJiLocation(string palletNo, string houseNo, string roadwayNo)
        {
            try
            {
                #region 验证

                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
                    throw new Exception("请输入要申请的托盘条码");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(houseNo))
                {
                    throw new Exception("请选择所属仓库");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(roadwayNo))
                {
                    throw new Exception("巷道不能为空");
                }
                //获取仓库类型
                var houseType = Db.Queryable<SysWareHouse>().First(a => a.WareHouseNo == houseNo);
                //验证是否为密集库
                if (houseType.Type != "3")
                {
                    throw new Exception("仓库不是密集库");
                }
                var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息

                //判断托盘条码是否有效
                if (stock == null)
                {
                    throw new Exception("托盘条码不受WMS管理，不可入库！");
                }

                #endregion

                OutCommandDto comDto;//返回wcs的入库命令

                #region 

                //查询托盘绑定信息(状态为等待入库的)
               

                var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
                //物料类别信息
                var skuCategoryList = Db.Queryable<SysMaterialCategory>().Where(m => m.IsDel == "0").ToList();
                
                var skuNo = "";//入库物料
                var isAddTask = true; //是否添加新任务
                var oldTaskNo = "";  //旧任务号
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
                //验证物料是否有成品
                foreach (var item in stockDetail)
                {
                    var skuItem = skuList.First(m => m.SkuNo == item.SkuNo);
                    if (skuItem.SkuNo == "100099")
                    {
                        continue;
                    }
                    if (skuItem.Type != "2")
                    {
                        throw new Exception("托盘上有不是成品的物料");
                    }
                }
                
                var upShelfOld = Db.Queryable<BllPalletUpShelf>().First(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" || m.Status == "1"));

                if (upShelfOld != null) //有上架入库信息
                {
                    
                    var beingTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == upShelfOld.TaskNo);
                    if (beingTask == null)
                    {
                        throw new Exception("该托盘正在入库，但未查询到任务信息");
                    }
                    if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
                    {
                        comDto = new OutCommandDto()
                        {
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型 
                            PalletNo = palletNo,//托盘号

                            StartRoadway = beingTask.StartRoadway, // 起始巷道
                            StartLocate = beingTask.StartRoadway, // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway, // 目标巷道
                                 
                            Order = 999,
                            Type = PLCTypeEnum.ShuttleCar,
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                            Db.Updateable(beingTask).ExecuteCommand();
                        }
                        if (upShelfOld.Status == "0")
                        {
                            upShelfOld.Status = "1";
                            Db.Updateable(upShelfOld).ExecuteCommand();
                        }
                        return comDto;
                    }
                    else
                    {
                        isAddTask = false;
                        oldTaskNo = beingTask.TaskNo;
                        skuNo = upShelfOld.SkuNo;//入库物料
                    }
                    
                }
                else //申请入库
                {
                    if (stockDetail.Count == 0)
                    {
                        throw new Exception($"{palletNo}托盘条码没有库存信息，不可入库！");
                    }
                    if (stockDetail.Count(m => !string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
                    {
                        throw new Exception("当前托盘已在库内，请核实");
                    }
                    skuNo = stockDetail.First().SkuNo;//入库物料

                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
                    #region 托盘回库规则

                    if (function != null)
                    {
                        //拣货完成后允许托盘回库
                        if (function.SetValue == "CompletePick")
                        {
                            var allot = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.LotNo == stockDetail[0].LotNo && a.PalletNo == palletNo && a.SkuNo == stockDetail[0].SkuNo);

                            //验证拣货明细是否存在
                            if (allot != null)
                            {
                                //验证当前托盘拣货信息是否已完成
                                if (allot.Status != "5")
                                {
                                    throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
                                }
                            }
                        }
                    }
                    #endregion
                }

                var allotLocate = new AllotLocation();

                #region 申请储位

                SysStorageLocat locate;
               
                var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
                if (sku == null)
                {
                    throw new Exception("物料信息中未查询到入库单明细包含的物料信息，不可入库");
                }
                //判断物料是否含有类别信息
                if (string.IsNullOrWhiteSpace(sku.CategoryNo))
                {
                    throw new Exception($"物料：{sku.SkuNo}未查询到类别信息");
                }

                var skuCategory = skuCategoryList.FirstOrDefault(m => m.CategoryNo == sku.CategoryNo);
                if (skuCategory == null)
                {
                    throw new Exception($"未在类别信息中查询到物料：{sku.SkuNo}包含的类别");
                }

                var areaStr = skuCategory.AreaNo.Split(",");
                var areaList = new List<string>();
                foreach (var item in areaStr)
                {
                    areaList.Add(item);
                }

                locate = allotLocate.GetMiJiSuiTableLocate(roadwayNo, areaList);
                if (locate == null)
                {
                    throw new Exception($"没有空储位");
                }

                #endregion

                Db.BeginTran();
                try
                {

                    if (isAddTask)
                    {
                        var taskNo = new Common().GetMaxNo("TK");
                        var inTask = new LogTask    //入库任务
                        {
                            TaskNo = taskNo,
                            Sender = "WMS",
                            Receiver = "WCS",
                            IsSuccess = 1, //是否下发成功 0失败 1成功
                            SendDate = DateTime.Now,  //发送时间
                            BackDate = DateTime.Now,  //返回时间
                            StartRoadway = "",            // 起始巷道
                            StartLocat = "",//起始位置
                            EndLocat = locate.LocatNo,//目标位置
                            EndRoadway = locate.RoadwayNo,  // 目标巷道
                            PalletNo = palletNo,//托盘码
                            IsSend = 1,//是否可再次下发
                            IsCancel = 1,//是否可取消
                            IsFinish = 1,//是否可完成
                            Type = "0",//任务类型 0 入库任务 1 出库任务  2 移库任务
                            Status = "1",//任务状态0：等待执行1正在执行2执行完成
                            OrderType = "0",//0 入库单 1 出库单  2 盘点单  3 移库单
                            Msg = "入库口到=>>" + locate.LocatNo + "的入库任务", //关键信息

                        };
                        Db.Insertable(inTask).ExecuteCommand();
                        var asnNo = "";
                        // 添加托盘绑定表托盘入库任务号 liudl
                        foreach (DataStockDetail stockModel in stockDetail)
                        {
                            var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
                            && m.PalletNo == stockModel.PalletNo && m.ASNNo == stockModel.ASNNo && m.ASNDetailNo == stockModel.ASNDetailNo);
                            if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.TaskNo))
                            {
                                bindModel.TaskNo = taskNo;
                                bindModel.WareHouseNo = locate.WareHouseNo;
                                bindModel.RoadwayNo = locate.RoadwayNo;
                                bindModel.LocatNo = locate.LocatNo;
                                Db.Updateable(bindModel).ExecuteCommand();
                                asnNo = stockModel.ASNNo;
                            }
                        }
                        foreach (DataStockDetail stockModel in stockDetail)
                        {
                            //添加托盘上架记录
                            var upShelf = new BllPalletUpShelf()
                            {
                                TaskNo = inTask.TaskNo,
                                TraceNo = asnNo,
                                PalletNo = palletNo,
                                SkuNo = stockModel.SkuNo,
                                SkuName = stockModel.SkuName,
                                LotNo = stockModel.LotNo,
                                Status = "1",

                                WareHouseNo = houseNo,
                                RoadwayNo = locate.RoadwayNo,
                                AreaNo = locate.AreaNo,
                                LocatNo = locate.LocatNo,

                                CreateUser = 0,
                            };
                            Db.Insertable(upShelf).ExecuteCommand();
                        }

                        oldTaskNo = taskNo;
                    }
                    else
                    {
                        var oldTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == oldTaskNo);
                        oldTask.EndLocat = locate.LocatNo;
                        oldTask.EndRoadway = locate.RoadwayNo;
                        if (oldTask.IsSuccess == 0)
                        {
                            oldTask.IsSuccess = 1;
                            oldTask.Status = "1";
                        }
                        Db.Updateable(oldTask).ExecuteCommand();


                        var bindModelList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.Status == "2"
                           && m.PalletNo == oldTask.PalletNo && m.TaskNo == oldTaskNo).ToList();
                        foreach (var bindModel in bindModelList)
                        {
                            if (string.IsNullOrWhiteSpace(bindModel.LocatNo))
                            {
                                bindModel.TaskNo = oldTask.TaskNo;
                                bindModel.WareHouseNo = locate.WareHouseNo;
                                bindModel.RoadwayNo = locate.RoadwayNo;
                                bindModel.LocatNo = locate.LocatNo;
                                Db.Updateable(bindModel).ExecuteCommand();

                            }
                        }
                        //更改上架信息
                        var upShelfList = Db.Queryable<BllPalletUpShelf>().Where(m => m.IsDel == "0" && m.TaskNo == oldTask.TaskNo && m.PalletNo == palletNo).ToList();
                        foreach (var upShelf in upShelfList)
                        {
                            upShelf.WareHouseNo = locate.WareHouseNo;
                            upShelf.RoadwayNo = locate.RoadwayNo;
                            upShelf.LocatNo = locate.LocatNo;
                            upShelf.Status = "1";
                            Db.Updateable(upShelf).ExecuteCommand();

                        }

                    }

                    locate.Status = "2";
                    Db.Updateable(locate).ExecuteCommand();
                   
                    Db.CommitTran();
                    comDto = new OutCommandDto()
                    {
                        TaskNo = oldTaskNo, // 任务号
                        TaskType = "0",// 任务类型
                        PalletNo = palletNo,//托盘号

                        StartRoadway = "",
                        StartLocate = "", // 起始位置
                        EndLocate = locate.LocatNo, // 目标位置 
                        EndRoadway = locate.RoadwayNo,   // 目标巷道

                        Order = 999,  //目标地址
                        Type = PLCTypeEnum.ShuttleCar
                    };

                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
                #endregion


                return comDto;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// agv走出储位修改储位信息，仅限平库储位
        /// </summary>
        /// <param name="taskNo"></param>
        /// <param name="userId"></param>
        public void UpLocateByAgvOut(string taskNo, int userId)
        {
            try
            {

                var task = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == taskNo);
                if (task == null)
                {
                    throw new Exception("未查询到任务信息");
                }
                if (task.Status != "1")
                {
                    throw new Exception("当前任务已完成");
                }
                if (userId != 0)
                {
                    //添加操作日志记录
                    var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
                }
                
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.StartLocat);
                if (locate == null)
                {
                    throw new Exception($"未查询到任务中的储位信息");
                }
                var pingAreaStr = Db.Queryable<SysStorageArea>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W04").Select(m => m.AreaNo).ToList();
                var pingLocateInfo = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locate.LocatNo && pingAreaStr.Contains(m.AreaNo) && m.IsDel == "0");
                if (pingLocateInfo == null)
                {
                    throw new Exception("当前任务起始储位不在平库储位");
                }
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == task.PalletNo).ToList();
                foreach (var item in stockDetail)
                {
                    item.WareHouseNo = "";
                    item.RoadwayNo = "";
                    item.AreaNo = "";
                    item.LocatNo = "";
                }
                Db.Updateable(stockDetail).ExecuteCommand();
                locate.Status = "0";
                Db.Updateable(locate).ExecuteCommand();
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 入库任务完成JC34
        /// </summary>
        /// <param name="taskNo"></param>
        /// <param name="userId"></param>
        /// <exception cref="Exception"></exception>
        public void ArrivalSuccess2(string taskNo, int userId)
        {
            try
            {
                //正常入库 
                var task = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == taskNo);
                if (task == null)
                {
                    throw new Exception("未查询到任务信息");
                }
                if (task.Status == "2")
                {
                    throw new Exception("当前任务已完成");
                }

                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
                var upShelf = Db.Queryable<BllPalletUpShelf>().First(m => m.TaskNo == taskNo);
                if (upShelf == null)
                {
                    throw new Exception("没有找到托盘上架信息");
                }
                //当前任务中的储位信息
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate == null)
                {
                    throw new Exception($"未查询到任务中的储位信息");
                }
                Db.BeginTran();

                task.Status = "2";//任务状态
                task.IsSend = 0;
                task.IsCancel = 0;
                task.IsFinish = 0;
                task.FinishDate = DateTime.Now;//完成时间
                Db.Updateable(task).ExecuteCommand();
                if (userId != 0)
                {
                    //添加操作日志记录
                    var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
                }

                //判断是否是回流入库完成
                if (!stockDetail.Any())
                {
                    throw new Exception("没有查询到库存信息");
                }

                foreach (var item in stockDetail)
                {
                    item.WareHouseNo = locate.WareHouseNo;
                    item.RoadwayNo = locate.RoadwayNo;
                    item.AreaNo = locate.AreaNo;
                    item.LocatNo = locate.LocatNo;
                    item.UpdateTime = DateTime.Now;
                    if (userId != 0)
                    {
                        item.UpdateUser = userId;
                    }
                }
                upShelf.Status = "2";
                Db.Updateable(upShelf).ExecuteCommand();

                locate.Status = "1";
                Db.Updateable(locate).ExecuteCommand();
                Db.Updateable(stockDetail).ExecuteCommand();
                Db.CommitTran();

            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 移库单的 移库任务完成JC34 兼容AGV小车移库
        /// </summary>
        /// <param name="taskNo"></param>
        /// <param name="userId"></param>
        /// <exception cref="Exception"></exception>
        public void MoveSuccess(string taskNo, int userId)
        {
            try
            {
                Db.BeginTran();
                //正常入库 
                var task = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == taskNo);
                if (task == null)
                {
                    throw new Exception("未查询到任务信息");
                }
                if (task.Status == "2")
                {
                    throw new Exception("当前任务已完成");
                }

                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
                //判断是否是回流入库完成
                if (!stockDetail.Any())
                {
                    throw new Exception("没有查询到库存信息");
                }
                //当前任务中的储位信息
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.StartLocat);
                if (locate == null)
                {
                    throw new Exception($"未查询到任务中的起始储位信息");
                }
                //当前任务中的储位信息
                var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate2 == null)
                {
                    throw new Exception($"未查询到任务中的目标储位信息");
                }
                
                task.Status = "2";//任务状态
                task.IsSend = 0;
                task.IsCancel = 0;
                task.IsFinish = 0;
                task.FinishDate = DateTime.Now;//完成时间
                Db.Updateable(task).ExecuteCommand();
                if (userId != 0)
                {
                    //添加操作日志记录
                    var k = new OperationASNServer().AddLogOperationAsn("库内作业", "库内日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
                }

                foreach (var item in stockDetail)
                {
                    if (locate2.LocatNo == "B040101")
                    {
                        item.WareHouseNo = "";
                        item.RoadwayNo = "";
                        item.AreaNo = "";
                        item.LocatNo = "";
                    }
                    else
                    {
                        item.WareHouseNo = locate2.WareHouseNo;
                        item.RoadwayNo = locate2.RoadwayNo;
                        item.AreaNo = locate2.AreaNo;
                        item.LocatNo = locate2.LocatNo;
                    }
                    item.UpdateTime = DateTime.Now;
                    if (userId != 0)
                    {
                        item.UpdateUser = userId;
                    }
                }

                if (locate.WareHouseNo != "W04")
                {
                    locate.Status = "0";
                    Db.Updateable(locate).ExecuteCommand();
                }
                
                if (locate2.LocatNo == "B040101")
                {
                    locate2.Status = "0";
                    Db.Updateable(locate2).ExecuteCommand();
                }
                else
                {
                    locate2.Status = "1";
                    Db.Updateable(locate).ExecuteCommand();
                }
                
                Db.Updateable(stockDetail).ExecuteCommand();
                Db.CommitTran();

            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 出库单的移库任务，JC34 货架托盘下架
        /// </summary>
        /// <param name="taskNo">任务号</param>
        /// <param name="userId">操作人</param>
        /// <exception cref="Exception"></exception>
        public void ExMoveSuccess(string taskNo, int userId)
        {
            try
            {
                //当前任务信息
                var task = Db.Queryable<LogTask>().First(m => m.TaskNo == taskNo && m.IsDel == "0");
                if (task == null)
                {
                    throw new Exception($"未查询到任务号为：‘{taskNo}’的任务信息");
                }
                if (task.Status == "2")
                {
                    throw new Exception("当前任务已完成");
                }
                Db.BeginTran();
                //库存中当前托盘的信息
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
                //当前任务中的目标储位信息
                //当前任务中的原储位
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.StartLocat);
                if (locate == null)
                {
                    throw new Exception($"WMS系统中没有该{task.StartLocat}储位对应的信息");
                }
                var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate2 == null)
                {
                    throw new Exception($"WMS系统中没有该{task.EndLocat}储位对应的信息");
                }
                //平库中储位集合
                var pingKuLocate = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == "W04" && m.IsDel == "0").ToList();
                var pingKuList = pingKuLocate.Select(m => m.LocatNo).ToList();
                try
                {

                    //task.Status = "5";//任务状态
                    ////判断起始目标位置都是平库  
                    //if (pingKuList.Contains(task.StartLocat) && pingKuList.Contains(task.EndLocat))
                    //{
                    task.Status = "2";
                    //}

                    task.IsSend = 0;
                    task.IsCancel = 0;
                    task.IsFinish = 0;
                    task.FinishDate = DateTime.Now;//完成时间
                    Db.Updateable(task).ExecuteCommand();

                    #region 修改储位状态

                    if (!pingKuList.Contains(task.StartLocat))
                    {
                        //原储位改为空储位 0
                        locate.Status = "0";
                        Db.Updateable(locate).ExecuteCommand();
                    }


                    //目标储位改为有货物 1
                    locate2.Status = "1";
                    Db.Updateable(locate2).ExecuteCommand();
                    
                    foreach (var item in stockDetail)
                    {
                        item.WareHouseNo = locate2.WareHouseNo;
                        item.AreaNo = locate2.AreaNo;
                        item.RoadwayNo = locate2.RoadwayNo;
                        item.LocatNo = locate2.LocatNo;
                    }
                    Db.Updateable(stockDetail).ExecuteCommand();
                    


                    #endregion

                    Db.CommitTran();
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("完成反馈失败：" + ex.Message);
            }
        }



        /// <summary>
        /// PDA下发出库
        /// </summary>
        /// <param name="soNo"></param>
        /// <param name="detailId"></param>
        /// <param name="outMode"></param>
        /// <param name="userId"></param>
        /// <param name="url"></param>
        /// <param name="str"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public List<OutCommandDto> IssueOutHouseLk(string soNo, string detailId,string outMode, int userId, string url, out string str)
        {
            try
            {
                var outDto1 = new List<OutCommandDto>(); //出库数据的集合（深度为1的储位）
                //记录错误信息的集合 //1:当前要出库的储位正在移出、2 出库的托盘储位信息错误(在储位表中未查询到)、3储位损坏不能出库、4 要出库的托盘正在入库
                 

                var com = new Common();
                var notice = Db.Queryable<BllExportNotice>().First(m => m.SONo == soNo && m.IsDel == "0");
                if (notice == null)
                {
                    throw new Exception($"未找到{soNo}出库单信息");
                }
                if (notice.WareHouseNo != "W02")
                {
                    throw new Exception("仓库号错误");
                }
                var intDetailId = int.Parse(detailId);
                if (intDetailId <=0) 
                {
                    throw new Exception("选择的出库单明细参数错误");
                }
                //所有要出库的出库分配信息(未下发的信息和待拣货的信息)
                var item = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.SONo == soNo && a.SODetailNo == intDetailId && a.Status == "0" );
                if (item == null) //判断是否有需要下发的出库流水
                {
                    throw new Exception("当前出库单据无需要下发的托盘");
                }

                #region 集合 

                //要出库的明细集合
                var outStockDetail = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == item.PalletNo).ToList();
                //物料编码表
                var skuList = Db.Queryable<SysMaterials>().Where(w => w.IsDel == "0");
                //包装表
                var packagList = Db.Queryable<SysPackag>().Where(w => w.IsDel == "0");
                Db.BeginTran();
                try
                {
                    List<LogTask> logTaskList = new List<LogTask>();//此次出库任务集合，为应对同托盘不同物料出库
                    var i = 0;
                    str = string.Empty;
                    var outLocatelist1 = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.AreaNo == "B02" && m.Flag == "0").ToList();
                    var outLocatelist2 = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.AreaNo == "B05" && m.Flag == "0").ToList();
                    //循环分配的信息生成出库任务
                     
                    var outModeLocate = outMode;
                        
                    var taskNoStr = "";

                    // 储位号
                    var locateNo = outStockDetail.First(m => m.PalletNo == item.PalletNo).LocatNo;

                    #region 判断

                    //判断托盘是否在库内
                    if (string.IsNullOrWhiteSpace(locateNo)) //库外
                    {
                        //判断托盘是否在入库中
                        var imBl = com.GetImTask(item.PalletNo);
                        if (imBl != null)
                        {
                            str = "要出库的托盘正在入库";
                            return outDto1;
                        }
                        //判断是否是已经出过库又回库 
                        if (item.Status == "0")
                        {
                            //如果不在仓库内，当前分配信息直接更新出库完成 
                            item.Status = "2";//状态
                            item.OutMode = outModeLocate;//出库口 
                            Db.Updateable(item).ExecuteCommand();
                            var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                            if (noticeDetail != null) //更新出库单据的下发数量
                            {
                                noticeDetail.FactQty += item.Qty;
                                Db.Updateable(noticeDetail).ExecuteCommand();
                            }

                            //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                            if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                            {
                                var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                {
                                    notice.Status = "3"; //变更状态为正在执行
                                    Db.Updateable(notice).ExecuteCommand();
                                }
                            }
                            str = "要出库的托盘已在库外";
                            return outDto1;
                        }
                        str = "要出库的托盘正在入库";
                        return outDto1;
                    }

                    var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == locateNo && m.IsDel == "0");//当前出库的储位信息
                    if (locate == null)
                    {
                        str = "出库的托盘储位信息错误(在储位表中未查询到)";
                        return outDto1;
                    }
                    //判断储位标志是否为损坏
                    if (locate.Flag == "2")
                    {
                        str = "储位损坏不能出库";
                        return outDto1;
                    }
                    if (locate.WareHouseNo != "W02")
                    {
                        str = "托盘不在货架库上";
                        return outDto1;
                    }
                    var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == outModeLocate && m.IsDel == "0");//当前出库的目标储位信息
                    if (locate2 == null)
                    {
                        str = "出库的托盘储位信息错误(在储位表中未查询到)";
                        return outDto1;
                    }
                    else if (locate2.Status != "0")
                    {
                        str = "目标储位状态不是空储位";
                        return outDto1;
                    }
                    #endregion

                    if (locate.Status == "1") //有物品
                    {
                        #region 添加出库任务

                        var taskNo = new Common().GetMaxNo("TK");
                        var exTask = new LogTask    //出库任务
                        {
                            TaskNo = taskNo,
                            Sender = "WMS",
                            Receiver = "WCS",
                            IsSuccess = 0, //是否下发成功 0失败 1成功

                            StartLocat = locate.LocatNo,//起始位置
                            EndLocat = outModeLocate,//目标位置
                            PalletNo = item.PalletNo,//托盘码
                            IsSend = 1,//是否可再次下发
                            IsCancel = 1,//是否可取消
                            IsFinish = 1,//是否可完成
                            Type = "1",//任务类型 0 入库任务 1 出库任务  2 移库任务
                            Status = "0",//任务状态0：等待执行1正在执行2执行完成
                            OrderType = "1",//0 入库单 1 出库单  2 盘点单  3 移库单
                            Msg = "从" + locate.LocatNo + "到" + outModeLocate + "的出库任务", //关键信息
                        };
                        Db.Insertable(exTask).ExecuteCommand();
                        logTaskList.Add(exTask);

                        outDto1.Add(new OutCommandDto()
                        {
                            TaskNo = exTask.TaskNo, // 任务号
                            TaskType = "1",// 任务类型 (出库)0入 1出 2移 

                            PalletNo = item.PalletNo,//托盘号
                            StartLocate = locate.LocatNo, // 起始位置
                            StartRoadway = locate.RoadwayNo,//其实巷道
                            EndLocate = outModeLocate, // 目标位置 

                            Order = 999,
                            Type = PLCTypeEnum.AGV

                        });
                        taskNoStr = exTask.TaskNo;

                        #endregion

                        #region 改变数据
                        if (item.Status == "0")//判断托盘是否下发过
                        {
                            var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                            if (noticeDetail != null) //更新出库单据的下发数量
                            {
                                noticeDetail.FactQty += item.Qty;
                                Db.Updateable(noticeDetail).ExecuteCommand();
                            }

                            //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                            if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                            {
                                var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                {
                                    notice.Status = "3"; //变更状态为正在执行
                                    Db.Updateable(notice).ExecuteCommand();
                                }
                            }
                        }
                        locate.Status = "3"; //要出库的储位改变状态 正在出库
                        Db.Updateable(locate).ExecuteCommand();
                        var locate2 = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == outModeLocate && m.IsDel == "0");//当前出库的目标储位信息
                        locate2.Status = "4";
                        Db.Updateable(locate2).ExecuteCommand();

                        item.TaskNo = taskNoStr; // 出库分配信息中更新任务号
                        item.Status = "1"; // 出库分配信息状态改为正在执行 
                        //item.UnstackingMode = unstackingMode2;//拆垛方式
                        item.OutMode = outModeLocate;//出库口
                        //item.LoadingAddre = unstackingMode2 == "0" ? loadingAddre : "";//装车口
                        Db.Updateable(item).ExecuteCommand();

                        #endregion
                        
                    }
                    else if (locate.Status == "3") //出库中
                    {
                        #region 改变数据
                        //判断是否是已经出过库又回库（状态为待拣货的 1）
                        if (item.Status == "0")
                        {
                            var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.SODetailNo);
                            if (noticeDetail != null) //更新出库单据的下发数量
                            {
                                noticeDetail.FactQty += item.Qty;
                                Db.Updateable(noticeDetail).ExecuteCommand();
                            }

                            //var notice2 = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == item.SONo);
                            if (notice.Status == "0" || notice.Status == "1" || notice.Status == "2")
                            {
                                var detailList = Db.Queryable<BllExportNoticeDetail>().Where(m => m.IsDel == "0" && m.SONo == item.SONo).ToList();
                                if (detailList.Count(m => m.Qty >= m.AllotQty) > 0)
                                {
                                    notice.Status = "3"; //变更状态为正在执行
                                    Db.Updateable(notice).ExecuteCommand();
                                }
                            }
                        }
                        var taskNo = Db.Queryable<LogTask>().First(m => m.OrderType == "1" && m.TaskNo != item.TaskNo && m.Status == "1" && m.PalletNo == item.PalletNo);
                        if (taskNo == null)
                        {
                            taskNo = logTaskList.FirstOrDefault(m => m.PalletNo == item.PalletNo);//当前有同托盘不同物料出库
                        }
                        if (taskNo == null)
                        {
                            throw new Exception($"托盘号：{item.PalletNo},出库异常");
                        }
                        item.TaskNo = taskNo.TaskNo;
                        item.Status = "1"; // 出库分配信息状态改为正在执行 
                        item.OutMode = item.OutMode;//出库口
                        //item.UnstackingMode = unstackingMode2;//拆垛模式
                        Db.Updateable(item).ExecuteCommand();
                        
                        #endregion
                    }
                    else if (locate.Status == "5") //移出中
                    {
                        str = "当前要出库的储位正在移出";
                        return outDto1; 
                    }
                    

                    //添加操作日志记录
                    var k = new OperationSOServer().AddLogOperationSo("PDA模块", "下发出库", soNo, "出库", $"点击出库按钮出库单号为：{soNo}的出库单", userId);
                    Db.CommitTran();
                    
                    if (outDto1.Count > 0)
                    {
                        // 正式运行程序放开
                        var list2 = outDto1.Select(m => m.TaskNo).ToList();
                        var jsonData = JsonConvert.SerializeObject(outDto1);
                        string response = "";

                        try
                        {
                            var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
                            response = HttpHelper.DoPost(url, jsonData, "下发给WCS出库命令", "WCS");
                            var time2 = DateTime.Now;//返回时间 .ToString("yyyy-MM-dd HH:mm:ss")

                            //解析返回数据 
                            var wcsModel = JsonConvert.DeserializeObject<WcsModel2>(response);
                            if (wcsModel.code == 200)
                            {
                                //更改任务的发送返回时间//
                                new TaskServer().EditTaskIssueOk(list2, time1, time2);
                                str = "下发成功";
                            }
                            else
                            {
                                new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.message);
                                throw new Exception(wcsModel.message);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new Exception(ex.Message);
                        }

                    }

                    return outDto1;
                }
                catch (Exception e)
                {
                    Db.RollbackTran();
                    throw new Exception(e.Message);
                }


                #endregion
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }


        #region MyRegion


        /// <summary>
        /// 向Limes发送请验信息
        /// </summary>
        /// <param name="model">model.Id:请验单主键；model.Code:出库口 </param>
        /// <param name="userId">操作用户</param>
        /// <param name="url">Wcs地址</param>
        /// <returns></returns>
        public bool SendInspectionRequest(IdVm model, int userId, string url, string userName)
        {
            try
            {
                // 判断请验单状态
                var data = Db.Queryable<BllQualityInspectionRequest>()
                    .Where(m => m.QcNo == model.Code && m.IsDel == "0" && m.Status == "0").ToList().FirstOrDefault();
                if (data == null)
                {
                    throw new Exception("操作失败!请验单状态变更.");
                }

                // 记录任务日志
                //var taskNo = new Common().GetMaxNo("TK");
                //var exTask = new LogTask()
                //{
                //     TaskNo = taskNo,
                //     Sender = "WMS",
                //     Receiver = "Limes",
                //     IsSuccess = 0,                  //是否下发成功 0失败 1成功
                //     StartLocat = "",               //起始位置
                //     PalletNo = "",                 //托盘码
                //     IsSend = 1,                    //是否可再次下发
                //     IsCancel = 1,                  //是否可取消
                //     IsFinish = 1,                  //是否可完成    
                //     Status = "0",                  //任务状态0：等待执行1正在执行2执行完成
                //     OrderType = "5",               //0 入库单 1 出库单  2 盘点单  3 移库单 4 取样出库单 5 其他
                //     EndLocat = "",          //目标位置
                //     Type = "3",                     //任务类型 0 入库任务 1 出库任务  2 移库任务
                //     Msg = "请验任务"
                //};

                //// 插入任务日志
                //Db.Insertable(exTask).ExecuteCommand();


                // 调用Limes接口发起请验
                var sendModel = new SendLimesModel()
                {
                    QcNo = data.QcNo,
                    SkuNo = data.SkuNo,
                    Qty = data.Qty.ToString(),
                    LotNo = data.LotNo,
                    SupplierLot = data.SupplierLot,
                    RequestUser = userName,                       // 请验人
                };
                var jsonData = JsonConvert.SerializeObject(sendModel);
                string response = "";

                try
                {
                    var time1 = DateTime.Now;//发送时间 .ToString("yyyy-MM-dd HH:mm:ss")
                    //response = HttpHelper.DoPost(url, jsonData, "上传Limes系统发起请验", "Limes");
                    var time2 = DateTime.Now;//返回时间 .ToString("yyyy-MM-dd HH:mm:ss")

                    ////解析返回数据 
                    //var limesModel = JsonConvert.DeserializeObject<LimesModel>(response);
                    //if (limesModel.Success == 0)
                    //{
                    

                    // 更新请验单信息
                    data.Status = "1";
                    data.SamplingQty = 10;//decimal.Parse(limesModel.SamplingQty);
                    data.RequestUser = userId;
                    data.RequestTime = DateTime.Now;
                    data.UpdateTime = DateTime.Now;
                    data.UpdateUser = userId;

                    Db.Updateable(data).ExecuteCommand();
                    //}
                    //if (limesModel.Success == -1)
                    //{
                    
                    //    throw new Exception(limesModel.Message);
                    //}
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }

                //添加操作日志记录
                var k = new OperationCrServer()
                    .AddLogOperationCr("质量管理", "质检请验", model.Code, "请验", $"向质量部分发起请验!", userId);

                return true;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #endregion


    }
}