Merge branch 'Liudl'

bklLiudl

2024-10-17 5408616fd72786b63cfe69a7426c3fb499b6962b

 Wms/WMS.BLL/BllAsnServer/PalletBindServer.cs

@@ -31,6 +31,368 @@
        {
        }

        #region 接口方法

        //绑定物料托盘
        public void BindPalletStock(BoxPalletBindVm model, int userId)
        {
            try
            {
                #region 判断

                //判断托盘是否在库外
                var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
                if (stockDetail != null)
                {
                    if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
                    {
                        throw new Exception("该托盘已有库存信息，请核实！");
                    }
                    return;
                }
                if (model.Type != "0" && model.Type != "1")
                {
                    throw new Exception("托盘类型错误");
                }
                if (string.IsNullOrEmpty(model.PalletNo))
                {
                    throw new Exception("托盘号不可为空!");
                }
                //托盘是否存在
                var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
                if (pallet == null)
                {
                    throw new Exception("未查询到托盘信息，请核实！");
                }
                if (model.Detail.Count == 0)
                {
                    throw new Exception("托盘绑定明细信息为空，请核实");
                }
                BllArrivalNotice notice = null;
                BllArrivalNoticeDetail detail = null;
                if (model.Type == "0")
                {
                    //0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 5：其它入库 6：代储入库
                    if (string.IsNullOrEmpty(model.AsnNo))
                    {
                        throw new Exception("单据号不可为空!");
                    }
                    //if (model.AsnDetailNo == 0)
                    //{
                    //    throw new Exception("单据明细不可为空!");
                    //}
                    //根据单据号获取入库单总单
                    notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo);
                    //notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo && a.OrderCode == model.OrderCode);
                    if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
                    {
                        throw new Exception("该单据已关单!");
                    }
                    if (notice.Type != "0")
                    {
                        throw new Exception("当前单据不能生产成品入库，请核实");
                    }
                    if (string.IsNullOrEmpty(model.LotNo))
                    {
                        throw new Exception("批次不能为空!");
                    }
                    // 验证入库单明细是否存在
                    detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.ASNNo == notice.ASNNo && m.LotNo == model.LotNo && m.SkuNo == model.SkuNo);
                    //detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == model.AsnDetailNo && m.ASNNo == model.AsnNo && m.LotNo == model.LotNo && m.SkuNo == model.SkuNo);
                    if (detail == null)
                    {
                        throw new Exception("当前物料及批次与单据无关联，请核实!");
                    }
                }

                #endregion

                Db.BeginTran();

                var comTime = DateTime.Now;

                #region 包装
                var package = Db.Queryable<SysPackag>().Where(m => m.IsDel == "0");
                var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == model.SkuNo);
                SysPackag pack = null;
                if (model.Type == "0")
                {
                    pack = package.First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo);     
                }
                else
                {
                    pack = package.First(m => m.IsDel == "0" && m.PackagNo == sku.PackagNo);     
                }

                var pNum = 0;//托盘物品数量 
                var bNum = 0;//箱码物品数量 

                if (pack == null)
                {
                    throw new Exception("获取物料包装失败，请核实!");
                }
                if (pack.L5Num.HasValue)
                {
                    pNum = (int)pack.L5Num;
                    bNum = (int)pack.L4Num;
                }
                else if (pack.L4Num.HasValue)
                {
                    pNum = (int)pack.L4Num;
                    bNum = (int)pack.L3Num;
                }
                else if (pack.L3Num.HasValue)
                {
                    pNum = (int)pack.L3Num;
                    bNum = (int)pack.L2Num;
                }
                else if (pack.L2Num.HasValue)
                {
                    pNum = (int)pack.L2Num;
                    bNum = (int)pack.L1Num;
                }
                else if (pack.L1Num.HasValue)
                {
                    pNum = (int)pack.L1Num;
                    bNum = (int)pack.L1Num;
                }
                if (pNum == 0 || bNum == 0)
                {
                    throw new Exception($"绑定失败，{detail.SkuNo}物品包装未找到！");
                }

                #endregion

                #region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
                var list = model.Detail.GroupBy(m => new { m.SkuNo, m.LotNo }).ToList();

                if (list.Count >= 2)
                {
                    var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
                    if (funSetting == null || funSetting.IsEnable == "OFF")
                    {
                        throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
                    }
                }

                #endregion

                //判断托盘绑定信息中是否有
                var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == detail.Id && m.PalletNo == model.PalletNo && m.Status != "2");
                var bindId = 0;
                if (bind == null)
                {
                    bind = new BllPalletBind
                    {
                        ASNNo = notice.ASNNo,
                        ASNDetailNo = detail.Id,
                        PalletNo = model.PalletNo,
                        PalletNo2 = "",
                        PalletNo3 = "",
                        Qty = model.Qty,
                        FullQty = pNum,
                        Status = "0",//等待执行
                        Type = model.Type, //托盘类型  0物料托  1空托盘托
                        LotNo = model.LotNo,
                        LotText = model.LotText,
                        SupplierLot = model.SupplierLot,
                        InspectMark = "0",      //是否取样托盘 
                        //SamplingQty = 0,     //取样数量  后期业务开发时 接口传值需添加对应字段判断
                        BitPalletMark = model.Qty == pNum ? "0" : "1",
                        IsBale = "0",
                        IsBelt = "0",
                        CreateUser = userId,

                    };
                    if (bind.FullQty < bind.Qty)
                    {
                        throw new Exception("托盘绑定数量已超出该物料包装数量");
                    }
                    // 插入托盘绑定表
                    bindId = Db.Insertable(bind).ExecuteReturnIdentity();
                }
                else
                {
                    throw new Exception("组盘信息重复");
                }


                #region 箱码信息 
                decimal factQty = 0.00m;//托盘总数量

                var boxInfoList = new List<BllBoxInfo>();
                if (model.Type == "1")//托盘托
                {
                    if (model.Detail.Count > 1)
                    {
                        throw new Exception("空托盘绑定信息中明细错误，超过了两条明细");
                    }
                    //添加箱码信息/空托盘明细信息
                    foreach (var box in model.Detail)
                    {
                        var boxInfo = new BllBoxInfo()
                        {
                            ASNNo = notice.ASNNo,
                            ASNDetailNo = detail.Id,
                            OrderCode = box.OrderCode,
                            BindNo = bindId,
                            BoxNo = box.BoxNo,
                            BoxNo2 = box.BoxNo2,
                            BoxNo3 = box.BoxNo3,
                            PalletNo = model.PalletNo,
                            Qty = box.Qty,
                            FullQty = box.FullQty,
                            Status = "1",
                            SkuNo = box.SkuNo,
                            SkuName = box.SkuName,
                            LotNo = box.LotNo,
                            LotText = box.LotText,
                            SupplierLot = model.SupplierLot,
                            ProductionTime = box.ProductionTime,
                            ExpirationTime = box.ExpirationTime,
                            CompleteTime = comTime,
                            InspectMark = box.InspectMark,
                            BitBoxMark = box.BitBoxMark,
                            InspectStatus = box.InspectStatus,
                            Origin = "WCS",
                            Standard = box.Standard,
                            PackageStandard = box.PackageStandard,
                            StoreTime = box.StoreTime,
                            CreateUser = userId,
                            CreateTime = comTime,
                        };

                        boxInfoList.Add(boxInfo);
                        factQty += box.Qty;
                    }
                    if (factQty > pNum)
                    {
                        throw new Exception($"绑定失败，托盘绑定数量大于该物品包装数量！");
                    }
                }
                else if (model.Type == "0")//物料托
                {
                    //if (model.Detail.Count(m => m.OrderCode != detail.OrderDetailCode) > 0)
                    //{
                    //    throw new Exception($"托盘绑定明细中，含有箱码生产工单不一致");
                    //}
                    if (model.Detail.Count(m => m.SkuNo != model.SkuNo || m.LotNo != model.LotNo) > 0)
                    {
                        throw new Exception($"托盘绑定明细中，含有箱码物料或批次不一致");
                    }
                    var boxGroup = model.Detail.GroupBy(m => m.BoxNo).ToList();
                    foreach (var g in boxGroup)
                    {
                        decimal boxFullQty = 0;//箱内总数量
                        foreach (var box in g)
                        {
                            factQty += box.Qty;
                            boxFullQty += box.Qty;
                            var boxInfo = new BllBoxInfo()
                            {
                                ASNNo = detail.ASNNo,
                                ASNDetailNo = detail.Id,
                                OrderCode = box.OrderCode,
                                BindNo = bindId,
                                BoxNo = box.BoxNo,
                                BoxNo2 = box.BoxNo2,
                                BoxNo3 = box.BoxNo3,
                                PalletNo = model.PalletNo,
                                Qty = box.Qty,
                                FullQty = box.FullQty,
                                Status = "1",//已组托
                                SkuNo = box.SkuNo,
                                SkuName = box.SkuName,
                                LotNo = box.LotNo,
                                LotText = box.LotText,
                                SupplierLot = model.SupplierLot,
                                ProductionTime = box.ProductionTime,
                                ExpirationTime = box.ExpirationTime,
                                CompleteTime = comTime,
                                InspectMark = box.InspectMark,
                                BitBoxMark = box.BitBoxMark,
                                InspectStatus = box.InspectStatus,
                                Origin = "WCS",
                                Standard = box.Standard,
                                PackageStandard = box.PackageStandard,
                                StoreTime = box.StoreTime,
                                QtyCount = (int)box.QtyCount,
                                QtyOrd = (int)box.QtyOrd,
                                CreateUser = userId,
                                CreateTime = comTime,
                            };
                            boxInfoList.Add(boxInfo);

                        }
                        if (boxFullQty > bNum)
                        {
                            throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
                        }
                    }
                }

                Db.Insertable(boxInfoList).ExecuteCommand();
                #endregion


                if (factQty != bind.Qty)
                {
                    throw new Exception("箱码明细总数量不同于托盘总数量，请核实");
                }

                #region 入库单及明细
                if (model.Type == "0")
                {
                    detail.FactQty += factQty;//已组数量
                    //detail.CompleteQty += factQty;//完成数量

                    detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
                    if (detail.CompleteQty >= detail.Qty)
                    {
                        detail.Status = "2";
                        detail.CompleteTime = comTime;
                    }
                    detail.UpdateUser = userId;
                    detail.UpdateTime = comTime;
                    //更新入库单明细
                    Db.Updateable(detail).ExecuteCommand();

                    notice.UpdateUser = userId;
                    notice.UpdateTime = comTime;
                    if (notice.Status == "0")
                    {
                        notice.Status = "1";
                    }
                    var asnDetailNum = Db.Queryable<BllArrivalNoticeDetail>().Count(m => m.IsDel == "0" && m.ASNNo == detail.ASNNo && m.Status != "2");
                    if (asnDetailNum == 0)
                    {
                        notice.Status = "2";
                        notice.CompleteTime = comTime;//完成时间
                    }
                    //更新入库单
                    Db.Updateable(notice).ExecuteCommand();
                }

                #endregion

                // 更改托盘使用状态
                var sqlStr = $"update SysPallets set Status = '1' where PalletNo = '{model.PalletNo}';";
                //添加托盘记录表数据
                sqlStr += $"insert into LogPalletTrack values('{model.PalletNo}','{notice.ASNNo}','组盘','0',getDate(),{userId},NULL,NULL);";
                Db.Ado.ExecuteCommand(sqlStr);
                new OperationASNServer().AddLogOperationAsn("PDA模块", "托盘绑定", notice.ASNNo, "添加", $"添加了托盘码为：{model.PalletNo}的组盘信息", userId);

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

        #endregion

        #region 托盘绑定
        public List<PalletBindDto> GetPalletBindList(PalletBindVm model, out int count)
        {
@@ -114,8 +476,19 @@
        {
            try
            {
                Expression<Func<BllBoxInfo, bool>> item1 = Expressionable.Create<BllBoxInfo>()
                  .AndIF(!string.IsNullOrWhiteSpace(model.ASNNo), it => it.ASNNo.Contains(model.ASNNo.Trim()))
                  .AndIF(!string.IsNullOrWhiteSpace(model.PalletNo), it => it.PalletNo.Contains(model.PalletNo.Trim()))
                  .AndIF(!string.IsNullOrWhiteSpace(model.LotNo), it => it.LotNo.Contains(model.LotNo.Trim()))
                  .AndIF(!string.IsNullOrWhiteSpace(model.SkuNo), it => it.SkuNo.Contains(model.SkuNo.Trim()))
                  .AndIF(!string.IsNullOrWhiteSpace(model.SkuName), it => it.SkuName.Contains(model.SkuName.Trim()))
                  .AndIF((model.BindNo != 0 && !string.IsNullOrWhiteSpace(model.BindNo.ToString())), it => it.BindNo == model.BindNo)
                  .And(m => m.IsDel == "0")
                  .ToExpression();

                var total = 0;
                var data = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == model.BindNo)
                DbHelper<BllBoxInfo> helper = new DbHelper<BllBoxInfo>(Db);
                var data = helper.GetAllWhereAsync(item1).Where(m => m.IsDel == "0")
                    .LeftJoin<BllPalletBind>((a, b) => a.BindNo == b.Id)
                    .GroupBy((a, b) => new
                    {
@@ -360,7 +733,7 @@
                }
                Db.BeginTran();
                var time = DateTime.Now;
                var qty = 0;
                decimal qty = 0;
                foreach (var item in boxInfos)
                {
                    //删除解绑箱支信息
@@ -380,7 +753,8 @@
                Db.Updateable(boxInfos).ExecuteCommand();

                //修改托盘绑定信息
                bind.Qty -= qty;
                bind.Qty -= qty;                    // 数量变更
                bind.BitPalletMark = "1";           // 零托标记变更

                if (bind.Qty == 0)
                {
@@ -524,7 +898,7 @@
                {
                    OrderNo = notice.ASNNo,
                    PalletNo = bind.PalletNo,
                    Msg = info == null ? $"物料：{noticeDetail.SkuNo}、批次：{noticeDetail.LotNo};": $"物料：{info.SkuNo}、批次：{info.LotNo};",
                    Msg = info == null ? $"物料：{noticeDetail.SkuNo}、批次：{noticeDetail.LotNo};" : $"物料：{info.SkuNo}、批次：{info.LotNo};",
                    Reason = reason,
                    Status = "0",
                    Opinion = "",
@@ -551,10 +925,24 @@

        #region 指定储位
        //指定储位数据源（正常的空储位）
        public List<LocatDto> GetLocateList(string houseNo, string roadwayNo, string row, string column, string layer, string locateNo, int page, int limit, out int count)
        public List<LocatDto> GetLocateList(string houseNo, string roadwayNo, string row, string column, string layer,
            string locateNo, string BindId, int page, int limit, out int count)
        {
            try
            {
                //获取托盘绑定
                var bindASNDetailNo = Db.Queryable<BllPalletBind>().Where(a => a.IsDel == "0" && a.Status == "0"
                && a.Id == int.Parse(BindId)).Select(a => a.ASNDetailNo).First();
                //获取单据明细
                var noticeDetailSkuNo = Db.Queryable<BllArrivalNoticeDetail>().Where(a => a.Id == bindASNDetailNo
                && a.IsDel == "0").Select(a => a.SkuNo).First();
                //获取物料
                var skuCategoryNo = Db.Queryable<SysMaterials>().Where(a => a.IsDel == "0" && a.SkuNo == noticeDetailSkuNo)
                    .Select(a => a.CategoryNo).First();
                //获取物料对应区域
                var categoryAreaNo = Db.Queryable<SysMaterialCategory>().Where(a => a.IsDel == "0" && a.CategoryNo == skuCategoryNo)
                    .Select(a => a.AreaNo).First();

                Expression<Func<SysStorageLocat, bool>> item = Expressionable.Create<SysStorageLocat>()
                   .AndIF(!string.IsNullOrWhiteSpace(roadwayNo), m => m.RoadwayNo == roadwayNo)
                   .AndIF(!string.IsNullOrWhiteSpace(row), m => m.Row == int.Parse(row))
@@ -562,9 +950,10 @@
                   .AndIF(!string.IsNullOrWhiteSpace(layer), m => m.Layer == int.Parse(layer))
                   .AndIF(!string.IsNullOrWhiteSpace(locateNo), m => m.LocatNo.Contains(locateNo))
                   .And(m => m.IsDel == "0" && m.Status == "0" && m.Flag == "0" && m.WareHouseNo == houseNo)
                   .And(m => m.AreaNo.Contains(categoryAreaNo))
                   .ToExpression();//注意 这一句 不能少
                var total = 0;
                var list = Db.Queryable<SysStorageLocat>().Where(item)
                var list = Db.Queryable<SysStorageLocat>().Where(item).OrderByDescending(a => a.Depth).OrderBy(a => a.Column)
                    .Select(a => new LocatDto()
                    {
                        Id = a.Id,
@@ -573,6 +962,7 @@
                        Row = a.Row,
                        Column = a.Column,
                        Layer = a.Layer,
                        Depth = a.Depth,
                        Status = a.Status
                    }).ToOffsetPage(page, limit, ref total);
                count = total;
@@ -611,6 +1001,59 @@
                {
                    throw new Exception("该储位状态不是空储位或标志不是正常的");
                }



                //判断当前托盘是否存在绑定信息
                if (!string.IsNullOrWhiteSpace(bind.LocatNo))
                {
                    //分割已绑储位与新储位
                    //已绑储位
                    var bindRow = bind.LocatNo.Substring(0, 2);
                    var bindColumn = bind.LocatNo.Substring(2, 2);
                    var bindLayer = bind.LocatNo.Substring(4, 2);
                    var bindDepth = bind.LocatNo.Substring(6, 2);
                    //新储位
                    var Row = locate.LocatNo.Substring(0, 2);
                    var Column = locate.LocatNo.Substring(2, 2);
                    var Layer = locate.LocatNo.Substring(4, 2);
                    var Depth = locate.LocatNo.Substring(6, 2);

                    if (bindDepth == "02")
                    {
                        //判断排列层是否相同
                        if (bindRow == Row && bindColumn == Column && bindLayer == Layer)
                        {
                            throw new Exception("同储位深度2不可向深度1切换！");
                        }
                    }
                }
                else
                {
                    //若是深度1的 则判断深度2是否为空储位
                    if (locate.Depth == "01")
                    {
                        var locateDepth = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.Row == locate.Row && a.Column == locate.Column && a.Layer == locate.Layer && a.Depth == "02");
                        if (locateDepth != null)
                        {
                            if (locateDepth.Status != "1")
                            {
                                throw new Exception("该储位深度2不是有物品，不可绑定");
                            }
                        }
                    }
                    //判断是否为深度2的 若为深度2 则获取深度1储位 判断是否为空储位
                    if (locate.Depth == "02")
                    {
                        var locateDepth = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.Row == locate.Row && a.Column == locate.Column && a.Layer == locate.Layer && a.Depth == "01");
                        if (locateDepth.Status != "0" || locateDepth.Flag == "2")
                        {
                            throw new Exception("该储位深度1不是空储位或标志不是正常的");
                        }
                    }
                }


                var bindIdList = Db.Queryable<BllPalletBind>().Where(m => m.IsDel == "0" && m.PalletNo == bind.PalletNo && m.Status != "2").Select(m => m.Id).ToList();
                //判断是否有零箱
                foreach (var item in bindIdList)
@@ -680,6 +1123,7 @@
        {
            try
            {
                #region 验证托盘合法性
                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
@@ -696,17 +1140,17 @@
                    throw new Exception("平库请使用PDA手持进行平库入库");
                }

                OutCommandDto comDto;//返回wcs的入库命令
                var isHaveLocateNo = false; //托盘绑定信息中是否已有指定储位

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

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


                OutCommandDto comDto;//返回wcs的入库命令
                var isHaveLocateNo = false; //  是否已有指定储位
                #region 

                //查询托盘绑定信息(状态为等待入库的)
@@ -741,6 +1185,11 @@
                            OutMode = "",  //目标地址
                            Order = 1
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                            Db.Updateable(beingTask).ExecuteCommand();
                        }
                        return comDto;
                    }
                    if (haveLocate != null)
@@ -748,6 +1197,8 @@
                        isHaveLocateNo = true; //已有指定储位
                    }


                    //  验证是否关联单据，获取托盘上存放的物料
                    if (palletBindList.First().Type == "0") //物料托入库
                    {
                        //判断是否绑定单据及单据状态是否正常
@@ -758,7 +1209,7 @@
                            {
                                throw new Exception("托盘存在物料未绑定入库单，不可入库！");
                            }
                            if (notice.Status == "3")
                            if (notice.Status == "3" || notice.Status == "4")
                            {
                                throw new Exception($"入库单{item.ASNNo}已关闭，不可入库！");
                            }
@@ -789,30 +1240,52 @@
                    }
                    skuNo = stockDetail.First().SkuNo;

                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
                    #region 托盘回库规则
                    #region 判断任务是否已经存在，若存在直接返回任务；
                    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)
                    {
                        comDto = new OutCommandDto()
                        {
                            PalletNo = palletNo,//托盘号
                            StartRoadway = beingTask.StartRoadway, // 起始巷道
                            StartLocate = "", // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway,  //  目标巷道
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型 (出库)
                            OutMode = "",  //目标地址
                            Order = 1
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                            beingTask.Status = "1";
                            Db.Updateable(beingTask).ExecuteCommand();
                        }

                        return comDto;
                    }
                    #endregion

                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun041" && 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);
                        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 != null)
                        {
                            //验证当前托盘拣货信息是否已完成
                            if (allot.Status != "5")
                            {
                                //验证当前托盘拣货信息是否已完成
                                if (allot.Status != "5")
                                {
                                    throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
                                }
                                throw new Exception("当前托盘拣货信息未完成，请完成后回库！");
                            }
                        }
                    }


                    #endregion
                }

@@ -820,6 +1293,7 @@

                SysStorageLocat locate;

                #region 根据sku确认区域划分
                var sku = skuList.FirstOrDefault(m => m.SkuNo == skuNo);
                if (sku == null)
                {
@@ -861,13 +1335,16 @@
                            break;
                    }
                }
                var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo))
                    .GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();

                SysRoadwayUseLog useLog = Db.Queryable<SysRoadwayUseLog>().Where(m=>m.IsDel =="0" && roadList.Contains(m.RoadwayNo)).OrderByDescending(l => l.Id).First(); //巷道最后一次使用记录
                var road = Db.Queryable<SysStorageRoadway>().Where(m => m.IsDel == "0" && m.Status == "0").Select(m => m.RoadwayNo).ToList();

                var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && areaList.Contains(m.AreaNo) && road.Contains(m.RoadwayNo)).GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();

                SysRoadwayUseLog useLog = Db.Queryable<SysRoadwayUseLog>().Where(m => m.IsDel == "0" && roadList.Contains(m.RoadwayNo)).OrderByDescending(l => l.Id).First(); //巷道最后一次使用记录
                #endregion


                #region 确定巷道排序

                List<string> roadList2 = new List<string>();
                List<string> roadSmall = new List<string>();
                List<string> roadLarge = new List<string>();
@@ -880,7 +1357,7 @@
                        {
                            continue;
                        }
                        //如果结果为0，则说明两个字符串相等；
                        //如果结果为0，则说明两个字符串相等；  ABC  BCE
                        //如果结果小于0，则说明第一个字符串小于第二个字符串；
                        //如果结果大于0，则说明第一个字符串大于第二个字符串。
                        var bol = String.CompareOrdinal(r, useLog.RoadwayNo);
@@ -895,9 +1372,13 @@
                    }
                    roadList2.AddRange(roadLarge);
                    roadList2.AddRange(roadSmall);
                    roadList = roadList2;
                }

                roadList = roadList2;
                
                if (roadList.Count == 0)
                {
                    throw new Exception("未查询到可能使用的巷道");
                }
                #endregion


@@ -917,21 +1398,21 @@
                            .Where(m => m.Status == "0" && m.Flag == "0" && areaList.Contains(m.AreaNo) && m.RoadwayNo == l).Count();

                        var bindNum = Db.Queryable<BllPalletBind>()
                            .Where(m => m.IsDel == "0" && m.Status == "0" && m.RoadwayNo== l)
                            .Where(m => m.IsDel == "0" && m.Status == "0" && m.RoadwayNo == l)
                            .GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
                        if (locateCount - bindNum > 0)
                        {
                            roadNo = l;
                        }
                        //当前巷有位置则退出
                        if (roadNo != null)
                        if (!string.IsNullOrWhiteSpace(roadNo))
                        {
                            break;
                        }
                    }
                    //如果跳巷道并且未找到合适空储位,则跳到最后一次使用的巷道查询

                    if (roadNo == null)
                    if (string.IsNullOrWhiteSpace(roadNo))
                    {
                        if (useLog != null)
                        {
@@ -944,14 +1425,14 @@
                            if (locateCount - bindNum > 0)
                            {
                                roadNo = useLog.RoadwayNo;
                            } 
                            }
                        }
                    }
                }
                else//按照巷道优先级分配
                {
                    foreach (var item in roadList)
                    { 
                    {
                        var locateCount = Db.Queryable<SysStorageLocat>()
                            .Where(m => m.Status == "0" && m.Flag == "0" && areaList.Contains(m.AreaNo) && m.RoadwayNo == item).Count();

@@ -964,10 +1445,10 @@
                            roadNo = item;
                        }
                        //当前巷有位置则退出
                        if (roadNo != null)
                        if (!string.IsNullOrWhiteSpace(roadNo))
                        {
                            break;
                        } 
                        }
                    }
                }

@@ -979,31 +1460,72 @@
                Db.BeginTran();
                try
                {
                    if (roadNo != null)
                    //添加巷道使用记录
                    var log = new SysRoadwayUseLog
                    {
                        //添加巷道使用记录
                        var log = new SysRoadwayUseLog
                        {
                            RoadwayNo = roadNo,
                            WareHouseNo = houseNo,
                            Row = 0,
                            Column = 0,
                            Layer = 0,
                        };
                        Db.Insertable(log).ExecuteCommand();
                    }
                        RoadwayNo = roadNo,
                        WareHouseNo = houseNo,
                        Row = 0,
                        Column = 0,
                        Layer = 0,
                    };
                    Db.Insertable(log).ExecuteCommand();

                    // 添加入库日志记录
                    var taskNo = new Common().GetMaxNo("TK");
                    var exTask = new LogTask    //入库任务
                    {
                        TaskNo = taskNo,
                        Sender = "WMS",
                        Receiver = "WCS",
                        IsSuccess = 1, //是否下发成功 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(exTask).ExecuteCommand();

                    //// 添加托盘绑定表托盘入库任务号  liudl
                    //if (palletBindList.Count < 1)
                    //{
                    //    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 = houseNo;
                    //            bindModel.RoadwayNo = roadNo;
                    //            Db.Updateable(bindModel).ExecuteCommand();
                    //        }
                    //    }
                    //}
                    if (palletBindList.Count >= 1)
                    {
                        foreach (var item in palletBindList)
                        {
                            item.WareHouseNo = houseNo;
                            item.RoadwayNo = roadNo;
                            item.TaskNo = "";
                            item.TaskNo = taskNo;
                            item.Status = "1";
                        }
                        Db.Updateable(palletBindList).ExecuteCommand();
                    }
                    Db.CommitTran();

                    comDto = new OutCommandDto()
                    {
                        PalletNo = palletNo,//托盘号
@@ -1011,12 +1533,291 @@
                        StartLocate = "", // 起始位置
                        EndLocate = "", // 目标位置 
                        EndRoadway = roadNo,   // 目标巷道
                        TaskNo = "", // 任务号
                        TaskNo = taskNo, // 任务号
                        TaskType = "0",// 任务类型:入库任务
                        OutMode = "",  //目标地址
                        Order = 1
                    };
                }
                catch (Exception ex)
                {
                    Db.RollbackTran();
                    throw new Exception(ex.Message);
                }
                #endregion

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

        // 申请巷道 参观模式
        public OutCommandDto RequestRoadWayModel(string palletNo, string houseNo)
        {
            try
            {
                #region 验证托盘合法性
                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
                    throw new Exception("请输入要申请的托盘条码");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(houseNo))
                {
                    throw new Exception("请选择所属仓库");
                }
                //验证是否为平库入库
                if (houseNo == "W02")
                {
                    throw new Exception("平库请使用PDA手持进行平库入库");
                }

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


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

                #region 判断任务是否已经存在，若存在直接返回任务；
                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)
                {
                    comDto = new OutCommandDto()
                    {
                        PalletNo = palletNo,//托盘号
                        StartRoadway = beingTask.StartRoadway, // 起始巷道
                        StartLocate = "", // 起始位置
                        EndLocate = beingTask.EndLocat, // 目标位置
                        EndRoadway = beingTask.EndRoadway,  //  目标巷道
                        TaskNo = beingTask.TaskNo, // 任务号
                        TaskType = "0",// 任务类型 (出库)
                        OutMode = "",  //目标地址
                        Order = 1
                    };
                    if (beingTask.IsSuccess == 0)
                    {
                        beingTask.IsSuccess = 1;
                        beingTask.Status = "1";
                        Db.Updateable(beingTask).ExecuteCommand();
                    }

                    return comDto;
                }
                #endregion



                var areaNoStr = "A03";
                var allotLocate = new AllotLocation();
                
                #region 根据sku确认区域划分
                
                var laneAllot = 0; //储位跳巷分配 0:跳着分配(一个一个分配)1:巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                var funSet3 = Db.Queryable<SysFunSetting>().First(m => m.IsDel == "0" && m.FunSetName == "储位跳巷分配" && m.IsEnable == "NO");
                if (funSet3 != null)
                {
                    switch (funSet3.SetValue)
                    {
                        case "JumpLaneAllot":
                            laneAllot = 0;//立库储位分配 巷道同优先级巷道跳着分配(一个一个分配)
                            break;
                        case "RankLaneAllot":
                            laneAllot = 1;//立库储位分配 巷道按照优先级分配，同优先级顺序分配(一个巷道满了再分配下一个的巷道储位)
                            break;
                        default:
                            laneAllot = 1;// 默认 跳着分配
                            break;
                    }
                }
                //启用的巷道集合
                var road = Db.Queryable<SysStorageRoadway>().Where(m => m.IsDel == "0" && m.Status == "0").Select(m => m.RoadwayNo).ToList();
                var roadList = Db.Queryable<SysStorageLocat>().Where(m => m.WareHouseNo == houseNo && m.AreaNo == areaNoStr && road.Contains(m.RoadwayNo))
                    .GroupBy(m => m.RoadwayNo).OrderBy(m => m.RoadwayNo).Select(m => m.RoadwayNo).ToList();

                SysRoadwayUseLog useLog = Db.Queryable<SysRoadwayUseLog>().Where(m => m.IsDel == "0" && roadList.Contains(m.RoadwayNo)).OrderByDescending(l => l.Id).First(); //巷道最后一次使用记录
                #endregion


                #region 确定巷道排序
                List<string> roadList2 = new List<string>();
                List<string> roadSmall = new List<string>();
                List<string> roadLarge = new List<string>();
                if (useLog != null)
                {
                    roadList2.Add(useLog.RoadwayNo);
                    foreach (var r in roadList)
                    {
                        if (r == useLog.RoadwayNo)
                        {
                            continue;
                        }
                        //如果结果为0，则说明两个字符串相等；  ABC  BCE
                        //如果结果小于0，则说明第一个字符串小于第二个字符串；
                        //如果结果大于0，则说明第一个字符串大于第二个字符串。
                        var bol = String.CompareOrdinal(r, useLog.RoadwayNo);
                        if (bol < 0)
                        {
                            roadSmall.Add(r);
                        }
                        if (bol > 0)
                        {
                            roadLarge.Add(r);
                        }
                    }
                    roadList2.AddRange(roadLarge);
                    roadList2.AddRange(roadSmall);
                    roadList = roadList2;
                }

                if (roadList.Count == 0)
                {
                    throw new Exception("未查询到可能使用的巷道");
                }
                #endregion


                var roadNo = "";
                if (laneAllot == 0)//跳巷道平均分配
                {
                    //取各巷道所有排第一个合适位
                    foreach (var l in roadList)
                    {
                        //如果上次是当前巷道则跳出
                        if (useLog != null && l == useLog.RoadwayNo)
                        {
                            continue;
                        }

                        var locateCount = Db.Queryable<SysStorageLocat>()
                            .Where(m => m.Status == "0" && m.Flag == "0" && m.AreaNo == areaNoStr && m.RoadwayNo == l).Count();

                        var taskNum = Db.Queryable<LogTask>()
                            .Where(m => m.IsDel == "0" && m.Type == "0" && (m.Status == "0" || m.Status == "1") && m.EndRoadway == l)
                            .GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
                        if (locateCount - taskNum > 0)
                        {
                            roadNo = l;
                        }
                        //当前巷有位置则退出
                        if (!string.IsNullOrWhiteSpace(roadNo))
                        {
                            break;
                        }
                    }
                    //如果跳巷道并且未找到合适空储位,则跳到最后一次使用的巷道查询

                    if (string.IsNullOrWhiteSpace(roadNo))
                    {
                        if (useLog != null)
                        {
                            var locateCount = Db.Queryable<SysStorageLocat>()
                                .Where(m => m.Status == "0" && m.Flag == "0" && m.AreaNo == areaNoStr && m.RoadwayNo == useLog.RoadwayNo).Count();

                            var taskNum = Db.Queryable<LogTask>()
                                .Where(m => m.IsDel == "0" && m.Type == "0" && (m.Status == "0" || m.Status == "1") && m.EndRoadway == useLog.RoadwayNo)
                                .GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();
                            if (locateCount - taskNum > 0)
                            {
                                roadNo = useLog.RoadwayNo;
                            }
                        }
                    }
                }
                else//按照巷道优先级分配
                {
                    roadList = Db.Queryable<SysStorageRoadway>().Where(m=> roadList.Contains(m.RoadwayNo)).OrderBy(m => new {m.Priority ,m.RoadwayNo}).Select(m=>m.RoadwayNo).ToList();
                    foreach (var item in roadList)
                    {
                        var locateCount = Db.Queryable<SysStorageLocat>()
                            .Where(m => m.Status == "0" && m.Flag == "0" && m.AreaNo == areaNoStr && m.RoadwayNo == item).Count();

                        var taskNum = Db.Queryable<LogTask>()
                            .Where(m => m.IsDel == "0" && m.Type == "0" && (m.Status == "0" ||  m.Status == "1") && m.EndRoadway == item)
                            .GroupBy(m => m.PalletNo).Select(m => m.PalletNo).Count();

                        if (locateCount - taskNum > 0)
                        {
                            roadNo = item;
                        }
                        //当前巷有位置则退出
                        if (!string.IsNullOrWhiteSpace(roadNo))
                        {
                            break;
                        }
                    }
                }

                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 exTask = new LogTask    //入库任务
                    {
                        TaskNo = taskNo,
                        Sender = "WMS",
                        Receiver = "WCS",
                        IsSuccess = 1, //是否下发成功 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 + "巷道的入库任务", //关键信息
                        TaskModel = "1"  //任务模式  1：演示模式

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

                    Db.CommitTran();

                    comDto = new OutCommandDto()
                    {
                        PalletNo = palletNo,//托盘号
                        StartRoadway = "",
                        StartLocate = "", // 起始位置
                        EndLocate = "", // 目标位置 
                        EndRoadway = roadNo,   // 目标巷道
                        TaskNo = taskNo, // 任务号
                        TaskType = "0",// 任务类型:入库任务
                        OutMode = "",  //目标地址
                        Order = 1
                    };
                }
                catch (Exception ex)
                {
@@ -1048,6 +1849,11 @@
                {
                    throw new Exception("请选择所属仓库");
                }
                //验证巷道是否为空
                if (string.IsNullOrWhiteSpace(roadwayNo))
                {
                    throw new Exception("巷道不能为空");
                }
                //验证是否为平库入库
                if (houseNo == "W02")
                {
@@ -1074,20 +1880,11 @@
                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();
                if (palletBindList.Count >= 1) //正常入库
                {
                    //var bindIdList = palletBindList.Select(m => m.Id).ToList();
                    //判断是否有零箱
                    //foreach (var item in bindIdList)
                    //{
                    //    var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BindNo == item);
                    //    if (boxInfo.Count(m => m.BitBoxMark == "1") > 0)
                    //    {
                    //        throw new Exception($"{palletNo}托盘上有零箱，请入零箱库！");
                    //    }
                    //}

                    var palletBind = palletBindList.FirstOrDefault(m => m.Status == "1");
                    if (palletBind != null)
                    {
@@ -1096,19 +1893,38 @@
                        {
                            throw new Exception("该托盘正在入库，但未查询到任务信息");
                        }
                        comDto = new OutCommandDto()
                        if (!string.IsNullOrWhiteSpace(beingTask.EndLocat))
                        {
                            PalletNo = palletNo,//托盘号
                            StartRoadway = beingTask.StartRoadway, // 起始巷道
                            StartLocate = "", // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway,                           //  目标巷道
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型 (出库)
                            OutMode = "",  //目标地址
                            Order = 1
                        };
                        return comDto;
                            comDto = new OutCommandDto()
                            {
                                PalletNo = palletNo,//托盘号
                                StartRoadway = beingTask.StartRoadway, // 起始巷道
                                StartLocate = "", // 起始位置
                                EndLocate = beingTask.EndLocat, // 目标位置
                                EndRoadway = beingTask.EndRoadway,                           //  目标巷道
                                TaskNo = beingTask.TaskNo, // 任务号
                                TaskType = "0",// 任务类型 (出库)
                                OutMode = "",  //目标地址
                                Order = 1
                            };
                            if (beingTask.IsSuccess == 0)
                            {
                                beingTask.IsSuccess = 1;//如果任务下发状态是未下发更改为已下发
                                Db.Updateable(beingTask).ExecuteCommand();
                            }
                            return comDto;

                        }
                        else
                        {
                            if (string.IsNullOrWhiteSpace(roadwayNo))
                            {
                                roadwayNo = beingTask.EndRoadway;
                            }
                            isAddTask = false;
                            oldTaskNo = beingTask.TaskNo;
                        }
                            
                    }
                    if (haveLocate != null)
                    {
@@ -1149,24 +1965,66 @@
                }
                else //回流入库
                {
                    var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo).ToList();
                    
                    if (stockDetail.Count == 0)
                    {
                        throw new Exception($"{palletNo}托盘条码不具有箱码信息，不可入库！");
                    }
                    skuNo = stockDetail.First().SkuNo;
                    //else
                    //{
                    //    //判断是否有零箱
                    //    var detailIdList = stockDetail.Select(m => m.Id).ToList();
                    //    var dataBoxInfo = Db.Queryable<DataBoxInfo>().Where(m => detailIdList.Contains(m.StockDetailId)).ToList();
                    //    if (dataBoxInfo.Count(m => m.BitBoxMark == "1")>0)
                    //    {
                    //        throw new Exception($"{palletNo}托盘上有零箱，不可入库！");
                    //    }
                    if (!string.IsNullOrWhiteSpace(stockDetail.First().WareHouseNo))
                    {
                        if (stockDetail.First().WareHouseNo == "W01")//立库
                        {
                            throw new Exception($"{palletNo}托盘上在立库中有库存储位信息，请核实！");
                        }

                    //}
                        if (stockDetail.First().WareHouseNo == "W02")//平库
                        {
                            var locatePingKu = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == stockDetail.First().LocatNo);
                            if (locatePingKu != null)
                            {
                                locatePingKu.Status = "0";
                                Db.Updateable(locatePingKu).ExecuteCommand();
                            }
                        }
                    }

                    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 = "", // 起始位置
                                EndLocate = beingTask.EndLocat, // 目标位置
                                EndRoadway = beingTask.EndRoadway,   //  目标巷道
                                TaskNo = beingTask.TaskNo, // 任务号
                                TaskType = "0",// 任务类型 (出库)
                                OutMode = "",  //目标地址
                                Order = 1
                            };
                            if (beingTask.IsSuccess == 0)
                            {
                                beingTask.IsSuccess = 1;
                                beingTask.Status = "1";
                                Db.Updateable(beingTask).ExecuteCommand();
                            }
                            return comDto;
                        }
                        else
                        {
                            if (string.IsNullOrWhiteSpace(roadwayNo))
                            {
                                roadwayNo = beingTask.EndRoadway;
                            }
                            isAddTask = false;
                            oldTaskNo = beingTask.TaskNo;
                        }
                    }

                    //获取对应回库规则
                    var function = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetName == "托盘回库验证" && a.IsEnable == "NO");
@@ -1233,46 +2091,74 @@
                Db.BeginTran();
                try
                {
                    //if (locate != null)
                    //{
                    //    //添加巷道使用记录
                    //    var log = new SysRoadwayUseLog
                    //    {
                    //        RoadwayNo = locate.RoadwayNo,
                    //        LocateNo = locate.LocatNo,
                    //        WareHouseNo = locate.WareHouseNo,
                    //        Row = locate.Row,
                    //        Column = locate.Column,
                    //        Layer = locate.Layer,
                    //        Depth = locate.Depth
                    //    };
                    //    Db.Insertable(log).ExecuteCommand();
                    //}

                    var taskNo = new Common().GetMaxNo("TK");
                    var exTask = new LogTask    //入库任务
                    if (isAddTask)
                    {
                        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 + "的入库任务", //关键信息
                        var taskNo = new Common().GetMaxNo("TK");
                        var exTask = 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(exTask).ExecuteCommand();
                        };
                        Db.Insertable(exTask).ExecuteCommand();
                        // 添加托盘绑定表托盘入库任务号 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();
                            }
                        }
                        oldTaskNo = taskNo;
                    }
                    else
                    {
                        var oldTask = Db.Queryable<LogTask>().First(m => m.IsDel == "0" && m.TaskNo == oldTaskNo);
                        oldTask.EndLocat = locate.LocatNo;
                        oldTask.EndRoadway = locate.RoadwayNo;
                        oldTask.Msg += $"{roadwayNo}巷道口=>>{locate.LocatNo}储位地址";
                        if (oldTask.IsSuccess == 0)
                        {
                            oldTask.IsSuccess = 1;
                            oldTask.Status = "1"; 
                        }
                        Db.Updateable(oldTask).ExecuteCommand();

                        var bindModel = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.Status == "2"
                           && m.PalletNo == oldTask.PalletNo && m.TaskNo == oldTaskNo);
                        if (bindModel != null && string.IsNullOrWhiteSpace(bindModel.LocatNo))
                        {
                            bindModel.TaskNo = oldTask.TaskNo;
                            bindModel.WareHouseNo = locate.WareHouseNo;
                            bindModel.RoadwayNo = locate.RoadwayNo;
                            bindModel.LocatNo = locate.LocatNo;
                            Db.Updateable(bindModel).ExecuteCommand();
                        }
                    }

                   
                    locate.Status = "2";
                    Db.Updateable(locate).ExecuteCommand();
                    if (palletBindList.Count >= 1)
@@ -1283,7 +2169,7 @@
                            item.WareHouseNo = locate.WareHouseNo;
                            item.RoadwayNo = locate.RoadwayNo;
                            item.LocatNo = locate.LocatNo;
                            item.TaskNo = taskNo;
                            item.TaskNo = oldTaskNo;
                        }
                        Db.Updateable(palletBindList).ExecuteCommand();
                    }
@@ -1295,7 +2181,7 @@
                        StartLocate = "", // 起始位置
                        EndLocate = locate.LocatNo, // 目标位置 
                        EndRoadway = locate.RoadwayNo,   // 目标巷道
                        TaskNo = exTask.TaskNo, // 任务号
                        TaskNo = oldTaskNo, // 任务号
                        TaskType = "0",// 任务类型 (出库)
                        OutMode = "",  //目标地址
                        Order = 1
@@ -1308,6 +2194,176 @@
                    throw new Exception(ex.Message);
                }
                #endregion


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


        //申请储位(参观模式)
        public OutCommandDto RequestLocationModel(string palletNo, string houseNo, string roadwayNo)
        {
            try
            {

                //验证托盘条码是否为空
                if (string.IsNullOrEmpty(palletNo))
                {
                    throw new Exception("请输入要申请的托盘条码");
                }
                //验证所属仓库是否为空
                if (string.IsNullOrEmpty(houseNo))
                {
                    throw new Exception("请选择所属仓库");
                }
                //验证巷道是否为空
                if (string.IsNullOrWhiteSpace(roadwayNo))
                {
                    throw new Exception("巷道不能为空");
                }
                //验证是否为平库入库
                if (houseNo == "W02")
                {
                    throw new Exception("平库请使用PDA手持进行平库入库");
                }
                //var stock = Db.Queryable<SysPallets>().First(a => a.PalletNo == palletNo);//托盘信息

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

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

                var isAddTask = false;
                var oldTaskNo = "";
                #region 

                 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 = "", // 起始位置
                            EndLocate = beingTask.EndLocat, // 目标位置
                            EndRoadway = beingTask.EndRoadway,   //  目标巷道
                            TaskNo = beingTask.TaskNo, // 任务号
                            TaskType = "0",// 任务类型 (出库)
                            OutMode = "",  //目标地址
                            Order = 1
                        };
                        if (beingTask.IsSuccess == 0)
                        {
                            beingTask.IsSuccess = 1;
                            beingTask.Status = "1";
                            Db.Updateable(beingTask).ExecuteCommand();
                        }
                        return comDto;
                    }
                    else
                    {
                        if (string.IsNullOrWhiteSpace(roadwayNo))
                        {
                            roadwayNo = beingTask.EndRoadway;
                        }
                    }
                    oldTaskNo = beingTask.TaskNo;
                }
                else
                {
                    isAddTask = true;
                }


                #endregion
                

                var allotLocate = new AllotLocation();

                SysStorageLocat locate;
                var areaList = new List<string>();
                areaList.Add("A03");
                locate = allotLocate.GetSuiTableLocate(houseNo, areaList, roadwayNo);
                 
                Db.BeginTran();
                try
                {
                    if (isAddTask)
                    {
                        var taskNo = new Common().GetMaxNo("TK");
                        var exTask = 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 + "的入库任务", //关键信息
                            TaskModel = "1"

                        };
                        Db.Insertable(exTask).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();
                    }


                    locate.Status = "2";
                    Db.Updateable(locate).ExecuteCommand();
                   
                    Db.CommitTran();
                    comDto = new OutCommandDto()
                    {
                        PalletNo = palletNo,//托盘号
                        StartRoadway = "",
                        StartLocate = "", // 起始位置
                        EndLocate = locate.LocatNo, // 目标位置 
                        EndRoadway = locate.RoadwayNo,   // 目标巷道
                        TaskNo = oldTaskNo, // 任务号
                        TaskType = "0",// 任务类型 (出库)
                        OutMode = "",  //目标地址
                        Order = 1
                    };

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


                return comDto;
@@ -1337,10 +2393,7 @@
                var stockDetail = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == task.PalletNo).ToList();
                //当前任务中的储位信息
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate == null)
                {
                    throw new Exception($"未查询到任务中的储位信息");
                }
                
                //获取箱码信息
                var box1 = Db.Queryable<BllBoxInfo>().First(a => a.PalletNo == task.PalletNo && a.IsDel == "0" && a.Status != "2");

@@ -1356,6 +2409,18 @@
                {
                    //添加操作日志记录
                    var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "完成", $"点击完成按钮、完成任务号为：{taskNo}的任务", userId);
                }
                if (task.TaskModel == "1") //演示模式
                {
                    locate.Status = "1";
                    Db.Updateable(locate).ExecuteCommand();
                    Db.CommitTran();
                    return;
                }
                // 判断储位是否为空
                if (locate == null)
                {
                    throw new Exception($"未查询到任务中的储位信息");
                }
                //判断是否是回流入库完成
                if (stockDetail.Any())
@@ -1457,6 +2522,7 @@
                                SkuName = boxInfo.SkuName,
                                Standard = sku.Standard,
                                ProductionTime = boxInfo.ProductionTime,
                                ExpirationTime = boxInfo.ExpirationTime,
                                SupplierLot = boxInfo.SupplierLot,
                                InspectStatus = boxInfo.InspectStatus,
                                InspectMark = boxInfo.InspectMark,
@@ -1499,7 +2565,7 @@
                            #endregion

                            break;
                        case "0":                            
                        case "0":
                            var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == item.ASNDetailNo);
                            if (noticeDetail == null)
                            {
@@ -1522,13 +2588,23 @@
                            }

                            //获取该批次最终质检结果
                            //var quality = Db.Queryable<BllQualityInspect>().Where(a => a.LotNo == noticeDetail.LotNo && a.IsDel == "0").OrderByDescending(a => a.CreateTime).ToList(); 
                            BllQualityInspect quality = new BllQualityInspect();
                            //判断是否为退货入库单
                            if (notice.Type == "3")
                            {
                                quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == noticeDetail.ASNNo && a.SkuNo == noticeDetail.SkuNo && a.LotNo == noticeDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
                            }
                            else
                            {
                                quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == noticeDetail.SkuNo && a.LotNo == noticeDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
                            }

                            #region 库存明细
                            var sd = new DataStockDetail()
                            {
                                LotNo = item.LotNo,
                                LotText = noticeDetail.LotText,
                                SupplierLot = noticeDetail.SupplierLot,                                
                                SupplierLot = noticeDetail.SupplierLot,
                                SkuNo = noticeDetail.SkuNo,
                                SkuName = noticeDetail.SkuName,
                                Standard = noticeDetail.Standard,
@@ -1558,31 +2634,39 @@
                                IsBelt = item.IsBelt,
                                Demo = item.Demo,

                                OwnerNo = ownerNo,
                                OwnerName = ownerName,

                                IsDel = "0",
                                CreateUser = 0,
                                CreateTime = comTime
                            };
                            //维护库存明细货主/供应商信息
                            if (notice.Type == "0" || notice.Type == "2" || notice.Type == "4" || notice.Type == "6" || notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
                            {
                                sd.OwnerNo = notice.CustomerNo;//货主编码
                                sd.OwnerName = notice.CustomerName;//货主名称
                            }
                            else if (notice.Type == "1" || notice.Type == "5")//1:采购入库,2:其它入库
                            {
                                sd.SupplierNo = notice.CustomerNo;//供应商编码
                                sd.SupplierName = notice.CustomerName;//供应商名称
                            }

                            //if (quality.Count() > 0)
                            //{
                            //    //修改合格不合格数量
                            //    if (quality[0].IsQualified == "1") //合格
                            //    {
                            //        //增加合格数量
                            //        quality[0].PassQty += item.Qty;
                            //        sd.InspectStatus = "1";
                            //    }
                            //    else if (quality[0].IsQualified == "0") //不合格
                            //    {
                            //        //增加不合格数量
                            //        quality[0].FailQty += item.Qty;
                            //        sd.InspectStatus = "2";
                            //    }
                            //    Db.Updateable(quality[0]).ExecuteCommand(); //修改质检信息
                            //}
                            if (quality != null)
                            {
                                //修改合格不合格数量
                                if (quality.IsQualified == "1") //合格
                                {
                                    //增加合格数量
                                    quality.PassQty += item.Qty;
                                    sd.InspectStatus = "1";
                                }
                                else if (quality.IsQualified == "0") //不合格
                                {
                                    //增加不合格数量
                                    quality.FailQty += item.Qty;
                                    sd.InspectStatus = "2";
                                }
                                Db.Updateable(quality).ExecuteCommand(); //修改质检信息
                            }

                            var sdId = Db.Insertable(sd).ExecuteReturnIdentity(); //新增库存明细信息

@@ -1612,6 +2696,7 @@
                                    SkuName = demo.SkuName,
                                    Standard = noticeDetail.Standard,
                                    ProductionTime = demo.ProductionTime,
                                    ExpirationTime = demo.ExpirationTime,
                                    SupplierLot = demo.SupplierLot,
                                    InspectStatus = demo.InspectStatus,
                                    InspectMark = demo.InspectMark,
@@ -1649,13 +2734,16 @@
                                    LockQty = 0,
                                    FrozenQty = 0,

                                    OwnerNo = ownerNo,
                                    OwnerName = ownerName,

                                    IsDel = "0",
                                    CreateUser = userId,
                                    CreateTime = comTime
                                };
                                //维护库存货主信息
                                if (notice.Type == "0" || notice.Type == "2" || notice.Type == "4" || notice.Type == "6" || notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
                                {
                                    stock.OwnerNo = notice.CustomerNo;//货主编码
                                    stock.OwnerName = notice.CustomerName;//货主名称
                                }
                                Db.Insertable(stock).ExecuteCommand();
                            }
                            #endregion
@@ -1673,7 +2761,7 @@
                            var asnDetailNum = Db.Queryable<BllArrivalNoticeDetail>()
                                .Count(m => m.IsDel == "0" && m.ASNNo == noticeDetail.ASNNo && m.Status != "2");
                            if (asnDetailNum == 0)
                            {                                
                            {
                                notice.Status = "2";
                                notice.CompleteTime = comTime;
                                Db.Updateable(notice).ExecuteCommand();
@@ -2076,13 +3164,11 @@
                    Db.Updateable(bind).ExecuteCommand();
                }
                var locate = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == task.EndLocat);
                if (locate == null)
                if (locate != null)
                {
                    throw new Exception("未查询道储位信息");
                    locate.Status = "0"; //修改储位状态
                    Db.Updateable(locate).ExecuteCommand();
                }

                locate.Status = "0"; //修改储位状态
                Db.Updateable(locate).ExecuteCommand();

                //添加操作日志记录
                var k = new OperationASNServer().AddLogOperationAsn("入库作业", "入库日志", taskNo, "取消", $"点击取消按钮取消了任务号为：{taskNo}的任务", (int)userId);
@@ -2090,6 +3176,7 @@
            }
            catch (Exception e)
            {
                Db.RollbackTran();
                throw new Exception(e.Message);
            }
        }