using HH.WMS.Entitys;
|
using HH.WMS.Entitys.Common;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Threading.Tasks;
|
using Newtonsoft.Json;
|
using HH.WMS.Entitys.Basic;
|
using System.Threading;
|
using HH.WMS.Common;
|
using HH.WMS.BLL;
|
using HH.WMS.BLL.CoreServer;
|
using HH.WMS.Entitys.Sys;
|
using HH.WMS.BLL.OutStock;
|
using HH.WMS.BLL.Algorithm;
|
using HH.WMS.Common.Algorithm;
|
using HH.WMS.Common.Algorithm.Out;
|
using HH.WMS.BLL.Common;
|
|
namespace HH.WMS.CoreServer.Service
|
{
|
public class WaveService
|
{
|
#region 线程
|
//内销线程
|
public Thread thNxCreateWave = null;
|
//外销线程
|
public Thread thWxCreateWave = null;
|
//执行分拣单线程
|
public Thread thExecuteSorting = null;
|
//执行分拣出，盘点出的任务
|
public Thread thExecuteTask = null;
|
#endregion
|
|
#region 开始
|
/// <summary>
|
/// 开始
|
/// </summary>
|
public void Start()
|
{
|
|
|
|
|
#region 执行分拣单
|
//执行分拣单
|
thExecuteSorting = thExecuteSorting ?? new Thread(() =>
|
{
|
DoRepeatAction(ExecuteSorting);
|
});
|
thExecuteSorting.IsBackground = true;
|
thExecuteSorting.Start();
|
#endregion
|
|
#region 执行任务
|
//执行任务
|
thExecuteTask = thExecuteTask ?? new Thread(() =>
|
{
|
DoRepeatAction(ExecuteTask);
|
});
|
thExecuteTask.IsBackground = true;
|
thExecuteTask.Start();
|
#endregion
|
}
|
#endregion
|
|
#region 重复执行一个action
|
/// <summary>
|
/// 重复执行一个action
|
/// </summary>
|
/// <param name="action"></param>
|
private void DoRepeatAction(Func<OperateResult> func)
|
{
|
while (true)
|
{
|
try
|
{
|
var result = func();
|
if (!result.Success)
|
{
|
Log.Info("error", result.Msg);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Info("error", ex.Message);
|
}
|
finally
|
{
|
//每次执行完休眠2秒钟
|
Thread.Sleep(2000);
|
}
|
}
|
}
|
#endregion
|
|
#region 执行分拣单，生成分拣明细
|
/// <summary>
|
/// 执行分拣单，生成分拣明细
|
/// </summary>
|
/// <returns></returns>
|
public OperateResult ExecuteSorting()
|
{
|
//获取待分拣分拣单
|
var staySortings = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetTopList(5, new
|
{
|
CN_S_STATE = Constants.Sorting_Stay
|
});
|
//分拣单子表
|
var staySortingDtl = new List<TN_WM_SORTING_DTLEntity>();
|
if (staySortings.Any())
|
{
|
//获取分拣单子表
|
staySortingDtl = BLLCreator.CreateDapper<TN_WM_SORTING_DTLEntity>().GetList(new
|
{
|
CN_S_SORTING_NO = staySortings.Select(s => s.CN_S_SORTING_NO).ToList()
|
});
|
}
|
//逐个执行，单个失败不会return
|
foreach (var staySorting in staySortings)
|
{
|
staySorting.SortingDtlList = staySortingDtl.FindAll(f => f.CN_S_SORTING_NO == staySorting.CN_S_SORTING_NO);
|
//调用算法获取分拣明细
|
var sortingLocationResult = GetSortingLocation(staySorting);
|
if (!sortingLocationResult.Success)
|
{
|
//消息
|
Log.Info("分拣单获取分拣明细失败：", JsonConvert.SerializeObject(sortingLocationResult));
|
continue;
|
}
|
//分拣明细
|
var sortingLocations = sortingLocationResult.GetData<List<TN_WM_SORTING_LOCATIONEntity>>();
|
staySorting.SortingLocationList.AddRange(sortingLocations);
|
|
|
var currentArea = BLLCreator.Create<MongoBLL>().GetArea(staySorting.CN_S_STOCK_AREA);
|
//自动库时生成任务
|
if (currentArea.CN_C_IS_AUTO == Constants.Y)
|
{
|
//生成任务
|
List<string> endAreas = new List<string>();
|
var outTaskResult = GetOutTask(staySorting, ref endAreas);
|
if (!outTaskResult.Success)
|
{
|
Log.Info("分拣单生成出库任务失败：", JsonConvert.SerializeObject(outTaskResult));
|
continue;
|
}
|
var tasks = outTaskResult.GetData<List<TN_WM_TASKEntity>>();
|
staySorting.Tasks = tasks;
|
staySorting.EndBits = endAreas;
|
}
|
|
var executeResult = BLLCreator.Create<WaveServiceBLL>().ExecuteSorting(staySorting);
|
if (!executeResult.Success)
|
{
|
//消息
|
Log.Info("执行分拣executeResult失败：", JsonConvert.SerializeObject(executeResult));
|
continue;
|
}
|
}
|
return OperateResult.Succeed();
|
}
|
#endregion
|
|
#region 执行任务
|
/// <summary>
|
/// 执行任务
|
/// </summary>
|
/// <returns></returns>
|
public OperateResult ExecuteTask()
|
{
|
var noExecuteTask = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetList(new
|
{
|
CN_B_SENDAMS = false,
|
CN_S_TASK_TYPE = new List<string>() { Constants.TaskType_SortingOut, Constants.TaskType_CheckOut },
|
}).OrderBy(o=>o.CN_T_CREATE);
|
foreach (var task in noExecuteTask)
|
{
|
//需要调作业区入库算法，算出货位给出库任务
|
var inAssignEntity = new InAssignEntity
|
{
|
objectType = InAssignEntity.ObjectType.托盘,
|
objectCode = task.CN_S_TRAY_CODE,
|
lockLocation = false,
|
lstAreaPrior = new List<areaPriorClass>()
|
{
|
{
|
new areaPriorClass{
|
areaCode = task.CN_S_END_AREA,
|
Prior = 1
|
}
|
}
|
}
|
};
|
Log.Info("ExecuteTask调用算法InAssign参数", JsonConvert.SerializeObject(inAssignEntity));
|
InAssignResultEntity inAssignResultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(inAssignEntity);
|
Log.Info("ExecuteTask调用算法InAssign结果", JsonConvert.SerializeObject(inAssignResultEntity));
|
if (!inAssignResultEntity.Success) continue;
|
|
//当前分拣单库区
|
task.EndAreaEntity = BLLCreator.Create<MongoBLL>().GetArea(task.CN_S_END_AREA);
|
|
task.CN_S_END_BIT = inAssignResultEntity.locationCode;
|
var executeTaskResult = BLLCreator.Create<WaveServiceBLL>().ExecuteTask(task);
|
if (!executeTaskResult.Success)
|
Log.Info("executeTaskResult Msg", executeTaskResult.Msg);
|
}
|
return OperateResult.Succeed();
|
}
|
#endregion
|
|
#region 获取任务
|
/// <summary>
|
/// 获取任务
|
/// </summary>
|
/// <param name="sortingEntity"></param>
|
/// <param name="endAreas"></param>
|
/// <returns></returns>
|
public OperateResult GetOutTask(TN_WM_SORTING_LISTEntity sortingEntity, ref List<string> endAreas)
|
{
|
try
|
{
|
//当前分拣单库区
|
var currentArea = BLLCreator.Create<MongoBLL>().GetArea(sortingEntity.CN_S_STOCK_AREA);
|
if (currentArea == null)
|
return OperateResult.Error("未找到库区：" + sortingEntity.CN_S_STOCK_AREA);
|
//托盘货位分组
|
var trayGroup = sortingEntity.SortingLocationList.GroupBy(g => new
|
{
|
g.CN_S_SORTING_NO,
|
g.CN_S_TRAY_CODE,
|
g.CN_S_LOCATION_CODE
|
}).Select(s => new
|
{
|
s.Key.CN_S_SORTING_NO,
|
s.Key.CN_S_TRAY_CODE,
|
s.Key.CN_S_LOCATION_CODE,
|
CN_F_QUANTITY = s.Sum(m => m.CN_F_QUANTITY)
|
});
|
//整托托盘
|
List<string> fullTrayCode = new List<string>();
|
//托盘区的需要考虑整托
|
if (currentArea.CN_S_AREA_NAME == Constants.TrayArea)
|
{
|
//托盘数量汇总
|
var trayQtyGroup = trayGroup.GroupBy(g => g.CN_S_TRAY_CODE).Select(s => new
|
{
|
CN_S_TRAY_CODE = s.Key,
|
CN_F_QUANTITY = s.Sum(m => m.CN_F_QUANTITY)
|
});
|
//所有托盘物料关联明细
|
var trayItems = BLLCreator.CreateDapper<TN_WM_B_TRAY_ITEM_MSTEntity>().GetList(new
|
{
|
CN_S_TRAY_CODE = trayQtyGroup.Select(s => s.CN_S_TRAY_CODE).ToList()
|
});
|
//比较算法返回的托盘物料数量与明细数量是否相等（整托）
|
foreach (var tray in trayQtyGroup)
|
{
|
//整托
|
if (tray.CN_F_QUANTITY ==
|
trayItems.Where(s => s.CN_S_TRAY_CODE == tray.CN_S_TRAY_CODE)
|
.Sum(m => m.CN_F_QUANTITY))
|
{
|
fullTrayCode.Add(tray.CN_S_TRAY_CODE);
|
}
|
}
|
}
|
List<TN_WM_TASKEntity> taskList = new List<TN_WM_TASKEntity>();
|
//存在非整托货位托盘
|
var pickTrays = trayGroup.Where(s => !fullTrayCode.Contains(s.CN_S_TRAY_CODE))
|
.Select(e => new TN_WM_SORTING_LOCATIONEntity()
|
{
|
CN_S_SORTING_NO = e.CN_S_SORTING_NO,
|
CN_S_TRAY_CODE = e.CN_S_TRAY_CODE,
|
CN_S_LOCATION_CODE = e.CN_S_LOCATION_CODE,
|
}).ToList();
|
if (pickTrays.Any())
|
{
|
//非整托任务
|
WorkflowEntity workflowEntity = new WorkflowEntity(Constants.Workflow_Out)
|
{
|
CirObj = Constants.Tray,
|
StartArea = currentArea.CN_S_AREA_CODE,
|
ReturnList = true
|
};
|
//找站点 GetWorkPosition
|
var trayWorkflow = BLLCreator.Create<WorkflowBLL>().GetWorkPosition(workflowEntity);
|
if (!trayWorkflow.Success) return trayWorkflow;
|
var workAreaPro = trayWorkflow.GetData<List<TN_WM_WORK_AREA_PROEntity>>();
|
//分拣出库任务
|
var pickTasks = GetTaskEntity(workAreaPro[0], pickTrays);
|
endAreas.AddRange(workAreaPro.Select(s => s.CN_S_END_AREA_CODE).ToList());
|
taskList.AddRange(pickTasks);
|
}
|
//存在非整托货位托盘
|
var fullTrays = trayGroup.Where(s => fullTrayCode.Contains(s.CN_S_TRAY_CODE))
|
.Select(e => new TN_WM_SORTING_LOCATIONEntity()
|
{
|
CN_S_SORTING_NO = e.CN_S_SORTING_NO,
|
CN_S_TRAY_CODE = e.CN_S_TRAY_CODE,
|
CN_S_LOCATION_CODE = e.CN_S_LOCATION_CODE,
|
}).ToList();
|
if (fullTrays.Any())
|
{
|
//整托任务
|
WorkflowEntity workflowEntity = new WorkflowEntity(Constants.Workflow_Out)
|
{
|
CirObj = Constants.Tray,
|
StartArea = currentArea.CN_S_AREA_CODE,
|
IsFullTray = Constants.Y,
|
};
|
//找站点 GetWorkPosition
|
var trayWorkflow = BLLCreator.Create<WorkflowBLL>().GetWorkPosition(workflowEntity);
|
if (!trayWorkflow.Success) return trayWorkflow;
|
var workAreaPro = trayWorkflow.GetData<TN_WM_WORK_AREA_PROEntity>();
|
|
//需要调作业区入库算法，算出货位给出库任务
|
var inAssignEntity = new InAssignEntity
|
{
|
objectType = InAssignEntity.ObjectType.托盘,
|
objectCode = fullTrays[0].CN_S_TRAY_CODE,
|
lockLocation = false,
|
lstAreaPrior = new List<areaPriorClass>()
|
{
|
{
|
new areaPriorClass{
|
areaCode = workAreaPro.CN_S_END_AREA_CODE,
|
Prior = 1
|
}
|
}
|
}
|
};
|
Log.Info("调用算法InAssign参数", JsonConvert.SerializeObject(inAssignEntity));
|
InAssignResultEntity inAssignResultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(inAssignEntity);
|
Log.Info("调用算法InAssign结果", JsonConvert.SerializeObject(inAssignResultEntity));
|
if (!inAssignResultEntity.Success) return OperateResult.Error(inAssignResultEntity.Msg);
|
//整托出库任务
|
var fullTasks = GetTaskEntity(workAreaPro, pickTrays, inAssignResultEntity.locationCode);
|
|
taskList.AddRange(fullTasks);
|
}
|
return OperateResult.Succeed(null, taskList);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
#region 获取任务实体
|
/// <summary>
|
/// 获取任务实体
|
/// </summary>
|
/// <param name="workArea"></param>
|
/// <param name="sortingEntity"></param>
|
/// <returns></returns>
|
private List<TN_WM_TASKEntity> GetTaskEntity(TN_WM_WORK_AREA_PROEntity workArea, List<TN_WM_SORTING_LOCATIONEntity> sortingLocations, string endBit = "")
|
{
|
var trayLocationGroup = sortingLocations.GroupBy(g => new
|
{
|
g.CN_S_TRAY_CODE,
|
g.CN_S_LOCATION_CODE,
|
g.CN_S_SORTING_NO
|
}).Select(s => new
|
{
|
s.Key.CN_S_TRAY_CODE,
|
s.Key.CN_S_LOCATION_CODE,
|
s.Key.CN_S_SORTING_NO
|
});
|
List<TN_WM_TASKEntity> taskList = new List<TN_WM_TASKEntity>();
|
foreach (var task in trayLocationGroup)
|
{
|
string postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_TaskNo + "\",\"orgId\":\"\",\"orgFlag\":\"\"}";
|
string taskNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
|
|
TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
|
{
|
CN_S_TASK_NO = taskNo,
|
CN_S_TASK_TYPE = Constants.TaskType_SortingOut,
|
CN_S_FROM_OP = Constants.Out,
|
CN_S_FROM_NO = task.CN_S_SORTING_NO,
|
CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
|
CN_S_STOCK_CODE = "",
|
CN_S_START_AREA = workArea.CN_S_START_AREA_CODE,
|
CN_S_START_BIT = task.CN_S_LOCATION_CODE,
|
CN_S_END_AREA = workArea.CN_S_END_AREA_CODE,
|
CN_S_END_BIT = endBit,
|
CN_S_STATE = Constants.TaskState_NoExecuted,
|
CN_T_CREATE = DateTime.Now,
|
CN_T_MODIFY = DateTime.Now,
|
EndAreaEntity = BLLCreator.Create<MongoBLL>().GetArea(workArea.CN_S_END_AREA_CODE)
|
};
|
taskList.Add(taskEntity);
|
}
|
return taskList;
|
}
|
#endregion
|
|
#region 是否在上班时间
|
/// <summary>
|
/// 是否在上班时间
|
/// </summary>
|
/// <returns></returns>
|
private WaveConfig WaveConfig()
|
{
|
//没加仓库条件
|
var waveStrategyValues = BLLCreator.CreateDapper<TN_WM_B_STRATEGY_VALUEEntity>().GetList(new
|
{
|
CN_S_CODE = new List<string>
|
{
|
Constants.Strategy_StartTime,
|
Constants.Strategy_EndTime,
|
Constants.Strategy_SeveralMaxCreateWave,
|
Constants.Strategy_LessMinute
|
}
|
});
|
WaveConfig waveConfig = new WaveConfig();
|
//上班时间
|
var startTime = waveStrategyValues.Find(f => f.CN_S_CODE == Constants.Strategy_StartTime);
|
string _startTime = startTime != null ? startTime.CN_S_VALUE : Constants.WaveDefault_StartTime;
|
_startTime = string.IsNullOrEmpty(_startTime) ? Constants.WaveDefault_StartTime : _startTime;
|
waveConfig.StartTime = DateTime.Parse(_startTime);
|
//下班时间
|
var endTime = waveStrategyValues.Find(f => f.CN_S_CODE == Constants.Strategy_EndTime);
|
string _endTime = endTime != null ? endTime.CN_S_VALUE : Constants.WaveDefault_EndTime;
|
_endTime = string.IsNullOrEmpty(_endTime) ? Constants.WaveDefault_EndTime : _endTime;
|
waveConfig.EndTime = DateTime.Parse(_endTime);
|
//内销几单一波
|
var severalMaxCreateWave = waveStrategyValues.Find(f => f.CN_S_CODE == Constants.Strategy_SeveralMaxCreateWave);
|
string _severalMaxCreateWave = severalMaxCreateWave != null ? severalMaxCreateWave.CN_S_VALUE : Constants.WaveDefault_SeveralMaxCreateWave;
|
_severalMaxCreateWave = string.IsNullOrEmpty(_severalMaxCreateWave) ? Constants.WaveDefault_SeveralMaxCreateWave : _severalMaxCreateWave;
|
waveConfig.SeveralMaxCreateWave = int.Parse(_severalMaxCreateWave);
|
//内销几分钟后生成
|
var lessMinute = waveStrategyValues.Find(f => f.CN_S_CODE == Constants.Strategy_LessMinute);
|
string _lessMinute = lessMinute != null ? lessMinute.CN_S_VALUE : Constants.WaveDefault_LessMinute;
|
_lessMinute = string.IsNullOrEmpty(_lessMinute) ? Constants.WaveDefault_LessMinute : _lessMinute;
|
waveConfig.LessMinute = int.Parse(_lessMinute);
|
//result
|
return waveConfig;
|
}
|
#endregion
|
|
#region 是否在上班时间
|
/// <summary>
|
/// 是否在上班时间
|
/// </summary>
|
/// <param name="waveConfig"></param>
|
/// <returns></returns>
|
private bool IsWorkTime(WaveConfig waveConfig)
|
{
|
try
|
{
|
TimeSpan dspWorkingDayAM = waveConfig.StartTime.TimeOfDay;
|
TimeSpan dspWorkingDayPM = waveConfig.EndTime.TimeOfDay;
|
TimeSpan dspNow = DateTime.Now.TimeOfDay;
|
if (dspNow >= dspWorkingDayAM && dspNow <= dspWorkingDayPM)
|
{
|
return true;
|
}
|
return false;
|
}
|
catch
|
{
|
return false;
|
}
|
}
|
#endregion
|
|
#region 创建波次分拣单
|
/// <summary>
|
/// 创建波次分拣单
|
/// </summary>
|
/// <param name="outList"></param>
|
/// <param name="isNX">是否内销</param>
|
/// <returns></returns>
|
public OperateResult WaveCreate(List<TN_WM_OUT_MSTEntity> outList)
|
{
|
//登陆信息&生成单号
|
UserRuleEntity user = new UserRuleEntity()
|
{
|
RuleCode = Constants.Rule_WaveNo
|
};
|
//生成波次号
|
string waveNo = user.GenerateNo();
|
|
return ChangeOutOperate(outList, (outMstList, batchesList, stockList, lstStrate) =>
|
{
|
|
//批分分配量
|
var bResult = stockList.BatchesStockAllocQty(batchesList, lstStrate);
|
if (!bResult.Success)
|
return bResult;
|
//批分结果数据
|
var batchesResult = bResult.GetData<BatchesResult>();
|
if (batchesResult == null)
|
return OperateResult.Error("生成打单数据异常");
|
//算库区
|
OperateResult outAreaResult = OutArea(batchesResult.OutMstList);
|
if (!outAreaResult.Success) return outAreaResult;
|
//算法库区返回结果
|
var algorResultEntity = outAreaResult.GetData<OutAreaResultAllEntity>();
|
Log.Info("WaveCreate 调用OutArea返回值algorResultEntity", JsonConvert.SerializeObject(algorResultEntity));
|
//算法库区返回结果
|
if (!algorResultEntity.Success)
|
return OperateResult.Error("算法异常：" + algorResultEntity.Msg);
|
//算法结果
|
var algorResult = algorResultEntity.itemOutAreaResult;
|
//算法结果
|
if (algorResult == null)
|
return OperateResult.Error("库存不足，请先完成来料区的上架");
|
//获取分拣单数据
|
var sortingDataResult = GetSortingData(algorResult, user, waveNo);
|
if (!sortingDataResult.Success)
|
return sortingDataResult;
|
//生成的分拣单数据
|
var sortingList = sortingDataResult.GetData<List<TN_WM_SORTING_LISTEntity>>();
|
List<string> itemCodes = new List<string>();
|
sortingList.ForEach(x =>
|
{
|
if (x.SortingDtlList != null)
|
x.SortingDtlList.ForEach(y =>
|
{
|
itemCodes.Add(y.CN_S_ITEM_CODE);
|
});
|
});
|
//分拣单的所有库区量表数据
|
var stockAreaList = BLLCreator.Create<DapperBLL<TN_WM_B_AREA_QTYEntity>>().GetList(new
|
{
|
CN_S_STOCK_AREA = sortingList.Select(x => x.CN_S_STOCK_AREA).ToList(),
|
CN_S_ITEM_CODE = itemCodes
|
});
|
|
Log.Info("批分库区参数 sortingList:", JsonConvert.SerializeObject(sortingList));
|
Log.Info("批分库区参数 lstStrate:", JsonConvert.SerializeObject(lstStrate));
|
//批分库区量表
|
var batchesAreaResult = stockAreaList.BatchesAreaQty(sortingList, lstStrate);
|
if (!batchesAreaResult.Success)
|
return batchesAreaResult;
|
Log.Info("批分库区结果 batchesAreaResult:", JsonConvert.SerializeObject(batchesAreaResult));
|
|
//波次实体
|
batchesResult.WaveMst = GetWaveEntity(batchesResult, waveNo);
|
if (batchesResult.ShortageOutList.Any())
|
{
|
//新的发货单赋值波次号
|
batchesResult.ShortageOutList.ForEach(f =>
|
{
|
if (f.CN_S_STATE != Constants.State_Shortage)
|
f.CN_S_WAVE_CODE = batchesResult.WaveMst.CN_S_WAVE_NO;
|
});
|
}
|
//分拣单实体
|
batchesResult.SortingList = sortingList;
|
//库区量表实体
|
batchesResult.StockAreaList = stockAreaList;
|
//创建波次分拣单
|
return BLLCreator.Create<WaveServiceBLL>().WaveCreate(batchesResult);
|
});
|
}
|
#endregion
|
|
#region 获取分拣单数据
|
/// <summary>
|
/// 获取分拣单数据
|
/// </summary>
|
/// <param name="outAreaResultList"></param>
|
/// <param name="user"></param>
|
/// <param name="waveNo"></param>
|
/// <returns></returns>
|
public OperateResult GetSortingData(List<OutAreaResultEntity> outAreaResultList, UserRuleEntity user, string waveNo)
|
{
|
try
|
{
|
//分拣单
|
List<TN_WM_SORTING_LISTEntity> sortingList = new List<TN_WM_SORTING_LISTEntity>();
|
//分拣单组别
|
user.RuleCode = Constants.SortingGroup;
|
string sortingGroup = user.GenerateNo();
|
//分拣单号
|
user.RuleCode = Constants.SortingNo;
|
int sortingIndex = 1;
|
IEnumerable<IGrouping<dynamic, OutAreaResultEntity>> igOutAreaResult = outAreaResultList.GroupBy(x => new { x.stockCode, x.areaCode });
|
foreach (var _igOutAreaResult in igOutAreaResult)
|
{
|
//分拣单
|
TN_WM_SORTING_LISTEntity sortingEntity = new TN_WM_SORTING_LISTEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_SORTING_NO = waveNo + "-" + sortingIndex++,
|
CN_S_OP_FROM = Constants.Rule_WaveNo,
|
CN_S_FROM_NO = waveNo,
|
CN_T_OPERATE = DateTime.Now.ToString(),// "", //丢里咯木
|
CN_S_STOCK_CODE = _igOutAreaResult.Key.stockCode,
|
CN_S_STOCK_AREA = _igOutAreaResult.Key.areaCode,
|
CN_S_STATE = Constants.Sorting_Stay,
|
CN_S_SEEDING_MODE = "",
|
CN_S_GROUP = sortingGroup,
|
CN_S_CREATOR = user.LoginCode,
|
CN_S_CREATOR_BY = user.LoginName,
|
CN_T_CREATE = DateTime.Now,
|
CN_S_MODIFY = user.LoginCode,
|
CN_S_MODIFY_BY = user.LoginName,
|
CN_T_MODIFY = DateTime.Now
|
};
|
//分拣单子表行索引
|
int sortingDtlindex = 1;
|
//分拣单子表
|
sortingEntity.SortingDtlList = new List<TN_WM_SORTING_DTLEntity>();
|
//分拣明细
|
sortingEntity.SortingLocationList = new List<TN_WM_SORTING_LOCATIONEntity>();
|
foreach (var outArea in _igOutAreaResult.AsEnumerable())
|
{
|
foreach (var d in outArea.lstItem)
|
{
|
//物料详细
|
AutoBomItemEntity item = BLLCreator.Create<MongoBLL>().GetItemEntity(d.itemCode) ?? new AutoBomItemEntity();
|
//分拣单子行
|
TN_WM_SORTING_DTLEntity sortingDtlEntity = new TN_WM_SORTING_DTLEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO,
|
CN_N_ROW_NO = sortingDtlindex++,
|
CN_F_QUANTITY = d.itemQty,
|
CN_S_ITEM_CODE = d.itemCode,
|
CN_S_ITEM_NAME = item.CN_S_ITEM_NAME,
|
CN_S_STATE = Constants.Sorting_Stay,
|
CN_S_LOT_NO = outArea.batchCode,
|
CN_S_PRODUCTION_BATCH = outArea.prodBatchCode,
|
CN_S_ITEM_STATE = outArea.itemState,
|
CN_S_OWNER = outArea.ownerName,
|
CN_S_MODEL = item.CN_S_MODEL,
|
CN_S_FIGURE_NO = item.CN_S_FIGURE_NO,
|
CN_S_MEASURE_UNIT = item.CN_S_MEASURE_UNIT
|
};
|
sortingEntity.SortingDtlList.Add(sortingDtlEntity);
|
}
|
}
|
sortingList.Add(sortingEntity);
|
}
|
return OperateResult.Succeed(null, sortingList);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
#region 获取波次实体
|
/// <summary>
|
/// 获取波次实体
|
/// </summary>
|
/// <param name="bResult"></param>
|
/// <returns></returns>
|
private TN_WM_WAVE_MSTEntity GetWaveEntity(BatchesResult bResult, string waveNo)
|
{
|
TN_WM_WAVE_MSTEntity waveMstEntity = new TN_WM_WAVE_MSTEntity()
|
{
|
CN_S_CREATE_TYPE = Constants.CreateType_Manual,
|
CN_S_WAVE_NO = waveNo,
|
CN_S_FROM = "WMS",
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_STATE = Constants.Sorting_Stay,
|
CN_T_CREATE = DateTime.Now,
|
CN_T_MODIFY = DateTime.Now,
|
CN_T_OPERATE = DateTime.Now,
|
CN_S_CREATOR = "自动",
|
CN_S_CREATOR_BY = "auto",
|
CN_S_MODIFY = "自动",
|
CN_S_MODIFY_BY = "auto",
|
CN_C_NEED_SEEDING = Constants.Y,
|
CN_S_STATUS = Constants.State_New,
|
CN_S_SEEDING_MODE = "",
|
CN_S_STOCK_CODE = bResult.OutMstList[0].CN_S_STOCK_CODE
|
};
|
waveMstEntity.WaveDtlList = new List<TN_WM_WAVE_DTLEntity>();
|
int index = 1;
|
foreach (var outDtl in bResult.OutMstList)
|
{
|
TN_WM_WAVE_DTLEntity waveDtlEntity = new TN_WM_WAVE_DTLEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_WAVE_NO = waveNo,
|
CN_S_ORDER_NO = outDtl.CN_S_OP_NO,
|
CN_S_STATE = Constants.State_New,
|
CN_T_CREATE = DateTime.Now,
|
CN_T_MODIFY = DateTime.Now,
|
CN_S_CREATOR = "自动",
|
CN_S_CREATOR_BY = "auto",
|
CN_S_MODIFY = "自动",
|
CN_S_MODIFY_BY = "auto",
|
CN_S_MSTGUID = waveMstEntity.CN_GUID,
|
CN_N_ORDER = index++
|
};
|
waveMstEntity.WaveDtlList.Add(waveDtlEntity);
|
}
|
return waveMstEntity;
|
}
|
#endregion
|
|
#region 获取分拣明细
|
/// <summary>
|
///获取分拣明细
|
/// </summary>
|
/// <param name="sortingEntity"></param>
|
/// <param name="user"></param>
|
/// <returns></returns>
|
private OperateResult GetSortingLocation(TN_WM_SORTING_LISTEntity sortingEntity)
|
{
|
try
|
{
|
//所有库区
|
var allAreas = BLLCreator.Create<MongoBLL>().GetArea();
|
//所有自动库区
|
var autoAreas = allAreas.FindAll(f => f.CN_C_IS_AUTO == Constants.Y);
|
//当前库区
|
var currentArea = allAreas.Find(f => f.CN_S_AREA_CODE == sortingEntity.CN_S_STOCK_AREA);
|
if (currentArea == null)
|
{
|
//未找到库区
|
string notFoundArea = "分拣单:{0}的库区:{1}在Mongo中未找到";
|
notFoundArea = string.Format(notFoundArea,
|
sortingEntity.CN_S_SORTING_NO,
|
sortingEntity.CN_S_STOCK_AREA);
|
return OperateResult.Error(notFoundArea);
|
}
|
//自动库分拣处理
|
if (currentArea.CN_C_IS_AUTO == Constants.Y)
|
{
|
if (currentArea.CN_S_CURRENT_MODE != Constants.CurrentMode_Out)
|
{
|
//当前库区不为出库模式，不允许生成明细
|
string notOutMode = "库区:{0}的模式为:{1},不允许执行分拣,请切换到:{2}";
|
notOutMode = string.Format(notOutMode,
|
currentArea.CN_S_AREA_CODE,
|
currentArea.CN_S_CURRENT_MODE,
|
Constants.CurrentMode_Out);
|
return OperateResult.Error(notOutMode);
|
}
|
// if (currentArea.CN_N_PICK_MAX > 0)
|
if(true)
|
{
|
//当前库区分拣中的分拣单
|
var beingSorting = BLLCreator.CreateDapper<TN_WM_SORTING_LISTEntity>().GetList(new
|
{
|
CN_S_STOCK_AREA = sortingEntity.CN_S_STOCK_AREA,
|
CN_S_STATE = Constants.Sorting_Being
|
});
|
//当前库区分拣中的分拣单数达到最大数
|
//if (beingSorting.Count >= currentArea.CN_N_PICK_MAX)
|
if (beingSorting.Count >=0)
|
{
|
//错误消息
|
string pickMaxError = "库区:{0}中正在分拣的分拣单数已达到可同时分拣的最大数:{1},请先分拣:{2}";
|
//pickMaxError = string.Format(pickMaxError, sortingEntity.CN_S_STOCK_AREA,
|
// currentArea.CN_N_PICK_MAX,
|
// string.Join(",", beingSorting.Select(s => s.CN_S_SORTING_NO))
|
// );
|
return OperateResult.Error(pickMaxError);
|
}
|
}
|
//调算法获取明细
|
return AlgorithmLocation(sortingEntity);
|
}
|
else
|
{
|
//收货区和暂存区
|
if (currentArea.CN_S_AREA_CLASS == Constants.ReceivingArea || currentArea.CN_S_AREA_CLASS == Constants.TempStorageArea)
|
{
|
return OperateResult.Error("收货区和暂存区的分拣明细待开发");
|
}
|
else//大件和平库的处理
|
{
|
return OperateResult.Error("大件和平库的分拣明细待开发");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
#region 算法获取明细
|
/// <summary>
|
/// 算法获取明细
|
/// </summary>
|
/// <param name="sortingEntity"></param>
|
/// <returns></returns>
|
private OperateResult AlgorithmLocation(TN_WM_SORTING_LISTEntity sortingEntity)
|
{
|
try
|
{
|
//分拣明细
|
List<TN_WM_SORTING_LOCATIONEntity> sortingLocationList = new List<TN_WM_SORTING_LOCATIONEntity>();
|
//调算法算货位
|
OperateResult outNewResult = OutNew(sortingEntity);
|
if (!outNewResult.Success) return outNewResult;
|
//算法结果
|
var outResult = outNewResult.GetData<OutResultEntityNew>();
|
//算法结果
|
if (outResult.lstItemNotEnough.Any())
|
{
|
outResult.lstItemNotEnough.ForEach(x =>
|
{
|
var currentNotEnough = sortingEntity.SortingDtlList.Find(s => s.CN_S_ITEM_CODE.Equals(x.itemCode));
|
if (currentNotEnough != null)
|
x.itemName = currentNotEnough.CN_S_ITEM_NAME;
|
});
|
return OperateResult.Warning("物料：" + string.Join(";", outResult.lstItemNotEnough.Select(x => x.itemCode)) + "库存不足，请先完成来料区的上架", outResult.lstItemNotEnough);
|
}
|
if (!outResult.Success)
|
return OperateResult.Error("算法异常：" + outResult.Msg);
|
|
if (sortingEntity.SortingDtlList.Sum(x => x.CN_F_QUANTITY) != Convert.ToDecimal(outResult.itemLocations.Sum(x => x.itemQty)))
|
{
|
return OperateResult.Error("算法异常：返回的物料信息不完整！");
|
}
|
var locations = outResult.itemLocations.Select(m =>
|
{
|
AutoBomItemEntity mm = BLLCreator.Create<MongoBLL>().GetItemEntity(m.itemCode) ?? new AutoBomItemEntity();
|
return new TN_WM_SORTING_LOCATIONEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString(),
|
CN_S_LOT_NO = m.batchCode,
|
CN_S_ITEM_STATE = m.itemState,
|
CN_S_OWNER = m.ownerName,
|
CN_F_QUANTITY = m.itemQty,
|
CN_F_PICKED_QTY = 0,
|
CN_S_ITEM_CODE = m.itemCode,
|
CN_S_LOCATION_CODE = m.locationCode,
|
CN_S_TRAY_CODE = m.trayCode,
|
CN_S_TRAY_GRID = m.trayGrid,
|
CN_S_SORTING_NO = sortingEntity.CN_S_SORTING_NO,
|
CN_S_STATE = sortingEntity.CN_S_STATE,
|
CN_S_ORDER_NO = "",
|
CN_S_CREATOR = "自动",
|
CN_S_CREATOR_BY = "auto",
|
CN_S_ITEM_NAME = mm.CN_S_ITEM_NAME,
|
CN_S_MODEL = mm.CN_S_MODEL,
|
CN_S_FIGURE_NO = mm.CN_S_FIGURE_NO,
|
CN_S_MEASURE_UNIT = mm.CN_S_MEASURE_UNIT,
|
CN_S_PACKING_UNIT = m.packUnit,
|
CN_F_PACKING_QTY = m.packQty,
|
CN_S_PRODUCTION_BATCH = m.prodBatchCode,
|
CN_T_CREATE = DateTime.Now,
|
CN_T_MODIFY = DateTime.Now
|
};
|
}).ToList();
|
sortingLocationList.AddRange(locations);
|
return OperateResult.Succeed(null, sortingLocationList);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
#region 带出出库订单,批分,仓库实体
|
/// <summary>
|
/// 带出出库订单实体
|
/// </summary>
|
/// <param name="opNo"></param>
|
/// <param name="funcOut"></param>
|
/// <returns></returns>
|
public OperateResult ChangeOutOperate(List<TN_WM_OUT_MSTEntity> outMst, Func<List<TN_WM_OUT_MSTEntity>, List<BatchesEntity>, List<TN_WM_B_STOCK_QTYEntity>, List<string>, OperateResult> funcOut)
|
{
|
try
|
{
|
List<BatchesEntity> batchesList = new List<BatchesEntity>();
|
|
foreach (var _out in outMst)
|
{
|
|
_out.OutDtlList = BLLCreator.Create<DapperBLL<TN_WM_OUT_DTLEntity>>().GetList(new
|
{
|
CN_S_OP_NO = _out.CN_S_OP_NO,
|
CN_C_AUTO_INOUT = false
|
});
|
//.FindAll(a =>
|
//{
|
// if (_out.CN_S_OUT_TYPE == Constants.OutType_BigOut) return true;
|
// //物料详细
|
// AutoBomItemEntity item = BLLCreator.Create<MongoBLL>().GetItemEntity(a.CN_S_ITEM_CODE);
|
// if (item == null)
|
// throw new Exception("autobom中未找到物料：" + a.CN_S_ITEM_CODE);
|
// if (item.CN_S_STORE_TYPE == Constants.BigArea)
|
// a.CN_C_BIG = true;
|
// return true;
|
//});
|
batchesList.AddRange(_out.OutDtlList.Select(p =>
|
{
|
return new BatchesEntity()
|
{
|
ItemCode = p.CN_S_ITEM_CODE,
|
ItemState = p.CN_S_ITEM_STATE,
|
ItemArrivalLot = p.CN_S_LOT_CODE,
|
ItemProductionLot = p.CN_S_PRODUCTION_BATCH,
|
Owner = _out.CN_S_OWNER,
|
Qty = p.CN_F_QUANTITY,
|
OpNo = _out.CN_S_OP_NO,
|
OutMst = _out,
|
IsFilter = p.CN_C_AUTO_INOUT
|
};
|
}).ToList());
|
}
|
//当前子表物料库存
|
var stockList = BLLCreator.Create<DapperBLL<TN_WM_B_STOCK_QTYEntity>>().GetList(new
|
{
|
CN_S_ITEM_CODE = batchesList.Select(p => p.ItemCode).ToList()
|
});
|
//算法策略
|
List<string> lstStrate = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetStrateListByAreaOrStock("", "", Constants.Out)
|
.OrderByDescending(a => a.CN_N_PRIORITY).Select(o => o.CN_S_CODE).ToList();
|
return funcOut(outMst, batchesList, stockList, lstStrate);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error(ex.Message);
|
}
|
}
|
#endregion
|
|
#region 算库区
|
/// <summary>
|
/// 算库区
|
/// </summary>
|
/// <param name="outMstList"></param>
|
/// <returns></returns>
|
private OperateResult OutArea(List<TN_WM_OUT_MSTEntity> outMstList)
|
{
|
try
|
{
|
//所有出库物料
|
var outItemList = new List<TN_WM_OUT_DTLEntity>();
|
outMstList.ForEach(p =>
|
{
|
//子表货主赋值
|
p.OutDtlList.ForEach(q => q.CN_S_OWNER = p.CN_S_OWNER);
|
outItemList.AddRange(p.OutDtlList);
|
});
|
//初始化调用算法数据
|
List<itemQueryClass> itemQuerys =
|
outItemList.GroupBy(p => new
|
{
|
p.CN_S_ITEM_CODE,
|
p.CN_S_ITEM_STATE,
|
p.CN_S_OWNER,
|
p.CN_S_LOT_CODE,
|
p.CN_S_PRODUCTION_BATCH
|
}).Select(x => new itemQueryClass()
|
{
|
itemCode = x.Key.CN_S_ITEM_CODE,
|
batchCode = x.Key.CN_S_LOT_CODE,
|
prodBatchCode = x.Key.CN_S_PRODUCTION_BATCH,
|
itemState = x.Key.CN_S_ITEM_STATE,
|
ownerName = x.Key.CN_S_OWNER,
|
stockCode = outMstList[0].CN_S_STOCK_CODE,
|
itemQty = x.Sum(y => y.CN_F_QUANTITY)
|
}).ToList();
|
//初始化调用算法库区
|
var allArea = BLLCreator.Create<MongoBLL>().GetArea();
|
List<areaPriorClass> lstAreaPrior = allArea.Select(p => new areaPriorClass()
|
{
|
areaCode = p.CN_S_AREA_CODE,
|
Prior = p.CN_N_PRIORITY
|
}).ToList();
|
|
Log.Info("调用OutArea参数 itemQuerys", JsonConvert.SerializeObject(itemQuerys));
|
Log.Info("调用OutArea参数 lstAreaPrior", JsonConvert.SerializeObject(lstAreaPrior));
|
//调用出库算法
|
string outAreaParams = JsonConvert.SerializeObject(new
|
{
|
itemQuerys = itemQuerys,
|
lstAreaPrior = lstAreaPrior
|
});
|
OutAreaResultAllEntity algorResultEntity = BLLCreator.Create<Out_AlgorBLL>().OutArea(itemQuerys, lstAreaPrior);
|
Log.Info("algorResultEntity", JsonConvert.SerializeObject(algorResultEntity));
|
|
return OperateResult.Succeed(null, algorResultEntity);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error("WaveService-OutArea:" + ex.Message);
|
}
|
}
|
#endregion
|
|
#region 算货位
|
/// <summary>
|
/// 算货位
|
/// </summary>
|
/// <param name="sortingEntity"></param>
|
/// <returns></returns>
|
private OperateResult OutNew(TN_WM_SORTING_LISTEntity sortingEntity)
|
{
|
try
|
{
|
//初始化调用算法数据
|
List<itemQueryClass> algorItems = sortingEntity.SortingDtlList.GroupBy(x => new
|
{
|
x.CN_S_ITEM_CODE,
|
x.CN_S_ITEM_STATE,
|
x.CN_S_OWNER,
|
x.CN_S_LOT_NO,
|
x.CN_S_PRODUCTION_BATCH
|
}).Select(y => new itemQueryClass()
|
{
|
stockCode = sortingEntity.CN_S_STOCK_CODE,
|
areaCode = sortingEntity.CN_S_STOCK_AREA,
|
itemCode = y.Key.CN_S_ITEM_CODE,
|
batchCode = y.Key.CN_S_LOT_NO,
|
prodBatchCode = y.Key.CN_S_PRODUCTION_BATCH,
|
itemState = y.Key.CN_S_ITEM_STATE,
|
ownerName = y.Key.CN_S_OWNER,
|
itemQty = y.Sum(z => z.CN_F_QUANTITY)
|
}).ToList();
|
var lstAreaPrior = algorItems.Select(x => new areaPriorClass()
|
{
|
areaCode = x.areaCode,
|
Prior = 1
|
}).ToList();
|
OutAlgorEnitty outNewParams = new OutAlgorEnitty
|
{
|
lstDevice = new List<Device>(),
|
lstAreaPrior = lstAreaPrior,
|
lstQueryItem = algorItems,
|
lockLocation = false
|
};
|
Log.Info("调用OutNew参数 outNewParams", JsonConvert.SerializeObject(outNewParams));
|
|
OutResultEntityNew outResult = BLLCreator.Create<Out_AlgorBLL>().OutNew(outNewParams);
|
|
Log.Info("调用OutNew返回值 outResult", JsonConvert.SerializeObject(outResult));
|
return OperateResult.Succeed(null, outResult);
|
}
|
catch (Exception ex)
|
{
|
return OperateResult.Error("WaveService-OutNew:" + ex.Message);
|
}
|
}
|
#endregion
|
}
|
|
#region 波次配置
|
/// <summary>
|
/// 波次配置
|
/// </summary>
|
public class WaveConfig
|
{
|
public DateTime StartTime { get; set; }
|
public DateTime EndTime { get; set; }
|
public int SeveralMaxCreateWave { get; set; }
|
public int LessMinute { get; set; }
|
}
|
#endregion
|
}
|
