JC24WMS.git - Gitblit

			@@ -2,6 +2,8 @@
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using Model.ModelDto.DataDto;
			using SqlSugar;
			using WMS.Entity.Context;
			using WMS.Entity.DataEntity;
			using WMS.Entity.SysEntity;
			@@ -52,16 +54,13 @@
			}
			#endregion
			decimal qty = 0; //分配的总数量
			var ztNum = needQty / fullPalletQty;//需要整托数
			var list = GetDataListOrderByDept(palletList);

			var zps = palletList.Where(s => s.Qty >= fullPalletQty).ToList();//整托
			var sps = palletList.Where(s => s.Qty < fullPalletQty).ToList();//散托(有可能是被锁定了数量的)

			if (allotSet == 0)//优先零箱（出完零箱出整箱）
			if (fullPalletQty == 0)//无包装物料分配
			{
			//已分配的托盘 key：库存明细ID，value：分配的数量
			var st = sps.OrderBy(s => s.ExpirationTime).ThenBy(s => s.Qty - s.LockQty - s.FrozenQty).ToList();//所有未使用的托盘（未被分配的）
			//散托
			var st = list.OrderBy(s => s.ExpirationTime).ThenBy(s => s.Qty - s.LockQty - s.FrozenQty).ToList();//所有未使用的托盘（未被分配的）
			//
			foreach (var s in st)
			{
			var detailQty = decimal.Parse((s.Qty - s.LockQty - s.FrozenQty).ToString());
			@@ -80,109 +79,144 @@
			break;
			}
			}

			//不够//取整托
			if (qty < needQty)
			{
			var zt = zps.OrderBy(s => s.ExpirationTime).ToList();//所有未使用的托盘（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);

			if (qty >= needQty)
			{
			break;
			}
			}


			}

			}
			else if (allotSet == 1)//优先整托（分配合适的整托数量）
			else
			{
			//先判断需要的数量
			//判断需要整托的数量是否大于0
			//是：先出整托，剩余的数量从托盘上数量最少的出、（如果找合适的数量、可能小数量很小概率会被分配到、有先进先出日期卡着）
			//否：数量从托盘上数量最少的出、（如果找合适的数量、可能小数量很小概率会被分配到、有先进先出日期卡着）
			//
			//取整托
			if (ztNum > 0)
			{
			var zt = zps.OrderBy(s => s.ExpirationTime).ToList();//所有未使用的托盘（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}
			//从整托和和散托中查找合适的(从数量少的先出往)
			if (qty < needQty)
			{
			var sIds = stockQtyDic.Select(s => s.Key).ToList();
			var zt = sps.Where(s => !sIds.Contains(s.Id)).OrderBy(s => s.ExpirationTime).ThenBy(m => m.Qty - m.LockQty - m.FrozenQty).ToList();//所有未使用（未被分配的）
			var ztNum = needQty / fullPalletQty;//需要整托数

			foreach (var ss in zt)


			var zps = list.Where(s => s.Qty >= fullPalletQty).ToList();//整托
			var sps = list.Where(s => s.Qty < fullPalletQty).ToList();//散托(有可能是被锁定了数量的)

			if (allotSet == 0)//优先零箱（出完零箱出整箱）
			{
			//已分配的托盘 key：库存明细ID，value：分配的数量
			var st = sps.OrderBy(s => s.ExpirationTime).ThenBy(s => s.Qty - s.LockQty - s.FrozenQty).ToList();//所有未使用的托盘（未被分配的）
			//散托
			foreach (var s in st)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			var detailQty = decimal.Parse((s.Qty - s.LockQty - s.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			SaveDic(stockQtyDic, s.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}
			//找完散托还不够再找整托
			if (qty < needQty)
			{
			var sIds = stockQtyDic.Select(s => s.Key).ToList();
			var zt = zps.Where(s => !sIds.Contains(s.Id)).OrderBy(s => s.ExpirationTime).ThenBy(m => m.Qty - m.LockQty - m.FrozenQty).ToList();//所有未使用（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}

			qty += detailQty;
			SaveDic(stockQtyDic, s.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}

			//不够//取整托
			if (qty < needQty)
			{
			var zt = zps.OrderBy(s => s.ExpirationTime).ToList();//所有未使用的托盘（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);

			if (qty >= needQty)
			{
			break;
			}
			}


			}

			}
			else if (allotSet == 1)//优先整托（分配合适的整托数量）
			{
			//先判断需要的数量
			//判断需要整托的数量是否大于0
			//是：先出整托，剩余的数量从托盘上数量最少的出、（如果找合适的数量、可能小数量很小概率会被分配到、有先进先出日期卡着）
			//否：数量从托盘上数量最少的出、（如果找合适的数量、可能小数量很小概率会被分配到、有先进先出日期卡着）
			//
			//取整托
			if (ztNum > 0)
			{
			var zt = zps.OrderBy(s => s.ExpirationTime).ToList();//所有未使用的托盘（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}
			//从整托和和散托中查找合适的(从数量少的先出往)
			if (qty < needQty)
			{
			var sIds = stockQtyDic.Select(s => s.Key).ToList();
			var zt = sps.Where(s => !sIds.Contains(s.Id)).OrderBy(s => s.ExpirationTime).ThenBy(m => m.Qty - m.LockQty - m.FrozenQty).ToList();//所有未使用（未被分配的）

			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}
			//找完散托还不够再找整托
			if (qty < needQty)
			{
			var sIds = stockQtyDic.Select(s => s.Key).ToList();
			var zt = zps.Where(s => !sIds.Contains(s.Id)).OrderBy(s => s.ExpirationTime).ThenBy(m => m.Qty - m.LockQty - m.FrozenQty).ToList();//所有未使用（未被分配的）
			foreach (var ss in zt)
			{
			var detailQty = decimal.Parse((ss.Qty - ss.LockQty - ss.FrozenQty).ToString());
			if (needQty - qty < detailQty)
			{
			var num = needQty - qty;
			qty += num;
			SaveDic(stockQtyDic, ss.Id, num);
			break;
			}
			qty += detailQty;
			SaveDic(stockQtyDic, ss.Id, detailQty);
			if (qty >= needQty)
			{
			break;
			}
			}
			}

			}
			}

			if (qty < needQty)
			{
			throw new Exception("库存数量不足");
			@@ -195,6 +229,386 @@
			throw new Exception("分配出库物料失败：" + e.Message);
			}

			}


			/// <summary>
			/// 原辅料取样出库分配库存
			/// </summary>
			/// <param name="palletList">托盘明细</param>
			/// <param name="boxInfoList">箱码明细</param>
			/// <param name="needQty">需求数</param>
			/// <param name="stockQtyDic">托出库物品数</param>
			/// <param name="useBoxQtyDic">托出库物品数</param>
			/// <param name="type">取样类型1：规则取样 2：随机取样</param>
			/// <param name="boxNum">需分配的箱数量随机取样用</param>
			/// <param name="pickNum"></param>
			/// <returns></returns>
			public decimal AllotPalletsQuYang(List<DataStockDetail> palletList, List<DataBoxInfo> boxInfoList, decimal needQty, Dictionary<int, decimal> stockQtyDic, Dictionary<int, decimal> useBoxQtyDic, string type, int boxNum, decimal pickNum)
			{
			try
			{
			decimal? qty = 0;
			var listOrder = boxInfoList.Where(m => m.IsDel == "0").OrderBy(m => m.BoxNo).ThenBy(m => m.Qty).ToList();//根据箱码、数量排序整箱的
			var boxList = listOrder.GroupBy(m => m.BoxNo).Select(m => m.Key).ToList();//分组后的箱码集合
			var boxCount = boxList.Count();//箱数量
			#region 旧分配原则

			//var outInfoCount = 0;
			//var boxStrList = new List<string>();//随机使用箱
			//Dictionary<string, decimal> useInfoQtyDic = new Dictionary<string, decimal>();//使用箱

			//if (type == "1")//规则取样（N<3;3<N<300;300<N）
			//{
			// if (boxCount<=3)//箱子小于3
			// {
			// foreach (var item in boxList)//循环箱子
			// {
			// boxStrList.Add(item);
			// }
			// }
			// else if (boxCount > 3)//箱子小于3
			// {
			// var a = Math.Sqrt(boxCount)+1;//开平方 //规则箱数 √N+1
			// if (boxCount > 300)
			// {
			// a = Math.Sqrt(boxCount) / 2 + 1;//规则箱数 √N/2+1
			// }
			// var b = Math.Floor(a); //取样的箱数

			// var lit = new List<int>();
			// do
			// {
			// byte[] buffer = Guid.NewGuid().ToByteArray();
			// int iSeed = BitConverter.ToInt32(buffer, 0);
			// Random random = new Random(iSeed);
			// var j = random.Next(0, boxCount);
			// if (lit.Contains(j))
			// {
			// continue;
			// }

			// var boxCode = boxList[j];//箱码
			// boxStrList.Add(boxCode);
			// lit.Add(j);

			// } while (lit.Count < b);

			// }
			//}
			//else if(type == "2") //随机取样(一批次出一箱)
			//{
			// if (boxCount < boxNum)
			// {
			// throw new Exception("当前库存整箱数少于输入的取样数");
			// }
			// var lit = new List<int>();
			// do
			// {
			// byte[] buffer = Guid.NewGuid().ToByteArray();
			// int iSeed = BitConverter.ToInt32(buffer, 0);
			// Random random = new Random(iSeed);
			// var j = random.Next(0, boxCount);
			// if (lit.Contains(j))
			// {
			// continue;
			// }

			// var boxCode = boxList[j];//箱码
			// boxStrList.Add(boxCode);
			// lit.Add(j);

			// } while (lit.Count < boxNum);
			//}
			//else
			//{
			// throw new Exception("请选择取样规则");
			//}
			//foreach (var item in boxStrList)//循环箱子
			//{
			// var box = listOrder.Where(m => m.BoxCode == item).ToList();
			// var infoCount = box.Count;//箱内支数量
			// if (infoCount <= 3) //支数量<=3
			// {
			// outInfoCount += infoCount;
			// SaveDic(useInfoQtyDic, item, infoCount);
			// }
			// else if (infoCount > 3)//箱内数量 > 3 且 <=300
			// {
			// //规则取样支数 √N+1
			// var c = Math.Sqrt(infoCount) + 1;//开平方

			// if (infoCount > 300) //箱内数量 > 300
			// {
			// //规则箱数 √N/2+1
			// c = Math.Sqrt(infoCount) / 2 + 1;
			// }
			// var d = Math.Floor(c); //取样的支数量

			// outInfoCount += (int)d;
			// SaveDic(useInfoQtyDic, item, (decimal)d);
			// }
			//}

			//var pingJunNum = needQty / outInfoCount;//平均每支取的数量
			//foreach (var item in useInfoQtyDic)
			//{
			// var box = listOrder.Where(m => m.BoxCode == item.Key).ToList();
			// var infoCount = box.Count;//箱内支数量
			// if (infoCount <= 3) //支数量<=3
			// {
			// foreach (var item2 in box)
			// {
			// if (pingJunNum >= item2.Qty)
			// {
			// throw new Exception("平均需取样数量大于等于箱支内数量");
			// }
			// qty += pingJunNum;
			// var tray = palletList.First(m => m.Id == item2.TrayId);

			// SaveDic(stockQtyDic, tray.Id, pingJunNum);

			// SaveDic(useBoxQtyDic, item2.Id, pingJunNum);
			// }
			// }
			// else if (infoCount > 3)//箱内数量 > 3 且 <=300
			// {
			// var e = item.Value; //取样的支数量

			// var lit2 = new List<int>();

			// do
			// {
			// byte[] buffer = Guid.NewGuid().ToByteArray();
			// int iSeed = BitConverter.ToInt32(buffer, 0);
			// Random random = new Random(iSeed);
			// var j = random.Next(0, infoCount);//随机箱内支码

			// if (lit2.Contains(j))
			// {
			// continue;
			// }

			// var info = box[j];
			// if (pingJunNum >= info.Qty)
			// {
			// throw new Exception("平均需取样数量大于等于箱支内数量");
			// }

			// qty += pingJunNum;
			// var tray = palletList.First(m => m.Id == info.TrayId);

			// SaveDic(stockQtyDic, tray.Id, pingJunNum);
			// SaveDic(useBoxQtyDic, info.Id, pingJunNum);
			// lit2.Add(j);


			// } while (lit2.Count < e);
			// }
			//}

			#endregion

			var outInfoCount = 0;
			var boxStrList = new List<string>();//随机使用箱
			Dictionary<string, int> useInfoQtyDic = new Dictionary<string, int>();//使用箱及每箱出多少支


			if (type == "1")//规则取样（N<3;3<N<300;300<N）
			{
			if (boxCount <= 3)//箱子小于3
			{
			foreach (var item in boxList)//循环箱子
			{
			boxStrList.Add(item);
			}
			}
			else if (boxCount > 3)//箱子小于3
			{
			var a = Math.Sqrt(boxCount) + 1;//开平方 //规则箱数 √N+1
			if (boxCount > 300)
			{
			a = Math.Sqrt(boxCount) / 2 + 1;//规则箱数 √N/2+1
			}
			var b = Math.Floor(a); //取样的箱数

			var lit = new List<int>();
			do
			{
			byte[] buffer = Guid.NewGuid().ToByteArray();
			int iSeed = BitConverter.ToInt32(buffer, 0);
			Random random = new Random(iSeed);
			var j = random.Next(0, boxCount);
			if (lit.Contains(j))
			{
			continue;
			}

			var boxCode = boxList[j];//箱码
			boxStrList.Add(boxCode);
			lit.Add(j);

			} while (lit.Count < b);

			}
			var zhi = listOrder.Count();
			if (zhi <= 3) //支数量<=3
			{
			outInfoCount += zhi;
			}
			else if (zhi > 3)//箱内数量 > 3 且 <=300
			{
			//规则取样支数 √N+1
			var c = Math.Sqrt(zhi) + 1;//开平方

			if (zhi > 300) //箱内数量 > 300
			{
			//规则箱数 √N/2+1
			c = Math.Sqrt(zhi) / 2 + 1;
			}
			var d = Math.Floor(c); //取样的支数量

			outInfoCount += (int)d;
			}
			}
			else if (type == "2") //随机取样(一批次出一箱)
			{
			if (boxCount < boxNum)
			{
			throw new Exception("当前库存整箱数少于输入的取样数");
			}
			var lit = new List<int>();
			do
			{
			byte[] buffer = Guid.NewGuid().ToByteArray();
			int iSeed = BitConverter.ToInt32(buffer, 0);
			Random random = new Random(iSeed);
			var j = random.Next(0, boxCount);
			if (lit.Contains(j))
			{
			continue;
			}

			var boxCode = boxList[j];//箱码
			boxStrList.Add(boxCode);
			lit.Add(j);

			} while (lit.Count < boxNum);

			var zhi = listOrder.Count(m => boxStrList.Contains(m.BoxNo));
			if (zhi <= 3) //支数量<=3
			{
			outInfoCount += zhi;
			}
			else if (zhi > 3)//箱内数量 > 3 且 <=300
			{
			//规则取样支数 √N+1
			var c = Math.Sqrt(zhi) + 1;//开平方

			if (zhi > 300) //箱内数量 > 300
			{
			//规则箱数 √N/2+1
			c = Math.Sqrt(zhi) / 2 + 1;
			}
			var d = Math.Floor(c); //取样的支数量

			outInfoCount += (int)d;
			}
			}
			else
			{
			throw new Exception("请选择取样规则");
			}

			var zhiCount = outInfoCount;
			var xiangCount = boxStrList.Count; //随机出的箱数量
			for (int i = 1; i <= boxStrList.Count; i++)
			{
			decimal t = zhiCount / xiangCount;
			var t2 = zhiCount % xiangCount;
			var t3 = 5 / 2;
			var t4 = 5 % 2;
			if (t2 > 0)
			{
			t += 1;
			}
			var q = (int)t;//箱内出多少支
			var infoCount = listOrder.Count(m => m.BoxNo == boxStrList[i - 1]);
			if (q > infoCount)
			{
			throw new Exception("箱内支数小于要分配的支数");
			}
			zhiCount -= q;
			xiangCount -= 1;
			SaveDic2(useInfoQtyDic, boxStrList[i - 1], q);
			}


			var pingJunNum = needQty / outInfoCount;// / pickNum;平均每支取的数量

			foreach (var item in useInfoQtyDic)
			{
			var box = listOrder.Where(m => m.BoxNo == item.Key).ToList();
			var infoCount = box.Count;//箱内支数量
			if (infoCount == item.Value) //支数量<=3
			{
			foreach (var item2 in box)
			{
			if (pingJunNum > item2.Qty)
			{
			throw new Exception("平均需取样数量大于等于箱支内数量");
			}
			qty += pingJunNum;
			var tray = palletList.First(m => m.Id == item2.Id);

			SaveDic(stockQtyDic, tray.Id, pingJunNum);

			SaveDic(useBoxQtyDic, item2.Id, pingJunNum);
			}
			}
			else
			{
			var e = item.Value; //取样的支数量

			var lit2 = new List<int>();

			do
			{
			byte[] buffer = Guid.NewGuid().ToByteArray();
			int iSeed = BitConverter.ToInt32(buffer, 0);
			Random random = new Random(iSeed);
			var j = random.Next(0, infoCount);//随机箱内支码

			if (lit2.Contains(j))
			{
			continue;
			}

			var info = box[j];
			if (pingJunNum > info.Qty)
			{
			throw new Exception("平均需取样数量大于等于箱支内数量");
			}

			qty += pingJunNum;
			var tray = palletList.First(m => m.Id == info.Id);

			SaveDic(stockQtyDic, tray.Id, pingJunNum);
			SaveDic(useBoxQtyDic, info.Id, pingJunNum);
			lit2.Add(j);


			} while (lit2.Count < e);
			}
			}


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


			@@ -216,8 +630,21 @@
			}
			}

			private void SaveDic2(Dictionary<string, int> dic, string key, int v)
			{
			if (dic.ContainsKey(key))
			{
			dic[key] += v;
			}
			else
			{
			dic.Add(key, v);
			}
			}

			//--------------------------------------------------------------------------------------------------------------

			#region MyRegion

			///// <summary>
			///// 获得背包承重w，装货物o，从第k件向后考虑，得到的最大价值
			@@ -260,5 +687,133 @@
			// return a > b ? a : b;
			//}

			#endregion


			private List<StockDetailDto> GetDataListOrderByDept(List<DataStockDetail> palletList)
			{
			try
			{
			var Db = DataContext.Db;
			var data = new List<StockDetailDto>();

			var list = palletList.Select(m => new StockDetailDto()
			{
			Id = m.Id,
			LotNo = m.LotNo,
			LotText = m.LotText,
			SupplierLot = m.SupplierLot,
			OwnerNo = m.OwnerNo,
			OwnerName = m.OwnerName,
			SupplierNo = m.SupplierNo,
			SupplierName = m.SupplierName,
			SkuNo = m.SkuNo,
			SkuName = m.SkuName,
			Standard = m.Standard,
			Qty = m.Qty,
			LockQty = m.LockQty,
			FrozenQty = m.FrozenQty,
			InspectQty = m.InspectQty,
			ASNNo = m.ASNNo,
			ASNDetailNo = m.ASNDetailNo,
			WareHouseNo = m.WareHouseNo,
			RoadwayNo = m.RoadwayNo,
			AreaNo = m.AreaNo,
			LocatNo = m.LocatNo,
			PalletNo = m.PalletNo,
			PalletNo2 = m.PalletNo2,
			PalletNo3 = m.PalletNo3,
			CompleteTime = m.CompleteTime,
			ProductionTime = m.ProductionTime,
			ExpirationTime = m.ExpirationTime,
			Status = m.Status,
			InspectMark = m.InspectMark,
			BitPalletMark = m.BitPalletMark,
			InspectStatus = m.InspectStatus,
			InspectTime = m.InspectTime,
			PackagNo = m.PackagNo,
			IsBale = m.IsBale,
			IsBelt = m.IsBelt,
			Demo = m.Demo,

			}).ToList();
			//库外托盘
			var detail1 = list.Where(m => string.IsNullOrWhiteSpace(m.LocatNo)).ToList();
			//平库内托盘
			var detail2 = list.Where(m => m.WareHouseNo == "W02").ToList();
			//立库内托盘
			var detail3 = list.Where(m => m.WareHouseNo == "W01").ToList();

			foreach (var item in detail2)
			{
			var dept = item.LocatNo.Substring(5,2);

			item.Dept = int.Parse(dept);
			}
			foreach (var item in detail3)
			{
			var dept = item.LocatNo.Substring(6, 2);

			item.Dept = int.Parse(dept);
			}
			//平库
			var locate1 = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W02").ToList();
			var data2 = new List<StockDetailDto>();
			foreach (var liku in detail2.OrderBy(m => m.Dept).ToList())
			{
			if (data2.Contains(liku))
			{
			continue;
			}
			data2.Add(liku);
			var currentLocate = locate1.First(m => m.LocatNo == liku.LocatNo);
			var locateAfter = locate1.Where(m => m.AreaNo == currentLocate.AreaNo && m.Layer == currentLocate.Layer && m.Row == currentLocate.Row && int.Parse(m.Depth) < int.Parse(currentLocate.Depth)).OrderBy(m => m.Depth).ToList();
			foreach (var locat in locateAfter)
			{
			if (detail3.Any(m => m.LocatNo == locat.LocatNo))
			{
			data2.Add(detail3.First(m => m.LocatNo == locat.LocatNo));
			}

			}
			}

			//立库
			var locate2 = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W01").ToList();

			var data3 = new List<StockDetailDto>();
			foreach (var liku in detail3.OrderBy(m => m.Dept).ToList())
			{
			if (data3.Contains(liku))
			{
			continue;
			}
			data3.Add(liku);
			var currentLocate = locate2.First(m => m.LocatNo == liku.LocatNo);
			var locateAfter = locate2.Where(m => m.Column == currentLocate.Column && m.Layer == currentLocate.Layer && m.Row == currentLocate.Row && int.Parse(m.Depth) < int.Parse(currentLocate.Depth)).OrderBy(m => m.Depth).ToList();
			foreach (var locat in locateAfter)
			{
			if (detail3.Any(m=>m.LocatNo == locat.LocatNo))
			{
			data3.Add(detail3.First(m=>m.LocatNo == locat.LocatNo));
			}

			}
			}


			data.AddRange(detail1);
			data.AddRange(data2);
			data.AddRange(data3);

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


			}
			}