using HH.WMS.Common.Algorithm.Out;
|
using HH.WMS.Entitys;
|
using HH.WMS.Entitys.Basic;
|
using HH.WMS.Entitys.Common;
|
using HH.WMS.Entitys.Entitys;
|
using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace HH.WMS.Common
|
{
|
public static class CommonExtension
|
{
|
#region 克隆对象
|
/// <summary>
|
/// 克隆对象
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="t"></param>
|
/// <returns></returns>
|
/// <history>[HanHe(zh)] CREATED 2018/09/16</history>
|
public static T DeepCloneObject<T>(this T t) where T : class
|
{
|
T model = System.Activator.CreateInstance<T>(); //实例化一个T类型对象
|
PropertyInfo[] propertyInfos = model.GetType().GetProperties(); //获取T对象的所有公共属性
|
foreach (PropertyInfo propertyInfo in propertyInfos)
|
{
|
//判断值是否为空，如果空赋值为null见else
|
if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
|
{
|
//如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
|
NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
|
//将convertsionType转换为nullable对的基础基元类型
|
propertyInfo.SetValue(model, Convert.ChangeType(propertyInfo.GetValue(t), nullableConverter.UnderlyingType), null);
|
}
|
else
|
{
|
propertyInfo.SetValue(model, Convert.ChangeType(propertyInfo.GetValue(t), propertyInfo.PropertyType), null);
|
}
|
}
|
return model;
|
}
|
public static IList<T> DeepCloneList<T>(this IList<T> tList) where T : class
|
{
|
IList<T> listNew = new List<T>();
|
foreach (var item in tList)
|
{
|
T model = System.Activator.CreateInstance<T>(); //实例化一个T类型对象
|
PropertyInfo[] propertyInfos = model.GetType().GetProperties(); //获取T对象的所有公共属性
|
foreach (PropertyInfo propertyInfo in propertyInfos)
|
{
|
//判断值是否为空，如果空赋值为null见else
|
if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
|
{
|
//如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
|
NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
|
//将convertsionType转换为nullable对的基础基元类型
|
propertyInfo.SetValue(model, Convert.ChangeType(propertyInfo.GetValue(item), nullableConverter.UnderlyingType), null);
|
}
|
else
|
{
|
propertyInfo.SetValue(model, Convert.ChangeType(propertyInfo.GetValue(item), propertyInfo.PropertyType), null);
|
}
|
}
|
listNew.Add(model);
|
}
|
return listNew;
|
}
|
#endregion
|
|
#region 批分仓库量通用方法
|
/// <summary>
|
/// 批分仓库量通用方法
|
/// </summary>
|
/// <param name="tStockList"></param>
|
/// <param name="beList"></param>
|
/// <param name="bType"></param>
|
/// <param name="generateOut">是否生成出库单</param>
|
/// <param name="sbField"></param>
|
/// <returns></returns>
|
public static OperateResult BatchesStockQty(this List<TN_WM_B_STOCK_QTYEntity> tStockList, List<BatchesEntity> beList,
|
BatchesType bType, StockBatchesField sbField, List<string> lstStrate, bool generateOut = false, bool isDropQty = false)
|
{
|
//锁定明细（反批分分配量时记录）
|
BatchesResult bResult = new BatchesResult();
|
foreach (var b in beList)
|
{
|
//需要生成出库单时，过滤
|
if (generateOut && b.IsFilter)
|
continue;
|
//匹配五要素 // p.CN_S_OWNER.Trim().Equals(b.Owner.Trim()) &&
|
var cis = tStockList.Where(p =>
|
p.CN_S_ITEM_CODE.Equals(b.ItemCode) &&
|
p.CN_S_ITEM_STATE.Equals(b.ItemState) &&
|
(string.IsNullOrEmpty(b.ItemArrivalLot) || b.ItemArrivalLot.Equals(p.CN_S_LOT_NO)) &&
|
(string.IsNullOrEmpty(b.ItemProductionLot) || b.ItemProductionLot.Equals(p.CN_S_PRODUCTION_BATCH)));
|
|
//暂时先倒序生产批次 then 到货批次 后续取策略
|
var cisList = cis.OrderBy(p => p.CN_S_LOT_NO).ToList();
|
|
foreach (string stegy in lstStrate)
|
{
|
//逐个策略进行计算
|
switch (stegy)
|
{
|
case "FirstInFirstOut":
|
cisList = cisList.OrderBy(o => o.CN_S_LOT_NO).ToList();
|
break;
|
case "FirstWarrantFirstOut":
|
var lstEmptyPBC = cisList.Where(o => string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).ToList();
|
var lstFilterItem = cisList.Where(o => !string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).OrderBy(o => o.CN_S_PRODUCTION_BATCH).ToList();
|
lstFilterItem.AddRange(lstEmptyPBC);
|
cisList = lstFilterItem;
|
break;
|
}
|
}
|
|
if (!cisList.Any())
|
return OperateResult.Error("库存中未找到物料：" + b.ItemCode);
|
//待批数
|
var qty = b.Qty;
|
if (qty == 0) continue;
|
switch (bType)
|
{
|
#region 正批分
|
//正批分
|
case BatchesType.ForwardBatch:
|
for (int i = 0; i < cisList.Count; i++)
|
{
|
//批分编辑量
|
if (sbField == StockBatchesField.EditingQty)
|
{
|
//可用量 = 库存量-分配量-编辑量
|
var availableQty = cisList[i].CN_F_QUANTITY - cisList[i].CN_F_ALLOC_QTY - cisList[i].CN_F_EDITING_QTY;
|
if (availableQty <= 0) continue;
|
if (availableQty >= qty)
|
{
|
cisList[i].CN_F_EDITING_QTY += qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_EDITING_QTY += availableQty;
|
qty -= availableQty;
|
continue;
|
}
|
}
|
//批分分配量
|
else if (sbField == StockBatchesField.AllocationQty)
|
{
|
//可用量 = 库存量-分配量
|
var availableQty = cisList[i].CN_F_QUANTITY - cisList[i].CN_F_ALLOC_QTY;// -cisList[i].CN_F_EDITING_QTY;
|
if (availableQty <= 0) continue;
|
if (isDropQty)
|
{
|
if (availableQty >= qty)
|
{
|
cisList[i].CN_F_QUANTITY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_QUANTITY -= availableQty;
|
qty -= availableQty;
|
continue;
|
}
|
}
|
else
|
{
|
if (availableQty >= qty)
|
{
|
cisList[i].CN_F_ALLOC_QTY += qty;
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, qty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_ALLOC_QTY += availableQty;
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, availableQty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
qty -= availableQty;
|
continue;
|
}
|
}
|
}
|
}
|
break;
|
#endregion
|
|
#region 反批分
|
//反批分
|
case BatchesType.ReverseBatch:
|
for (int i = cisList.Count - 1; i >= 0; i--)
|
{
|
//批分编辑量
|
if (sbField == StockBatchesField.EditingQty)
|
{
|
var editingQty = cisList[i].CN_F_EDITING_QTY;
|
if (editingQty <= 0) continue;
|
if (editingQty >= qty)
|
{
|
cisList[i].CN_F_EDITING_QTY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_EDITING_QTY = 0;
|
qty -= editingQty;
|
continue;
|
}
|
}
|
//批分分配量 (反批分分配量，相当于批分出库明细了)
|
else if (sbField == StockBatchesField.AllocationQty)
|
{
|
var allocQty = cisList[i].CN_F_ALLOC_QTY;
|
if (allocQty <= 0) continue;
|
if (allocQty >= qty)
|
{
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, qty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
cisList[i].CN_F_ALLOC_QTY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, allocQty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
cisList[i].CN_F_ALLOC_QTY = 0;
|
qty -= allocQty;
|
continue;
|
}
|
}
|
}
|
break;
|
#endregion
|
}
|
#region 批分失败
|
|
if (qty > 0)
|
{
|
switch (bType)
|
{
|
case BatchesType.ForwardBatch:
|
switch (sbField)
|
{
|
case StockBatchesField.EditingQty:
|
case StockBatchesField.AllocationQty:
|
return OperateResult.Error("物料批分失败：物料编码：" + b.ItemCode + "库存量不足");
|
}
|
break;
|
case BatchesType.ReverseBatch:
|
switch (sbField)
|
{
|
case StockBatchesField.EditingQty:
|
return OperateResult.Error("物料反批分失败：物料编码：" + b.ItemCode + "编辑量不足");
|
case StockBatchesField.AllocationQty:
|
return OperateResult.Error("物料反批分失败：物料编码：" + b.ItemCode + "分配量不足");
|
}
|
break;
|
}
|
}
|
#endregion
|
}
|
|
#region 生成出库单
|
if (generateOut)
|
{
|
//若是反批分分配量，生成出库单信息
|
IEnumerable<IGrouping<string, BatchesEntity>> beGroup = beList.GroupBy(p => p.OpNo);
|
foreach (var be in beGroup)
|
{
|
//出库订单
|
TN_WM_OUT_MSTEntity outMst = be.AsEnumerable().ToList()[0].OutMst;
|
//修改出库订单主子表为‘待出库’
|
outMst.CN_S_STATE = Constants.State_WaitOut;
|
if (isDropQty)
|
outMst.CN_S_STATE = Constants.State_Completed;
|
outMst.OutDtlList.ForEach(p =>
|
{
|
p.CN_S_STATE = outMst.CN_S_STATE;
|
});
|
bResult.OutMstList.Add(outMst);
|
// 生成出库单号
|
UserRuleEntity user = new UserRuleEntity()
|
{
|
OrgCode = "0",
|
RuleCode = Constants.Rule_Out
|
};
|
string outNo = user.GenerateNo();
|
//将锁定库存改成根据出库单来锁
|
//if (bResult.OutLockingDtlList.FindAll(x => x.CN_S_FROM_NO == be.Key).Any())
|
//{
|
// foreach (var _updateStockDtl in bResult.OutLockingDtlList)
|
// {
|
// if (_updateStockDtl.CN_S_FROM_NO.Equals(be.Key))
|
// _updateStockDtl.CN_S_FROM_NO = outNo;
|
// }
|
//}
|
//非一进一出,生成出库单
|
var notAutoInOut = outMst.OutDtlList.FindAll(p => !p.CN_C_AUTO_INOUT);
|
if (notAutoInOut.Any())
|
{
|
var reduceInventoryMstEntity = GetReduceInventoryMst(outNo, Constants.Rule_OutOrder, outMst);
|
reduceInventoryMstEntity.DTLEntity.AddRange(GetReduceInventoryDtl(outNo, notAutoInOut));
|
bResult.ReduceInventoryMstList.Add(reduceInventoryMstEntity);
|
}
|
//生成一进一出出库单
|
var autoInOut = outMst.OutDtlList.FindAll(p => p.CN_C_AUTO_INOUT);
|
if (autoInOut.Any())
|
{
|
var reduceInventoryMstEntity = GetReduceInventoryMst(outNo, Constants.Auto_InOut, outMst);
|
reduceInventoryMstEntity.DTLEntity.AddRange(GetReduceInventoryDtl(outNo, autoInOut));
|
bResult.ReduceInventoryMstList.Add(reduceInventoryMstEntity);
|
}
|
}
|
}
|
#endregion
|
|
return OperateResult.Succeed(null, bResult);
|
}
|
#endregion
|
|
#region 出库单主表
|
/// <summary>
|
/// 出库单主表
|
/// </summary>
|
/// <param name="opNo"></param>
|
/// <param name="opClass"></param>
|
/// <param name="outMst"></param>
|
/// <returns></returns>
|
private static TN_WM_REDUCE_INVENTORY_MSTEntity GetReduceInventoryMst(string opNo, string opClass, TN_WM_OUT_MSTEntity outMst)
|
{
|
var mst = new TN_WM_REDUCE_INVENTORY_MSTEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_OP_NO = opNo,
|
CN_S_OP_TYPE = outMst.CN_S_OP_TYPE,
|
CN_S_STOCK_CODE = outMst.CN_S_STOCK_CODE,
|
CN_T_OPERATE = outMst.CN_T_OP_DATE,
|
CN_S_OP_FROM = Constants.Rule_OutOrder,
|
CN_S_OP_CLASS = opClass,
|
CN_S_FROM_NO = outMst.CN_S_OP_NO,
|
CN_S_STATE = Constants.State_WaitOut,
|
CN_S_NOTE = outMst.CN_S_NOTE,
|
CN_S_AUDITOR = outMst.CN_S_AUDITOR,
|
CN_T_AUDIT_TIME = outMst.CN_T_AUDIT_TIME,
|
CN_S_AUDIT_REMARK = outMst.CN_S_AUDIT_REMARK,
|
CN_S_CREATOR = outMst.CN_S_CREATOR,
|
CN_S_CREATOR_BY = outMst.CN_S_CREATOR_BY,
|
CN_T_CREATE = DateTime.Now,
|
CN_S_MODIFY = outMst.CN_S_MODIFY,
|
CN_S_MODIFY_BY = outMst.CN_S_MODIFY_BY,
|
CN_T_MODIFY = DateTime.Now,
|
CN_C_PRINT = "N",
|
};
|
mst.DTLEntity = new List<TN_WM_REDUCE_INVENTORY_DTLEntity>();
|
return mst;
|
}
|
#endregion
|
|
#region 出库单子表
|
/// <summary>
|
/// 出库单子表
|
/// </summary>
|
/// <param name="opNo"></param>
|
/// <param name="outDtl"></param>
|
/// <returns></returns>
|
private static List<TN_WM_REDUCE_INVENTORY_DTLEntity> GetReduceInventoryDtl(string opNo, List<TN_WM_OUT_DTLEntity> outDtlList)
|
{
|
var dtlList = new List<TN_WM_REDUCE_INVENTORY_DTLEntity>();
|
foreach (var outDtl in outDtlList)
|
{
|
var dtl = new TN_WM_REDUCE_INVENTORY_DTLEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_OP_NO = opNo,
|
CN_N_ROW_NO = outDtl.CN_N_ROW_NO,
|
CN_S_SERIAL_NO = outDtl.CN_S_SERIAL_NO,
|
CN_S_OWNER = "",
|
CN_S_ITEM_CODE = outDtl.CN_S_ITEM_CODE,
|
CN_S_ITEM_NAME = outDtl.CN_S_ITEM_NAME,
|
CN_S_ITEM_STATE = outDtl.CN_S_ITEM_STATE,
|
CN_S_LOT_CODE = outDtl.CN_S_LOT_CODE,
|
CN_F_QUANTITY = outDtl.CN_F_QUANTITY,
|
CN_S_NOTE = outDtl.CN_S_NOTE,
|
CN_S_STATE = outDtl.CN_S_STATE,
|
CN_S_FIGURE_NO = outDtl.CN_S_FIGURE_NO,
|
CN_S_MODEL = outDtl.CN_S_MODEL,
|
CN_S_MEASURE_UNIT = outDtl.CN_S_MEASURE_UNIT,
|
CN_F_SALE_PRICE = outDtl.CN_F_SALE_PRICE,
|
CN_F_SALE_MONEY = outDtl.CN_F_SALE_MONEY,
|
CN_C_IS_BALANCE = "N",
|
CN_C_IS_SCRAP = "N"
|
};
|
dtlList.Add(dtl);
|
}
|
return dtlList;
|
}
|
#endregion
|
|
#region 根据分拣单批分库区（不通用）
|
/// <summary>
|
/// 根据分拣单批分库区（不通用）
|
/// </summary>
|
/// <param name="tAreaList"></param>
|
/// <param name="beList"></param>
|
/// <returns></returns>
|
public static OperateResult BatchesAreaQty(this List<TN_WM_B_AREA_QTYEntity> tAreaList, List<TN_WM_SORTING_LISTEntity> sortingList, List<string> lstStrate, bool reverseBatch = false)
|
{
|
var sortingDtlList = new List<TN_WM_SORTING_DTLEntity>();
|
sortingList.ForEach(p =>
|
{
|
sortingDtlList.AddRange(p.SortingDtlList);
|
});
|
if (sortingDtlList.Any())
|
{
|
foreach (var s in sortingDtlList)
|
{
|
var cia = tAreaList.Where(p =>
|
p.CN_S_ITEM_CODE.Equals(s.CN_S_ITEM_CODE) &&
|
p.CN_S_ITEM_STATE.Equals(s.CN_S_ITEM_STATE) &&
|
p.CN_S_OWNER.Trim().Equals(s.CN_S_OWNER.Trim()) &&
|
(string.IsNullOrEmpty(s.CN_S_LOT_NO) || s.CN_S_LOT_NO.Equals(p.CN_S_LOT_NO)) &&
|
(string.IsNullOrEmpty(s.CN_S_PRODUCTION_BATCH) || s.CN_S_PRODUCTION_BATCH.Equals(p.CN_S_PRODUCTION_BATCH)));
|
|
//暂时先倒序生产批次 then 到货批次 后续取策略
|
var ciaList = cia.OrderBy(p => p.CN_S_LOT_NO).ToList();
|
|
foreach (string stegy in lstStrate)
|
{
|
//逐个策略进行计算
|
switch (stegy)
|
{
|
case "FirstInFirstOut":
|
ciaList = ciaList.OrderBy(o => o.CN_S_LOT_NO).ToList();
|
break;
|
case "FirstWarrantFirstOut":
|
var lstEmptyPBC = ciaList.Where(o => string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).ToList();
|
var lstFilterItem = ciaList.Where(o => !string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).OrderBy(o => o.CN_S_PRODUCTION_BATCH).ToList();
|
lstFilterItem.AddRange(lstEmptyPBC);
|
ciaList = lstFilterItem;
|
break;
|
}
|
}
|
|
if (!ciaList.Any())
|
return OperateResult.Error("库区中未找到物料：" + s.CN_S_ITEM_CODE);
|
//待批数
|
var qty = s.CN_F_QUANTITY;
|
if (qty == 0) continue;
|
|
foreach (var area in ciaList)
|
{
|
if (reverseBatch)
|
{
|
var currentCount = area.CN_F_ALLOC_QTY;
|
if (currentCount <= 0) continue;
|
if (currentCount >= qty)
|
{
|
area.CN_F_QUANTITY -= qty;
|
area.CN_F_ALLOC_QTY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
area.CN_F_QUANTITY -= currentCount;
|
area.CN_F_ALLOC_QTY = 0;
|
qty -= currentCount;
|
continue;
|
}
|
}
|
else
|
{
|
//当前可用量
|
var currentCount = area.CN_F_QUANTITY + area.CN_F_PLANNED_QTY - area.CN_F_ALLOC_QTY;
|
if (currentCount <= 0) continue;
|
if (currentCount >= qty)
|
{
|
area.CN_F_ALLOC_QTY += qty;
|
//outLockList.Add(GetOutLockingDtlEntity(area, s.CN_S_SORTING_NO, qty));
|
qty = 0;
|
break;
|
}
|
else
|
{
|
area.CN_F_ALLOC_QTY += currentCount;
|
//outLockList.Add(GetOutLockingDtlEntity(area, s.CN_S_SORTING_NO, currentCount));
|
qty -= currentCount;
|
continue;
|
}
|
}
|
}
|
if (qty > 0)
|
{
|
if (reverseBatch)
|
{
|
return OperateResult.Error("物料反批分失败：物料编码：" + s.CN_S_ITEM_CODE + "在库区中分配量不足");
|
}
|
else
|
{
|
return OperateResult.Error("物料批分失败：物料编码：" + s.CN_S_ITEM_CODE + "在库区中库存量不足");
|
}
|
}
|
}
|
return OperateResult.Succeed();
|
}
|
return OperateResult.Error("未找到分拣数据");
|
}
|
#endregion
|
|
#region 根据算法返回结果批分库区(不加分配量，直接减库存量)
|
/// <summary>
|
/// 根据算法返回结果批分库区(不加分配量，直接减库存量)
|
/// </summary>
|
/// <param name="tAreaList"></param>
|
/// <param name="outAreaResultList"></param>
|
/// <returns></returns>
|
public static OperateResult BatchesAreaQty(this List<TN_WM_B_AREA_QTYEntity> tAreaList, List<OutAreaResultEntity> outAreaResultList, List<string> lstStrate)
|
{
|
foreach (var item in outAreaResultList)
|
{
|
if (!item.lstItem.Any())
|
return OperateResult.Error("未找到库区：" + item.areaCode + "中的物料");
|
foreach (var s in item.lstItem)
|
{
|
var cia = tAreaList.Where(p =>
|
p.CN_S_ITEM_CODE.Equals(s.itemCode) &&
|
p.CN_S_ITEM_STATE.Equals(item.itemState) &&
|
p.CN_S_OWNER.Trim().Equals(item.ownerName.Trim()) &&
|
(string.IsNullOrEmpty(item.batchCode) || item.batchCode.Equals(p.CN_S_LOT_NO)) &&
|
(string.IsNullOrEmpty(item.prodBatchCode) || item.prodBatchCode.Equals(p.CN_S_PRODUCTION_BATCH)));
|
//暂时先倒序生产批次 then 到货批次 后续取策略
|
var ciaList = cia.OrderBy(p => p.CN_S_LOT_NO).ToList();
|
foreach (string stegy in lstStrate)
|
{
|
//逐个策略进行计算
|
switch (stegy)
|
{
|
case "FirstInFirstOut":
|
ciaList = ciaList.OrderBy(o => o.CN_S_LOT_NO).ToList();
|
break;
|
case "FirstWarrantFirstOut":
|
var lstEmptyPBC = ciaList.Where(o => string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).ToList();
|
var lstFilterItem = ciaList.Where(o => !string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).OrderBy(o => o.CN_S_PRODUCTION_BATCH).ToList();
|
lstFilterItem.AddRange(lstEmptyPBC);
|
ciaList = lstFilterItem;
|
break;
|
}
|
}
|
if (!ciaList.Any())
|
return OperateResult.Error("库区中未找到物料：" + s.itemCode);
|
//待批数
|
var qty = s.itemQty;
|
if (qty == 0) continue;
|
|
foreach (var area in ciaList)
|
{
|
//当前可用量
|
var currentCount = area.CN_F_QUANTITY + area.CN_F_PLANNED_QTY - area.CN_F_ALLOC_QTY;
|
if (currentCount <= 0) continue;
|
if (currentCount >= qty)
|
{
|
//area.CN_F_ALLOC_QTY += qty;
|
area.CN_F_QUANTITY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
//area.CN_F_ALLOC_QTY += currentCount;
|
area.CN_F_QUANTITY -= currentCount;
|
qty -= currentCount;
|
continue;
|
}
|
}
|
if (qty > 0)
|
{
|
return OperateResult.Error("物料批分失败：物料编码：" + s.itemCode + "在库区中库存量不足");
|
}
|
}
|
}
|
return OperateResult.Succeed();
|
}
|
#endregion
|
|
//public static OperateResult DropTrayItemQty(this List<BatchesEntity> beList)
|
//{
|
// var trayItemMstList = BLLCreator<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new
|
// {
|
// CN_S_TRAY_CODE = sortingResult.Select(x => x.CN_S_TRAY_CODE).ToList(),
|
// CN_S_ITEM_CODE = sortingResult.Select(x => x.CN_S_ITEM_CODE).ToList()
|
// });
|
//}
|
|
#region 批分托盘物料分配量通用方法
|
/// <summary>
|
/// 批分托盘物料分配量通用方法
|
/// </summary>
|
/// <param name="trayItemList"></param>
|
/// <param name="beList"></param>
|
/// <param name="bType"></param>
|
/// <returns></returns>
|
public static OperateResult BatchesTrayItemQty(this List<TN_WM_B_TRAY_ITEM_MSTEntity> trayItemList, List<BatchesEntity> beList, BatchesType bType)
|
{
|
foreach (var b in beList)
|
{
|
//匹配托盘和物料编码
|
var cis = trayItemList.Where(p =>
|
p.CN_S_ITEM_CODE.Equals(b.ItemCode) &&
|
p.CN_S_TRAY_CODE.Equals(b.TrayCode));
|
if (!cis.Any())
|
return OperateResult.Error("批分失败，托盘：" + b.TrayCode + "中未找到物料：" + b.ItemCode);
|
|
var cisList = cis.OrderBy(p => p.CN_S_LOT_NO).ToList();
|
//待批数
|
var qty = b.Qty;
|
if (qty == 0) continue;
|
switch (bType)
|
{
|
#region 正批分
|
//正批分
|
case BatchesType.ForwardBatch:
|
for (int i = 0; i < cisList.Count; i++)
|
{
|
//可用量 = 库存量-分配量-编辑量
|
var availableQty = cisList[i].CN_F_QUANTITY - cisList[i].CN_F_ALLOC_QTY;
|
if (availableQty <= 0) continue;
|
if (availableQty >= qty)
|
{
|
cisList[i].CN_F_ALLOC_QTY += qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_ALLOC_QTY += availableQty;
|
qty -= availableQty;
|
continue;
|
}
|
}
|
break;
|
#endregion
|
|
#region 反批分
|
//反批分
|
case BatchesType.ReverseBatch:
|
for (int i = cisList.Count - 1; i >= 0; i--)
|
{
|
var allocQty = cisList[i].CN_F_ALLOC_QTY;
|
if (allocQty <= 0) continue;
|
if (allocQty >= qty)
|
{
|
cisList[i].CN_F_ALLOC_QTY -= qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
cisList[i].CN_F_ALLOC_QTY = 0;
|
qty -= allocQty;
|
continue;
|
}
|
}
|
break;
|
#endregion
|
}
|
#region 批分失败
|
//批分失败
|
if (qty > 0)
|
{
|
switch (bType)
|
{
|
case BatchesType.ForwardBatch:
|
return OperateResult.Error("批分失败，托盘：" + b.TrayCode + "中物料：" + b.ItemCode + "不足");
|
case BatchesType.ReverseBatch:
|
return OperateResult.Error("反批分失败，托盘：" + b.TrayCode + "中物料：" + b.ItemCode + "分配量不足");
|
}
|
}
|
#endregion
|
}
|
return OperateResult.Succeed();
|
}
|
#endregion
|
|
#region 获取锁定实体
|
/// <summary>
|
/// 获取锁定实体
|
/// </summary>
|
/// <param name="stockEntity">仓库实体</param>
|
/// <param name="opNo">锁定单据号</param>
|
/// <param name="lockNum">锁定数量</param>
|
/// <returns></returns>
|
private static TN_WM_B_OUTLOCKING_DTLEntity GetOutLockingDtlEntity(TN_WM_B_STOCK_QTYEntity stockEntity, string opNo, decimal lockNum)
|
{
|
return new TN_WM_B_OUTLOCKING_DTLEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_OP_FROM = Constants.Rule_OutOrder,
|
CN_S_FROM_NO = opNo,
|
CN_S_STOCK_CODE = stockEntity.CN_S_STOCK_CODE,
|
CN_S_OWNER = stockEntity.CN_S_OWNER.Trim(),
|
CN_S_ITEM_CODE = stockEntity.CN_S_ITEM_CODE,
|
CN_S_ITEM_NAME = stockEntity.CN_S_ITEM_NAME,
|
CN_S_ITEM_STATE = stockEntity.CN_S_ITEM_STATE,
|
CN_S_LOT_NO = stockEntity.CN_S_LOT_NO,
|
CN_F_QUANTITY = lockNum,
|
CN_T_LOCK = DateTime.Now,
|
CN_S_TABLE_ID = stockEntity.CN_GUID,
|
CN_S_TABLE_TYPE = "1",
|
CN_S_STATE = Constants.State_Executing,
|
CN_F_SUM_USE = 0,
|
CN_T_USE = DateTime.Now,
|
CN_F_SUM_CANCEL = 0,
|
CN_T_CANCEL = DateTime.Now,
|
};
|
}
|
private static TN_WM_B_OUTLOCKING_DTLEntity GetOutLockingDtlEntity(TN_WM_B_AREA_QTYEntity areaEntity, string opNo, decimal lockNum)
|
{
|
return new TN_WM_B_OUTLOCKING_DTLEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_OP_FROM = Constants.Rule_SortingNo,
|
CN_S_FROM_NO = opNo,
|
CN_S_STOCK_CODE = areaEntity.CN_S_STOCK_CODE,
|
CN_S_OWNER = areaEntity.CN_S_OWNER.Trim(),
|
CN_S_ITEM_CODE = areaEntity.CN_S_ITEM_CODE,
|
CN_S_ITEM_NAME = areaEntity.CN_S_ITEM_NAME,
|
CN_S_ITEM_STATE = areaEntity.CN_S_ITEM_STATE,
|
CN_S_LOT_NO = areaEntity.CN_S_LOT_NO,
|
CN_F_QUANTITY = lockNum,
|
CN_T_LOCK = DateTime.Now,
|
CN_S_TABLE_ID = areaEntity.CN_GUID,
|
CN_S_TABLE_TYPE = "2",
|
CN_S_STATE = Constants.State_Executing,
|
CN_F_SUM_USE = 0,
|
CN_T_USE = DateTime.Now,
|
CN_F_SUM_CANCEL = 0,
|
CN_T_CANCEL = DateTime.Now,
|
};
|
}
|
#endregion
|
|
#region 生成单号
|
/// <summary>
|
/// 生成单号
|
/// </summary>
|
/// <param name="user"></param>
|
/// <returns></returns>
|
public static string GenerateNo(this UserRuleEntity user)
|
{
|
//string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + user.RuleCode + "\",\"orgId\":\"" + user.OrgCode + "\",\"orgFlag\":\"" + user.OrgFlag + "\"}";
|
var postData = new
|
{
|
appCode = "AutoWMS",
|
ruleName = user.RuleCode,
|
orgId = 0,
|
orgFlag = ""
|
};
|
|
return WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", JsonConvert.SerializeObject(postData));
|
}
|
#endregion
|
|
#region 批分分配量
|
/// <summary>
|
/// 批分分配量
|
/// </summary>
|
/// <param name="tStockList"></param>
|
/// <param name="beList"></param>
|
/// <param name="lstStrate"></param>
|
/// <returns></returns>
|
public static OperateResult BatchesStockAllocQty(this List<TN_WM_B_STOCK_QTYEntity> tStockList, List<BatchesEntity> beList, List<string> lstStrate)
|
{
|
try
|
{
|
//锁定明细（反批分分配量时记录）
|
BatchesResult bResult = new BatchesResult();
|
//记录有缺货的出库单
|
List<TN_WM_OUT_MSTEntity> shortageList = new List<TN_WM_OUT_MSTEntity>();
|
foreach (var b in beList)
|
{
|
//匹配五要素
|
var cis = tStockList.Where(p =>
|
p.CN_S_ITEM_CODE.Equals(b.ItemCode) &&
|
p.CN_S_ITEM_STATE.Equals(b.ItemState) &&
|
p.CN_S_OWNER.Trim().Equals(b.Owner.Trim()) &&
|
(string.IsNullOrEmpty(b.ItemArrivalLot) || b.ItemArrivalLot.Equals(p.CN_S_LOT_NO)) &&
|
(string.IsNullOrEmpty(b.ItemProductionLot) || b.ItemProductionLot.Equals(p.CN_S_PRODUCTION_BATCH)));
|
|
//暂时先倒序生产批次 then 到货批次 后续取策略
|
var cisList = cis.OrderBy(p => p.CN_S_LOT_NO).ToList();
|
|
foreach (string stegy in lstStrate)
|
{
|
//逐个策略进行计算
|
switch (stegy)
|
{
|
case "FirstInFirstOut":
|
cisList = cisList.OrderBy(o => o.CN_S_LOT_NO).ToList();
|
break;
|
case "FirstWarrantFirstOut":
|
var lstEmptyPBC = cisList.Where(o => string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).ToList();
|
var lstFilterItem = cisList.Where(o => !string.IsNullOrEmpty(o.CN_S_PRODUCTION_BATCH)).OrderBy(o => o.CN_S_PRODUCTION_BATCH).ToList();
|
lstFilterItem.AddRange(lstEmptyPBC);
|
cisList = lstFilterItem;
|
break;
|
}
|
}
|
|
if (!cisList.Any())
|
return OperateResult.Error("库存中未找到物料：" + b.ItemCode);
|
//待批数
|
var qty = b.Qty;
|
if (qty == 0) continue;
|
|
for (int i = 0; i < cisList.Count; i++)
|
{
|
//可用量 = 库存量-分配量
|
var availableQty = cisList[i].CN_F_QUANTITY - cisList[i].CN_F_ALLOC_QTY;// -cisList[i].CN_F_EDITING_QTY;
|
if (availableQty <= 0) continue;
|
|
if (availableQty >= qty)
|
{
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, qty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
cisList[i].CN_F_ALLOC_QTY += qty;
|
qty = 0;
|
break;
|
}
|
else
|
{
|
//记录锁定明细
|
var outLockingDtlEntity = GetOutLockingDtlEntity(cisList[i], b.OpNo, availableQty);
|
bResult.OutLockingDtlList.Add(outLockingDtlEntity);
|
cisList[i].CN_F_ALLOC_QTY += availableQty;
|
qty -= availableQty;
|
continue;
|
}
|
}
|
|
#region 批分失败
|
|
if (qty > 0)
|
{
|
Log.Info("存在缺货", "出库单：" + b.OpNo + ",缺货物料：" + b.ItemCode + ",缺货数量：" + qty);
|
//如果没记录过该出库单的缺货记录
|
if (!shortageList.Exists(e => e.CN_S_OP_NO.Equals(b.OpNo)))
|
{
|
shortageList.Add(b.OutMst);
|
}
|
var shortageOutEntity = shortageList.Find(f => f.CN_S_OP_NO == b.OpNo)
|
.OutDtlList.Find(x =>
|
x.CN_S_ITEM_CODE == b.ItemCode &&
|
x.CN_S_ITEM_STATE == b.ItemState &&
|
x.CN_S_OWNER.Trim() == b.Owner.Trim() &&
|
x.CN_S_LOT_CODE == b.ItemArrivalLot &&
|
x.CN_S_PRODUCTION_BATCH == b.ItemProductionLot);
|
|
Log.Info("存在缺货 shortageOutEntity", JsonConvert.SerializeObject(shortageOutEntity));
|
if (shortageOutEntity != null)
|
{
|
//缺货数量
|
shortageOutEntity.CN_F_SHORTAGE_QTY = qty;
|
}
|
}
|
|
#endregion
|
}
|
|
#region 生成出库单
|
//若是反批分分配量，生成出库单信息
|
IEnumerable<IGrouping<string, BatchesEntity>> beGroup = beList.GroupBy(p => p.OpNo);
|
foreach (var be in beGroup)
|
{
|
//出库订单
|
TN_WM_OUT_MSTEntity outMst = be.AsEnumerable().ToList()[0].OutMst;
|
//当前出库单是否缺货的物料，
|
var shortageCurrentOut = shortageList.Find(f => f.CN_S_OP_NO.Equals(be.Key));
|
//存在缺货的物料 & 生成新的发货单
|
if (shortageCurrentOut != null)
|
{
|
outMst.OutDtlList = shortageCurrentOut.OutDtlList.FindAll(p => p.CN_F_SHORTAGE_QTY < p.CN_F_QUANTITY);
|
//GenerateNewOut(outMst, true);
|
//全部缺货
|
if (!outMst.OutDtlList.Any())
|
{
|
//当前出库单为全部缺货
|
shortageCurrentOut.CN_S_STATE = Constants.State_Shortage;
|
continue;
|
}
|
else
|
{
|
//当前出库单设为取消
|
shortageCurrentOut.CN_B_CANCEL = true;
|
//缺货的部分物料生成新的发货单
|
var shortageNewOut = GenerateNewOut(outMst, true);
|
//不缺货的部分物料生成新的发货单
|
outMst = GenerateNewOut(outMst, false);
|
//记录新增的有缺货的发货单
|
bResult.ShortageOutList.Add(shortageNewOut);
|
bResult.ShortageOutList.Add(outMst);
|
//锁定明细改为新的发货单来锁
|
var oldOutLocking = bResult.OutLockingDtlList.FindAll(x => x.CN_S_FROM_NO == shortageCurrentOut.CN_S_OP_NO);
|
if (oldOutLocking.Any())
|
{
|
oldOutLocking.ForEach(f =>
|
{
|
f.CN_S_FROM_NO = outMst.CN_S_OP_NO;
|
});
|
}
|
}
|
//记录之前的出库单，取消 || 全部缺货
|
bResult.CancelAndAllShortageOut.Add(shortageCurrentOut);
|
}
|
|
//修改出库订单主子表为‘待出库’
|
outMst.CN_S_STATE = Constants.State_WaitOut;
|
|
outMst.OutDtlList.ForEach(p =>
|
{
|
p.CN_S_STATE = outMst.CN_S_STATE;
|
});
|
//if (outMst.CN_S_OUT_TYPE != Constants.OutType_BigOut)
|
//{
|
// var bigOut = GenerateBigOut(ref outMst, bResult.CancelAndAllShortageOut);
|
// if (bigOut != null)
|
// {
|
// //锁定明细把大件的排除掉
|
// var bigItems = bResult.OutLockingDtlList.FindAll(f => f.CN_S_FROM_NO == bigOut.CN_S_SPLIT_FROM && bigOut.OutDtlList.Exists(e => e.CN_S_ITEM_CODE == f.CN_S_ITEM_CODE));
|
// bigItems.ForEach(e =>
|
// {
|
// bResult.OutLockingDtlList.Remove(e);
|
// });
|
// bResult.ShortageOutList.Add(bigOut);
|
// //如果当前单据也是拆分的单据，并且全部是大件时
|
// if (!string.IsNullOrEmpty(outMst.CN_S_SPLIT_FROM) && !outMst.OutDtlList.Any())
|
// {
|
// var exists = bResult.ShortageOutList.Find(f => f.CN_S_OP_NO == outMst.CN_S_OP_NO);
|
// if (exists != null)
|
// bResult.ShortageOutList.Remove(exists);
|
// }
|
// }
|
//}
|
if (outMst.OutDtlList.Any())
|
{
|
bResult.OutMstList.Add(outMst);
|
// 生成出库单号
|
UserRuleEntity user = new UserRuleEntity()
|
{
|
OrgCode = "0",
|
RuleCode = Constants.Rule_Out
|
};
|
string outNo = user.GenerateNo();
|
|
//发货单子表明细
|
if (outMst.OutDtlList.Any())
|
{
|
//减少库存业务主表
|
var reduceInventoryMstEntity = GetReduceInventoryMst(outNo, Constants.Rule_OutOrder, outMst);
|
//减少库存业务子表
|
reduceInventoryMstEntity.DTLEntity.AddRange(GetReduceInventoryDtl(outNo, outMst.OutDtlList));
|
//记录减少库存业务表
|
bResult.ReduceInventoryMstList.Add(reduceInventoryMstEntity);
|
}
|
}
|
}
|
#endregion
|
|
return OperateResult.Succeed(null, bResult);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
private static TN_WM_OUT_MSTEntity GenerateBigOut(ref TN_WM_OUT_MSTEntity currentOutEntity, List<TN_WM_OUT_MSTEntity> cancelList)
|
{
|
List<TN_WM_OUT_DTLEntity> bigDtlList = currentOutEntity.OutDtlList.FindAll(a => a.CN_C_BIG);
|
if (bigDtlList.Any())
|
{
|
TN_WM_OUT_MSTEntity newOutMst = currentOutEntity.Clone() as TN_WM_OUT_MSTEntity;
|
newOutMst.CN_GUID = Guid.NewGuid().ToString();
|
string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_OutOrder + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
|
string orderNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
|
newOutMst.CN_S_OP_NO = orderNo;
|
newOutMst.CN_S_STATE = Constants.State_Audit;
|
bigDtlList.ForEach(e =>
|
{
|
e.CN_GUID = Guid.NewGuid().ToString();
|
e.CN_S_OP_NO = orderNo;
|
e.CN_S_ITEM_STATE = newOutMst.CN_S_STATE;
|
e.CN_S_MSTGUID = newOutMst.CN_GUID;
|
});
|
newOutMst.CN_S_SPLIT_FROM = currentOutEntity.CN_S_OP_NO;
|
newOutMst.CN_S_OUT_TYPE = Constants.OutType_BigOut;
|
newOutMst.OutDtlList = bigDtlList;
|
if (!string.IsNullOrEmpty(currentOutEntity.CN_S_SPLIT_FROM))
|
{
|
//之前单据是拆分后的单据
|
newOutMst.CN_S_SPLIT_FROM = currentOutEntity.CN_S_SPLIT_FROM;
|
}
|
else
|
{
|
//取消之前的单据
|
currentOutEntity.CN_B_CANCEL = true;
|
cancelList.Add(currentOutEntity);
|
}
|
//全部都是大件
|
if (currentOutEntity.OutDtlList.Sum(s => s.CN_F_QUANTITY) == bigDtlList.Sum(s => s.CN_F_QUANTITY))
|
{
|
currentOutEntity.OutDtlList = new List<TN_WM_OUT_DTLEntity>();
|
}
|
else
|
{
|
//非大件
|
currentOutEntity.OutDtlList = currentOutEntity.OutDtlList.FindAll(a => !a.CN_C_BIG);
|
}
|
return newOutMst;
|
}
|
return null;
|
}
|
|
#region 取消当前发货单，返回新的发货单
|
/// <summary>
|
/// 取消当前发货单，返回新的发货单
|
/// </summary>
|
/// <param name="oldOutEntity"></param>
|
/// <param name="isShortage">是否返回缺货的</param>
|
/// <returns></returns>
|
private static TN_WM_OUT_MSTEntity GenerateNewOut(TN_WM_OUT_MSTEntity oldOutEntity, bool isShortage)
|
{
|
TN_WM_OUT_MSTEntity newOutMst = oldOutEntity.Clone() as TN_WM_OUT_MSTEntity;
|
newOutMst.CN_GUID = Guid.NewGuid().ToString();
|
string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_OutOrder + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
|
string orderNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
|
newOutMst.CN_S_OP_NO = orderNo;
|
newOutMst.CN_S_SPLIT_FROM = oldOutEntity.CN_S_OP_NO;
|
newOutMst.CN_S_STATE = isShortage ? Constants.State_Shortage : Constants.State_WaitOut;
|
newOutMst.OutDtlList = new List<TN_WM_OUT_DTLEntity>();
|
foreach (var dtl in oldOutEntity.OutDtlList)
|
{
|
TN_WM_OUT_DTLEntity newOutDtl = dtl.Clone() as TN_WM_OUT_DTLEntity;
|
newOutDtl.CN_GUID = Guid.NewGuid().ToString();
|
newOutDtl.CN_S_OP_NO = newOutMst.CN_S_OP_NO;
|
newOutDtl.CN_S_MSTGUID = newOutMst.CN_GUID;
|
newOutDtl.CN_S_STATE = newOutMst.CN_S_STATE;
|
//生成缺货的明细
|
if (isShortage)
|
{
|
if (dtl.CN_F_SHORTAGE_QTY > 0)
|
{
|
|
newOutMst.CN_S_OUT_TYPE = Constants.OutType_ShortageOut;
|
newOutDtl.CN_F_QUANTITY = dtl.CN_F_SHORTAGE_QTY;
|
}
|
}
|
else//生成新的明细
|
{
|
if (dtl.CN_F_QUANTITY > dtl.CN_F_SHORTAGE_QTY)
|
{
|
newOutDtl.CN_F_QUANTITY = dtl.CN_F_QUANTITY - dtl.CN_F_SHORTAGE_QTY;
|
}
|
}
|
if (newOutDtl.CN_F_QUANTITY > 0)
|
newOutMst.OutDtlList.Add(newOutDtl);
|
}
|
return newOutMst;
|
}
|
#endregion
|
}
|
}
|
