JC34WMS.git - Gitblit

			@@ -21,6 +21,14 @@
			using Model.ModelDto.DataDto;
			using System.Xml.Schema;
			using ZXing.OneD;
			using System.Threading.Tasks;
			using System.Security.Policy;
			using Newtonsoft.Json;
			using Utility.Tools;
			using Model.ModelDto.SysDto;
			using Model.ModelVm.SysVm;
			using System.Security.Cryptography.X509Certificates;
			using AutoMapper.Configuration.Annotations;

			namespace WMS.BLL.BllPdaServer
			{
			@@ -28,17 +36,1610 @@
			{
			private static readonly SqlSugarScope Db = DataContext.Db;

			// 获取单据列表
			public List<ArrivalNoticeDto> GetArrivalNotices(ArrivalNoticeVm model)
			#region JC34

			/// <summary>
			/// 绑定托盘贴标物料
			/// </summary>
			/// <param name="model"></param>
			/// <param name="userId"></param>
			/// <exception cref="Exception"></exception>
			public void BindPalletPasteCode(PdaPalletBindVm model, int userId)
			{
			try
			{
			#region 判断
			//0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 8：生产退料入库


			if (string.IsNullOrEmpty(model.AsnNo))
			{
			throw new Exception("单据号不可为空!");
			}
			if (model.AsnDetailId == null \|\| model.AsnDetailId == 0)
			{
			throw new Exception("物料-批次不可为空!");
			}
			if (string.IsNullOrEmpty(model.PalletNo))
			{
			throw new Exception("托盘号不可为空!");
			}
			//根据单据号获取入库单总单
			var notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo);
			if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
			{
			throw new Exception("该单据已关单!");
			}
			if (string.IsNullOrEmpty(model.LotNo))
			{
			throw new Exception("物料-批次不可为空!");
			}
			else
			{
			//从物料名称-批次中取出批次
			int indexOfDash = model.LotNo.IndexOf("-");
			if (indexOfDash != -1)
			{
			model.LotNo = model.LotNo.Substring(indexOfDash + 1);
			}
			else
			{
			throw new Exception("物料-批次不可为空!");
			}
			}

			//判断箱码信息
			if (string.IsNullOrEmpty(model.BoxNo))
			{
			throw new Exception("箱码信息不可为空!");
			}
			//是否连续组托 0：否 1：是
			if (model.IsContinue == "1")
			{
			if (string.IsNullOrWhiteSpace(model.TailBoxNo))
			{
			throw new Exception("开启连续组托时，尾箱码信息不可为空!");
			}
			}

			//托盘信息是否存在
			var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (pallet == null)
			{
			throw new Exception("未查询到托盘信息，请核实！");
			}
			//验证入库单明细是否存在
			var detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == model.AsnDetailId && m.ASNNo == model.AsnNo && m.LotNo.Contains(model.LotNo));
			if (detail == null)
			{
			throw new Exception("当前物料及批次与单据无关联，请核实!");
			}
			//判断托盘是否在库外
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (stockDetail != null && !string.IsNullOrEmpty(stockDetail.WareHouseNo))
			{
			throw new Exception("该托盘已有储位信息，不可组托，请核实！");
			}

			#endregion

			//开启事务
			Db.BeginTran();
			//当前时间
			var comTime = DateTime.Now;

			#region 包装

			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == detail.SkuNo);
			var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo);

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

			//公共方法获取包装数量
			new Common().GetPackQtyInfo(detail.PackagNo, ref pNum, ref bNum);

			#endregion

			#region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
			var palletBind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNNo == model.AsnNo && m.PalletNo == model.PalletNo && m.ASNDetailNo != model.AsnDetailId);
			if (palletBind != null)
			{
			var box = Db.Queryable<BllBoxInfo>().First(m => m.IsDel == "0" && m.BindNo == palletBind.Id && m.BitBoxMark == "0");
			if (box != null && (box.SkuNo != detail.SkuNo \|\| !detail.LotNo.Contains(box.LotNo)))
			{
			var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
			if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			{
			throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
			}
			}
			}
			#endregion

			#region 箱码信息
			var msgStr = $"箱号为{model.BoxNo}";
			var boxInfoList = new List<BllBoxInfo>();

			//首箱
			var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == model.BoxNo).ToList();
			if (boxInfo.Count == 0)
			{
			throw new Exception("箱码信息不存在!");
			}
			boxInfoList.AddRange(boxInfo);
			//是否连续组托
			if (model.IsContinue == "1")
			{
			//尾箱
			var boxInfo2 = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == model.TailBoxNo).ToList();
			if (boxInfo2.Count == 0)
			{
			throw new Exception("尾箱码信息不存在!");
			}
			boxInfoList.AddRange(boxInfo2);
			var sql = $"select * from BllBoxInfo where IsDel = '0' and boxNo>'{model.BoxNo}' and boxNo<'{model.TailBoxNo}'; ";
			var list = Db.Ado.SqlQuery<BllBoxInfo>(sql);
			boxInfoList.AddRange(list);
			msgStr += $"尾箱号为{model.TailBoxNo}";
			}
			//绑定箱总数量
			//model.SkuQty = boxInfoList.Sum(s => s.Qty);
			//和选择的批次同批次的箱码信息
			var sameBoxInfoList = boxInfoList.Where(w => w.LotNo == model.LotNo && w.Status == "0").ToList();
			//和选择的批次不同批次的箱码信息（拼箱批次）
			var notBoxInfoList = boxInfoList.Where(w => w.LotNo != model.LotNo).ToList();
			#endregion

			if (sameBoxInfoList.Count <= 0)
			{
			throw new Exception("箱码信息不存在!");
			}
			else
			{
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == model.AsnDetailId && m.PalletNo == model.PalletNo && m.LotNo == model.LotNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = model.AsnNo,
			ASNDetailNo = (int)model.AsnDetailId,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = model.SkuQty,//不包含拼箱中非同批次数量
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = model.LotNo,
			LotText = detail.LotText,
			SupplierLot = detail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += model.SkuQty;
			}

			#endregion

			#region 库存明细和质检信息
			//获取该批次最终质检结果
			BllQualityInspect quality = new BllQualityInspect();
			//判断是否为退货入库单
			if (notice.Type == "3")
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == detail.ASNNo && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			else
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			var tags = "0";
			if (notice.Type == "3" \|\| notice.Type == "4")
			{
			tags = "1";
			}

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.PalletNo == model.PalletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = bind.ASNNo,
			ASNDetailNo = bind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = detail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息 //0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")
			{
			sd1.OwnerNo = notice.CustomerNo;//货主编码
			sd1.OwnerName = notice.CustomerName;//货主名称
			}
			else if (notice.Type == "1" \|\| notice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = notice.CustomerNo;//供应商编码
			sd1.SupplierName = notice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量
			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量

			//标签组托
			var boxGroup = sameBoxInfoList.GroupBy(m => m.BoxNo).ToList();
			foreach (var g in boxGroup)
			{
			decimal boxFullQty = 0;//箱内总数量
			foreach (var box in g)
			{
			if (box.BindNo != null && box.BindNo != 0)
			{
			continue;
			}
			//箱内物料批次与单据明细不符合
			if (box.SkuNo != detail.SkuNo \|\| box.LotNo != model.LotNo)
			{
			throw new Exception($"-1:{box.BoxNo}箱内物料及批次与单据不一致，请核实!");
			}

			box.ASNNo = model.AsnNo;
			box.ASNDetailNo = model.AsnDetailId;
			box.BindNo = bindId;
			box.PalletNo = model.PalletNo;
			box.Status = "2";
			//box.InspectMark = model.IsSample; //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//box.SamplingQty = 0; //取样数量后期业务开发时接口传值需添加对应字段判断
			box.CompleteTime = comTime;
			box.UpdateTime = comTime;
			box.UpdateUser = userId;

			//box.Qty = box.Qty;
			//box.BitBoxMark = box.Qty == box.FullQty ? "0" : "1";

			factQty += box.Qty;
			boxFullQty += box.Qty;
			if (box.InspectMark == "1") //判断是否取样
			{
			isSample = "1";
			sampleQty += (decimal)box.SamplingQty;
			}

			#region 库存箱码明细
			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BindNo = bind.Id,
			BoxNo = box.BoxNo,
			BoxNo2 = box.BoxNo2,
			BoxNo3 = box.BoxNo3,
			PalletNo = box.PalletNo,
			PalletNo2 = box.PalletNo2,
			PalletNo3 = box.PalletNo3,
			Qty = box.Qty,
			FullQty = box.FullQty,
			Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			LotNo = box.LotNo,
			LotText = box.LotText,
			SkuNo = box.SkuNo,
			SkuName = box.SkuName,
			Standard = sku.Standard,
			ProductionTime = box.ProductionTime,
			SupplierLot = box.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = box.InspectMark,
			BitBoxMark = box.BitBoxMark,
			ExpirationTime = box.ExpirationTime,

			CreateUser = 0,
			CreateTime = comTime
			};
			//添加库存箱码明细
			Db.Insertable(box2).ExecuteCommand();
			#endregion
			}
			if (boxFullQty > bNum)
			{
			throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
			}
			}
			//更改箱支关系表信息
			Db.Updateable(boxInfoList).ExecuteCommand();

			// 更新托盘绑定表
			bind.Qty += factQty;

			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#region 入库单及明细
			detail.FactQty += factQty;//已组数量
			detail.CompleteQty += factQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			detail.IsSampling = "1";
			}
			detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (detail.CompleteQty >= detail.Qty)
			{
			detail.Status = "2";
			detail.CompleteTime = comTime;
			}
			detail.UpdateUser = userId;
			detail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(detail).ExecuteCommand();

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

			#region 库存明细
			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();
			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;

			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1" && sku.IsControlled != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = detail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = detail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion
			}

			//拼箱
			if (notBoxInfoList.Count > 0)
			{
			var gbox = notBoxInfoList.GroupBy(g => g.BoxNo).ToList();
			if (gbox.Count > 1)
			{
			throw new Exception("一个托盘上只能有1个拼箱!");
			}
			gbox = notBoxInfoList.GroupBy(g => g.LotNo).ToList();
			if (gbox.Count > 1)
			{
			throw new Exception("一个箱内最多能有2个不同批次物料!");
			}
			var pinBoxNo = notBoxInfoList[0].BoxNo;//拼箱箱码
			var pinBoxLotNo = notBoxInfoList[0].LotNo;//拼箱批次号
			//拼箱数量(和选择的批次不同批次的箱码数量)
			decimal pinBoxQty = notBoxInfoList.Sum(s => s.Qty);

			var dataBoxList = Db.Queryable<DataBoxInfo>().Where(w => w.IsDel == "0" && w.BoxNo == pinBoxNo && w.LotNo == pinBoxLotNo).ToList();
			if (dataBoxList.Count > 0)//已有库存
			{
			//原托盘绑定信息
			var oldPalletBind = Db.Queryable<BllPalletBind>().First(w => w.Id == notBoxInfoList[0].BindNo);
			//原入库单明细
			var oldAsnDetail = Db.Queryable<BllArrivalNoticeDetail>().First(w => w.Id == oldPalletBind.ASNDetailNo);
			//原入库单
			var oldAsnNotice = Db.Queryable<BllArrivalNotice>().First(w => w.ASNNo == oldAsnDetail.ASNNo);
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == oldAsnDetail.Id && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = oldAsnDetail.ASNNo,
			ASNDetailNo = oldAsnDetail.Id,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = 0,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = pinBoxLotNo,
			LotText = oldAsnDetail.LotText,
			SupplierLot = oldAsnDetail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += pinBoxQty;

			Db.Updateable(bind).ExecuteCommand();
			}
			#endregion

			// 插入库存明细数据
			var sd1 = new DataStockDetail()
			{
			LotNo = pinBoxLotNo,
			LotText = notBoxInfoList[0].LotText,
			SupplierLot = notBoxInfoList[0].SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = pinBoxQty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = oldPalletBind.ASNNo,
			ASNDetailNo = oldPalletBind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = "0",
			CompleteTime = comTime,
			ProductionTime = oldPalletBind.ProductionTime,
			ExpirationTime = oldPalletBind.ExpirationTime,
			Status = "0",
			InspectMark = oldPalletBind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = oldPalletBind.BitPalletMark,
			PackagNo = oldAsnDetail.PackagNo,
			IsBale = oldPalletBind.IsBale,
			IsBelt = oldPalletBind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};
			//维护库存明细货主/供应商信息
			if (oldAsnNotice.Type == "0" \|\| oldAsnNotice.Type == "2" \|\| oldAsnNotice.Type == "4" \|\| oldAsnNotice.Type == "6" \|\| oldAsnNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = oldAsnNotice.CustomerNo;//货主编码
			sd1.OwnerName = oldAsnNotice.CustomerName;//货主名称
			}
			else if (oldAsnNotice.Type == "1" \|\| oldAsnNotice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = oldAsnNotice.CustomerNo;//供应商编码
			sd1.SupplierName = oldAsnNotice.CustomerName;//供应商名称
			}
			//添加库存明细
			var sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			foreach (var item in dataBoxList)
			{
			item.StockDetailId = sdId1;//库存明细id
			item.BindNo = bind.Id;//托盘绑定id
			}
			//更新库存箱支明细表
			Db.Updateable(dataBoxList).ExecuteCommand();

			//托盘解绑信息
			var palletUnbind = Db.Queryable<BllPalletUnbind>().First(w => w.IsDel == "0" && w.UpbindPalletNo == oldPalletBind.PalletNo && w.BoxNo == pinBoxNo);
			if (palletUnbind == null)
			{
			throw new Exception("拼箱的托盘解绑信息不存在!");
			}
			palletUnbind.BindPalletNo = model.PalletNo;//绑定托盘号
			palletUnbind.UpdateTime = comTime;
			palletUnbind.UpdateUser = userId;
			//更新托盘解绑绑定表信息
			Db.Updateable(palletUnbind).ExecuteCommand();
			}
			else
			{
			string sql = $@"SELECT detail.* FROM BllArrivalNoticeDetail as detail
			JOIN BllArrivalNotice as notice ON detail.ASNNo=notice.ASNNo
			WHERE notice.IsDel='0'
			AND ( notice.Status=0 or notice.Status=1 )
			AND detail.IsDel='0'
			AND detail.LotNo='{pinBoxLotNo}'
			AND detail.SkuNo='{sku.SkuNo}'
			ORDER BY detail.CreateTime ";
			//找到拼箱内其他批次所属入库单明细
			var arrDetail = Db.Ado.SqlQuery<BllArrivalNoticeDetail>(sql).FirstOrDefault();
			if (arrDetail == null)
			{
			throw new Exception("拼箱内物料所属入库单明细不存在!");
			}
			//找到拼箱内其他批次所属入库单
			var arrNotice = Db.Queryable<BllArrivalNotice>().First(w => w.IsDel == "0" && w.ASNNo == arrDetail.ASNNo);
			if (arrNotice == null)
			{
			throw new Exception("拼箱内物料所属入库单不存在!");
			}
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == arrDetail.Id && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = arrDetail.ASNNo,
			ASNDetailNo = arrDetail.Id,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = 0,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = pinBoxLotNo,
			LotText = arrDetail.LotText,
			SupplierLot = arrDetail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			}
			#endregion

			#region 库存明细和质检信息
			//获取该批次最终质检结果
			BllQualityInspect quality = new BllQualityInspect();
			//判断是否为退货入库单
			if (arrNotice.Type == "3")
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == arrDetail.ASNNo && a.SkuNo == arrDetail.SkuNo && a.LotNo == arrDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			else
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == arrDetail.SkuNo && a.LotNo == arrDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			var tags = "0";
			if (arrNotice.Type == "3" \|\| arrNotice.Type == "4")
			{
			tags = "1";
			}

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNDetailNo == arrDetail.Id && m.PalletNo == model.PalletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = pinBoxLotNo,
			LotText = notBoxInfoList[0].LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = arrDetail.ASNNo,
			ASNDetailNo = arrDetail.Id,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = arrDetail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息
			if (arrNotice.Type == "0" \|\| arrNotice.Type == "2" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "6" \|\| arrNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = arrNotice.CustomerNo;//货主编码
			sd1.OwnerName = arrNotice.CustomerName;//货主名称
			}
			else if (arrNotice.Type == "1" \|\| arrNotice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = arrNotice.CustomerNo;//供应商编码
			sd1.SupplierName = arrNotice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量
			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量

			//标签组托
			var boxGroup = notBoxInfoList.GroupBy(m => m.BoxNo).ToList();
			foreach (var g in boxGroup)
			{
			decimal boxFullQty = 0;//箱内总数量
			foreach (var box in g)
			{
			if (box.BindNo != null && box.BindNo != 0)
			{
			continue;
			}
			//箱内物料批次与单据明细不符合
			if (box.SkuNo != arrDetail.SkuNo \|\| box.LotNo != arrDetail.LotNo)
			{
			throw new Exception($"-1:{box.BoxNo}箱内物料及批次与单据不一致，请核实!");
			}

			box.ASNNo = arrDetail.ASNNo;
			box.ASNDetailNo = arrDetail.Id;
			box.BindNo = bindId;
			box.PalletNo = model.PalletNo;
			box.Status = "2";
			//box.InspectMark = model.IsSample; //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//box.SamplingQty = 0; //取样数量后期业务开发时接口传值需添加对应字段判断
			box.CompleteTime = comTime;
			box.UpdateTime = comTime;
			box.UpdateUser = userId;

			//box.Qty = box.Qty;
			//box.BitBoxMark = box.Qty == box.FullQty ? "0" : "1";

			factQty += box.Qty;
			boxFullQty += box.Qty;
			if (box.InspectMark == "1") //判断是否取样
			{
			isSample = "1";
			sampleQty += (decimal)box.SamplingQty;
			}

			#region 库存箱码明细
			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BindNo = bind.Id,
			BoxNo = box.BoxNo,
			BoxNo2 = box.BoxNo2,
			BoxNo3 = box.BoxNo3,
			PalletNo = box.PalletNo,
			PalletNo2 = box.PalletNo2,
			PalletNo3 = box.PalletNo3,
			Qty = box.Qty,
			FullQty = box.FullQty,
			Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			LotNo = box.LotNo,
			LotText = box.LotText,
			SkuNo = box.SkuNo,
			SkuName = box.SkuName,
			Standard = sku.Standard,
			ProductionTime = box.ProductionTime,
			SupplierLot = box.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = box.InspectMark,
			BitBoxMark = box.BitBoxMark,
			ExpirationTime = box.ExpirationTime,

			CreateUser = 0,
			CreateTime = comTime
			};
			//添加库存箱码明细
			Db.Insertable(box2).ExecuteCommand();
			#endregion
			}
			if (boxFullQty > bNum)
			{
			throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
			}
			}
			//更改箱支关系表信息
			Db.Updateable(boxInfoList).ExecuteCommand();

			// 更新托盘绑定表
			bind.Qty += factQty;

			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#region 入库单及明细
			arrDetail.FactQty += factQty;//已组数量
			arrDetail.CompleteQty += factQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			arrDetail.IsSampling = "1";
			}
			arrDetail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (arrDetail.CompleteQty >= arrDetail.Qty)
			{
			arrDetail.Status = "2";
			arrDetail.CompleteTime = comTime;
			}
			arrDetail.UpdateUser = userId;
			arrDetail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(arrDetail).ExecuteCommand();

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

			#region 库存明细
			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();
			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;

			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (arrNotice.Type == "0" \|\| arrNotice.Type == "2" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "6" \|\| arrNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((arrNotice.Type == "1" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "5") && sku.IsInspect != "1" && sku.IsControlled != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = arrDetail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = arrDetail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion
			}
			}
			// 更改托盘使用状态
			var sqlStr = $"update SysPallets set Status = '1' where PalletNo = '{model.PalletNo}';";
			//添加托盘记录表数据
			sqlStr += $"insert into LogPalletTrack values('{model.PalletNo}','{model.AsnNo}','组盘','0',getDate(),{userId},NULL,NULL);";
			Db.Ado.ExecuteCommand(sqlStr);
			new OperationASNServer().AddLogOperationAsn("PDA模块", "托盘绑定", model.AsnNo, "添加", $"添加了托盘码为：{model.PalletNo}、{msgStr}的组盘信息", userId);

			//提交事务
			Db.CommitTran();
			}
			catch (Exception e)
			{
			//回滚事务
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}

			/// <summary>
			/// 绑定托盘不贴标物料
			/// </summary>
			/// <param name="model"></param>
			/// <param name="userId"></param>
			/// <exception cref="Exception"></exception>
			public void BindPalletNoPasteCode(PdaPalletBindVm model, int userId)
			{
			try
			{
			Db.BeginTran();
			#region 判断

			//0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 8：生产退料入库


			if (string.IsNullOrEmpty(model.AsnNo))
			{
			throw new Exception("单据号不可为空!");
			}
			if (model.AsnDetailId == null \|\| model.AsnDetailId == 0)
			{
			throw new Exception("物料不可为空!");
			}
			if (string.IsNullOrEmpty(model.PalletNo))
			{
			throw new Exception("托盘号不可为空!");
			}
			if (model.SkuQty < 0)
			{
			throw new Exception("物料数量不能小于0!");
			}
			//根据单据号获取入库单总单
			var notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo);
			if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
			{
			throw new Exception("该单据已关单!");
			}

			if (string.IsNullOrEmpty(model.LotNo))
			{
			throw new Exception("物料批次不为空!");
			}
			else
			{
			//从物料名称-批次中取出批次
			int indexOfDash = model.LotNo.IndexOf("-");
			if (indexOfDash != -1)
			{
			model.LotNo = model.LotNo.Substring(indexOfDash + 1);
			}
			else
			{
			throw new Exception("物料批次不可为空!");
			}
			}

			//托盘是否存在
			var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (pallet == null)
			{
			throw new Exception("未查询到托盘信息，请核实！");
			}
			// 验证入库单明细是否存在
			var detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == model.AsnDetailId && m.ASNNo == model.AsnNo && m.LotNo.Contains(model.LotNo));
			if (detail == null)
			{
			throw new Exception("当前物料及批次与单据无关联，请核实!");
			}
			//判断托盘是否在库外
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (stockDetail != null && !string.IsNullOrEmpty(stockDetail.WareHouseNo))
			{
			throw new Exception("该托盘已有储位信息，请核实！");
			}
			//if (stockDetail != null && (stockDetail.SkuNo != detail.SkuNo \|\| stockDetail.LotNo != model.LotNo))
			//{
			// throw new Exception("该托盘在库存已有其它物料批次信息，请核实！");
			//}

			#endregion

			#region 包装

			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == detail.SkuNo);
			//var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo); // liudl 由Sku包装编号变更为入库单明细包装编号

			var pNum = 0;//托盘物品数量
			var bNum = 0;//箱码物品数量
			//公共方法获取包装数量
			new Common().GetPackQtyInfo(detail.PackagNo, ref pNum, ref bNum);


			#endregion

			#region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
			//var palletBind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNNo == model.AsnNo && m.PalletNo == model.PalletNo && m.ASNDetailNo != model.AsnDetailId);
			//if (palletBind != null)
			//{
			// var box = Db.Queryable<BllBoxInfo>().First(m => m.IsDel == "0" && m.BindNo == palletBind.Id && m.BitBoxMark == "0");
			// if (box != null && (box.SkuNo != detail.SkuNo \|\| !detail.LotNo.Contains(box.LotNo)))
			// {
			// var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
			// if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			// {
			// throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
			// }
			// }
			//}
			#endregion

			var comTime = DateTime.Now;

			#region 组托信息

			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == model.AsnDetailId && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			DateTime? pTime = null;//生产日期
			DateTime? eTime = null;//失效日期
			if (!string.IsNullOrWhiteSpace(detail.Lot1))
			{
			pTime = DateTime.Parse(detail.Lot1);
			}
			if (!string.IsNullOrWhiteSpace(detail.Lot2))
			{
			eTime = DateTime.Parse(detail.Lot2);
			}


			bind = new BllPalletBind
			{
			ASNNo = model.AsnNo,
			ASNDetailNo = (int)model.AsnDetailId,
			PalletNo = model.PalletNo,

			Qty = model.SkuQty,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = model.LotNo,
			LotText = detail.LotText,
			SupplierLot = detail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			ProductionTime = pTime,
			ExpirationTime = eTime,
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,

			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += model.SkuQty;
			}
			if (bind.Qty < 0)
			{
			throw new Exception("组托数量不能小于0");
			}

			#endregion

			#region 库存明细
			//获取该批次最终质检结果
			BllQualityInspect quality = new BllQualityInspect();
			//判断是否为退货入库单
			if (notice.Type == "3")
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == detail.ASNNo && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			else
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			var tags = "0";
			if (notice.Type == "3" \|\| notice.Type == "4")
			{
			tags = "1";
			}
			//验证库存托盘是否有贴标物料
			var skuStr = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0" && m.IsPasteCode == "1").Select(m => m.SkuNo).ToList();
			var sdHave = Db.Queryable<DataStockDetail>().Count(m => m.IsDel == "0" && m.PalletNo == model.PalletNo && skuStr.Contains(m.SkuNo));
			if (sdHave>0)
			{
			throw new Exception("当前托盘含有贴标物料信息，不能组托");
			}
			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>()
			.First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.PalletNo == model.PalletNo && m.SkuNo == detail.SkuNo && m.LotNo == bind.LotNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand(); //修改质检信息
			}
			else
			{
			string inspectStatusStr = "0";
			if (sku.IsInspect == "1")
			{
			inspectStatusStr = "1";
			}

			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = bind.ASNNo,
			ASNDetailNo = bind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = inspectStatusStr,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = detail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息 //0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")
			{
			sd1.OwnerNo = notice.CustomerNo;//货主编码
			sd1.OwnerName = notice.CustomerName;//货主名称
			}
			else if (notice.Type == "1" \|\| notice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = notice.CustomerNo;//供应商编码
			sd1.SupplierName = notice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			#region 更改组托信息

			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量


			//if (bind.FullQty < bind.Qty && isTextTable == 0)
			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			//if (bind.Qty > pNum && isTextTable == 0)
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#endregion

			#region 入库单及明细
			decimal addQty = model.SkuQty;

			detail.FactQty += addQty;//已组数量
			detail.CompleteQty += addQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			detail.IsSampling = "1";
			}
			detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (detail.CompleteQty >= detail.Qty)
			{
			detail.Status = "2";
			detail.CompleteTime = comTime;
			}
			detail.UpdateUser = userId;
			detail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(detail).ExecuteCommand();

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

			#region 更改库存明细数量

			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();

			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += model.SkuQty;


			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1" && sku.IsControlled != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = detail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = detail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion

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

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

			/// <summary>
			/// 获取需要贴标签的入库单单据号集合
			/// </summary>
			/// <returns></returns>
			public List<string> GetPasteAsnNoStrList()
			{
			try
			{

			var modelList = Db.Queryable<BllArrivalNoticeDetail>()
			.LeftJoin<BllArrivalNotice>((tb1, tb2) => tb1.ASNNo == tb2.ASNNo )
			.LeftJoin<SysMaterials>((tb1, tb2, tb3) => tb1.SkuNo == tb3.SkuNo )
			.Where((tb1, tb2, tb3) => tb1.IsDel == "0" && tb2.IsDel == "0" && (tb2.Status == "0" \|\| tb2.Status == "1") && tb3.IsDel == "0" && tb3.IsPasteCode == "1")
			.Select((tb1, tb2, tb3) => tb1.ASNNo).Distinct().ToList();

			return modelList;
			}
			catch (Exception e)
			{
			throw new Exception(e.Message);
			}
			}
			/// <summary>
			/// 获取不需要贴标签的入库单单据号集合
			/// </summary>
			/// <returns></returns>
			public List<string> GetNoPasteAsnNoStrList()
			{
			try
			{

			var modelList = Db.Queryable<BllArrivalNoticeDetail>()
			.LeftJoin<BllArrivalNotice>((tb1, tb2) => tb1.ASNNo == tb2.ASNNo )
			.LeftJoin<SysMaterials>((tb1, tb2, tb3) => tb1.SkuNo == tb3.SkuNo )
			.Where((tb1, tb2, tb3) => tb1.IsDel == "0" && tb2.IsDel == "0" && (tb2.Status == "0" \|\| tb2.Status == "1") && tb3.IsDel == "0" && tb3.IsPasteCode == "0")
			.Select((tb1, tb2, tb3) => tb1.ASNNo).Distinct().ToList();

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

			/// <summary>
			/// 根据单据号获取单据明细列表
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<ArrivalNoticeDetailDto> GetBindArrivalNoticeDetails(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			try
			{
			// 未关单的单据
			sqlString = $"select * from BllArrivalNotice where Type in ({model.Type}) and Status != '3' and Status != '4' and IsDel='0' order by CreateTime;";
			var modelList = Db.Ado.SqlQuery<ArrivalNoticeDto>(sqlString);
			sqlString = $"select * from BllArrivalNoticeDetail where ASNNo = '{model.ASNNo}' and isdel='0' order by CreateTime;";
			var modelList = Db.Ado.SqlQuery<ArrivalNoticeDetailDto>(sqlString);
			List<ArrivalNoticeDetailDto> noticeList = new List<ArrivalNoticeDetailDto>();
			foreach (var item in modelList)
			{
			if (string.IsNullOrEmpty(item.LotNo))
			{
			noticeList.Add(item);
			}
			else
			{
			string[] LotNoList = item.LotNo.Split(';');
			foreach (var item2 in LotNoList)
			{
			ArrivalNoticeDetailDto entry = new ArrivalNoticeDetailDto()
			{
			Id = item.Id,
			ASNNo = item.ASNNo,
			CompleteQty = item.CompleteQty,
			CompleteTime = item.CompleteTime,
			CreateTime = item.CreateTime,
			Qty = item.Qty,
			FactQty = item.FactQty,
			LotNo = item2,
			Money = item.Money,
			PackagNo = item.PackagNo,
			PackagName = item.PackagName,
			Status = item.Status,
			SkuNo = item.SkuNo,
			SkuName = item.SkuName,
			};

			return modelList;

			noticeList.Add(entry);
			}
			}
			}
			List<ArrivalNoticeDetailDto> list = new List<ArrivalNoticeDetailDto>();
			foreach (var item in noticeList)
			{
			string str = BySkuNoGetPackInfo(item.SkuNo);
			if (str == "贴标")
			{
			list.Add(item);
			}
			}

			return list;
			}
			catch (Exception ex)
			{
			@@ -46,24 +1647,11 @@
			}
			}

			//根据入库单号获取入库总单信息
			public List<BllArrivalNotice> GetArrivalNotice(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			try
			{
			sqlString = $"select * from BllArrivalNotice where ASNNo = '{model.ASNNo}' and isdel='0' ";
			var modelList = Db.Ado.SqlQuery<BllArrivalNotice>(sqlString);

			return modelList;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			// 根据单据号获取单据明细列表
			/// <summary>
			/// 根据单据号获取单据明细列表
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<ArrivalNoticeDetailDto> GetArrivalNoticeDetails(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			@@ -90,7 +1678,11 @@
			}
			}

			// 根据单据明细ID获取明细详情
			/// <summary>
			/// 根据单据明细ID获取明细详情
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public ArrivalNoticeDetailDto GetArrivalNoticeDetail(ArrivalNoticeDetailVm model)
			{
			string sqlString = string.Empty;
			@@ -131,6 +1723,437 @@
			}

			/// <summary>
			/// 根据箱码获取标签箱码信息
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<BoxInfoDto> GetBindBoxInfos(BoxInfoVm model,string url)
			{
			try
			{
			if (string.IsNullOrEmpty(model.BoxNo))
			{
			throw new Exception("请扫描外箱条码!");
			}
			if (string.IsNullOrWhiteSpace(model.ASNNo))
			{
			throw new Exception("请选择入库单号!");
			}
			var noticeList = Db.Queryable<BllArrivalNotice>().Where(m => m.IsDel == "0" && m.ASNNo == model.ASNNo).ToList();
			if (noticeList.Count != 1)
			{
			throw new Exception("入库单号重复!");
			}
			var notice = noticeList.First();
			if (notice.Type == "0") //成品入库
			{
			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);

			if (models.Count != 0)
			{
			return models;
			}
			else
			{
			var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == model.BoxNo).ToList();

			if (boxInfo.Count == 0)
			{
			models = GetFMBindBoxInfos(model.BoxNo, url);
			return models;
			}
			else
			{
			if (boxInfo.Count(m => m.Status != "0") > 0)
			{
			throw new Exception("箱码信息状态不是等待执行");
			}
			return models;
			}



			}
			}
			else if (notice.Type == "1" \|\| notice.Type == "4") //采购入库
			{
			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);

			if (models.Count != 0)
			{
			return models;
			}
			else
			{
			throw new Exception("没有查询到箱码信息");
			}
			}
			else if (notice.Type == "3") //退货入库
			{
			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);

			if (models.Count != 0)
			{
			return models;
			}
			else
			{
			sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo2 = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);
			if (models.Count != 0)
			{
			return models;
			}
			else
			{
			sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo3 = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);
			if (models.Count != 0)
			{
			return models;
			}
			}
			}

			#region 获取最后一次出库拣货中的箱码信息

			var comBox = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.BoxNo == model.BoxNo).GroupBy(m => m.ExportAllotId).Select(m => m.ExportAllotId).ToList();
			if (comBox.Count == 0)
			{
			comBox = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.BoxNo2 == model.BoxNo).GroupBy(m => m.ExportAllotId).Select(m => m.ExportAllotId).ToList();
			if (comBox.Count == 0)
			{
			comBox = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.BoxNo3 == model.BoxNo).GroupBy(m => m.ExportAllotId).Select(m => m.ExportAllotId).ToList();
			}
			}
			var i = 0;//循环次数
			DateTime time = DateTime.Now;
			var allotId = 0;
			foreach (var item in comBox)
			{
			var comBoxList = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == item).OrderByDescending(m => m.CreateTime).First();
			if (i == 0)
			{
			time = comBoxList.CreateTime;
			allotId = comBoxList.ExportAllotId;
			}
			else if (comBoxList.CreateTime > time)
			{
			time = comBoxList.CreateTime;
			allotId = comBoxList.ExportAllotId;
			}
			i++;
			}
			if (allotId != 0)
			{
			var addComBox = Db.Queryable<BllCompleteDetail>().Where(m => m.IsDel == "0" && m.ExportAllotId == allotId).ToList();
			var addComList = addComBox.GroupBy(m => m.BoxNo).ToList();
			var sku = Db.Queryable<SysMaterials>().First(m => m.SkuNo == addComBox.First().SkuNo);
			var pNum = 0;
			var bNum = 0;
			new Common().GetPackQtyInfo(sku.PackagNo, ref pNum, ref bNum);
			var boxList = new List<BllBoxInfo>();
			foreach (var com in addComList)
			{
			//箱内总数和
			var qtySum = addComBox.Where(m => m.BoxNo == com.Key).Sum(m => m.CompleteQty);
			var bitBox = "1";
			if (qtySum == bNum)
			{
			bitBox = "0";
			}
			foreach (var item in com)
			{
			if (item.BoxNo != model.BoxNo)
			{
			if (item.BoxNo2 != model.BoxNo)
			{
			if (item.BoxNo3 != model.BoxNo)
			{
			continue;
			}
			}
			}
			var boxInfo = new BllBoxInfo()
			{
			BoxNo = item.BoxNo,
			BoxNo2 = item.BoxNo2,
			BoxNo3 = item.BoxNo3,
			SkuNo = item.SkuNo,
			SkuName = item.SkuName,
			LotNo = item.LotNo,
			LotText = item.LotText,
			Qty = (decimal)item.CompleteQty,
			FullQty = bNum,
			//ProductionTime = ,
			//ExpirationTime = ,
			InspectMark = "0",
			InspectStatus = "0",
			BitBoxMark = bitBox,
			Origin = "WMS",
			Status = "0",
			CreateUser = 0
			};
			boxList.Add(boxInfo);
			}

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

			string sqlString2 = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models2 = Db.Ado.SqlQuery<BoxInfoDto>(sqlString2);

			if (models2.Count != 0)
			{
			return models2;
			}
			else
			{
			sqlString2 = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo2 = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			models2 = Db.Ado.SqlQuery<BoxInfoDto>(sqlString2);
			if (models2.Count != 0)
			{
			return models2;
			}
			else
			{
			sqlString2 = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo3 = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			models2 = Db.Ado.SqlQuery<BoxInfoDto>(sqlString2);
			if (models2.Count != 0)
			{
			return models2;
			}
			}
			}


			}

			throw new Exception("箱码信息不存在!");
			#endregion

			}
			else
			{
			throw new Exception("单据类型错误");
			}
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 根据箱码向追溯系统请求标签箱码信息
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<BoxInfoDto> GetFMBindBoxInfos(string boxno,string url)
			{
			try
			{
			#region 箱码请求接口，正式系统放开
			var data = new
			{
			BoxCode = boxno
			};
			var jsonData = JsonConvert.SerializeObject(data);

			var response = HttpHelper.DoPost(url, jsonData, "箱码信息请求", "FM");

			var obj = JsonConvert.DeserializeObject<FumaGetBoxModel>(response);//解析返回数据
			if (obj.Success != "0")
			{
			throw new Exception("请求失败" + obj.Message);
			}
			#endregion
			var sku = Db.Queryable<SysMaterials>().First(m => m.SkuNo == obj.Product.SkuNo);
			var pNum = 0;//托盘物品数量
			var bNum = 0;//箱码物品数量
			if (sku == null)
			{
			throw new Exception($"未查询到物料{obj.Product.SkuNo}信息");
			}
			new Common().GetPackQtyInfo(sku.PackagNo, ref pNum, ref bNum);
			if (pNum == 0 \|\| bNum == 0)
			{
			throw new Exception($"{sku.SkuNo}物品包装未找到！");
			}

			var boxList = new List<BllBoxInfo>();
			var comTime = DateTime.Now;
			//添加箱码信息
			foreach (var box in obj.Product.BoxInfoList)
			{
			foreach (var box2 in box.BoxInfo2List)
			{
			foreach (var box3 in box2.BoxInfo3List)
			{
			var boxInfo = new BllBoxInfo()
			{
			BoxNo = box.BoxNo,
			BoxNo2 = box2.BoxNo2,
			BoxNo3 = box3.BoxNo3,
			Qty = box3.Qty,
			BitBoxMark = box.BitBoxMark,

			ASNNo = "",
			//ASNDetailNo = noticeDetail.Id,
			OrderCode = "",//notice.OrderCode
			//BindNo = bindId,
			//PalletNo = model.PallNo,
			FullQty = bNum,
			Status = "2",
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			LotNo = obj.Product.LotNo,
			LotText = obj.Product.LotText,
			ProductionTime = DateTime.Parse(obj.Product.ProductionTime),
			ExpirationTime = DateTime.Parse(obj.Product.ExpirationTime),
			//CompleteTime = "",
			InspectMark = "0",
			InspectStatus = "0",
			Origin = "赋码",
			CreateTime = comTime,
			CreateUser = 0
			};
			boxList.Add(boxInfo);
			}

			}
			}
			Db.Fastest<BllBoxInfo>().BulkCopy(boxList);


			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{boxno}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString); // response

			if (models.Count == 0)
			{
			throw new Exception("箱码信息不存在!");
			}

			return models;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 验证托盘是否存在
			/// </summary>
			/// <param name="palletNo">托盘号</param>
			@@ -153,11 +2176,16 @@
			{
			if (models[0].Status == "1")
			{
			sqlString = $"select count(id) from DataStockDetail where PalletNo = '{palletNo}' and isnull(LocatNo,'') != '' and isdel = '0';";
			int rowNum = Db.Ado.GetInt(sqlString);
			if (rowNum > 0)
			var detail = Db.Queryable<DataStockDetail>().First(m=>m.PalletNo == palletNo );

			if (detail!= null && !string.IsNullOrWhiteSpace(detail.LocatNo))
			{
			sqlMsg = "-1:托盘使用中，此托盘应在库内请核实!";
			var pingAreaStr = Db.Queryable<SysStorageArea>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W04" && m.AreaNo != "B06" && m.AreaNo != "B07").Select(m => m.AreaNo).ToList();
			var pingLocateInfo = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == detail.LocatNo && pingAreaStr.Contains(m.AreaNo) && m.IsDel == "0");
			if (pingLocateInfo == null)
			{
			sqlMsg = "-1:托盘使用中，此托盘应在库内请核实!";
			}
			}
			}
			}
			@@ -167,6 +2195,713 @@
			}

			return sqlMsg;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 根据单据获取标签数量
			/// </summary>
			/// <param name="asnNo">入库单</param>
			/// <param name="asnDetailId">入库单明细号</param>
			/// <returns></returns>
			public BoxListInfoDto GetBoxCountByAsn(string asnNo,int? asnDetailId)
			{
			try
			{

			var detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == asnDetailId);
			if (detail == null)
			{
			throw new Exception("没有查询到单据明细信息");
			}
			var data = new BoxListInfoDto()
			{
			SkuNo = detail.SkuNo,
			SkuName = detail.SkuName,
			LotNo = detail.LotNo,

			};
			//获取状态是未组托的标签信息
			var models = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.ASNNo == asnNo && m.ASNDetailNo == asnDetailId && m.Status == "0")
			.GroupBy(m=> new { m.ProductionTime,m.ExpirationTime })
			.Select(m=>new { m.ProductionTime ,m.ExpirationTime}).OrderBy(m=>m.ProductionTime).ToList();//&& m.Status == "0"
			foreach (var item in models)
			{
			var boxNoList = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.Status == "0" && m.ASNNo == asnNo && m.ASNDetailNo == asnDetailId && m.ProductionTime == item.ProductionTime).Select(m => m.BoxNo).ToList();
			if (boxNoList.Count > 0)
			{
			data.BoxNoList = boxNoList;
			data.Date1 = item.ProductionTime == null ? "" : Convert.ToDateTime(item.ProductionTime).ToString("yyyy-MM-dd");
			data.Date2 = item.ExpirationTime == null ? "" : Convert.ToDateTime(item.ExpirationTime).ToString("yyyy-MM-dd");

			break;
			}
			}
			return data;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 保存指定的储位
			/// </summary>
			/// <param name="palletNo"></param>
			/// <param name="locateNo"></param>
			/// <param name="userId"></param>
			/// <exception cref="Exception"></exception>
			public void SaveAppointLocate(string palletNo, string locateNo, int userId)
			{
			try
			{
			//托盘库存信息
			var stockDetailList = Db.Queryable<DataStockDetail>().Where(m => m.IsDel == "0" && m.PalletNo == palletNo).ToList();
			if (stockDetailList.Count(m=> string.IsNullOrWhiteSpace(m.LocatNo)) > 0)
			{
			throw new Exception("托盘没有在平库储位上");
			}
			//判断托盘的储位是否是平库
			var stockDetail = stockDetailList.First();
			var oldLocate = stockDetail.LocatNo;
			var pingAreaStr = Db.Queryable<SysStorageArea>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W04" && m.AreaNo != "B06" && m.AreaNo != "B07").Select(m => m.AreaNo).ToList();
			var pingLocateInfo = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == oldLocate && pingAreaStr.Contains(m.AreaNo) && m.IsDel == "0");
			if (pingLocateInfo == null)
			{
			throw new Exception("当前托盘所在的储位没有在系统中找到信息");
			}

			var skuList = Db.Queryable<SysMaterials>().Where(m => m.IsDel == "0").ToList();
			//验证物料是否有成品
			foreach (var item in stockDetailList)
			{
			var skuItem = skuList.First(m => m.SkuNo == item.SkuNo);
			if (skuItem.Type == "2")
			{
			throw new Exception("成品物料请入成品库");
			}
			}
			//储位
			var locate = Db.Queryable<SysStorageLocat>().First(m => m.IsDel == "0" && m.LocatNo == locateNo);
			if (locate == null)
			{
			throw new Exception("未查询到储位的信息");
			}
			if (locate.WareHouseNo != "W02")
			{
			throw new Exception("只能指定立库的储位");
			}
			if (locate.Status != "0" \|\| locate.Flag != "0")
			{
			throw new Exception("该储位状态不是空储位或标志不是正常的");
			}


			Db.BeginTran();
			try
			{
			var time = DateTime.Now;
			//判断当前托盘是否存在绑定信息
			var task = Db.Queryable<LogTask>().First(m=> m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" \|\| m.Status == "1") && m.OrderType == "0" && m.Type == "0");

			var upShelf = Db.Queryable<BllPalletUpShelf>().First(m => m.IsDel == "0" && m.PalletNo == palletNo && (m.Status == "0" \|\| m.Status == "1"));
			if (task != null)
			{
			if (task.Status == "1")
			{
			throw new Exception("托盘正在执行任务，不可指定储位");
			}
			if (task.Status == "0")
			{
			if (upShelf != null)
			{
			if (upShelf.Status == "1")
			{
			throw new Exception("托盘正在执行上架任务，不可指定储位");
			}
			if (upShelf.Status == "0")
			{
			if (locate.LocatNo == task.EndLocat)
			{
			throw new Exception("已指定储位，无需重复指定");
			}
			//重新指定储位
			task.EndLocat = locate.LocatNo;
			task.EndRoadway = locate.RoadwayNo;
			upShelf.LocatNo = locate.LocatNo;
			upShelf.RoadwayNo = locate.RoadwayNo;
			Db.Updateable(task).ExecuteCommand();
			Db.Updateable(upShelf).ExecuteCommand();
			new OperationASNServer().AddLogOperationAsn("PDA模块", "指定储位", palletNo, "编辑", $"指定了储位：{locate.LocatNo}、托盘码：{palletNo}的信息", userId);
			Db.CommitTran();
			return;
			}
			}
			else
			{
			throw new Exception("查询出任务但没有上架记录，信息错误");
			}
			}
			}

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

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

			//添加托盘上架记录
			var upShelfAdd = new BllPalletUpShelf()
			{
			TaskNo = addTask.TaskNo,
			TraceNo = "",
			PalletNo = palletNo,
			SkuNo = stockDetail.SkuNo,
			SkuName = stockDetail.SkuName,
			LotNo = stockDetail.LotNo,
			Status = "0",

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

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

			locate.Status = "2";

			Db.Updateable(locate).ExecuteCommand();

			new OperationASNServer().AddLogOperationAsn("PDA模块", "指定储位", palletNo, "编辑", $"指定了储位：{locate.LocatNo}、托盘码：{palletNo}的信息", userId);
			Db.CommitTran();
			}
			catch (Exception e)
			{
			Db.RollbackTran();
			throw new Exception(e.Message);
			}

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

			/// <summary>
			/// 根据箱码获取标签箱码信息（车间入库-获取WMS生成的箱信息）
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<BoxInfoDto> GetWmsBoxInfos(string boxNo)
			{
			try
			{
			if (string.IsNullOrEmpty(boxNo))
			{
			throw new Exception("请扫描外箱条码!");
			}

			string sqlString = $@"SELECT BoxNo, SkuNo, SkuName, LotNo, BitBoxMark, SUM(Qty) as Qty FROM BllBoxInfo
			WHERE IsDel = '0' and Status='0' and BoxNo = '{boxNo}'
			GROUP BY BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);

			if (models.Count != 0)
			{
			return models;
			}
			else
			{
			throw new Exception("没有查询到箱码信息");
			}

			}
			catch (Exception ex)
			{
			throw ex;
			}
			}


			public void ChejianIn(string palletNo,string boxNo,decimal qty,string areaNo,int userId)
			{
			try
			{
			#region MyRegion

			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘号不能为空");
			}
			if (string.IsNullOrWhiteSpace(boxNo))
			{
			throw new Exception("箱号不能为空");
			}
			if (qty<=0)
			{
			throw new Exception("数量不能小等0");
			}
			var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == boxNo).ToList();
			if (boxInfo.Count == 0)
			{
			throw new Exception("未查询到当前箱号信息");
			}
			var boxInfoOne = boxInfo.First();
			var pall = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (pall == null)
			{
			throw new Exception("未查询到当前托盘信息");
			}
			#endregion

			//开启事务
			Db.BeginTran();
			//当前时间
			var comTime = DateTime.Now;

			#region 包装

			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == boxInfoOne.SkuNo);
			var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == sku.PackagNo);

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

			//公共方法获取包装数量
			new Common().GetPackQtyInfo(pack.PackagNo, ref pNum, ref bNum);

			#endregion

			var msgStr = $"箱号为{boxNo}";
			var boxInfoList = new List<BllBoxInfo>();


			boxInfoList.AddRange(boxInfo);

			#region 库存明细

			var area = Db.Queryable<SysStorageArea>().First(m => m.IsDel == "0" && m.AreaNo == areaNo);
			if (area == null)
			{
			throw new Exception("入库区域不能为空");
			}

			var tags = "0";

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.SkuNo== boxInfoOne.SkuNo && m.LotNo == boxInfoOne.LotNo && m.PalletNo == palletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			if (sd1.AreaNo!= areaNo)
			{
			throw new Exception("选择的区域与库存不同");
			}
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty += qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			var sd2 = Db.Queryable<DataStockDetail>().Where(m => m.PalletNo == palletNo && m.IsDel == "0" && !string.IsNullOrWhiteSpace(m.AreaNo));
			if (sd2.Count(m=>m.AreaNo!= areaNo) > 0)
			{
			throw new Exception("当前托盘位置与选择的不同，请核实");
			}
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			ASNNo = "",
			LotNo = boxInfoOne.LotNo,
			LotText = boxInfoOne.LotText,
			SupplierLot = boxInfoOne.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			WareHouseNo = area.WareHouseNo,//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = area.AreaNo,//所属区域
			LocatNo = "",//储位地址
			PalletNo = palletNo,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = boxInfoOne.ProductionTime,
			ExpirationTime = boxInfoOne.ExpirationTime,
			Status = "0",
			InspectMark = boxInfoOne.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = "1",
			PackagNo = sku.PackagNo,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量


			//标签组托
			var boxGroup = boxInfo.GroupBy(m => m.BoxNo).ToList();
			foreach (var g in boxGroup)
			{
			decimal boxFullQty = 0;//箱内总数量
			foreach (var box in g)
			{
			if (box.BindNo != null && box.BindNo != 0)
			{
			continue;
			}


			box.PalletNo = palletNo;
			box.Status = "2";

			box.CompleteTime = comTime;
			box.UpdateTime = comTime;
			box.UpdateUser = userId;

			//box.Qty = box.Qty;
			//box.BitBoxMark = box.Qty == box.FullQty ? "0" : "1";

			factQty += box.Qty;
			boxFullQty += box.Qty;

			#region 库存箱码明细
			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BoxNo = box.BoxNo,
			BoxNo2 = box.BoxNo2,
			BoxNo3 = box.BoxNo3,
			PalletNo = box.PalletNo,
			PalletNo2 = box.PalletNo2,
			PalletNo3 = box.PalletNo3,
			Qty = box.Qty,
			FullQty = box.FullQty,
			Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			LotNo = box.LotNo,
			LotText = box.LotText,
			SkuNo = box.SkuNo,
			SkuName = box.SkuName,
			Standard = sku.Standard,
			ProductionTime = box.ProductionTime,
			SupplierLot = box.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = box.InspectMark,
			BitBoxMark = box.BitBoxMark,
			ExpirationTime = box.ExpirationTime,

			CreateUser = 0,
			CreateTime = comTime
			};
			//添加库存箱码明细
			Db.Insertable(box2).ExecuteCommand();
			#endregion
			}
			if (boxFullQty > bNum)
			{
			throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
			}
			}
			//更改箱支关系表信息
			Db.Updateable(boxInfoList).ExecuteCommand();


			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == boxInfoOne.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = boxInfoOne.LotNo,
			LotText = boxInfoOne.LotText,
			Qty = qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = "0",
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

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

			//提交事务
			Db.CommitTran();

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

			/// <summary>
			/// 车间绑定托盘不贴标物料
			/// </summary>
			/// <param name="model"></param>
			/// <param name="userId"></param>
			/// <exception cref="Exception"></exception>
			public void ChejianQtyIn(string palletNo, string skuNo, string lotNo, decimal qty, string areaNo, int userId)
			{
			try
			{
			#region MyRegion

			if (string.IsNullOrWhiteSpace(palletNo))
			{
			throw new Exception("托盘号不能为空");
			}
			if (string.IsNullOrWhiteSpace(skuNo))
			{
			throw new Exception("物料不能为空");
			}
			if (qty <= 0)
			{
			throw new Exception("数量不能小等0");
			}
			var skuInfo = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == skuNo);
			if (skuInfo == null)
			{
			throw new Exception("未查询到物料信息");
			}
			var pall = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == palletNo);
			if (pall == null)
			{
			throw new Exception("未查询到当前托盘信息");
			}
			#endregion

			//开启事务
			Db.BeginTran();
			//当前时间
			var comTime = DateTime.Now;

			#region 包装

			var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == skuInfo.PackagNo);

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

			//公共方法获取包装数量
			new Common().GetPackQtyInfo(pack.PackagNo, ref pNum, ref bNum);

			#endregion



			#region 库存明细

			var area = Db.Queryable<SysStorageArea>().First(m => m.IsDel == "0" && m.AreaNo == areaNo);
			if (area == null)
			{
			throw new Exception("入库区域不能为空");
			}

			var tags = "0";

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.SkuNo == skuNo && m.LotNo == lotNo && m.PalletNo == palletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			if (sd1.AreaNo != areaNo)
			{
			throw new Exception("选择的区域与库存不同");
			}
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty += qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;
			if (sd1.Qty >= pNum)
			{
			sd1.BitPalletMark = "0";
			}
			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = lotNo,
			SupplierLot = "",
			SkuNo = skuInfo.SkuNo,
			SkuName = skuInfo.SkuName,
			Standard = skuInfo.Standard,
			Qty = qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			WareHouseNo = area.WareHouseNo,//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = area.AreaNo,//所属区域
			LocatNo = "",//储位地址
			PalletNo = palletNo,
			PalletTags = tags,
			CompleteTime = comTime,
			//ProductionTime = boxInfoOne.ProductionTime,
			//ExpirationTime = boxInfoOne.ExpirationTime,
			Status = "0",
			InspectMark = "0",
			InspectStatus = "1",
			BitPalletMark = qty >= pNum ?"0" :"1",
			PackagNo = skuInfo.PackagNo,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量


			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == skuInfo.SkuNo && m.LotNo == lotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = skuInfo.SkuNo,
			SkuName = skuInfo.SkuName,
			Standard = skuInfo.Standard,
			LotNo = lotNo,
			LotText = "",
			Qty = qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = "0",
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

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

			//提交事务
			Db.CommitTran();

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

			}

			#endregion
			// 获取单据列表
			public List<ArrivalNoticeDto> GetArrivalNotices(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			try
			{
			// 未关单的单据
			sqlString = $"select * from BllArrivalNotice where Type in ({model.Type}) and Status != '3' and Status != '4' and IsDel='0' order by CreateTime;";
			var modelList = Db.Ado.SqlQuery<ArrivalNoticeDto>(sqlString);

			return modelList;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			//根据入库单号获取入库总单信息
			public List<BllArrivalNotice> GetArrivalNotice(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			try
			{
			sqlString = $"select * from BllArrivalNotice where ASNNo = '{model.ASNNo}' and isdel='0' ";
			var modelList = Db.Ado.SqlQuery<BllArrivalNotice>(sqlString);

			return modelList;
			}
			catch (Exception ex)
			{
			@@ -375,35 +3110,35 @@
			};
			var id = Db.Insertable(modelpb).ExecuteReturnIdentity();

			var modelbb = new BllBoxInfo
			{
			ASNNo = "",
			ASNDetailNo = null,
			BindNo = id,
			PalletNo = model.PalletNo,
			PalletNo2 = model.PalletNo2,
			PalletNo3 = model.PalletNo3,
			Status = "2",
			CompleteTime = DateTime.Now,
			Qty = (int)model.Qty,
			FullQty = pNum,
			SkuNo = sku.SkuNo,
			SkuName = sku.PackagNo,
			LotNo = "",
			LotText = "",
			SupplierLot = "",
			InspectStatus = sku.IsInspect,
			Origin = "PDA",
			BoxNo = "",
			BoxNo2 = "",
			BoxNo3 = "",
			InspectMark = "",
			BitBoxMark = "0",
			//var modelbb = new BllBoxInfo
			//{
			// ASNNo = "",
			// ASNDetailNo = null,
			// BindNo = id,
			// PalletNo = model.PalletNo,
			// PalletNo2 = model.PalletNo2,
			// PalletNo3 = model.PalletNo3,
			// Status = "2",
			// CompleteTime = DateTime.Now,
			// Qty = (int)model.Qty,
			// FullQty = pNum,
			// SkuNo = sku.SkuNo,
			// SkuName = sku.SkuName,
			// LotNo = "",
			// LotText = "",
			// SupplierLot = "",
			// InspectStatus = sku.IsInspect,
			// Origin = "PDA",
			// BoxNo = "",
			// BoxNo2 = "",
			// BoxNo3 = "",
			// InspectMark = "",
			// BitBoxMark = "0",

			CreateUser = (int)model.CreateUser,
			CreateTime = datetime
			};
			Db.Insertable(modelbb).ExecuteCommand();
			// CreateUser = (int)model.CreateUser,
			// CreateTime = datetime
			//};
			//Db.Insertable(modelbb).ExecuteCommand();

			//添加库存

			@@ -451,35 +3186,35 @@

			#region 库存箱码明细

			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BindNo = modelpb.Id,
			BoxNo = modelbb.BoxNo,
			BoxNo2 = modelbb.BoxNo2,
			BoxNo3 = modelbb.BoxNo3,
			PalletNo = modelbb.PalletNo,
			PalletNo2 = modelbb.PalletNo2,
			PalletNo3 = modelbb.PalletNo3,
			Qty = modelbb.Qty,
			FullQty = modelbb.FullQty,
			Status = "2",
			LotNo = modelbb.LotNo,
			LotText = modelbb.LotText,
			SkuNo = modelbb.SkuNo,
			SkuName = modelbb.SkuName,
			Standard = sku.Standard,
			ProductionTime = modelbb.ProductionTime,
			SupplierLot = modelbb.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = modelbb.InspectMark,
			BitBoxMark = modelbb.BitBoxMark,
			ExpirationTime = modelbb.ExpirationTime,
			//var box2 = new DataBoxInfo()
			//{
			// StockDetailId = sdId1,
			// BindNo = modelpb.Id,
			// BoxNo = modelbb.BoxNo,
			// BoxNo2 = modelbb.BoxNo2,
			// BoxNo3 = modelbb.BoxNo3,
			// PalletNo = modelbb.PalletNo,
			// PalletNo2 = modelbb.PalletNo2,
			// PalletNo3 = modelbb.PalletNo3,
			// Qty = modelbb.Qty,
			// FullQty = modelbb.FullQty,
			// Status = "2",
			// LotNo = modelbb.LotNo,
			// LotText = modelbb.LotText,
			// SkuNo = modelbb.SkuNo,
			// SkuName = modelbb.SkuName,
			// Standard = sku.Standard,
			// ProductionTime = modelbb.ProductionTime,
			// SupplierLot = modelbb.SupplierLot,
			// InspectStatus = sku.IsInspect,
			// InspectMark = modelbb.InspectMark,
			// BitBoxMark = modelbb.BitBoxMark,
			// ExpirationTime = modelbb.ExpirationTime,

			CreateUser = 0,
			CreateTime = datetime
			};
			Db.Insertable(box2).ExecuteCommand();
			// CreateUser = 0,
			// CreateTime = datetime
			//};
			//Db.Insertable(box2).ExecuteCommand();
			#endregion

			#region 库存
			@@ -1521,7 +4256,7 @@
			try
			{
			string strMsg = "";
			var storageLocat = Db.Queryable<SysStorageLocat>().First(w => w.IsDel == "0" && w.LocatNo == locatNo && w.Status == "0" && w.WareHouseNo == "W02");
			var storageLocat = Db.Queryable<SysStorageLocat>().First(w => w.IsDel == "0" && w.LocatNo == locatNo && w.Status == "0" && w.WareHouseNo == "W04");
			if (storageLocat == null)
			{
			throw new Exception("-1:地码(储位信息)不存在或非空闲状态，请核查!");
			@@ -1884,156 +4619,9 @@
			}

			#region 产品组托
			/// <summary>
			/// 根据箱码获取标签箱码信息
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<BoxInfoDto> GetBindBoxInfos(BoxInfoVm model)
			{
			try
			{
			if (string.IsNullOrEmpty(model.BoxNo))
			{
			throw new Exception("请扫描外箱条码!");
			}
			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{model.BoxNo}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString);


			if (models.Count == 0 )
			{
			throw new Exception("箱码信息不存在!");
			}

			return models;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 根据箱码向追溯系统请求标签箱码信息
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			public List<BoxInfoDto> GetFMBindBoxInfos(string boxno)
			{
			try
			{
			#region 箱码请求接口，正式系统放开
			/*var jsonData = JsonConvert.SerializeObject(boxno);

			var response = HttpHelper.DoPost(url, jsonData, "箱码信息请求", "FM");

			var obj = JsonConvert.DeserializeObject<ErpModel>(response);//解析返回数据
			if (obj.Success != 0)
			{
			throw new Exception("请求失败" + obj.Message);
			}*/
			#endregion
			string sqlString = $@"SELECT
			ASNNo,
			BoxNo,
			SkuNo,
			SkuName,
			LotNo,
			BitBoxMark,
			SUM(Qty) as Qty
			FROM BllBoxInfo
			WHERE IsDel = '0'
			AND Status='0'
			AND BoxNo = '{boxno}'
			GROUP BY ASNNo,BoxNo,SkuNo,SkuName,LotNo,BitBoxMark; ";
			var models = Db.Ado.SqlQuery<BoxInfoDto>(sqlString); // response

			if (models.Count == 0)
			{
			throw new Exception("箱码信息不存在!");
			}

			return models;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			// 根据单据号获取单据明细列表
			public List<ArrivalNoticeDetailDto> GetBindArrivalNoticeDetails(ArrivalNoticeVm model)
			{
			string sqlString = string.Empty;
			try
			{
			sqlString = $"select * from BllArrivalNoticeDetail where ASNNo = '{model.ASNNo}' and isdel='0' order by CreateTime;";
			var modelList = Db.Ado.SqlQuery<ArrivalNoticeDetailDto>(sqlString);
			List<ArrivalNoticeDetailDto> noticeList = new List<ArrivalNoticeDetailDto>();
			foreach (var item in modelList)
			{
			if (string.IsNullOrEmpty(item.LotNo))
			{
			noticeList.Add(item);
			}
			else
			{
			string[] LotNoList = item.LotNo.Split(';');
			foreach (var item2 in LotNoList)
			{
			ArrivalNoticeDetailDto entry = new ArrivalNoticeDetailDto()
			{
			Id = item.Id,
			ASNNo = item.ASNNo,
			CompleteQty = item.CompleteQty,
			CompleteTime = item.CompleteTime,
			CreateTime = item.CreateTime,
			Qty = item.Qty,
			FactQty = item.FactQty,
			LotNo = item2,
			Money = item.Money,
			PackagNo = item.PackagNo,
			PackagName = item.PackagName,
			Status = item.Status,
			SkuNo = item.SkuNo,
			SkuName = item.SkuName,
			};


			noticeList.Add(entry);
			}
			}
			}
			List<ArrivalNoticeDetailDto> list = new List<ArrivalNoticeDetailDto>();
			foreach (var item in noticeList)
			{
			string str = BySkuNoGetPackInfo(item.SkuNo);
			if (str == "贴标")
			{
			list.Add(item);
			}
			}

			return list;
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}


			//根据物料获取是否存在包装信息
			public string BySkuNoGetPackInfo(string skuNo)
			{
			@@ -3376,7 +5964,7 @@
			#endregion

			#region 质检请验
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1")
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1" && sku.IsControlled != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			@@ -3416,1545 +6004,7 @@
			}
			}

			//JC26绑定托盘贴标物料
			public void BindPalletPasteCode(PdaPalletBindVm model, int userId)
			{
			try
			{
			#region 判断
			//0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 5：其它入库 6：代储入库
			var TypeLot = "5, 6";

			if (string.IsNullOrEmpty(model.AsnNo))
			{
			throw new Exception("单据号不可为空!");
			}
			if (model.AsnDetailId == null \|\| model.AsnDetailId == 0)
			{
			throw new Exception("物料不可为空!");
			}
			if (string.IsNullOrEmpty(model.PalletNo))
			{
			throw new Exception("托盘号不可为空!");
			}
			//根据单据号获取入库单总单
			var notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo);
			if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
			{
			throw new Exception("该单据已关单!");
			}

			if (string.IsNullOrEmpty(model.LotNo))
			{
			throw new Exception("物料不为空!");
			}
			else
			{
			//从物料名称-批次中取出批次
			int indexOfDash = model.LotNo.IndexOf("-");
			if (indexOfDash != -1)
			{
			model.LotNo = model.LotNo.Substring(indexOfDash + 1);
			}
			else
			{
			throw new Exception("物料批次不可为空!");
			}
			}

			//判断箱码信息
			if (string.IsNullOrEmpty(model.BoxNo))
			{
			throw new Exception("箱码信息不可为空!");
			}
			//是否连续组托 0：否 1：是
			if (model.IsContinue == "1")
			{
			if (string.IsNullOrWhiteSpace(model.TailBoxNo))
			{
			throw new Exception("开启连续组托时，尾箱码信息不可为空!");
			}
			}

			//托盘信息是否存在
			var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (pallet == null)
			{
			throw new Exception("未查询到托盘信息，请核实！");
			}
			//验证入库单明细是否存在
			var detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == model.AsnDetailId && m.ASNNo == model.AsnNo && m.LotNo.Contains(model.LotNo));
			if (detail == null)
			{
			throw new Exception("当前物料及批次与单据无关联，请核实!");
			}
			//判断托盘是否在库外
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (stockDetail != null && !string.IsNullOrEmpty(stockDetail.WareHouseNo))
			{
			throw new Exception("该托盘已有储位信息，请核实！");
			}
			/*if (stockDetail != null && stockDetail.SkuNo != detail.SkuNo)
			{
			throw new Exception("该托盘在库存已有其它物料信息，请核实！");
			}*/
			#endregion

			//开启事务
			Db.BeginTran();
			//当前时间
			var comTime = DateTime.Now;

			#region 包装
			var package = Db.Queryable<SysPackag>().Where(m => m.IsDel == "0");
			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == detail.SkuNo);
			var pack = package.First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo); // liudl 由Sku包装编号变更为入库单明细包装编号

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

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

			#endregion

			#region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
			var palletBind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNNo == model.AsnNo && m.PalletNo == model.PalletNo && m.ASNDetailNo != model.AsnDetailId);
			if (palletBind != null)
			{
			var box = Db.Queryable<BllBoxInfo>().First(m => m.IsDel == "0" && m.BindNo == palletBind.Id && m.BitBoxMark == "0");
			if (box != null && (box.SkuNo != detail.SkuNo \|\| !detail.LotNo.Contains(box.LotNo)))
			{
			var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
			if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			{
			throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
			}
			}
			}
			#endregion

			#region 箱码信息
			var msgStr = $"箱号为{model.BoxNo}";
			var boxInfoList = new List<BllBoxInfo>();

			//首箱
			var boxInfo = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == model.BoxNo).ToList();
			if (boxInfo.Count == 0)
			{
			throw new Exception("箱码信息不存在!");
			}
			boxInfoList.AddRange(boxInfo);
			//是否连续组托
			if (model.IsContinue == "1")
			{
			//尾箱
			var boxInfo2 = Db.Queryable<BllBoxInfo>().Where(m => m.IsDel == "0" && m.BoxNo == model.TailBoxNo).ToList();
			if (boxInfo2.Count == 0)
			{
			throw new Exception("尾箱码信息不存在!");
			}
			boxInfoList.AddRange(boxInfo2);
			var sql = $"select * from BllBoxInfo where IsDel = '0' and boxNo>'{model.BoxNo}' and boxNo<'{model.TailBoxNo}'; ";
			var list = Db.Ado.SqlQuery<BllBoxInfo>(sql);
			boxInfoList.AddRange(list);
			msgStr += $"尾箱号为{model.TailBoxNo}";
			}
			//绑定箱总数量
			//model.SkuQty = boxInfoList.Sum(s => s.Qty);
			//和选择的批次同批次的箱码信息
			var sameBoxInfoList = boxInfoList.Where(w => w.LotNo == model.LotNo && w.Status == "0").ToList();
			//和选择的批次不同批次的箱码信息（拼箱批次）
			var notBoxInfoList = boxInfoList.Where(w => w.LotNo != model.LotNo).ToList();
			#endregion

			if (sameBoxInfoList.Count <= 0)
			{
			throw new Exception("箱码信息不存在!");
			}
			else
			{
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == model.AsnDetailId && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = model.AsnNo,
			ASNDetailNo = (int)model.AsnDetailId,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = model.SkuQty,//不包含拼箱中非同批次数量
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = model.LotNo,
			LotText = detail.LotText,
			SupplierLot = detail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += model.SkuQty;
			}
			/*if (bind.Qty < 0)
			{
			throw new Exception("组盘数量不能小于0");
			}*/
			#endregion

			#region 库存明细和质检信息
			//获取该批次最终质检结果
			BllQualityInspect quality = new BllQualityInspect();
			//判断是否为退货入库单
			if (notice.Type == "3")
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == detail.ASNNo && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			else
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == detail.SkuNo && a.LotNo == detail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			var tags = "0";
			if (notice.Type == "3" \|\| notice.Type == "4")
			{
			tags = "1";
			}

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.PalletNo == model.PalletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = bind.ASNNo,
			ASNDetailNo = bind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = detail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = notice.CustomerNo;//货主编码
			sd1.OwnerName = notice.CustomerName;//货主名称
			}
			else if (notice.Type == "1" \|\| notice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = notice.CustomerNo;//供应商编码
			sd1.SupplierName = notice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量
			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量

			//标签组托
			var boxGroup = sameBoxInfoList.GroupBy(m => m.BoxNo).ToList();
			foreach (var g in boxGroup)
			{
			decimal boxFullQty = 0;//箱内总数量
			foreach (var box in g)
			{
			if (box.BindNo != null && box.BindNo != 0)
			{
			continue;
			}
			//箱内物料批次与单据明细不符合
			if (box.SkuNo != detail.SkuNo \|\| box.LotNo != model.LotNo)
			{
			throw new Exception($"-1:{box.BoxNo}箱内物料及批次与单据不一致，请核实!");
			}

			box.ASNNo = model.AsnNo;
			box.ASNDetailNo = model.AsnDetailId;
			box.BindNo = bindId;
			box.PalletNo = model.PalletNo;
			box.Status = "2";
			//box.InspectMark = model.IsSample; //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//box.SamplingQty = 0; //取样数量后期业务开发时接口传值需添加对应字段判断
			box.CompleteTime = comTime;
			box.UpdateTime = comTime;
			box.UpdateUser = userId;

			//box.Qty = box.Qty;
			//box.BitBoxMark = box.Qty == box.FullQty ? "0" : "1";

			factQty += box.Qty;
			boxFullQty += box.Qty;
			if (box.InspectMark == "1") //判断是否取样
			{
			isSample = "1";
			sampleQty += (decimal)box.SamplingQty;
			}

			#region 库存箱码明细
			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BindNo = bind.Id,
			BoxNo = box.BoxNo,
			BoxNo2 = box.BoxNo2,
			BoxNo3 = box.BoxNo3,
			PalletNo = box.PalletNo,
			PalletNo2 = box.PalletNo2,
			PalletNo3 = box.PalletNo3,
			Qty = box.Qty,
			FullQty = box.FullQty,
			Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			LotNo = box.LotNo,
			LotText = box.LotText,
			SkuNo = box.SkuNo,
			SkuName = box.SkuName,
			Standard = sku.Standard,
			ProductionTime = box.ProductionTime,
			SupplierLot = box.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = box.InspectMark,
			BitBoxMark = box.BitBoxMark,
			ExpirationTime = box.ExpirationTime,

			CreateUser = 0,
			CreateTime = comTime
			};
			//添加库存箱码明细
			Db.Insertable(box2).ExecuteCommand();
			#endregion
			}
			if (boxFullQty > bNum)
			{
			throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
			}
			}
			//更改箱支关系表信息
			Db.Updateable(boxInfoList).ExecuteCommand();

			// 更新托盘绑定表
			bind.Qty += factQty;

			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#region 入库单及明细
			detail.FactQty += factQty;//已组数量
			detail.CompleteQty += factQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			detail.IsSampling = "1";
			}
			detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (detail.CompleteQty >= detail.Qty)
			{
			detail.Status = "2";
			detail.CompleteTime = comTime;
			}
			detail.UpdateUser = userId;
			detail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(detail).ExecuteCommand();

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

			#region 库存明细
			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();
			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;

			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = detail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = detail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion
			}
			//拼箱
			if (notBoxInfoList.Count > 0)
			{
			var gbox = notBoxInfoList.GroupBy(g => g.BoxNo).ToList();
			if (gbox.Count > 1)
			{
			throw new Exception("一个托盘上只能有1个拼箱!");
			}
			gbox = notBoxInfoList.GroupBy(g => g.LotNo).ToList();
			if (gbox.Count > 1)
			{
			throw new Exception("一个箱内最多能有2个不同批次物料!");
			}
			var pinBoxNo = notBoxInfoList[0].BoxNo;//拼箱箱码
			var pinBoxLotNo = notBoxInfoList[0].LotNo;//拼箱批次号
			//拼箱数量(和选择的批次不同批次的箱码数量)
			decimal pinBoxQty = notBoxInfoList.Sum(s => s.Qty);

			var dataBoxList = Db.Queryable<DataBoxInfo>().Where(w => w.IsDel == "0" && w.BoxNo == pinBoxNo && w.LotNo == pinBoxLotNo).ToList();
			if (dataBoxList.Count > 0)//已有库存
			{
			//原托盘绑定信息
			var oldPalletBind = Db.Queryable<BllPalletBind>().First(w => w.Id == notBoxInfoList[0].BindNo);
			//原入库单明细
			var oldAsnDetail = Db.Queryable<BllArrivalNoticeDetail>().First(w => w.Id == oldPalletBind.ASNDetailNo);
			//原入库单
			var oldAsnNotice = Db.Queryable<BllArrivalNotice>().First(w => w.ASNNo == oldAsnDetail.ASNNo);
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == oldAsnDetail.Id && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = oldAsnDetail.ASNNo,
			ASNDetailNo = oldAsnDetail.Id,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = 0,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = pinBoxLotNo,
			LotText = oldAsnDetail.LotText,
			SupplierLot = oldAsnDetail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += pinBoxQty;

			Db.Updateable(bind).ExecuteCommand();
			}
			#endregion

			// 插入库存明细数据
			var sd1 = new DataStockDetail()
			{
			LotNo = pinBoxLotNo,
			LotText = notBoxInfoList[0].LotText,
			SupplierLot = notBoxInfoList[0].SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = pinBoxQty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = oldPalletBind.ASNNo,
			ASNDetailNo = oldPalletBind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = "0",
			CompleteTime = comTime,
			ProductionTime = oldPalletBind.ProductionTime,
			ExpirationTime = oldPalletBind.ExpirationTime,
			Status = "0",
			InspectMark = oldPalletBind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = oldPalletBind.BitPalletMark,
			PackagNo = oldAsnDetail.PackagNo,
			IsBale = oldPalletBind.IsBale,
			IsBelt = oldPalletBind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};
			//维护库存明细货主/供应商信息
			if (oldAsnNotice.Type == "0" \|\| oldAsnNotice.Type == "2" \|\| oldAsnNotice.Type == "4" \|\| oldAsnNotice.Type == "6" \|\| oldAsnNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = oldAsnNotice.CustomerNo;//货主编码
			sd1.OwnerName = oldAsnNotice.CustomerName;//货主名称
			}
			else if (oldAsnNotice.Type == "1" \|\| oldAsnNotice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = oldAsnNotice.CustomerNo;//供应商编码
			sd1.SupplierName = oldAsnNotice.CustomerName;//供应商名称
			}
			//添加库存明细
			var sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			foreach (var item in dataBoxList)
			{
			item.StockDetailId = sdId1;//库存明细id
			item.BindNo = bind.Id;//托盘绑定id
			}
			//更新库存箱支明细表
			Db.Updateable(dataBoxList).ExecuteCommand();

			//托盘解绑信息
			var palletUnbind = Db.Queryable<BllPalletUnbind>().First(w => w.IsDel == "0" && w.UpbindPalletNo == oldPalletBind.PalletNo && w.BoxNo == pinBoxNo);
			if (palletUnbind == null)
			{
			throw new Exception("拼箱的托盘解绑信息不存在!");
			}
			palletUnbind.BindPalletNo = model.PalletNo;//绑定托盘号
			palletUnbind.UpdateTime = comTime;
			palletUnbind.UpdateUser = userId;
			//更新托盘解绑绑定表信息
			Db.Updateable(palletUnbind).ExecuteCommand();
			}
			else
			{
			string sql = $@"SELECT detail.* FROM BllArrivalNoticeDetail as detail
			JOIN BllArrivalNotice as notice ON detail.ASNNo=notice.ASNNo
			WHERE notice.IsDel='0'
			AND ( notice.Status=0 or notice.Status=1 )
			AND detail.IsDel='0'
			AND detail.LotNo='{pinBoxLotNo}'
			AND detail.SkuNo='{sku.SkuNo}'
			ORDER BY detail.CreateTime ";
			//找到拼箱内其他批次所属入库单明细
			var arrDetail = Db.Ado.SqlQuery<BllArrivalNoticeDetail>(sql).FirstOrDefault();
			if (arrDetail == null)
			{
			throw new Exception("拼箱内物料所属入库单明细不存在!");
			}
			//找到拼箱内其他批次所属入库单
			var arrNotice = Db.Queryable<BllArrivalNotice>().First(w => w.IsDel == "0" && w.ASNNo == arrDetail.ASNNo);
			if (arrNotice == null)
			{
			throw new Exception("拼箱内物料所属入库单不存在!");
			}
			#region 托盘绑定信息
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == arrDetail.Id && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			bind = new BllPalletBind
			{
			ASNNo = arrDetail.ASNNo,
			ASNDetailNo = arrDetail.Id,
			PalletNo = model.PalletNo,
			PalletNo2 = "",
			PalletNo3 = "",
			Qty = 0,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = pinBoxLotNo,
			LotText = arrDetail.LotText,
			SupplierLot = arrDetail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,
			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			}
			#endregion

			#region 库存明细和质检信息
			//获取该批次最终质检结果
			BllQualityInspect quality = new BllQualityInspect();
			//判断是否为退货入库单
			if (arrNotice.Type == "3")
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.ASNNo == arrDetail.ASNNo && a.SkuNo == arrDetail.SkuNo && a.LotNo == arrDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			else
			{
			quality = Db.Queryable<BllQualityInspect>().Where(a => a.IsDel == "0" && a.SkuNo == arrDetail.SkuNo && a.LotNo == arrDetail.LotNo).OrderByDescending(a => a.CreateTime).First();
			}
			var tags = "0";
			if (arrNotice.Type == "3" \|\| arrNotice.Type == "4")
			{
			tags = "1";
			}

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.ASNDetailNo == arrDetail.Id && m.PalletNo == model.PalletNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand();
			}
			else
			{
			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = pinBoxLotNo,
			LotText = notBoxInfoList[0].LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = arrDetail.ASNNo,
			ASNDetailNo = arrDetail.Id,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = sku.IsInspect,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = arrDetail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息
			if (arrNotice.Type == "0" \|\| arrNotice.Type == "2" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "6" \|\| arrNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = arrNotice.CustomerNo;//货主编码
			sd1.OwnerName = arrNotice.CustomerName;//货主名称
			}
			else if (arrNotice.Type == "1" \|\| arrNotice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = arrNotice.CustomerNo;//供应商编码
			sd1.SupplierName = arrNotice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion

			// 更改箱支关系表
			decimal factQty = 0.00m;//托盘总数量
			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量

			//标签组托
			var boxGroup = notBoxInfoList.GroupBy(m => m.BoxNo).ToList();
			foreach (var g in boxGroup)
			{
			decimal boxFullQty = 0;//箱内总数量
			foreach (var box in g)
			{
			if (box.BindNo != null && box.BindNo != 0)
			{
			continue;
			}
			//箱内物料批次与单据明细不符合
			if (box.SkuNo != arrDetail.SkuNo \|\| box.LotNo != arrDetail.LotNo)
			{
			throw new Exception($"-1:{box.BoxNo}箱内物料及批次与单据不一致，请核实!");
			}

			box.ASNNo = arrDetail.ASNNo;
			box.ASNDetailNo = arrDetail.Id;
			box.BindNo = bindId;
			box.PalletNo = model.PalletNo;
			box.Status = "2";
			//box.InspectMark = model.IsSample; //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//box.SamplingQty = 0; //取样数量后期业务开发时接口传值需添加对应字段判断
			box.CompleteTime = comTime;
			box.UpdateTime = comTime;
			box.UpdateUser = userId;

			//box.Qty = box.Qty;
			//box.BitBoxMark = box.Qty == box.FullQty ? "0" : "1";

			factQty += box.Qty;
			boxFullQty += box.Qty;
			if (box.InspectMark == "1") //判断是否取样
			{
			isSample = "1";
			sampleQty += (decimal)box.SamplingQty;
			}

			#region 库存箱码明细
			var box2 = new DataBoxInfo()
			{
			StockDetailId = sdId1,
			BindNo = bind.Id,
			BoxNo = box.BoxNo,
			BoxNo2 = box.BoxNo2,
			BoxNo3 = box.BoxNo3,
			PalletNo = box.PalletNo,
			PalletNo2 = box.PalletNo2,
			PalletNo3 = box.PalletNo3,
			Qty = box.Qty,
			FullQty = box.FullQty,
			Status = "2",//0：未组托 1：已组托 2：已入库 3：已出库 4:已分配 5：已拣货
			LotNo = box.LotNo,
			LotText = box.LotText,
			SkuNo = box.SkuNo,
			SkuName = box.SkuName,
			Standard = sku.Standard,
			ProductionTime = box.ProductionTime,
			SupplierLot = box.SupplierLot,
			InspectStatus = sku.IsInspect,
			InspectMark = box.InspectMark,
			BitBoxMark = box.BitBoxMark,
			ExpirationTime = box.ExpirationTime,

			CreateUser = 0,
			CreateTime = comTime
			};
			//添加库存箱码明细
			Db.Insertable(box2).ExecuteCommand();
			#endregion
			}
			if (boxFullQty > bNum)
			{
			throw new Exception($"绑定失败，{g.Key}箱码绑定数量大于该物品包装数量！");
			}
			}
			//更改箱支关系表信息
			Db.Updateable(boxInfoList).ExecuteCommand();

			// 更新托盘绑定表
			bind.Qty += factQty;

			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#region 入库单及明细
			arrDetail.FactQty += factQty;//已组数量
			arrDetail.CompleteQty += factQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			arrDetail.IsSampling = "1";
			}
			arrDetail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (arrDetail.CompleteQty >= arrDetail.Qty)
			{
			arrDetail.Status = "2";
			arrDetail.CompleteTime = comTime;
			}
			arrDetail.UpdateUser = userId;
			arrDetail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(arrDetail).ExecuteCommand();

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

			#region 库存明细
			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();
			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += factQty;

			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (arrNotice.Type == "0" \|\| arrNotice.Type == "2" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "6" \|\| arrNotice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((arrNotice.Type == "1" \|\| arrNotice.Type == "4" \|\| arrNotice.Type == "5") && sku.IsInspect != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = arrDetail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = arrDetail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion
			}
			}
			// 更改托盘使用状态
			var sqlStr = $"update SysPallets set Status = '1' where PalletNo = '{model.PalletNo}';";
			//添加托盘记录表数据
			sqlStr += $"insert into LogPalletTrack values('{model.PalletNo}','{model.AsnNo}','组盘','0',getDate(),{userId},NULL,NULL);";
			Db.Ado.ExecuteCommand(sqlStr);
			new OperationASNServer().AddLogOperationAsn("PDA模块", "托盘绑定", model.AsnNo, "添加", $"添加了托盘码为：{model.PalletNo}、{msgStr}的组盘信息", userId);

			//提交事务
			Db.CommitTran();
			}
			catch (Exception e)
			{
			//回滚事务
			Db.RollbackTran();
			throw new Exception(e.Message);
			}
			}

			//JC26绑定托盘不贴标物料
			public void BindPalletNoPasteCode(PdaPalletBindVm model, int userId)
			{

			#region 判断

			//0：成品入库 1：采购入库 3：退货入库 4：车间余料入库 5：其它入库 6：代储入库
			var TypeLot = "5, 6";

			if (string.IsNullOrEmpty(model.AsnNo))
			{
			throw new Exception("单据号不可为空!");
			}
			if (model.AsnDetailId == null \|\| model.AsnDetailId == 0)
			{
			throw new Exception("物料不可为空!");
			}
			if (string.IsNullOrEmpty(model.PalletNo))
			{
			throw new Exception("托盘号不可为空!");
			}
			if (model.SkuQty < 0)
			{
			throw new Exception("物料数量不能小于0!");
			}
			//根据单据号获取入库单总单
			var notice = Db.Queryable<BllArrivalNotice>().First(a => a.IsDel == "0" && a.ASNNo == model.AsnNo);
			if (notice.Status != "0" && notice.Status != "1" && notice.Status != "2")
			{
			throw new Exception("该单据已关单!");
			}

			if (string.IsNullOrEmpty(model.LotNo))
			{
			throw new Exception("物料批次不为空!");
			}
			else
			{
			//从物料名称-批次中取出批次
			int indexOfDash = model.LotNo.IndexOf("-");
			if (indexOfDash != -1)
			{
			model.LotNo = model.LotNo.Substring(indexOfDash + 1);
			}
			else
			{
			if (!TypeLot.Contains(notice.Type))
			{
			throw new Exception("物料批次不可为空!");
			}

			model.LotNo = "";
			}
			}

			//int isTextTable = model.TableType;
			#endregion

			var comTime = DateTime.Now;

			//托盘是否存在
			var pallet = Db.Queryable<SysPallets>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (pallet == null)
			{
			throw new Exception("未查询到托盘信息，请核实！");
			}
			// 验证入库单明细是否存在
			var detail = Db.Queryable<BllArrivalNoticeDetail>().First(m => m.IsDel == "0" && m.Id == model.AsnDetailId && m.ASNNo == model.AsnNo && m.LotNo.Contains(model.LotNo));
			if (detail == null)
			{
			throw new Exception("当前物料及批次与单据无关联，请核实!");
			}
			//判断托盘是否在库外
			var stockDetail = Db.Queryable<DataStockDetail>().First(m => m.IsDel == "0" && m.PalletNo == model.PalletNo);
			if (stockDetail != null && !string.IsNullOrEmpty(stockDetail.WareHouseNo))
			{
			throw new Exception("该托盘已有储位信息，请核实！");
			}
			if (stockDetail != null && (stockDetail.SkuNo != detail.SkuNo \|\| stockDetail.LotNo != model.LotNo))
			{
			throw new Exception("该托盘在库存已有其它物料批次信息，请核实！");
			}

			#region 包装
			var sku = Db.Queryable<SysMaterials>().First(m => m.IsDel == "0" && m.SkuNo == detail.SkuNo);
			var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == detail.PackagNo); // liudl 由Sku包装编号变更为入库单明细包装编号

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

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

			#endregion

			#region 验证是否允许立库同托盘不同物料入库或同托盘同物料不同批次入库
			var palletBind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNNo == model.AsnNo && m.PalletNo == model.PalletNo && m.ASNDetailNo != model.AsnDetailId);
			if (palletBind != null)
			{
			var box = Db.Queryable<BllBoxInfo>().First(m => m.IsDel == "0" && m.BindNo == palletBind.Id && m.BitBoxMark == "0");
			if (box != null && (box.SkuNo != detail.SkuNo \|\| !detail.LotNo.Contains(box.LotNo)))
			{
			var funSetting = Db.Queryable<SysFunSetting>().First(a => a.IsDel == "0" && a.FunSetNo == "Fun045");
			if (funSetting == null \|\| funSetting.IsEnable == "OFF")
			{
			throw new Exception($"不允许立库同托盘不同物料入库或同托盘不同批次入库！");
			}
			}
			}
			#endregion
			//liudl && m.Status != "2" 组盘既入库完成无需根据托盘状态判断
			var bind = Db.Queryable<BllPalletBind>().First(m => m.IsDel == "0" && m.ASNDetailNo == model.AsnDetailId && m.PalletNo == model.PalletNo);
			var bindId = 0;
			if (bind == null)
			{
			DateTime? pTime = null;
			DateTime? eTime = null;
			if (!string.IsNullOrWhiteSpace(detail.Lot1))
			{
			pTime = DateTime.Parse(detail.Lot1);
			}
			if (!string.IsNullOrWhiteSpace(detail.Lot2))
			{
			eTime = DateTime.Parse(detail.Lot2);
			}


			bind = new BllPalletBind
			{
			ASNNo = model.AsnNo,
			ASNDetailNo = (int)model.AsnDetailId,
			PalletNo = model.PalletNo,

			Qty = model.SkuQty,
			FullQty = pNum,
			Status = "2",//入库完成
			Type = "0",
			LotNo = model.LotNo,
			LotText = detail.LotText,
			SupplierLot = detail.SupplierLot,
			//InspectMark = model.IsSample, //是否取样托盘后期业务开发时接口传值需添加对应字段判断
			//SamplingQty = 0, //取样数量后期业务开发时接口传值需添加对应字段判断
			ProductionTime = pTime,
			ExpirationTime = eTime,
			BitPalletMark = "1",
			IsBale = "0",
			IsBelt = "0",
			CreateUser = userId,
			Demo = model.Demo,

			};
			// 插入托盘绑定表
			bindId = Db.Insertable(bind).ExecuteReturnIdentity();
			}
			else
			{
			bindId = bind.Id;
			bind.Qty += model.SkuQty;
			}
			if (bind.Qty < 0)
			{
			throw new Exception("组盘数量不能小于0");
			}

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

			// 判断库存明细是否已有此托盘信息
			var sd1 = Db.Queryable<DataStockDetail>()
			.First(m => m.IsDel == "0" && m.ASNDetailNo == bind.ASNDetailNo && m.PalletNo == model.PalletNo && m.LotNo == bind.LotNo);
			var sdId1 = 0;
			if (sd1 != null)
			{
			sdId1 = sd1.Id;
			// 库存已存在更新数据
			sd1.Qty = bind.Qty;
			sd1.CompleteTime = comTime;
			sd1.UpdateUser = userId;
			sd1.UpdateTime = comTime;

			Db.Updateable(sd1).ExecuteCommand(); //修改质检信息
			}
			else
			{
			string inspectStatusStr = "0";
			if (sku.IsInspect == "1")
			{
			inspectStatusStr = "1";
			}

			// 库存不存在插入数据
			sd1 = new DataStockDetail()
			{
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			SupplierLot = bind.SupplierLot,
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			InspectQty = 0,
			ASNNo = bind.ASNNo,
			ASNDetailNo = bind.ASNDetailNo,
			WareHouseNo = "",//所属仓库
			RoadwayNo = "",//所属巷道
			AreaNo = "",//所属区域
			LocatNo = "",//储位地址
			PalletNo = bind.PalletNo,
			PalletNo2 = bind.PalletNo2,
			PalletNo3 = bind.PalletNo3,
			PalletTags = tags,
			CompleteTime = comTime,
			ProductionTime = bind.ProductionTime,
			ExpirationTime = bind.ExpirationTime,
			Status = "0",
			InspectMark = bind.InspectMark,
			InspectStatus = inspectStatusStr,
			BitPalletMark = bind.BitPalletMark,
			PackagNo = detail.PackagNo, //liudl 由sku的包装编号变为入库单明细的包装编码
			IsBale = bind.IsBale,
			IsBelt = bind.IsBelt,

			IsDel = "0",
			CreateUser = 0,
			CreateTime = comTime
			};

			//维护库存明细货主/供应商信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			sd1.OwnerNo = notice.CustomerNo;//货主编码
			sd1.OwnerName = notice.CustomerName;//货主名称
			}
			else if (notice.Type == "1" \|\| notice.Type == "5")//1:采购入库,2:其它入库
			{
			sd1.SupplierNo = notice.CustomerNo;//供应商编码
			sd1.SupplierName = notice.CustomerName;//供应商名称
			}
			if (quality != null)
			{
			//修改合格不合格数量
			if (quality.IsQualified == "1") //合格
			{
			//增加合格数量
			quality.PassQty += bind.Qty;
			sd1.InspectStatus = "1";
			}
			else if (quality.IsQualified == "0") //不合格
			{
			//增加不合格数量
			quality.FailQty += bind.Qty;
			sd1.InspectStatus = "2";
			}
			Db.Updateable(quality).ExecuteCommand(); //修改质检信息
			}
			//添加库存明细
			sdId1 = Db.Insertable(sd1).ExecuteReturnIdentity();
			}
			#endregion



			// 更改箱支关系表

			var isSample = "0";//是否取样
			var sampleQty = 0m;//取样数量


			//if (bind.FullQty < bind.Qty && isTextTable == 0)
			if (bind.FullQty < bind.Qty)
			{
			throw new Exception("托盘绑定数量已超出该物料包装数量");
			}

			if (bind.FullQty == bind.Qty)
			{
			bind.BitPalletMark = "0";
			sd1.BitPalletMark = "0";
			}
			//if (bind.Qty > pNum && isTextTable == 0)
			if (bind.Qty > pNum)
			{
			throw new Exception($"绑定失败，{bind.PalletNo}托盘绑定数量大于该物品托盘包装数量！");
			}

			if (isSample == "1")
			{
			bind.InspectMark = "1";
			bind.SamplingQty = bind.SamplingQty == null ? sampleQty : bind.SamplingQty + sampleQty;
			}
			Db.Updateable(bind).Where(m => m.Id == bindId).ExecuteCommand();

			#region 入库单及明细
			decimal addQty = model.SkuQty;

			detail.FactQty += addQty;//已组数量
			detail.CompleteQty += addQty;//完成数量
			if (isSample == "1") //后期业务开发时接口传值改为判断是否取样
			{
			detail.IsSampling = "1";
			}
			detail.Status = "1";//0：等待执行 1：正在执行 2：执行完成
			if (detail.CompleteQty >= detail.Qty)
			{
			detail.Status = "2";
			detail.CompleteTime = comTime;
			}
			detail.UpdateUser = userId;
			detail.UpdateTime = comTime;
			//更新入库单明细
			Db.Updateable(detail).ExecuteCommand();

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

			#region 库存明细
			sd1.Qty = bind.Qty;
			//更改库存明细数量
			Db.Updateable(sd1).Where(m => m.Id == sdId1).ExecuteCommand();
			#endregion

			#region 库存
			var dataStock = Db.Queryable<DataStock>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo);
			if (dataStock != null)
			{
			dataStock.Qty += model.SkuQty;


			if (bind.InspectMark == "1")
			{
			dataStock.IsSampling = bind.InspectMark;
			}
			Db.Updateable(dataStock).ExecuteCommand();
			}
			else
			{
			var stock = new DataStock()
			{
			SkuNo = sku.SkuNo,
			SkuName = sku.SkuName,
			Standard = sku.Standard,
			LotNo = bind.LotNo,
			LotText = bind.LotText,
			Qty = bind.Qty,
			LockQty = 0,
			FrozenQty = 0,
			IsSampling = bind.InspectMark,
			IsDel = "0",
			CreateUser = userId,
			CreateTime = comTime
			};
			//维护库存货主信息
			if (notice.Type == "0" \|\| notice.Type == "2" \|\| notice.Type == "4" \|\| notice.Type == "6" \|\| notice.Type == "7")//0:成品入库，2:中间品入库,4:车间余料入库,6:代储入库,7:寄存入库
			{
			stock.OwnerNo = notice.CustomerNo;//货主编码
			stock.OwnerName = notice.CustomerName;//货主名称
			}
			Db.Insertable(stock).ExecuteCommand();
			}
			#endregion

			#region 质检请验
			if ((notice.Type == "1" \|\| notice.Type == "4" \|\| notice.Type == "5") && sku.IsInspect != "1")
			{
			var qualityRequest = Db.Queryable<BllQualityInspectionRequest>().First(m => m.IsDel == "0" && m.SkuNo == sku.SkuNo && m.LotNo == bind.LotNo && m.SupplierLot == bind.SupplierLot);
			if (qualityRequest == null)
			{
			string qcNo = new Common().GetMaxNo("QC");
			qualityRequest = new BllQualityInspectionRequest();
			qualityRequest.QcNo = qcNo;
			qualityRequest.Status = "0";
			qualityRequest.SkuNo = sku.SkuNo;
			qualityRequest.SkuName = sku.SkuName;
			qualityRequest.LotNo = bind.LotNo;
			qualityRequest.SupplierLot = bind.SupplierLot;
			qualityRequest.Qty = detail.Qty;
			qualityRequest.SamplingQty = 0;
			qualityRequest.ASNNo = detail.ASNNo;
			qualityRequest.CreateUser = userId;
			qualityRequest.CreateTime = comTime;
			//添加质检请验单
			Db.Insertable(qualityRequest).ExecuteCommand();
			}
			}
			#endregion

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


			#endregion

			@@ -5343,7 +6393,7 @@
			//修改库存明细信息
			foreach (var item in stockDetail)
			{
			item.Status = "0"; // 状态更改为待分配
			//item.Status = "0"; // 状态更改为待分配
			item.WareHouseNo = storageLocat.WareHouseNo; // 所属仓库
			item.RoadwayNo = storageLocat.RoadwayNo; // 所属巷道
			item.AreaNo = storageLocat.AreaNo; // 所属区域
			@@ -5353,16 +6403,7 @@
			//修改库存明细信息
			Db.Updateable(item).ExecuteCommand();
			}
			//获取拣货信息
			var alotr = Db.Queryable<BllExportAllot>().First(a => a.IsDel == "0" && a.PalletNo == model.PalletNo && a.Status == "4");
			if (alotr != null)
			{
			alotr.Status = "5"; //5 已完成
			alotr.UpdateUser = model.CreateUser; //修改人
			alotr.UpdateTime = serverTime; //修改时间
			//修改拣货信息
			Db.Updateable(alotr).ExecuteCommand();
			}

			#region 任务及组托信息
			//创建任务信息
			var taskNo = new Common().GetMaxNo("TK");
			@@ -5375,14 +6416,14 @@
			SendDate = DateTime.Now, //发送时间
			BackDate = DateTime.Now, //返回时间
			StartLocat = "",//起始位置
			EndLocat = "平库",//目标位置
			EndLocat = model.LocatNo,//目标位置
			PalletNo = model.PalletNo,//托盘码
			IsSend = 0,//是否可再次下发
			IsCancel = 0,//是否可取消
			IsFinish = 0,//是否可完成
			Type = "0",//任务类型 0 入库任务 1 出库任务 2 移库任务
			Status = "2",//任务状态0：等待执行1正在执行2执行完成
			OrderType = "3",//0 入库单 1 出库单 2 盘点单 3 移库单
			OrderType = "0",//0 入库单 1 出库单 2 盘点单 3 移库单
			Msg = "平库的入库任务",
			};
			Db.Insertable(exTask).ExecuteCommand();
			@@ -5407,15 +6448,15 @@
			var upShelf = new BllPalletUpShelf()
			{
			TaskNo = exTask.TaskNo,
			TraceNo = bindInfo.ASNNo,
			PalletNo = bindInfo.PalletNo,
			TraceNo = bindInfo== null? "": bindInfo.ASNNo,
			PalletNo = model.PalletNo,
			SkuNo = palletupinfo.SkuNo,
			SkuName = palletupinfo.SkuName,
			LotNo = palletupinfo.LotNo,
			Status = "2",
			LocatNo = model.LocatNo,
			WareHouseNo = bindInfo.WareHouseNo,
			RoadwayNo = bindInfo.RoadwayNo,
			WareHouseNo = storageLocat.WareHouseNo,
			RoadwayNo = storageLocat.RoadwayNo,
			AreaNo = storageLocat.AreaNo,

			CreateUser = 0,
			@@ -5765,5 +6806,359 @@

			#endregion

			#region 线边标签
			/// <summary>
			/// 根据物料编码、名称获取物料信息
			/// </summary>
			/// <param name="model">编码名称</param>
			/// <returns>物料详细信息</returns>
			public MaterialsDto GetSkuInfo(GetMaterialsVm model)
			{
			try
			{
			if (string.IsNullOrEmpty(model.SkuNo) && string.IsNullOrEmpty(model.SkuName))
			{
			throw new Exception("请输入物料编码或物料名称!");
			}

			var skuModels = Db.Queryable<SysMaterials>().Where(m => (m.SkuNo == model.SkuNo \|\| m.SkuName == model.SkuName) && m.IsDel == "0").Select< MaterialsDto>().ToList();
			if (skuModels.Count <= 0)
			{
			throw new Exception("物料不存在！");
			}

			return skuModels.First();
			}
			catch (Exception ex)
			{
			throw ex;
			}
			}

			/// <summary>
			/// 生成条码标签
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			/// <exception cref="Exception"></exception>
			public List<BllBoxInfo> AddLabels(LabelsVm model)
			{
			try
			{
			if (decimal.TryParse(model.SkuNum, out decimal skuQty))
			{
			if (skuQty <= 0)
			{
			throw new Exception("箱内数量不能小于等于0");
			}
			}
			else
			{
			throw new Exception("箱内数量请输入数字！");
			}

			// 验证物料信息是否存在
			var skuModels = Db.Queryable<SysMaterials>().Where(m => (m.SkuNo == model.SkuNo \|\| m.SkuName == model.SkuName) && m.IsDel == "0").Select<MaterialsDto>().ToList();
			if (skuModels.Count <= 0)
			{
			throw new Exception("物料不存在！");
			}


			#region
			var skuModel = skuModels.First();
			var pack = Db.Queryable<SysPackag>().First(m => m.IsDel == "0" && m.PackagNo == skuModel.PackagNo);
			if (pack == null)
			{
			throw new Exception("未查询到当前物料的包装信息");
			}

			var packStr = "";
			if (!string.IsNullOrWhiteSpace(pack.L1Name))
			{
			packStr += pack.L1Num + "/" + pack.L1Name;
			}
			if (!string.IsNullOrWhiteSpace(pack.L2Name))
			{
			packStr += "-" + pack.L2Num + "/" + pack.L2Name;
			}
			if (!string.IsNullOrWhiteSpace(pack.L3Name))
			{
			packStr += "-" + pack.L3Num + "/" + pack.L3Name;
			}
			if (!string.IsNullOrWhiteSpace(pack.L4Name))
			{
			packStr += "-" + pack.L4Num + "/" + pack.L4Name;
			}
			if (!string.IsNullOrWhiteSpace(pack.L5Name))
			{
			packStr += "-" + pack.L5Num + "/" + pack.L5Name;
			}
			#endregion

			#region 包装查询

			var bNum = 0;//箱物品数量
			var zNum = 0;//支物品数量
			var packLevel = 0;

			if (pack.L2Num.HasValue)
			{
			if (pack.L2Name != "托")
			{
			packLevel = 1;//JC34项目只有一级标签
			bNum = Convert.ToInt32(pack.L2Num);
			}
			}
			if (pack.L1Num.HasValue)
			{
			if (packLevel == 0)
			{
			packLevel = 1;
			bNum = Convert.ToInt32(pack.L1Num);
			}
			zNum = Convert.ToInt32(pack.L1Num);
			}

			if (packLevel < 1)//包装等级小于1，按照1级标签打印
			{
			throw new Exception("包装信息有误，小于一级");
			}

			if (skuQty > bNum * 5)
			{
			throw new Exception("箱内数量大于包装5倍，不可打印");
			}
			#endregion
			var modelList = new List<BllBoxInfo>();
			var label = Db.Queryable<BllBoxInfo>().Where(m => m.LotNo == model.LotNo && m.SkuNo == model.SkuNo && m.IsDel == "0").ToList();

			Db.BeginTran();
			if (packLevel == 1)
			{
			#region 一级包装
			int labelNum = 1;
			labelNum = int.Parse(Math.Ceiling(skuQty / bNum).ToString());//标签数量


			#region 获取/生成批次号
			string maxLotNoStr = ""; //批次号
			string maxBoxCode = ""; //箱码号

			maxLotNoStr = model.LotNo;
			maxBoxCode = label.Where(m => m.LotNo == maxLotNoStr).Max(a => a.BoxNo);
			#endregion

			for (int i = 1; i <= labelNum; i++)
			{
			decimal boxQty = 0;
			if (i == labelNum)
			{
			// 最后一个条码
			var s = bNum * (i - 1);
			if (bNum > skuQty - s)
			{
			boxQty = skuQty - s;// 数量
			}
			else
			{
			boxQty = bNum;// 数量
			}
			}
			else
			{
			boxQty = bNum; // 数量
			}

			//获取箱码
			if (string.IsNullOrWhiteSpace(maxBoxCode))
			{
			var str = "B" + maxLotNoStr + "000001"; //批号+ 流水 B 230201 0001 000001
			maxBoxCode = str;
			}
			else
			{
			maxBoxCode = maxBoxCode.Substring(0, maxBoxCode.Length - 6) + (int.Parse(maxBoxCode.Substring(maxBoxCode.Length - 6, 6)) + 1).ToString().PadLeft(6, '0');
			}

			// 将条码保存到原料条码表
			var labelModel = new BllBoxInfo()
			{
			BoxNo = maxBoxCode,
			Qty = boxQty,
			FullQty = bNum,
			Status = "0",
			SkuNo = model.SkuNo,
			SkuName = model.SkuName,
			LotNo = maxLotNoStr,
			Standard = skuModel.Standard,
			PackageStandard = packStr,
			InspectMark = "0",
			BitBoxMark = bNum > boxQty ? "1" : "0",
			InspectStatus = "0",

			ProductionTime = DateTime.Parse(model.TimeFrom),
			StoreTime = DateTime.Parse(model.TimeEnd),
			ExpirationTime = DateTime.Parse(model.TimeEnd),

			Origin = "WMS生成",
			CreateUser = (int)model.userId,
			CreateTime = DateTime.Now,
			};

			Db.Insertable(labelModel).ExecuteCommand();
			modelList.Add(labelModel);
			}

			#endregion
			}
			else //(packLevel == 2)
			{
			#region 二级包装

			if (skuQty > bNum * 5)
			{
			throw new Exception("箱内数量大于包装5倍，不可打印");
			}

			var qty2 = skuQty;
			int labelNum2 = 1; //生产箱条码数量

			labelNum2 = int.Parse(Math.Ceiling(qty2 / bNum).ToString());

			var ss = bNum / zNum; //每箱支标签数量
			var labelNumZ2 = Math.Ceiling((decimal)ss);

			#region 获取/生成批次号

			string maxCodestr2 = ""; //批次
			string maxboxcode2 = ""; //箱码
			string maxboxcode3 = ""; //支码

			maxCodestr2 = model.LotNo;
			maxboxcode2 = label.Where(m => m.LotNo == maxCodestr2).Max(a => a.BoxNo);
			maxboxcode3 = label.Where(m => m.LotNo == maxCodestr2).Max(a => a.BoxNo3);//支号
			#endregion

			for (int i = 1; i <= labelNum2; i++)//箱码标签
			{
			//箱内数量
			decimal boxQty = 0;
			if (i == labelNum2)
			{
			// 最后一个条码
			var s = bNum * (i - 1);
			if (bNum > qty2 - s)
			{
			boxQty = qty2 - s;// 数量
			}
			else
			{
			boxQty = bNum;// 数量
			}
			}
			else
			{
			boxQty = bNum; // 数量
			}

			//获取箱码
			if (string.IsNullOrWhiteSpace(maxboxcode2))
			{
			maxboxcode2 = "B" + maxCodestr2 + "000001"; // 箱号批号+第几箱
			}
			else
			{
			maxboxcode2 = maxboxcode2.Substring(0, 11) + (int.Parse(maxboxcode2.Substring(11, 6)) + 1).ToString().PadLeft(6, '0');
			}
			//获取箱内支标签数量
			if (i == labelNum2)
			{
			var isGo2 = false;
			var sl = 0;
			for (int j = 1; j <= labelNumZ2; j++)
			{
			if (isGo2)
			{
			break;
			}
			var s = bNum * (i - 1);
			var s2 = zNum * (j - 1);
			if (zNum >= qty2 - s - s2)
			{
			isGo2 = true;
			}
			sl++;
			}
			labelNumZ2 = sl;
			}

			for (int j = 1; j <= labelNumZ2; j++)//最小单位标签
			{

			decimal d = zNum;
			if (i == labelNum2)
			{
			var s = bNum * (i - 1);
			var s2 = zNum * (j - 1);
			if (zNum >= qty2 - s - s2)
			{
			d = qty2 - s - s2; // 数量
			}
			}

			if (string.IsNullOrWhiteSpace(maxboxcode3))
			{
			maxboxcode3 = "Z" + maxCodestr2 + "0001"; // 支号批号+第几箱
			}
			else
			{
			maxboxcode3 = maxboxcode3.Substring(0, 11) + (int.Parse(maxboxcode3.Substring(11, 4)) + 1).ToString().PadLeft(4, '0');
			}

			// 将条码保存到原料条码表
			var labelModel = new BllBoxInfo()
			{
			BoxNo = maxboxcode2,
			BoxNo3 = maxboxcode3,
			Qty = d,
			FullQty = bNum,
			Status = "0",
			SkuNo = model.SkuNo,
			SkuName = skuModel.SkuName,
			LotNo = maxCodestr2,
			Standard = skuModel.Standard,
			PackageStandard = packStr,
			InspectMark = "0",
			BitBoxMark = bNum > boxQty ? "1" : "0",
			InspectStatus = "0",

			ProductionTime = DateTime.Parse(model.TimeFrom),
			StoreTime = DateTime.Parse(model.TimeEnd),
			ExpirationTime = DateTime.Parse(model.TimeEnd),

			Origin = "WMS生成",
			CreateUser = (int)model.userId,
			CreateTime = DateTime.Now,
			};

			Db.Insertable(labelModel).ExecuteCommand();
			modelList.Add(labelModel);
			}
			}
			#endregion
			}
			Db.CommitTran();

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

			}
			}