JC26WMS.git - Gitblit

			@@ -319,7 +319,7 @@
			}

			//出库pda拣货
			public void SoSetPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, int userId)
			public async Task SoSetPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, int userId)
			{
			Db.BeginTran();
			try
			@@ -328,60 +328,60 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(soDetailId))
			{
			throw new Exception("出库物料-批次不能为空");
			throw Oops.Bah("出库物料-批次不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
			{
			throw new Exception("追溯条码和拣货数量不能同时输入");
			throw Oops.Bah("追溯条码和拣货数量不能同时输入");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
			.FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}
			#endregion

			@@ -389,28 +389,28 @@
			{
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
			boxInfos = boxInfo.ToList();
			boxInfos = await boxInfo.ToListAsync();
			if (boxInfo.Count() <= 0)
			{
			throw new Exception("该托盘上没有可拣货的箱子");
			throw Oops.Bah("该托盘上没有可拣货的箱子");
			}
			var boxQty = boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
			var boxQty = await boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
			if (boxQty[0] > needQty)
			{
			throw new Exception("拣货数量不能大于箱内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
			}
			decimal pickQty = 0;//拣货的数量
			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
			var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
			var comList = new List<BllCompleteDetail>();
			foreach (var item in boxInfos)
			{
			if (comDetailList.Any(m => m.BoxNo3 == item.BoxNo3) && item.BoxNo3 != null)
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			if (item.SkuNo != allot.SkuNo \|\| item.LotNo != allot.LotNo)
			{
			throw new Exception("当前托盘上有其他不同物料批次，拣货失败");
			throw Oops.Bah("当前托盘上有其他不同物料批次，拣货失败");
			}
			//添加拣货明细
			var completeDetail = new BllCompleteDetail()
			@@ -437,60 +437,60 @@
			comList.Add(completeDetail);

			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			pickQty += item.Qty;
			}
			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot.CompleteQty += pickQty;
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			allot.UpdateTime = DateTime.Now;
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();
			//删除库存明细
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			//删除或修改库存
			stock.Qty -= pickQty;
			stock.LockQty -= pickQty;
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}
			//改变托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += pickQty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			if (notice.IsWave == "1")
			{
			var waveNum = Db.Queryable<BllExportNotice>().Count(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			var waveNum = await Db.Queryable<BllExportNotice>().CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			if (waveNum == 0)
			{
			var wave = Db.Queryable<BllWaveMage>().First(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			if (wave != null)
			{
			wave.Status = "4";
			wave.UpdateUser = userId;
			wave.UpdateTime = DateTime.Now;
			Db.Updateable(wave).ExecuteCommand();
			await Db.Updateable(wave).ExecuteCommandAsync();
			}
			}
			}
			@@ -502,11 +502,11 @@
			var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
			if (boxInfo.Count() == 0)
			if (await boxInfo.CountAsync() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			boxInfos = boxInfo.ToList();
			boxInfos = await boxInfo.ToListAsync();

			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
			if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
			@@ -515,28 +515,28 @@

			if (boxInfos.Count() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			if (boxInfos.Count() > 1)
			{
			throw new Exception("该追溯支码的信息大于1条，信息错误，请核实！");
			throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
			}

			if (boxInfos.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfos.First().Qty;
			if (boxQty > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}

			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			}

			@@ -546,16 +546,16 @@
			{
			if (boxInfo.Count() > 1)
			{
			throw new Exception("该箱码内存在支码不能进行数量拣货");
			throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
			}
			decimal boxQty = boxInfo.First().Qty;
			if (Convert.ToInt32(pickQty1) > boxQty)
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			if (Convert.ToInt32(pickQty1) > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}

			biaoShi = "2";
			@@ -564,23 +564,23 @@
			{
			if (boxInfo.Count() == 0)
			{
			throw new Exception("未查询到该箱码的信息");
			throw Oops.Bah("未查询到该箱码的信息");
			}
			if (boxInfo.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
			var boxQty = await boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
			if (boxQty[0] > needQty)
			{
			throw new Exception("拣货数量不能大于箱内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
			}

			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
			{
			throw new Exception($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			}
			}
			}
			@@ -616,20 +616,20 @@
			if (biaoShi != "2")
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else//数量拣货
			{
			if (decimal.Parse(pickQty1) == item.Qty)
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else
			{
			item.Qty -= decimal.Parse(pickQty1);
			item.BitBoxMark = "1";//零箱标识
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}
			pickQty += item.Qty;
			@@ -641,11 +641,11 @@
			foreach (var item in boxSurplusList)
			{
			item.BitBoxMark = "1";
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}

			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot.CompleteQty += pickQty;
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			@@ -654,7 +654,7 @@
			{
			//判断该托盘是否还存在物料存在改为待回库待回库完成后改为已完成
			}
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			//删除或修改库存明细
			stockDetail.BitPalletMark = "1";//修改为零托标识
			@@ -675,58 +675,58 @@

			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			stock.Qty -= pickQty;
			stock.LockQty -= pickQty;
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}
			var num2 = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == palletNo);
			var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (num2 <= 0)
			{
			//改变托盘状态
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}
			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += pickQty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			if (notice.IsWave == "1")
			{
			var waveNum = Db.Queryable<BllExportNotice>()
			.Count(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			var waveNum = await Db.Queryable<BllExportNotice>()
			.CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			if (waveNum == 0)
			{
			var wave = Db.Queryable<BllWaveMage>().First(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			if (wave != null)
			{
			wave.Status = "4";
			wave.UpdateUser = userId;
			wave.UpdateTime = DateTime.Now;
			Db.Updateable(wave).ExecuteCommand();
			await Db.Updateable(wave).ExecuteCommandAsync();
			}
			}
			}
			@@ -736,6 +736,10 @@
			var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
			Db.CommitTran();
			}
			catch (AppFriendlyException e)
			{
			Db.RollbackTran();
			}
			catch (Exception e)
			{
			Db.RollbackTran();
			@@ -744,7 +748,7 @@
			}

			//出库pda拣货
			public void SoSetQtyPick(string soNo, string soDetailId, string palletNo, string PickQty, int userId)
			public async Task SoSetQtyPick(string soNo, string soDetailId, string palletNo, string PickQty, int userId)
			{
			Db.BeginTran();
			try
			@@ -753,7 +757,7 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			//if (string.IsNullOrWhiteSpace(soDetailId))
			//{
			@@ -761,56 +765,56 @@
			//}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
			.FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;
			if (int.Parse(PickQty) > needQty)
			{
			throw new Exception("拣货数量不能大于托内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
			}

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}
			#endregion
			//获取当前托盘拣货明细
			var complete = Db.Queryable<BllCompleteDetail>().First(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);
			var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

			//判读是否存在拣货明细
			int isComplete = 0;
			@@ -850,7 +854,7 @@
			comList.Add(completeDetail);

			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			}
			else if (isComplete == 1)
			{
			@@ -858,14 +862,14 @@
			complete.UpdateUser = userId;
			complete.UpdateTime = Db.GetDate();

			Db.Updateable(complete).ExecuteCommand();
			await Db.Updateable(complete).ExecuteCommandAsync();
			}

			//修改出库分配信息
			allot.CompleteQty += int.Parse(PickQty);
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			allot.UpdateTime = DateTime.Now;
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			int isDel = 0;

			@@ -887,62 +891,62 @@
			}
			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			isDel = 1;
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			//删除或修改库存
			stock.Qty -= int.Parse(PickQty);
			stock.LockQty -= int.Parse(PickQty);
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			//改变托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}

			//判断托盘上物料是否拣货完毕
			if (isDel == 0)
			{
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}

			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += int.Parse(PickQty);
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			if (notice.IsWave == "1")
			{
			var waveNum = Db.Queryable<BllExportNotice>().Count(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			var waveNum = await Db.Queryable<BllExportNotice>().CountAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo && m.Status != "4");
			if (waveNum <= 0)
			{
			var wave = Db.Queryable<BllWaveMage>().First(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			var wave = await Db.Queryable<BllWaveMage>().FirstAsync(m => m.IsDel == "0" && m.WaveNo == notice.WaveNo);
			if (wave != null)
			{
			wave.Status = "4";
			wave.UpdateUser = userId;
			wave.UpdateTime = DateTime.Now;
			Db.Updateable(wave).ExecuteCommand();
			await Db.Updateable(wave).ExecuteCommandAsync();
			}
			}
			}
			@@ -956,7 +960,6 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}

			@@ -968,33 +971,31 @@
			/// <param name="url"> </param>
			/// <returns></returns>
			/// <exception cref="Exception"></exception>
			public string IssuePlnOutHouse(OutModePalletVm model, int userId, string url)
			public async Task<string> IssuePlnOutHouse(OutModePalletVm model, int userId, string url)
			{
			try
			{
			string strMsg = "";
			var outDtoList = new List<OutCommandDto>(); //出库数据的集合
			//获取当前时间
			DateTime serverTime = Db.GetDate();
			//获取库存明细是否小于等于该垛数
			string str = "select * from DataStockDetail where IsDel = '0' and SkuNo = '100099' and Status = '0' ";
			var stockDetail = Db.Ado.SqlQuery<DataStockDetail>(str);
			//string str = "select * from DataStockDetail where IsDel = '0' and SkuNo = '100099' and Status = '0' ";
			//var stockDetail = Db.Ado.SqlQuery<DataStockDetail>(str);
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(s => s.IsDel == "0" && s.SkuNo == "100099" && s.Status == "0").ToListAsync();
			if (stockDetail.Count > 0)
			{
			//判断是否大于需要垛数
			if (stockDetail.Count < int.Parse(model.Num))
			{
			strMsg = "需要垛数大于库存垛数，请重新输入!";
			return strMsg;
			throw Oops.Bah("需要垛数大于库存垛数，请重新输入!");
			}
			}
			//获取库存总表信息
			var stock = Db.Queryable<DataStock>().First(s => s.IsDel == "0" && s.SkuNo == "100099");
			var stock = await Db.Queryable<DataStock>().FirstAsync(s => s.IsDel == "0" && s.SkuNo == "100099");
			//验证库存总表是否为空
			if (stock == null)
			{
			strMsg = "库存信息不存在，请核查!";
			return strMsg;
			throw Oops.Bah("库存信息不存在，请核查!");
			}

			int i = 0;
			@@ -1005,7 +1006,7 @@
			foreach (var s in stockDetail)
			{
			//获取储位信息
			var locat = Db.Queryable<SysStorageLocat>().First(l => l.LocatNo == s.LocatNo && l.IsDel == "0" && l.WareHouseNo == "W01");
			var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(l => l.LocatNo == s.LocatNo && l.IsDel == "0" && l.WareHouseNo == "W01");

			if (locat != null)
			{
			@@ -1018,7 +1019,7 @@
			locat.UpdateTime = serverTime; //修改时间
			locat.UpdateUser = userId; //修改人
			//修改储位信息
			Db.Updateable(locat).ExecuteCommand();
			await Db.Updateable(locat).ExecuteCommandAsync();
			}

			//增加库存锁定数量
			@@ -1027,7 +1028,7 @@
			stock.UpdateTime = serverTime; //修改时间
			stock.UpdateUser = userId; //修改人
			//修改库存总表信息
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();

			//增加库存明细锁定数量
			//s.AllotQty +=
			@@ -1036,7 +1037,7 @@
			s.UpdateUser = userId; //修改人
			s.Status = "2"; //2 已分配
			//修改库存明细信息
			Db.Updateable(s).ExecuteCommand();
			await Db.Updateable(s).ExecuteCommandAsync();

			#region 分配

			@@ -1068,7 +1069,7 @@
			CreateUser = userId,
			CreateTime = DateTime.Now
			};
			Db.Insertable(allot).ExecuteCommand();
			await Db.Insertable(allot).ExecuteCommandAsync();

			#endregion

			@@ -1107,7 +1108,7 @@
			OutMode = model.OutMode, //目标地址
			Order = 1
			});
			Db.Insertable(exTask).ExecuteCommand();
			await Db.Insertable(exTask).ExecuteCommandAsync();

			#endregion
			i += 1;
			@@ -1137,13 +1138,17 @@
			{
			//更改任务的发送返回时间//
			new TaskServer().EditTaskIssueOk(list2, time1, time2);
			str += "下发成功";
			//str += "下发成功";
			}
			if (wcsModel.StatusCode == -1)
			{
			new TaskServer().EditTaskIssueNo(list2, time1, time2, wcsModel.Msg);
			throw new Exception(wcsModel.Msg);
			throw Oops.Bah(wcsModel.Msg);
			}
			}
			catch (AppFriendlyException e)
			{
			throw Oops.Bah(e.Message);
			}
			catch (Exception ex)
			{
			@@ -1162,35 +1167,28 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			return "";
			}

			}

			//获取平库托盘信息
			public List<Model.ModelDto.BoxInfo> GetPingKuInfoByPallet(string soNo, string palletNo)
			public async Task<List<BoxInfo>> GetPingKuInfoByPallet(string soNo, string palletNo)
			{
			try
			var info = Db.Queryable<BllExportAllot>().Where(m => m.SONo == soNo && m.PalletNo == palletNo && m.IsDel == "0");
			if (await info.CountAsync() == 0)
			{
			var info = Db.Queryable<BllExportAllot>().Where(m => m.SONo == soNo && m.PalletNo == palletNo && m.IsDel == "0");
			if (info.Count() == 0)
			{
			throw new Exception("未查询到托盘分配下发的信息");
			}

			var data = info.GroupBy(m => new { m.SkuNo, m.SkuName, m.LotNo }).Select(m => new BoxInfo()
			{
			SkuNo = m.SkuNo,
			SkuName = m.SkuName,
			LotNo = m.LotNo
			}).ToList();

			return data;
			throw Oops.Bah("未查询到托盘分配下发的信息");
			}
			catch (Exception e)

			var data = await info.GroupBy(m => new { m.SkuNo, m.SkuName, m.LotNo }).Select(m => new BoxInfo()
			{
			throw new Exception(e.Message);
			}
			SkuNo = m.SkuNo,
			SkuName = m.SkuName,
			LotNo = m.LotNo
			}).ToListAsync();

			return data;
			}

			/// <summary>
			@@ -1199,224 +1197,202 @@
			/// <param name="soNo">单据号</param>
			/// <param name="palletNo">托盘码</param>
			/// <param name="userId">操作人</param>
			public void PlaneExportSuccess(string soNo, string palletNo, int userId)
			public async Task PlaneExportSuccess(string soNo, string palletNo, int userId)
			{
			#region 托盘信息

			//获取托盘信息
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(p => p.IsDel == "0" && p.PalletNo == palletNo);
			//验证托盘信息是否为空
			if (pallet == null)
			{
			throw Oops.Bah("托盘信息不存在，请检查!");
			}
			if (pallet.Status == "0")
			{
			throw Oops.Bah("托盘未使用，请检查!");
			}
			#endregion

			#region 托盘是否在平库验证

			var result = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.PalletNo == palletNo);
			if (result == null)
			{
			throw Oops.Bah("库存信息中不存在该托盘信息，请检查!");
			}

			//if (result.WareHouseNo != "W02")//W02：零箱库
			//{
			// throw Oops.Bah("该托盘未在零箱库，请检查!");
			//}

			#endregion

			#region 验证储位状态是否正常

			var locat = await Db.Queryable<SysStorageLocat>().FirstAsync(a => a.IsDel == "0" && a.LocatNo == result.LocatNo);
			if (locat == null)
			{
			throw Oops.Bah("未获取到对应储位信息，请检查!");
			}
			if (locat.Status != "3")
			{
			throw Oops.Bah("当前储位不是有物品，请检查!");
			}

			#endregion

			//获取库存明细信息
			var stockDetail = await Db.Queryable<DataStockDetail>().Where(s => s.IsDel == "0" && s.PalletNo == palletNo).ToListAsync();
			//验证库存明细信息是否存在
			if (stockDetail == null)
			{
			throw Oops.Bah("库存明细不存在，请检查库存信息!");
			}

			Db.BeginTran();

			try
			{
			#region 托盘信息

			//获取托盘信息
			var pallet = Db.Queryable<SysPallets>().First(p => p.IsDel == "0" && p.PalletNo == palletNo);
			//验证托盘信息是否为空
			if (pallet == null)
			foreach (var item in stockDetail)
			{
			throw new Exception("托盘信息不存在，请检查!");
			}
			if (pallet.Status == "0")
			{
			throw new Exception("托盘未使用，请检查!");
			}
			#endregion

			#region 托盘是否在平库验证

			var result = Db.Queryable<DataStockDetail>().First(m => m.PalletNo == palletNo);
			if (result == null)
			{
			throw new Exception("库存信息中不存在该托盘信息，请检查!");
			}

			if (result.WareHouseNo != "W02")//W02：零箱库
			{
			throw new Exception("该托盘未在零箱库，请检查!");
			}

			#endregion

			#region 验证储位状态是否正常

			var locat = Db.Queryable<SysStorageLocat>().First(a => a.IsDel == "0" && a.LocatNo == result.LocatNo);
			if (locat == null)
			{
			throw new Exception("未获取到对应储位信息，请检查!");
			}
			if (locat.Status != "1")
			{
			throw new Exception("当前储位不是有物品，请检查!");
			}

			#endregion

			//获取库存明细信息
			var stockDetail = Db.Queryable<DataStockDetail>().Where(s => s.IsDel == "0" && s.PalletNo == palletNo).ToList();
			//验证库存明细信息是否存在
			if (stockDetail == null)
			{
			throw new Exception("库存明细不存在，请检查库存信息!");
			}

			Db.BeginTran();

			try
			{
			foreach (var item in stockDetail)
			if (item.SkuNo == "100099")//判断是否是空托出库
			{
			if (item.SkuNo == "100099")//判断是否是空托出库
			//判断总库存是否为0，如果为0删除否则减去数量
			var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.SkuNo == "100099");

			if (stock != null)
			{
			//判断总库存是否为0，如果为0删除否则减去数量
			var stock = Db.Queryable<DataStock>().First(m => m.SkuNo == "100099");

			if (stock != null)
			if (item.LockQty != null)
			{
			if (item.LockQty != null)
			{
			stock.Qty -= item.LockQty.Value;
			stock.LockQty -= item.LockQty.Value;
			Db.Updateable(stock).ExecuteCommand();
			}

			if (stock.Qty == 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			}
			stock.Qty -= item.LockQty.Value;
			stock.LockQty -= item.LockQty.Value;
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			//托盘状态改为未使用
			var sCode = Db.Queryable<SysPallets>().First(m => m.PalletNo == item.PalletNo);
			if (sCode != null)
			if (stock.Qty == 0)
			{
			sCode.Status = "0";
			Db.Updateable(sCode).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			Db.Deleteable(item).ExecuteCommand();

			continue;
			}
			item.LocatNo = "";//储位更改（改为空）
			item.WareHouseNo = "";//所属仓库更改（改为空）
			item.RoadwayNo = "";//所属巷道更改（改为空）
			item.AreaNo = "";//所属区域更改（改为空）
			Db.Updateable(item).ExecuteCommand();
			}
			//变更储位状态
			locat.Status = "0";//储位更改（改为空储位）
			Db.Updateable(locat).ExecuteCommand();

			//出库流水（更改状态）
			var allot = Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo && m.SONo == soNo).ToList();

			foreach (var item in allot)
			{
			if (item.SkuNo == "100099")
			//托盘状态改为未使用
			var sCode = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == item.PalletNo);
			if (sCode != null)
			{
			item.Status = "5";
			item.CompleteQty += stockDetail[0].Qty;
			sCode.Status = "0";
			await Db.Updateable(sCode).ExecuteCommandAsync();
			}
			else
			{
			item.Status = "2";
			}
			await Db.Deleteable(item).ExecuteCommandAsync();

			continue;
			}
			Db.Updateable(allot).ExecuteCommand();

			#region 添加出库操作日志记录信息

			//添加操作日志记录
			var k = new OperationSOServer().AddLogOperationSo("出库作业", "拣货明细", soNo, "完成", $"用PDA完成了单据号为{soNo}的平库出库", userId);

			#endregion

			Db.CommitTran();
			item.LocatNo = "";//储位更改（改为空）
			item.WareHouseNo = "";//所属仓库更改（改为空）
			item.RoadwayNo = "";//所属巷道更改（改为空）
			item.AreaNo = "";//所属区域更改（改为空）
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			catch (Exception e)
			//变更储位状态
			locat.Status = "0";//储位更改（改为空储位）
			await Db.Updateable(locat).ExecuteCommandAsync();

			//出库流水（更改状态）
			var allot = await Db.Queryable<BllExportAllot>().Where(m => m.IsDel == "0" && m.Status == "1" && m.PalletNo == palletNo && m.SONo == soNo).ToListAsync();

			foreach (var item in allot)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			if (item.SkuNo == "100099")
			{
			item.Status = "5";
			item.CompleteQty += stockDetail[0].Qty;
			}
			else
			{
			item.Status = "2";
			}

			}
			await Db.Updateable(allot).ExecuteCommandAsync();

			#region 添加出库操作日志记录信息

			//添加操作日志记录
			var k = new OperationSOServer().AddLogOperationSo("出库作业", "拣货明细", soNo, "完成", $"用PDA完成了单据号为{soNo}的平库出库", userId);

			#endregion

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

			//根据托盘号获取取样类型
			public string GetSampleType(string palletNo)
			public async Task<string> GetSampleType(string palletNo)
			{
			try
			var type = "";
			var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			var type = "";
			var detail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			throw new Exception("当前托盘未在库存中");
			}
			//怎么判断当前托盘是库外要取样的托盘，正常出库剩余托盘目前这种情况也能拣货啊，也没有分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
			if (allot != null)
			{
			var soNo = Db.Queryable<BllExportNotice>()
			.First(m => m.IsDel == "0" && m.SONo == allot.SONo);
			if (soNo == null)
			{
			throw new Exception("未找到托盘上出库单据信息");
			}
			if (soNo.Type != "3")
			{
			throw new Exception("该托盘不是取样托盘");
			}
			type = "0";//库内取样
			}
			else
			{
			//判断当前托盘是否是在平库或库外
			type = "1";//库前取样
			}
			return type;
			throw Oops.Bah("当前托盘未在库存中");
			}
			catch (Exception e)
			//怎么判断当前托盘是库外要取样的托盘，正常出库剩余托盘目前这种情况也能拣货啊，也没有分配信息
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
			if (allot != null)
			{
			throw new Exception(e.Message);
			var soNo = await Db.Queryable<BllExportNotice>()
			.FirstAsync(m => m.IsDel == "0" && m.SONo == allot.SONo);
			if (soNo == null)
			{
			throw Oops.Bah("未找到托盘上出库单据信息");
			}
			if (soNo.Type != "3")
			{
			throw Oops.Bah("该托盘不是取样托盘");
			}
			type = "0";//库内取样
			}
			else
			{
			//判断当前托盘是否是在平库或库外
			type = "1";//库前取样
			}
			return type;
			}

			//根据托盘号获取入库单据
			public List<string> GetAsnNoByPallet(string palletNo)
			public async Task<List<string>> GetAsnNoByPallet(string palletNo)
			{
			try
			var type = "";
			var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			var type = "";
			var detail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			throw new Exception("当前托盘未在库存中");
			}
			throw Oops.Bah("当前托盘未在库存中");
			}

			var list = new List<string>();
			if (string.IsNullOrWhiteSpace(detail.ASNNo))
			{
			throw new Exception("未查询到该托盘的入库单信息");
			}
			list.Add(detail.ASNNo);
			return list;
			}
			catch (Exception e)
			var list = new List<string>();
			if (string.IsNullOrWhiteSpace(detail.ASNNo))
			{
			throw new Exception(e.Message);
			throw Oops.Bah("未查询到该托盘的入库单信息");
			}
			list.Add(detail.ASNNo);
			return list;
			}

			//取样出库拣货(标签)
			public void SampleSoSetPick(string soType, string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, string asnNo, int userId)
			public async Task SampleSoSetPick(string soType, string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, string asnNo, int userId)
			{
			Db.BeginTran();
			try
			{
			if (string.IsNullOrWhiteSpace(soType))
			{
			throw new Exception("取样标识不能为空");
			throw Oops.Bah("取样标识不能为空");
			}

			//soType: 0库内取样，有出库单及分配信息； 1库前取样，反向添加出库单及分配信息
			@@ -1427,46 +1403,46 @@

			if (string.IsNullOrWhiteSpace(asnNo))
			{
			throw new Exception("入库单不能为空");
			throw Oops.Bah("入库单不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
			{
			throw new Exception("追溯条码和拣货数量不能同时输入");
			throw Oops.Bah("追溯条码和拣货数量不能同时输入");
			}
			//先判断是否是库外取样托盘
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
			if (allot != null)
			{
			throw new Exception("当前托盘不属于库前取样");
			throw Oops.Bah("当前托盘不属于库前取样");
			}


			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘的库存明细信息！");
			throw Oops.Bah("未查询到该托盘的库存明细信息！");
			}

			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == stockDetail.SkuNo);
			if (sku == null)
			{
			throw new Exception("未查询到当前托盘上的物料信息");
			throw Oops.Bah("未查询到当前托盘上的物料信息");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
			//创建出库单
			if (notice == null \|\| notice.Status == "6")
			{
			@@ -1477,7 +1453,7 @@
			//获取自增单据号
			billNo = new Common().GetMaxNo("SO");
			var no = billNo;
			bl = Db.Queryable<BllExportNotice>().Any(m => m.SONo == no);
			bl = await Db.Queryable<BllExportNotice>().AnyAsync(m => m.SONo == no);
			} while (bl);


			@@ -1495,12 +1471,12 @@
			CreateUser = userId,
			};

			var n = Db.Insertable(addNotice).ExecuteReturnEntity();
			var n = await Db.Insertable(addNotice).ExecuteReturnEntityAsync();
			notice = n;
			}

			//创建出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
			if (noticeDetail == null)
			{
			var addNoticeDetail = new BllExportNoticeDetail()
			@@ -1528,11 +1504,11 @@
			CreateUser = userId,

			};
			var m = Db.Insertable(addNoticeDetail).ExecuteReturnEntity();
			var m = await Db.Insertable(addNoticeDetail).ExecuteReturnEntityAsync();
			noticeDetail = m;
			}
			//出库分配信息
			var allot2 = Db.Queryable<BllExportAllot>().First(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
			var allot2 = await Db.Queryable<BllExportAllot>().FirstAsync(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
			if (allot2 == null)
			{
			//添加分配表信息
			@@ -1564,7 +1540,7 @@
			UpdateTime = DateTime.Now
			};

			var fp = Db.Insertable(addAllot).ExecuteReturnEntity();
			var fp = await Db.Insertable(addAllot).ExecuteReturnEntityAsync();
			allot2 = fp;
			}

			@@ -1576,34 +1552,34 @@
			var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
			if (boxInfo.Count() == 0)
			if (await boxInfo.CountAsync() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			boxInfos = boxInfo.ToList();
			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot2.Id && m.PalletNo == palletNo).ToList();
			boxInfos = await boxInfo.ToListAsync();
			var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot2.Id && m.PalletNo == palletNo).ToListAsync();
			if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
			{
			boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

			if (boxInfos.Count() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			if (boxInfos.Count() > 1)
			{
			throw new Exception("该追溯支码的信息大于1条，信息错误，请核实！");
			throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
			}

			if (boxInfos.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			}
			biaoShi = "1";
			@@ -1612,12 +1588,12 @@
			{
			if (boxInfo.Count() > 1)
			{
			throw new Exception("该箱码内存在支码不能进行数量拣货");
			throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
			}
			decimal boxQty = boxInfo.First().Qty;
			if (Convert.ToInt32(pickQty1) > boxQty)
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}

			biaoShi = "2";
			@@ -1626,17 +1602,17 @@
			{
			if (boxInfo.Count() == 0)
			{
			throw new Exception("未查询到该箱码的信息");
			throw Oops.Bah("未查询到该箱码的信息");
			}
			if (boxInfo.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
			{
			throw new Exception($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			}
			}
			}
			@@ -1677,21 +1653,21 @@
			if (biaoShi != "2")
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else//数量拣货
			{
			if (decimal.Parse(pickQty1) == item.Qty)
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else
			{
			item.Qty -= decimal.Parse(pickQty1);
			item.BitBoxMark = "1";//零箱标识
			item.InspectMark = "1";//抽检箱标识
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}
			pickQty += biaoShi == "2" ? decimal.Parse(pickQty1) : item.Qty;
			@@ -1706,15 +1682,15 @@
			{
			item.BitBoxMark = "1";
			item.InspectMark = "1";
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}

			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot2.Qty += pickQty;
			allot2.CompleteQty += pickQty;
			Db.Updateable(allot2).ExecuteCommand();
			await Db.Updateable(allot2).ExecuteCommandAsync();

			//删除或修改库存明细
			stockDetail.BitPalletMark = "1";//修改为零托标识
			@@ -1722,32 +1698,32 @@

			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			stock.Qty -= pickQty;
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}
			var num2 = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == palletNo);
			var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (num2 <= 0)
			{
			//改变托盘状态
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}
			//修改出库单明细拣货数量
			noticeDetail.Qty += pickQty;
			@@ -1755,7 +1731,7 @@
			noticeDetail.FactQty += pickQty;
			noticeDetail.CompleteQty += pickQty;
			noticeDetail.Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * noticeDetail.Qty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			}
			else if (soType == "0")
			@@ -1764,60 +1740,60 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(soDetailId))
			{
			throw new Exception("出库物料-批次不能为空");
			throw Oops.Bah("出库物料-批次不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
			{
			throw new Exception("追溯条码和拣货数量不能同时输入");
			throw Oops.Bah("追溯条码和拣货数量不能同时输入");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
			.FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}

			#endregion
			@@ -1825,39 +1801,39 @@
			var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
			if (boxInfo.Count() == 0)
			if (await boxInfo.CountAsync() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			boxInfos = boxInfo.ToList();
			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
			boxInfos = await boxInfo.ToListAsync();
			var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
			if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
			{
			boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

			if (boxInfos.Count() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			if (boxInfos.Count() > 1)
			{
			throw new Exception("该追溯支码的信息大于1条，信息错误，请核实！");
			throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
			}

			if (boxInfos.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfos.First().Qty;
			if (boxQty > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}
			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			}
			biaoShi = "1";
			@@ -1866,16 +1842,16 @@
			{
			if (boxInfo.Count() > 1)
			{
			throw new Exception("该箱码内存在支码不能进行数量拣货");
			throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
			}
			decimal boxQty = boxInfo.First().Qty;
			if (Convert.ToInt32(pickQty1) > boxQty)
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			if (Convert.ToInt32(pickQty1) > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}

			biaoShi = "2";
			@@ -1884,22 +1860,22 @@
			{
			if (boxInfo.Count() == 0)
			{
			throw new Exception("未查询到该箱码的信息");
			throw Oops.Bah("未查询到该箱码的信息");
			}
			if (boxInfo.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
			if (boxQty[0] > needQty)
			{
			throw new Exception("拣货数量不能大于箱内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
			}
			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
			{
			throw new Exception($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			}
			}
			}
			@@ -1939,21 +1915,21 @@
			if (biaoShi != "2")
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else//数量拣货
			{
			if (decimal.Parse(pickQty1) == item.Qty)
			{
			//删除库存箱码明细
			Db.Deleteable(item).ExecuteCommand();
			await Db.Deleteable(item).ExecuteCommandAsync();
			}
			else
			{
			item.Qty -= decimal.Parse(pickQty1);
			item.BitBoxMark = "1";//零箱标识
			item.InspectMark = "1"; //抽检箱标识
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}
			pickQty += item.Qty;
			@@ -1965,11 +1941,11 @@
			foreach (var item in boxSurplusList)
			{
			item.BitBoxMark = "1";
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}

			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot.CompleteQty += pickQty;
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			@@ -1978,7 +1954,7 @@
			{
			//判断该托盘是否还存在物料存在改为待回库待回库完成后改为已完成
			}
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			//删除或修改库存明细
			stockDetail.BitPalletMark = "1";//修改为零托标识
			@@ -2000,47 +1976,47 @@

			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			stock.Qty -= pickQty;
			stock.LockQty -= pickQty;
			stock.IsSampling = "1";
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}
			var num2 = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == palletNo);
			var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (num2 <= 0)
			{
			//改变托盘状态
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}
			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += pickQty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			}
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			//添加操作日志记录
			var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货出库", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}的拣货操作", userId);
			@@ -2049,61 +2025,60 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}

			//取样出库拣货(无标签)
			public void SampleSoSetQtyPick(string soType, string soNo, string soDetailId, string palletNo, string PickQty, string asnNo, int userId)
			public async Task SampleSoSetQtyPick(string soType, string soNo, string soDetailId, string palletNo, string PickQty, string asnNo, int userId)
			{
			Db.BeginTran();
			try
			{
			if (string.IsNullOrWhiteSpace(soType))
			{
			throw new Exception("取样标识不能为空");
			throw Oops.Bah("取样标识不能为空");
			}

			if (soType == "1")
			{
			if (string.IsNullOrWhiteSpace(asnNo))
			{
			throw new Exception("入库单据不能为空");
			throw Oops.Bah("入库单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			//先判断是否是库外取样托盘
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && m.PalletNo == palletNo && m.Status != "5" && m.Status != "6");
			if (allot != null)
			{
			throw new Exception("当前托盘不属于库前取样");
			throw Oops.Bah("当前托盘不属于库前取样");
			}


			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == asnNo && m.PalletNo == palletNo);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘的库存明细信息！");
			throw Oops.Bah("未查询到该托盘的库存明细信息！");
			}

			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == stockDetail.SkuNo);
			var sku = await Db.Queryable<SysMaterials>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == stockDetail.SkuNo);
			if (sku == null)
			{
			throw new Exception("未查询到当前托盘上的物料信息");
			throw Oops.Bah("未查询到当前托盘上的物料信息");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.AsnSampleNo == asnNo);
			//创建出库单
			if (notice == null \|\| notice.Status == "6")
			{
			@@ -2114,7 +2089,7 @@
			//获取自增单据号
			billNo = new Common().GetMaxNo("SO");
			var no = billNo;
			bl = Db.Queryable<BllExportNotice>().Any(m => m.SONo == no);
			bl = await Db.Queryable<BllExportNotice>().AnyAsync(m => m.SONo == no);
			} while (bl);

			var addNotice = new BllExportNotice()
			@@ -2131,12 +2106,12 @@
			CreateUser = userId,
			};

			var n = Db.Insertable(addNotice).ExecuteReturnEntity();
			var n = await Db.Insertable(addNotice).ExecuteReturnEntityAsync();
			notice = n;
			}

			//创建出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>().First(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.SONo == notice.SONo && m.SkuNo == stockDetail.SkuNo && m.LotNo.Contains(stockDetail.LotNo));
			if (noticeDetail == null)
			{
			var addNoticeDetail = new BllExportNoticeDetail()
			@@ -2164,11 +2139,11 @@
			CreateUser = userId,

			};
			var m = Db.Insertable(addNoticeDetail).ExecuteReturnEntity();
			var m = await Db.Insertable(addNoticeDetail).ExecuteReturnEntityAsync();
			noticeDetail = m;
			}
			//出库分配信息
			var allot2 = Db.Queryable<BllExportAllot>().First(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
			var allot2 = await Db.Queryable<BllExportAllot>().FirstAsync(m => m.IsDel == "0" && m.Status == "5" && m.SONo == notice.SONo && m.PalletNo == palletNo);
			if (allot2 == null)
			{
			//添加分配表信息
			@@ -2200,12 +2175,12 @@
			UpdateTime = DateTime.Now
			};

			var fp = Db.Insertable(addAllot).ExecuteReturnEntity();
			var fp = await Db.Insertable(addAllot).ExecuteReturnEntityAsync();
			allot2 = fp;
			}

			//获取当前托盘拣货明细
			var complete = Db.Queryable<BllCompleteDetail>().First(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.ExportAllotId == allot2.Id && a.StockId == stockDetail.Id);
			var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.ExportAllotId == allot2.Id && a.StockId == stockDetail.Id);

			//判读是否存在拣货明细
			int isComplete = 0;
			@@ -2244,7 +2219,7 @@
			comList.Add(completeDetail);

			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			}
			else if (isComplete == 1)
			{
			@@ -2252,7 +2227,7 @@
			complete.UpdateUser = userId;
			complete.UpdateTime = Db.GetDate();

			Db.Updateable(complete).ExecuteCommand();
			await Db.Updateable(complete).ExecuteCommandAsync();
			}


			@@ -2260,7 +2235,7 @@
			//修改出库分配信息
			allot2.Qty += int.Parse(PickQty);
			allot2.CompleteQty += int.Parse(PickQty);
			Db.Updateable(allot2).ExecuteCommand();
			await Db.Updateable(allot2).ExecuteCommandAsync();

			int isDel = 0;

			@@ -2282,36 +2257,36 @@
			}
			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			isDel = 1;
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			//删除或修改库存
			stock.Qty -= int.Parse(PickQty);
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			//改变托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}

			//判断托盘上物料是否拣货完毕
			if (isDel == 0)
			{
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}

			//修改出库单明细拣货数量
			@@ -2320,7 +2295,7 @@
			noticeDetail.FactQty += int.Parse(PickQty);
			noticeDetail.CompleteQty += int.Parse(PickQty);
			noticeDetail.Money = string.IsNullOrWhiteSpace(sku.Price.ToString()) ? null : sku.Price * noticeDetail.Qty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			}
			else if (soType == "0")
			@@ -2329,7 +2304,7 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			//if (string.IsNullOrWhiteSpace(soDetailId))
			//{
			@@ -2337,56 +2312,56 @@
			//}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;
			if (int.Parse(PickQty) > needQty)
			{
			throw new Exception("拣货数量不能大于托内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
			}

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}
			#endregion
			//获取当前托盘拣货明细
			var complete = Db.Queryable<BllCompleteDetail>().First(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);
			var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

			//判读是否存在拣货明细
			int isComplete = 0;
			@@ -2425,7 +2400,7 @@
			comList.Add(completeDetail);

			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			}
			else if (isComplete == 1)
			{
			@@ -2433,7 +2408,7 @@
			complete.UpdateUser = userId;
			complete.UpdateTime = Db.GetDate();

			Db.Updateable(complete).ExecuteCommand();
			await Db.Updateable(complete).ExecuteCommandAsync();
			}


			@@ -2443,7 +2418,7 @@
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";

			allot.UpdateTime = DateTime.Now;
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			int isDel = 0;

			@@ -2466,12 +2441,12 @@
			}
			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			isDel = 1;
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			//删除或修改库存
			stock.Qty -= int.Parse(PickQty);
			@@ -2479,39 +2454,39 @@
			stock.IsSampling = "1"; //是否取样
			if (stock.Qty <= 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			//改变托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}

			//判断托盘上物料是否拣货完毕
			if (isDel == 0)
			{
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}

			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += int.Parse(PickQty);
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			}
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();

			}

			@@ -2522,7 +2497,6 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}

			@@ -2538,7 +2512,7 @@
			/// <param name="pickQty1"></param>
			/// <param name="palletNoNew"></param>
			/// <param name="userId"></param>
			public void SoSetPinPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, string palletNoNew, int userId)
			public async Task SoSetPinPick(string soNo, string soDetailId, string palletNo, string boxNo, string boxNo3, string pickQty1, string palletNoNew, int userId)
			{
			Db.BeginTran();
			try
			@@ -2548,71 +2522,71 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(soDetailId))
			{
			throw new Exception("出库物料-批次不能为空");
			throw Oops.Bah("出库物料-批次不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty1) && int.Parse(pickQty1) > 0)
			{
			throw new Exception("追溯条码和拣货数量不能同时输入");
			throw Oops.Bah("追溯条码和拣货数量不能同时输入");
			}
			if (string.IsNullOrWhiteSpace(palletNoNew))
			{
			throw new Exception("新托盘码不能为空");
			throw Oops.Bah("新托盘码不能为空");
			}
			if (palletNo == palletNoNew)//原托盘与新托盘一致
			{
			if (!string.IsNullOrEmpty(boxNo))
			{
			throw new Exception("原托盘与新托盘一致，请选择整托出库");
			throw Oops.Bah("原托盘与新托盘一致，请选择整托出库");
			}
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
			.FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}

			#endregion
			@@ -2620,14 +2594,14 @@
			#region 拼托信息
			var sdId = 0;
			bool isNew = false;
			var pinStockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
			var pinStockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
			if (pinStockDetail != null)
			{
			if (palletNo != palletNoNew)//非整托拣货
			{
			if (pinStockDetail.SONo != notice.SONo)
			{
			throw new Exception("拼托托盘上只能放同一个出库单下的物料！");
			throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
			}
			if (pinStockDetail.SkuName != stockDetail.SkuName \|\| pinStockDetail.LotNo != stockDetail.LotNo)
			{
			@@ -2640,14 +2614,14 @@
			{
			isNew = true;

			var newPalletInfo = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
			var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
			if (newPalletInfo == null)
			{
			throw new Exception("新托盘信息不存在或已被使用！");
			throw Oops.Bah("新托盘信息不存在或已被使用！");
			}
			//修改新托盘状态
			newPalletInfo.Status = "1";
			Db.Updateable(newPalletInfo).ExecuteCommand();
			await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
			}
			var sd = new DataStockDetail();
			if (isNew)
			@@ -2693,7 +2667,7 @@
			sd.CreateTime = nowDate;

			//新增拼托库存明细信息
			sdId = Db.Insertable(sd).ExecuteReturnIdentity();
			sdId = await Db.Insertable(sd).ExecuteReturnIdentityAsync();
			}
			#endregion

			@@ -2702,28 +2676,28 @@
			{
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo);//找到托盘上所有箱码
			boxInfos = boxInfo.ToList();
			boxInfos = await boxInfo.ToListAsync();
			if (boxInfo.Count() <= 0)
			{
			throw new Exception("该托盘上没有可拣货的箱子");
			throw Oops.Bah("该托盘上没有可拣货的箱子");
			}
			var boxQty = boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
			var boxQty = await boxInfo.GroupBy(m => m.PalletNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
			if (boxQty[0] > needQty)
			{
			throw new Exception("拣货数量不能大于箱内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
			}

			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
			var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
			var comList = new List<BllCompleteDetail>();
			foreach (var item in boxInfos)
			{
			if (comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			if (item.SkuNo != allot.SkuNo \|\| item.LotNo != allot.LotNo)
			{
			throw new Exception("当前托盘上有其他不同物料批次，拣货失败");
			throw Oops.Bah("当前托盘上有其他不同物料批次，拣货失败");
			}
			//添加拣货明细
			var completeDetail = new BllCompleteDetail()
			@@ -2757,41 +2731,41 @@
			}
			item.Status = "5";//箱支状态，0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			//修改库存箱码明细
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();

			pickQty += item.Qty;
			}
			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot.CompleteQty += pickQty;
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			allot.UpdateTime = DateTime.Now;
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			if (palletNo != palletNoNew)
			{
			//删除原托盘库存明细
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();

			//改变原托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}
			else
			{
			stockDetail.SONo = soNo;
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}

			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += pickQty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			@@ -2800,48 +2774,48 @@
			notice.Status = "4"; //更改为执行完成
			}
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			}
			else
			{
			var biaoShi = "0";//0：整箱拣货、1：散支拣货、2：数量拣货
			List<DataBoxInfo> boxInfos;
			var boxInfo = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo);
			if (boxInfo.Count() == 0)
			if (await boxInfo.CountAsync() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			boxInfos = boxInfo.ToList();
			boxInfos = await boxInfo.ToListAsync();

			var comDetailList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToList();
			var comDetailList = await Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allot.Id && m.PalletNo == palletNo).ToListAsync();
			if (!string.IsNullOrWhiteSpace(boxNo3)) //散支拣货
			{
			boxInfos = boxInfos.Where(m => m.BoxNo3 == boxNo3).ToList();

			if (boxInfos.Count() == 0)
			{
			throw new Exception("未查询到该箱码及追溯码的信息");
			throw Oops.Bah("未查询到该箱码及追溯码的信息");
			}
			if (boxInfos.Count() > 1)
			{
			throw new Exception("该追溯支码的信息大于1条，信息错误，请核实！");
			throw Oops.Bah("该追溯支码的信息大于1条，信息错误，请核实！");
			}

			if (boxInfos.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfos.First().Qty;
			if (boxQty > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}

			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo3 == item.BoxNo3))
			{
			throw new Exception($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}中{item.BoxNo3}已拣货完成，请勿重复拣货");
			}
			}

			@@ -2851,16 +2825,16 @@
			{
			if (boxInfo.Count() > 1)
			{
			throw new Exception("该箱码内存在支码不能进行数量拣货");
			throw Oops.Bah("该箱码内存在支码不能进行数量拣货");
			}
			decimal boxQty = boxInfo.First().Qty;
			if (Convert.ToInt32(pickQty1) > boxQty)
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			if (Convert.ToInt32(pickQty1) > needQty)
			{
			throw new Exception("拣货数量不能大于剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于剩余待拣数量");
			}

			biaoShi = "2";
			@@ -2869,23 +2843,23 @@
			{
			if (boxInfo.Count() == 0)
			{
			throw new Exception("未查询到该箱码的信息");
			throw Oops.Bah("未查询到该箱码的信息");
			}
			if (boxInfo.Any(m => m.PalletNo != palletNo))
			{
			throw new Exception("该托盘与箱码没有绑定关系");
			throw Oops.Bah("该托盘与箱码没有绑定关系");
			}
			var boxQty = boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToList();
			var boxQty = await boxInfo.GroupBy(m => m.BoxNo).Select(m => SqlFunc.AggregateSum(m.Qty)).ToListAsync();
			if (boxQty[0] > needQty)
			{
			throw new Exception("拣货数量不能大于箱内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于箱内剩余待拣数量");
			}

			foreach (var item in boxInfos)
			{
			if (biaoShi != "2" && comDetailList.Any(m => m.BoxNo == item.BoxNo))
			{
			throw new Exception($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			throw Oops.Bah($"当前{item.BoxNo}已拣货完成，请勿重复拣货");
			}
			}
			}
			@@ -2924,7 +2898,7 @@
			item.BindNo = null;//托盘绑定号
			item.PalletNo = palletNoNew;
			item.Status = "5";//箱支状态，0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();

			pickQty += item.Qty;
			}
			@@ -2937,7 +2911,7 @@
			item.BoxNo = item.BoxNo3;//将支码赋给箱码
			item.BitBoxMark = "1";//零箱标记
			item.Status = "5";//箱支状态，0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();

			pickQty += item.Qty;
			}
			@@ -2950,13 +2924,13 @@
			item.BindNo = null;//托盘绑定号
			item.PalletNo = palletNoNew;
			item.Status = "5";//箱支状态，0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			else
			{
			item.Qty -= decimal.Parse(pickQty1);
			item.BitBoxMark = "1";//零箱标识
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}

			pickQty += int.Parse(pickQty1);
			@@ -2969,11 +2943,11 @@
			foreach (var item in boxSurplusList)
			{
			item.BitBoxMark = "1";
			Db.Updateable(item).ExecuteCommand();
			await Db.Updateable(item).ExecuteCommandAsync();
			}
			}

			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			//修改出库分配信息
			allot.CompleteQty += pickQty;
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			@@ -2982,7 +2956,7 @@
			{
			//判断该托盘是否还存在物料存在改为待回库待回库完成后改为已完成
			}
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			//删除或修改库存明细
			stockDetail.BitPalletMark = "1";//修改为零托标识
			@@ -3003,36 +2977,36 @@

			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			var num2 = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == palletNo);
			var num2 = await Db.Queryable<DataStockDetail>().CountAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (num2 <= 0)
			{
			//改变托盘状态
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}
			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}
			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += pickQty;
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			}
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();
			}

			if (isNew)
			@@ -3047,7 +3021,7 @@
			//修改拼托托盘库存明细
			pinStockDetail.Qty += pickQty;
			pinStockDetail.LockQty += pickQty;
			Db.Updateable(pinStockDetail).ExecuteCommand();
			await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
			}
			}

			@@ -3058,7 +3032,6 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}
			/// <summary>
			@@ -3070,7 +3043,7 @@
			/// <param name="PickQty"></param>
			/// <param name="palletNoNew"></param>
			/// <param name="userId"></param>
			public void SoSetQtyPinPick(string soNo, string soDetailId, string palletNo, string PickQty, string palletNoNew, int userId)
			public async Task SoSetQtyPinPick(string soNo, string soDetailId, string palletNo, string PickQty, string palletNoNew, int userId)
			{
			Db.BeginTran();
			try
			@@ -3080,7 +3053,7 @@

			if (string.IsNullOrWhiteSpace(soNo))
			{
			throw new Exception("出库单据不能为空");
			throw Oops.Bah("出库单据不能为空");
			}
			//if (string.IsNullOrWhiteSpace(soDetailId))
			//{
			@@ -3088,76 +3061,76 @@
			//}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘码不能为空");
			throw Oops.Bah("托盘码不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNoNew))
			{
			throw new Exception("新托盘码不能为空");
			throw Oops.Bah("新托盘码不能为空");
			}

			//出库单
			var notice = Db.Queryable<BllExportNotice>().First(m => m.IsDel == "0" && m.SONo == soNo);
			var notice = await Db.Queryable<BllExportNotice>().FirstAsync(m => m.IsDel == "0" && m.SONo == soNo);
			if (notice == null)
			{
			throw new Exception("未查询到该出库单的信息");
			throw Oops.Bah("未查询到该出库单的信息");
			}
			if (notice.Status != "3")
			{
			throw new Exception("出库单的状态不是正在执行，不能拣货");
			throw Oops.Bah("出库单的状态不是正在执行，不能拣货");
			}
			//出库单明细
			var noticeDetail = Db.Queryable<BllExportNoticeDetail>()
			.First(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			var noticeDetail = await Db.Queryable<BllExportNoticeDetail>()
			.FirstAsync(m => m.IsDel == "0" && m.Id == int.Parse(soDetailId));
			if (noticeDetail == null)
			{
			throw new Exception("未查询到该出库单明细的信息");
			throw Oops.Bah("未查询到该出库单明细的信息");
			}
			//出库分配信息
			var allot = Db.Queryable<BllExportAllot>().First(m =>
			var allot = await Db.Queryable<BllExportAllot>().FirstAsync(m =>
			m.IsDel == "0" && (m.Status == "2" \|\| m.Status == "3") && m.SONo == soNo &&
			m.SODetailNo == int.Parse(soDetailId) && m.PalletNo == palletNo);
			if (allot == null)
			{
			throw new Exception("未查询到该托盘的分配信息");
			throw Oops.Bah("未查询到该托盘的分配信息");
			}
			//剩余拣货数量（待拣减去已拣）
			var needQty = allot.Qty - allot.CompleteQty;
			if (int.Parse(PickQty) > needQty)
			{
			throw new Exception("拣货数量不能大于托内剩余待拣数量");
			throw Oops.Bah("拣货数量不能大于托内剩余待拣数量");
			}

			//库存明细
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.Id == allot.StockId);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.Id == allot.StockId);
			if (stockDetail == null)
			{
			throw new Exception("未查询到该托盘分配的库存明细信息！");
			throw Oops.Bah("未查询到该托盘分配的库存明细信息！");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(a => a.IsDel == "0" && a.SkuNo == stockDetail.SkuNo && a.LotNo == stockDetail.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询到该托盘分配的库存信息！");
			throw Oops.Bah("未查询到该托盘分配的库存信息！");
			}
			if (palletNo == palletNoNew)//原托盘与新托盘一致
			{
			if (int.Parse(PickQty) != stockDetail.Qty)
			{
			throw new Exception("原托盘与新托盘一致，需要把托盘上所有数量拣货");
			throw Oops.Bah("原托盘与新托盘一致，需要把托盘上所有数量拣货");
			}
			}
			#endregion

			#region 拼托信息
			bool isNew = false;
			var pinStockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
			var pinStockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew);
			if (pinStockDetail != null)
			{
			if (palletNo != palletNoNew)//非整托拣货
			{
			if (pinStockDetail.SONo != notice.SONo)
			{
			throw new Exception("拼托托盘上只能放同一个出库单下的物料！");
			throw Oops.Bah("拼托托盘上只能放同一个出库单下的物料！");
			}
			if (pinStockDetail.SkuName != stockDetail.SkuName \|\| pinStockDetail.LotNo != stockDetail.LotNo)
			{
			@@ -3169,14 +3142,14 @@
			{
			isNew = true;

			var newPalletInfo = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
			var newPalletInfo = await Db.Queryable<SysPallets>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNoNew && m.Status == "0");
			if (newPalletInfo == null)
			{
			throw new Exception("新托盘信息不存在或已被使用！");
			throw Oops.Bah("新托盘信息不存在或已被使用！");
			}
			//修改新托盘状态
			newPalletInfo.Status = "1";
			Db.Updateable(newPalletInfo).ExecuteCommand();
			await Db.Updateable(newPalletInfo).ExecuteCommandAsync();
			}

			if (isNew)
			@@ -3227,7 +3200,7 @@
			sd.CreateTime = nowDate;

			//新增拼托库存明细信息
			Db.Insertable(sd).ExecuteReturnIdentity();
			await Db.Insertable(sd).ExecuteReturnIdentityAsync();
			}
			else
			{
			@@ -3236,18 +3209,18 @@
			//修改拼托托盘库存明细
			pinStockDetail.Qty += int.Parse(PickQty);
			pinStockDetail.LockQty += int.Parse(PickQty);
			Db.Updateable(pinStockDetail).ExecuteCommand();
			await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
			}
			else
			{
			pinStockDetail.SONo = soNo;
			Db.Updateable(pinStockDetail).ExecuteCommand();
			await Db.Updateable(pinStockDetail).ExecuteCommandAsync();
			}
			}
			#endregion

			//获取当前托盘拣货明细
			var complete = Db.Queryable<BllCompleteDetail>().First(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);
			var complete = await Db.Queryable<BllCompleteDetail>().FirstAsync(a => a.IsDel == "0" && a.PalletNo == palletNo && a.SONo == notice.SONo && a.SODetailNo == noticeDetail.Id && a.ExportAllotId == allot.Id && a.StockId == stockDetail.Id);

			//判读是否存在拣货明细
			int isComplete = 0;
			@@ -3287,7 +3260,7 @@
			comList.Add(completeDetail);

			//添加拣货明细
			Db.Insertable(comList).ExecuteCommand();
			await Db.Insertable(comList).ExecuteCommandAsync();
			}
			else if (isComplete == 1)
			{
			@@ -3295,14 +3268,14 @@
			complete.UpdateUser = userId;
			complete.UpdateTime = Db.GetDate();

			Db.Updateable(complete).ExecuteCommand();
			await Db.Updateable(complete).ExecuteCommandAsync();
			}

			//修改出库分配信息
			allot.CompleteQty += int.Parse(PickQty);
			allot.Status = allot.Qty == allot.CompleteQty ? "5" : "3";
			allot.UpdateTime = DateTime.Now;
			Db.Updateable(allot).ExecuteCommand();
			await Db.Updateable(allot).ExecuteCommandAsync();

			int isDel = 0;

			@@ -3326,12 +3299,12 @@
			}
			if (stockDetail.Qty <= 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			isDel = 1;
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			}
			else
			@@ -3342,28 +3315,28 @@
			if (isDel == 0)
			{
			//改变托盘状态为：未使用
			var pallet = Db.Queryable<SysPallets>().First(m => m.PalletNo == palletNo && m.IsDel == "0");
			var pallet = await Db.Queryable<SysPallets>().FirstAsync(m => m.PalletNo == palletNo && m.IsDel == "0");
			if (pallet == null)
			{
			throw new Exception("未在托盘表中查询到托盘信息");
			throw Oops.Bah("未在托盘表中查询到托盘信息");
			}

			pallet.Status = "0";
			Db.Updateable(pallet).ExecuteCommand();
			await Db.Updateable(pallet).ExecuteCommandAsync();
			}

			//修改出库单明细拣货数量
			noticeDetail.CompleteQty += int.Parse(PickQty);
			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();

			var num = Db.Queryable<BllExportNoticeDetail>()
			.Count(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			var num = await Db.Queryable<BllExportNoticeDetail>()
			.CountAsync(m => m.IsDel == "0" && m.SONo == soNo && m.CompleteQty < m.Qty);
			if (num <= 0)
			{
			notice.Status = "4"; //更改为执行完成
			}
			//修改出库单信息
			Db.Updateable(notice).ExecuteCommand();
			await Db.Updateable(notice).ExecuteCommandAsync();

			//添加操作日志记录
			var k = new OperationSOServer().AddLogOperationSo("PDA模块", "拣货拼托", soNo, "拣货", $"在PDA上对出库单号为：{soNo}的托盘码为：{palletNo}，新托盘码为：{palletNoNew}的拣货操作", userId);
			@@ -3372,7 +3345,6 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}
			#endregion
			@@ -3380,75 +3352,53 @@
			#region JC23版取样

			//根据托盘号获取取样类型
			public string GetSampleType2(string palletNo)
			public async Task<string> GetSampleType2(string palletNo)
			{
			try
			var type = "";
			var detail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			var type = "";
			var detail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (detail == null)
			{
			throw new Exception("当前托盘未在库存中");
			}

			var boxInfo = Db.Queryable<DataBoxInfo>().Count(m => m.IsDel == "0" && m.StockDetailId == detail.Id);

			//判断托盘上是否有箱码信息
			if (boxInfo > 0)
			{
			type = "0";//标签取样
			}
			else
			{
			type = "1";//数量取样
			}
			return type;
			throw Oops.Bah("当前托盘未在库存中");
			}
			catch (Exception e)

			var boxInfo = await Db.Queryable<DataBoxInfo>().CountAsync(m => m.IsDel == "0" && m.StockDetailId == detail.Id);

			//判断托盘上是否有箱码信息
			if (boxInfo > 0)
			{
			throw new Exception(e.Message);
			type = "0";//标签取样
			}
			else
			{
			type = "1";//数量取样
			}
			return type;
			}

			//获取待出库或待取样的请验单
			public List<string> GetInspectionNo()
			public async Task<List<string>> GetInspectionNo()
			{
			try
			{
			var data = Db.Queryable<BllQualityInspectionRequest>().Where(m => m.IsDel == "0" && (m.Status == "1" \|\| m.Status == "2")).OrderByDescending(m => m.QcNo).Select(m => m.QcNo).ToList();
			return data;
			}
			catch (Exception e)
			{
			throw new Exception(e.Message);
			}
			return await Db.Queryable<BllQualityInspectionRequest>().Where(m => m.IsDel == "0" && (m.Status == "1" \|\| m.Status == "2")).OrderByDescending(m => m.QcNo).Select(m => m.QcNo).ToListAsync();
			}

			//获取请验单相关信息
			public InspectionRequestDto GetInspectionRequestInfo(string qcNo)
			public async Task<InspectionRequestDto> GetInspectionRequestInfo(string qcNo)
			{
			try
			{
			var data = new InspectionRequestDto();
			var inspectionRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.QcNo == qcNo);
			var samplingQty = Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).Sum(m => m.CompleteQty);
			var data = new InspectionRequestDto();
			var inspectionRequest = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
			var samplingQty = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).SumAsync(m => m.CompleteQty);

			data.QcNo = qcNo;
			data.Sku = inspectionRequest.SkuNo;
			data.LotNo = inspectionRequest.LotNo;
			data.Qty = inspectionRequest.SamplingQty.ToString();
			data.SamplingQty = samplingQty == null ? "0" : samplingQty.ToString();
			data.QcNo = qcNo;
			data.Sku = inspectionRequest.SkuNo;
			data.LotNo = inspectionRequest.LotNo;
			data.Qty = inspectionRequest.SamplingQty.ToString();
			data.SamplingQty = samplingQty == null ? "0" : samplingQty.ToString();

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

			//取样出库拣货(标签)
			public void SampleSetPick(string qcNo, string palletNo, string boxNo, string boxNo3, string pickQty, int userId)
			public async Task SampleSetPick(string qcNo, string palletNo, string boxNo, string boxNo3, string pickQty, int userId)
			{
			try
			{
			@@ -3456,20 +3406,20 @@

			if (string.IsNullOrWhiteSpace(qcNo))
			{
			throw new Exception("请验单据不能为空");
			throw Oops.Bah("请验单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘号不能为空");
			throw Oops.Bah("托盘号不能为空");
			}
			var type = GetSampleType2(palletNo);
			var type = await GetSampleType2(palletNo);
			if (type != "0")
			{
			throw new Exception("当前托盘请在数量页签取样");
			throw Oops.Bah("当前托盘请在数量页签取样");
			}
			if (string.IsNullOrEmpty(boxNo))
			{
			throw new Exception("外箱条码不能为空");
			throw Oops.Bah("外箱条码不能为空");
			}
			//if (!string.IsNullOrEmpty(boxNo3) && !string.IsNullOrEmpty(pickQty) && int.Parse(pickQty) > 0)
			//{
			@@ -3477,44 +3427,44 @@
			//}

			//请验单
			var inspecd = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.QcNo == qcNo);
			var inspecd = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
			if (inspecd == null)
			{
			throw new Exception("未查询到请验单信息");
			throw Oops.Bah("未查询到请验单信息");
			}
			if (inspecd.Status == "0" \|\| inspecd.Status == "3")
			{
			throw new Exception("请验单状态错误，请核实");
			throw Oops.Bah("请验单状态错误，请核实");
			}
			//库存明细信息
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (stockDetail == null)
			{
			throw new Exception("未在库存中查询出当前托盘信息");
			throw Oops.Bah("未在库存中查询出当前托盘信息");
			}
			if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
			{
			throw new Exception("当前托盘不是库外托盘，请核实");
			throw Oops.Bah("当前托盘不是库外托盘，请核实");
			}
			//箱支信息
			var boxInfoList = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToList();
			var boxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToListAsync();
			//库存总表
			var stock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询出库存总信息");
			throw Oops.Bah("未查询出库存总信息");
			}
			//入库单
			var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
			var notice = await Db.Queryable<BllArrivalNotice>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
			if (notice == null)
			{
			throw new Exception("未查询到入库单信息");
			throw Oops.Bah("未查询到入库单信息");
			}

			#endregion

			//取样明细记录表
			var sampld = Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToList();
			var sampld = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToListAsync();

			var isAddSampld = false;
			var PickType = ""; //0数量拣货 1 箱支拣货
			@@ -3531,16 +3481,16 @@
			{
			if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) == 0)
			{
			throw new Exception("未查询到支码信息");
			throw Oops.Bah("未查询到支码信息");
			}
			if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) > 1)
			{
			throw new Exception("支码信息数据信息错误，请核实");
			throw Oops.Bah("支码信息数据信息错误，请核实");
			}
			EditboxInfo = Db.Queryable<DataBoxInfo>().First(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3);
			EditboxInfo = await Db.Queryable<DataBoxInfo>().FirstAsync(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3);
			if (EditboxInfo.Qty < decimal.Parse(pickQty))
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo && m.BoxNo3 == EditboxInfo.BoxNo3) == 0;
			}
			@@ -3549,33 +3499,33 @@

			if (boxInfoList.Count == 0)
			{
			throw new Exception("未在托盘上查询到箱码信息，请核实");
			throw Oops.Bah("未在托盘上查询到箱码信息，请核实");
			}
			if (boxInfoList.Count > 1)
			{
			throw new Exception("箱码数据信息错误，请核实");
			throw Oops.Bah("箱码数据信息错误，请核实");
			}
			if (boxInfoList.Count(m => !string.IsNullOrWhiteSpace(m.BoxNo3)) > 0)
			{
			throw new Exception("当前箱码中含有支码，请输入支码信息取样");
			throw Oops.Bah("当前箱码中含有支码，请输入支码信息取样");
			}
			EditboxInfo = Db.Queryable<DataBoxInfo>().First(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo);
			EditboxInfo = await Db.Queryable<DataBoxInfo>().FirstAsync(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo);

			if (EditboxInfo.Qty < decimal.Parse(pickQty))
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo) == 0;

			}
			if (sampld.Sum(m => m.CompleteQty) + decimal.Parse(pickQty) > inspecd.SamplingQty)
			{
			throw new Exception("取样总拣货数量大于请验单取样数量");
			throw Oops.Bah("取样总拣货数量大于请验单取样数量");
			}
			//判断箱中是否含有支码，有：不让拣数量
			if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < decimal.Parse(pickQty))
			{
			throw new Exception("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			}
			}
			else //箱支拣货
			@@ -3588,16 +3538,16 @@

			if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) == 0)
			{
			throw new Exception("未查询到支码信息");
			throw Oops.Bah("未查询到支码信息");
			}
			if (boxInfoList.Count(m => m.BoxNo3 == boxNo3) > 1)
			{
			throw new Exception("支码数据信息错误，请核实");
			throw Oops.Bah("支码数据信息错误，请核实");
			}
			EditboxInfoList = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3).ToList();
			EditboxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo && m.BoxNo3 == boxNo3).ToListAsync();
			if (EditboxInfoList.Sum(m => m.Qty) + sampld.Sum(m => m.CompleteQty) > inspecd.SamplingQty)
			{
			throw new Exception("取样总拣货数量大于请验单取样数量");
			throw Oops.Bah("取样总拣货数量大于请验单取样数量");
			}
			qty = EditboxInfoList.Sum(m => m.Qty);
			//isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo && m.BoxNo3 == EditboxInfo.BoxNo3) == 0;
			@@ -3607,32 +3557,32 @@

			if (boxInfoList.Count == 0)
			{
			throw new Exception("未在托盘上查询到箱码信息，请核实");
			throw Oops.Bah("未在托盘上查询到箱码信息，请核实");
			}
			if (boxInfoList.Count > 1)
			{
			throw new Exception("箱码数据信息错误，请核实");
			throw Oops.Bah("箱码数据信息错误，请核实");
			}
			if (boxInfoList.Count(m => !string.IsNullOrWhiteSpace(m.BoxNo3)) > 0)
			{
			throw new Exception("当前箱码中含有支码，请输入支码信息取样");
			throw Oops.Bah("当前箱码中含有支码，请输入支码信息取样");
			}
			EditboxInfoList = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToList();
			EditboxInfoList = await Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.StockDetailId == stockDetail.Id && m.BoxNo == boxNo).ToListAsync();

			if (EditboxInfo.Qty < decimal.Parse(pickQty))
			{
			throw new Exception("拣货数量不能大于箱内数量");
			throw Oops.Bah("拣货数量不能大于箱内数量");
			}
			qty = EditboxInfoList.Sum(m => m.Qty);
			//isAddSampld = sampld.Count(m => m.PalletNo == palletNo && m.BoxNo == EditboxInfo.BoxNo) == 0;
			}
			if (sampld.Sum(m => m.CompleteQty) + qty > inspecd.SamplingQty)
			{
			throw new Exception("取样总拣货数量大于请验单取样数量");
			throw Oops.Bah("取样总拣货数量大于请验单取样数量");
			}
			if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < qty)
			{
			throw new Exception("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			}
			}
			#endregion
			@@ -3797,7 +3747,7 @@
			CreateTime = DateTime.Now,
			CreateUser = userId
			};
			Db.Insertable(sampleDetail).ExecuteCommand();
			await Db.Insertable(sampleDetail).ExecuteCommandAsync();
			//}
			//else
			//{
			@@ -3816,7 +3766,7 @@
			#region 修改库存三表

			//拆包有效期更改
			var unpackWarranty = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo).UnpackWarranty;
			var unpackWarranty = (await Db.Queryable<SysMaterials>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo)).UnpackWarranty;

			foreach (var item in boxInfoList)
			{
			@@ -3834,31 +3784,31 @@
			}
			}
			}
			Db.Updateable(boxInfoList).ExecuteCommand();
			await Db.Updateable(boxInfoList).ExecuteCommandAsync();

			//库存箱码

			Db.Deleteable(boxInfo).ExecuteCommand();
			await Db.Deleteable(boxInfo).ExecuteCommandAsync();

			//库存明细
			stockDetail.Qty -= boxInfo.Qty;
			if (stockDetail.Qty == 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			//库存总表
			stock.Qty -= boxInfo.Qty;
			if (stock.Qty == 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			#endregion
			@@ -3868,12 +3818,12 @@
			//不是上传完毕的修改取样状态
			if (notice.Status != "4")
			{
			var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var noticeDetail = await Db.Queryable<BllArrivalNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (noticeDetail.IsSampling == "0")
			{
			noticeDetail.IsSampling = "1";

			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();
			}

			}
			@@ -3891,7 +3841,7 @@
			inspecd.Status = "3";
			}

			Db.Updateable(inspecd).ExecuteCommand();
			await Db.Updateable(inspecd).ExecuteCommandAsync();
			#endregion
			}

			@@ -3905,13 +3855,12 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}


			//取样出库拣货(数量)
			public void SampleSetQtyPick(string qcNo, string palletNo, string pickQty, int userId)
			public async Task SampleSetQtyPick(string qcNo, string palletNo, string pickQty, int userId)
			{
			try
			{
			@@ -3919,63 +3868,63 @@

			if (string.IsNullOrWhiteSpace(qcNo))
			{
			throw new Exception("请验单据不能为空");
			throw Oops.Bah("请验单据不能为空");
			}
			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘号不能为空");
			throw Oops.Bah("托盘号不能为空");
			}
			var type = GetSampleType2(palletNo);
			var type = await GetSampleType2(palletNo);
			if (type != "1")
			{
			throw new Exception("当前托盘请在标签页签取样");
			throw Oops.Bah("当前托盘请在标签页签取样");
			}
			if (string.IsNullOrWhiteSpace(pickQty))
			{
			throw new Exception("拣货数量不能为空");
			throw Oops.Bah("拣货数量不能为空");
			}
			if (decimal.Parse(pickQty) <= 0)
			{
			throw new Exception("拣货数量不能小于等于0");
			throw Oops.Bah("拣货数量不能小于等于0");
			}

			//请验单
			var inspecd = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.QcNo == qcNo);
			var inspecd = await Db.Queryable<BllQualityInspectionRequest>().FirstAsync(m => m.IsDel == "0" && m.QcNo == qcNo);
			if (inspecd == null)
			{
			throw new Exception("未查询到请验单信息");
			throw Oops.Bah("未查询到请验单信息");
			}
			if (inspecd.Status == "0" \|\| inspecd.Status == "3")
			{
			throw new Exception("请验单状态错误，请核实");
			throw Oops.Bah("请验单状态错误，请核实");
			}
			//库存明细信息
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == palletNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var stockDetail = await Db.Queryable<DataStockDetail>().FirstAsync(m => m.IsDel == "0" && m.PalletNo == palletNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (stockDetail == null)
			{
			throw new Exception("未在库存中查询出当前托盘信息");
			throw Oops.Bah("未在库存中查询出当前托盘信息");
			}
			if (!string.IsNullOrWhiteSpace(stockDetail.LocatNo))
			{
			throw new Exception("当前托盘不是库外托盘，请核实");
			throw Oops.Bah("当前托盘不是库外托盘，请核实");
			}
			//库存总表
			var stock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var stock = await Db.Queryable<DataStock>().FirstAsync(m => m.IsDel == "0" && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (stock == null)
			{
			throw new Exception("未查询出库存总信息");
			throw Oops.Bah("未查询出库存总信息");
			}
			//入库单
			var notice = Db.Queryable<BllArrivalNotice>().First(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
			var notice = await Db.Queryable<BllArrivalNotice>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo);
			if (notice == null)
			{
			throw new Exception("未查询到入库单信息");
			throw Oops.Bah("未查询到入库单信息");
			}

			#endregion

			//取样明细记录表
			var sampld = Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToList();
			var sampld = await Db.Queryable<BllSamplingDetails>().Where(m => m.IsDel == "0" && m.QcNo == qcNo).ToListAsync();
			var qty = decimal.Parse(pickQty);
			//var isAddSampld = sampld.Count(m => m.PalletNo == palletNo) == 0;

			@@ -3984,12 +3933,12 @@

			if (sampld.Sum(m => m.CompleteQty) + qty > inspecd.SamplingQty)
			{
			throw new Exception("取样总拣货数量大于请验单取样数量");
			throw Oops.Bah("取样总拣货数量大于请验单取样数量");
			}
			//判断箱中是否含有支码，有：不让拣数量
			if (stockDetail.Qty - stockDetail.LockQty - stockDetail.FrozenQty < qty)
			{
			throw new Exception("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			throw Oops.Bah("托盘上可用数量小于取样数量，请核实锁定、冻结数量");
			}


			@@ -4015,7 +3964,7 @@
			CreateTime = DateTime.Now,
			CreateUser = userId
			};
			Db.Insertable(sampleDetail).ExecuteCommand();
			await Db.Insertable(sampleDetail).ExecuteCommandAsync();
			//}
			//else
			//{
			@@ -4034,24 +3983,24 @@
			stockDetail.Qty -= qty;
			if (stockDetail.Qty == 0)
			{
			Db.Deleteable(stockDetail).ExecuteCommand();
			await Db.Deleteable(stockDetail).ExecuteCommandAsync();
			}
			else
			{
			stockDetail.BitPalletMark = "1";
			stockDetail.InspectMark = "1";

			Db.Updateable(stockDetail).ExecuteCommand();
			await Db.Updateable(stockDetail).ExecuteCommandAsync();
			}
			//库存总表
			stock.Qty -= qty;
			if (stock.Qty == 0)
			{
			Db.Deleteable(stock).ExecuteCommand();
			await Db.Deleteable(stock).ExecuteCommandAsync();
			}
			else
			{
			Db.Updateable(stock).ExecuteCommand();
			await Db.Updateable(stock).ExecuteCommandAsync();
			}

			#endregion
			@@ -4061,12 +4010,12 @@
			//不是上传完毕的修改取样状态
			if (notice.Status != "4")
			{
			var noticeDetail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			var noticeDetail = await Db.Queryable<BllArrivalNoticeDetail>().FirstAsync(m => m.IsDel == "0" && m.ASNNo == inspecd.ASNNo && m.SkuNo == inspecd.SkuNo && m.LotNo == inspecd.LotNo);
			if (noticeDetail.IsSampling == "0")
			{
			noticeDetail.IsSampling = "1";

			Db.Updateable(noticeDetail).ExecuteCommand();
			await Db.Updateable(noticeDetail).ExecuteCommandAsync();
			}

			}
			@@ -4081,7 +4030,7 @@
			{
			inspecd.Status = "3";
			}
			Db.Updateable(inspecd).ExecuteCommand();
			await Db.Updateable(inspecd).ExecuteCommandAsync();
			#endregion


			@@ -4093,7 +4042,6 @@
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}