using System;
|
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;
|
|
namespace WMS.BLL.Logic
|
{
|
public class AllotSku
|
{
|
/// <summary>
|
/// 分配货物
|
/// </summary>
|
/// <param name="palletList">库存明细集合</param>
|
/// <param name="needQty">需要分配的数量</param>
|
/// <param name="fullPalletQty">满托数量</param>
|
/// <param name="fullBoxQty">满箱数量</param>
|
/// <param name="stockQtyDic">托出库物品数 key:库存托盘表的ID、val:托盘上的数量</param>
|
/// <param name="lotNo">批次</param>
|
/// <param name="isMixBox">是否接受拼箱 0：否 1：是</param>
|
/// <returns></returns>
|
public decimal AllotPallets(List<DataStockDetail> palletList, decimal needQty, int fullPalletQty, int fullBoxQty, Dictionary<int, decimal> stockQtyDic,string house)
|
{
|
//优先先进先出（快过期的先出）
|
//优先零箱、零托（出完零箱出整箱）
|
//优先匹配数、（分配合适的数量）
|
|
try
|
{
|
var contextDb = DataContext.Db;
|
|
#region 分配规则
|
|
var funSet = contextDb.Queryable<SysFunSetting>().Where(m => m.IsDel == "0" && m.FunSetName == "分配规则" && m.IsEnable == "NO").ToList().FirstOrDefault();
|
|
var allotSet = 1;//分配规则设定
|
|
if (funSet != null)
|
{
|
switch (funSet.FunSetNo)
|
{
|
case "Fun001":
|
allotSet = 0;//优先零托（出完零托出整托）
|
break;
|
case "Fun002":
|
allotSet = 1;//优先整托（分配合适的整托数量）
|
break;
|
default:
|
allotSet = 1;// 默认：优先整托、
|
break;
|
}
|
}
|
#endregion
|
var list = palletList;
|
decimal qty = 0; //分配的总数量
|
|
if (house == "W01") //仓库是密集库先进行排序
|
{
|
list = GetDataListOrder(palletList);
|
}
|
|
if (fullPalletQty == 0)//无包装物料分配
|
{
|
//已分配的托盘 key：库存明细ID，value：分配的数量
|
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());
|
if (needQty - qty < detailQty)
|
{
|
var num = needQty - qty;
|
qty += num;
|
SaveDic(stockQtyDic, s.Id, num);
|
break;
|
}
|
|
qty += detailQty;
|
SaveDic(stockQtyDic, s.Id, detailQty);
|
if (qty >= needQty)
|
{
|
break;
|
}
|
}
|
}
|
else
|
{
|
var ztNum = needQty / fullPalletQty;//需要整托数
|
|
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((s.Qty - s.LockQty - s.FrozenQty).ToString());
|
if (needQty - qty < detailQty)
|
{
|
var num = needQty - qty;
|
qty += num;
|
SaveDic(stockQtyDic, s.Id, num);
|
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("库存数量不足");
|
}
|
return qty;
|
|
}
|
catch (Exception e)
|
{
|
throw new Exception("分配出库物料失败：" + e.Message);
|
}
|
|
}
|
|
/// <summary>
|
/// 根据储位深度获取分配的优先级别信息(密集库)
|
/// </summary>
|
/// <param name="palletList"></param>
|
/// <returns></returns>
|
public List<DataStockDetail> GetDataListOrder(List<DataStockDetail> palletList)
|
{
|
try
|
{
|
var Db = DataContext.Db;
|
var data = new List<DataStockDetail>();
|
var locateList = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W01").ToList();
|
var list = palletList;
|
//库外托盘
|
var detail1 = list.Where(m => string.IsNullOrWhiteSpace(m.LocatNo)).OrderByDescending(a => a.PalletTags).ToList();
|
// 库外
|
data.AddRange(detail1);
|
//密集库内托盘
|
var detail2 = list.Where(m => m.WareHouseNo == "W01").ToList();
|
|
var detail3 = detail2.GroupBy(m=>m.RoadwayNo).OrderBy(m=>m.Key).ToList();
|
|
foreach (var item in detail3)
|
{
|
var locates = locateList.Where(m => m.RoadwayNo == item.Key).FirstOrDefault();
|
if (locates == null)
|
{
|
throw new Exception("未查询到巷道内的储位信息");
|
}
|
//如果结果为0，则说明两个字符串相等； ABC BCE
|
//如果结果小于0，则说明第一个字符串小于第二个字符串；
|
//如果结果大于0，则说明第一个字符串大于第二个字符串。
|
var bol = String.CompareOrdinal(locates.LocatNo, locates.AisleOne);
|
|
//储位小于通道口 倒序
|
//储位大于通道口 正序
|
if (bol < 0)
|
{
|
//var s = item.OrderByDescending(m => m.LocatNo).ToList();
|
data.AddRange(item.OrderByDescending(m => m.LocatNo));
|
}
|
if (bol > 0)
|
{
|
data.AddRange(item.OrderBy(m => m.LocatNo));
|
}
|
|
}
|
|
return data;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
/// <summary>
|
/// 查找出混箱中其他批次总数量
|
/// </summary>
|
/// <param name="stockDetailId"></param>
|
/// <param name="lotNo"></param>
|
/// <returns></returns>
|
private decimal GetMixBoxQty(int stockDetailId,string lotNo)
|
{
|
var contextDb = DataContext.Db;
|
//查找出混箱集合
|
List<string> mixBoxList = contextDb.Queryable<DataBoxInfo>()
|
.Where(w => w.IsDel == "0" && w.StockDetailId == stockDetailId)
|
.GroupBy(g => g.LotNo)
|
.Having(h => SqlFunc.AggregateCount(h.LotNo) > 1)
|
.Select(s => s.BoxNo).ToList();
|
|
decimal otherLotQty = contextDb.Queryable<DataBoxInfo>()
|
.Where(w => w.IsDel == "0" && w.StockDetailId == stockDetailId && mixBoxList.Contains(w.BoxNo) && w.LotNo != lotNo)
|
.Sum(s => s.Qty);
|
|
return otherLotQty;
|
}
|
|
/// <summary>
|
/// JC23领料出库分配货物（分配托盘上全部物料，防止四楼不同投料口分配同一托盘物料冲突）
|
/// </summary>
|
/// <param name="palletList">库存明细集合</param>
|
/// <param name="needQty">需要分配的数量</param>
|
/// <param name="fullPalletQty">满托数量</param>
|
/// <param name="fullBoxQty">满箱数量</param>
|
/// <param name="stockQtyDic">托出库物品数 key:库存托盘表的ID、val:托盘上的数量</param>
|
/// <returns></returns>
|
public decimal LingLiaoAllotPallets(List<DataStockDetail> palletList, decimal needQty, int fullPalletQty, int fullBoxQty, Dictionary<int, decimal> stockQtyDic)
|
{
|
try
|
{
|
var contextDb = DataContext.Db;
|
|
#region 分配规则 领料出库不适用分配规则、整个托盘都会被分配
|
|
//var funSet = contextDb.Queryable<SysFunSetting>().Where(m => m.IsDel == "0" && m.FunSetName == "分配规则" && m.IsEnable == "NO").ToList().FirstOrDefault();
|
|
//var allotSet = 1;//分配规则设定
|
|
//if (funSet != null)
|
//{
|
// switch (funSet.FunSetNo)
|
// {
|
// case "Fun001":
|
// allotSet = 0;//优先零托（出完零托出整托）
|
// break;
|
// case "Fun002":
|
// allotSet = 1;//优先整托（分配合适的整托数量）
|
// break;
|
// default:
|
// allotSet = 1;// 默认：优先整托、
|
// break;
|
// }
|
//}
|
#endregion
|
|
//分配：优先库外(正常情况下不存在库外托盘)、平库、立库 2：数量少的先出（零托优先）
|
decimal qty = 0; //分配的总数量
|
var list = GetDataListOrderByDept(palletList);
|
|
if (fullPalletQty == 0)//无包装物料分配
|
{
|
//已分配的托盘 key：库存明细ID，value：分配的数量
|
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());
|
|
qty += detailQty;
|
SaveDic(stockQtyDic, s.Id, detailQty);
|
if (qty >= needQty)
|
{
|
break;
|
}
|
}
|
}
|
else
|
{
|
var ztNum = needQty / fullPalletQty;//需要整托数
|
|
|
|
var zps = list.Where(s => s.Qty >= fullPalletQty).ToList();//整托
|
var sps = list.Where(s => s.Qty < fullPalletQty).ToList();//散托(有可能是被锁定了数量的)
|
|
|
//已分配的托盘 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((s.Qty - s.LockQty - s.FrozenQty).ToString());
|
|
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());
|
|
qty += detailQty;
|
SaveDic(stockQtyDic, ss.Id, detailQty);
|
|
if (qty >= needQty)
|
{
|
break;
|
}
|
}
|
|
}
|
|
|
|
}
|
|
if (qty < needQty)
|
{
|
throw new Exception("库存数量不足");
|
}
|
return qty;
|
|
}
|
catch (Exception e)
|
{
|
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);
|
}
|
}
|
|
|
/// <summary>
|
/// 保存字典
|
/// </summary>
|
/// <param name="dic"></param>
|
/// <param name="key"></param>
|
/// <param name="v"></param>
|
private void SaveDic(Dictionary<int, decimal> dic, int key, decimal v)
|
{
|
if (dic.ContainsKey(key))
|
{
|
dic[key] += v;
|
}
|
else
|
{
|
dic.Add(key, v);
|
}
|
}
|
|
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件向后考虑，得到的最大价值
|
///// </summary>
|
///// <param name="w">背包承重</param>
|
///// <param name="o">货物o</param>
|
///// <param name="k">第几件开始默认索引0</param>
|
///// <returns></returns>
|
//public static int GetMaxValue(int w, int[,] o, int k)
|
//{
|
// int v, t1, t2;
|
// //如果是最后一件货物
|
// if (k == o.GetLength(1) - 1)
|
// {
|
// if (w >= o[0, k])
|
// {
|
// v = o[1, k];
|
// }
|
// else
|
// {
|
// v = 0;
|
// }
|
// }
|
// //如果装得下当前货物
|
// else if (w >= o[0, k])
|
// {
|
// t1 = GetMaxValue(w - o[0, k], o, k + 1) + o[1, k];
|
// t2 = GetMaxValue(w, o, k + 1);
|
// v = GetMax(t1, t2);
|
// }
|
// //装不下当前货物的情况
|
// else
|
// {
|
// v = GetMaxValue(w, o, k + 1);
|
// }
|
// return v;
|
//}
|
//public static int GetMax(int a, int b)
|
//{
|
// return a > b ? a : b;
|
//}
|
|
#endregion
|
|
/// <summary>
|
/// 根据储位深度获取分配的优先级别信息
|
/// </summary>
|
/// <param name="palletList"></param>
|
/// <returns></returns>
|
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,
|
PalletTags = m.PalletTags
|
|
}).ToList();
|
//库外托盘
|
var detail1 = list.Where(m => string.IsNullOrWhiteSpace(m.LocatNo)).OrderByDescending(a => a.PalletTags).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");
|
//var data2 = new List<StockDetailDto>();
|
//foreach (var pingku in detail2.OrderByDescending(a => a.PalletTags).ThenBy(m => m.Dept).ToList())
|
//{
|
// if (data2.Contains(pingku))
|
// {
|
// continue;
|
// }
|
|
// var currentLocate = locate1.First(m => m.LocatNo == pingku.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 (detail2.Any(m => m.LocatNo == locat.LocatNo) && !data2.Contains(detail2.First(m => m.LocatNo == locat.LocatNo)))
|
// {
|
// data2.Add(detail2.First(m => m.LocatNo == locat.LocatNo));
|
// }
|
|
// }
|
// data2.Add(pingku);
|
//}
|
|
//立库
|
var locate2 = Db.Queryable<SysStorageLocat>().Where(m => m.IsDel == "0" && m.WareHouseNo == "W01").ToList();
|
var data3 = new List<StockDetailDto>();
|
foreach (var liku in detail3.OrderByDescending(a => a.PalletTags).ThenBy(m => m.Dept).ToList())
|
{
|
if (data3.Contains(liku))
|
{
|
continue;
|
}
|
|
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.Contains(detail3.First(m => m.LocatNo == locat.LocatNo)))
|
{
|
data3.Add(detail3.First(m=>m.LocatNo == locat.LocatNo));
|
}
|
|
}
|
data3.Add(liku);
|
}
|
|
|
data.AddRange(detail1); // 库外
|
data.AddRange(detail2); // 平库
|
data.AddRange(data3); // 立库
|
|
return data;
|
}
|
catch (Exception e)
|
{
|
throw new Exception(e.Message);
|
}
|
}
|
|
|
}
|
}
|
