using HH.WCS.HangYang.api;
|
using HH.WCS.HangYang.core;
|
using HH.WCS.HangYang.dispatch;
|
using HH.WCS.HangYang.LISTA.models;
|
using HH.WCS.HangYang.LISTA.process;
|
using HH.WCS.HangYang.util;
|
using HH.WCS.HangYang.wms;
|
using Newtonsoft.Json;
|
using NLog.Fluent;
|
using Opc.Ua;
|
using SqlSugar;
|
using Swashbuckle.Swagger;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection;
|
using System.Security.Cryptography;
|
using System.Text;
|
using System.Threading.Tasks;
|
using static HH.WCS.HangYang.api.OtherModel.Putaway_Order_In;
|
using static HH.WCS.HangYang.LISTA.process.HttpModel;
|
using static HH.WCS.HangYang.util.Settings;
|
using static HH.WCS.HangYang.wms.WMSHelper;
|
using static System.Runtime.CompilerServices.RuntimeHelpers;
|
|
namespace HH.WCS.HangYang.process
|
{
|
internal class TaskProcess
|
{
|
#region 任务相关
|
//--------------------------------------------------任务相关--------------------------------------------------
|
/// <summary>
|
/// 取货卸货完成，缓存位状态更新
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="v"></param>
|
internal static void CacheBitUpdate(WCSTask mst, bool load)
|
{
|
var trayCarryCount = mst.N_CNTR_COUNT > 0 ? mst.N_CNTR_COUNT : 1;
|
if (load)
|
{
|
LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
|
LocationHelper.UnBindingLoc(mst.S_START_LOC, mst.S_CNTR_CODE.Split(',').ToList());
|
|
}
|
else
|
{
|
|
LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
|
LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList(), mst.S_NOTE);
|
}
|
|
}
|
|
/// <summary>
|
/// 任务取消，缓存位状态更新
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static void CacheBitCancelUpdate(WCSTask mst)
|
{
|
//任务取消，取货完成前的，起点的loadingCount和终点unLoadingCount都清除，取货完成的只处理终点
|
if (WCSHelper.CheckActionRecordExist(mst.S_CODE, 4))
|
{
|
//根据客户现场要求，如果取货完成任务失败人工拉到终点，我们就当卸货完成处理；如果是人工拉走到其它区域，我们就解锁终点，删除托盘。
|
//终点绑定
|
CacheBitUpdate(mst, false);
|
LocationHelper.UnLockLoc(mst.S_END_LOC);
|
}
|
else
|
{
|
|
//起点终点解锁
|
LocationHelper.UnLockLoc(mst.S_START_LOC);
|
LocationHelper.UnLockLoc(mst.S_END_LOC);
|
|
}
|
|
}
|
|
|
/// <summary>
|
/// 任务拦截
|
/// </summary>
|
/// <param name="task"></param>
|
/// <returns></returns>
|
internal static bool Intercept(WCSTask mst)
|
{
|
var result = false;
|
|
return result;
|
}
|
|
/// <summary>
|
/// 任务状态更新处理
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="state"></param>
|
internal static void OperateStatus(WCSTask mst, int state)
|
{
|
if (state == 4)
|
{
|
CacheBitUpdate(mst, true);
|
}
|
if (state == 6)//卸货完成
|
{
|
CacheBitUpdate(mst, false);
|
}
|
if (state == 7)
|
{
|
CacheBitCancelUpdate(mst);
|
}
|
}
|
|
/// <summary>
|
/// 推送任务
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static bool SendTask(WCSTask mst)
|
{
|
|
|
var result = false;
|
var start = "0"; var end = "0";
|
var taskType = mst.S_TYPE.Trim();
|
// if (mst.N_B_STATE == 0) {
|
if (mst.N_SCHEDULE_TYPE == 1)
|
{
|
start = LocationHelper.GetAgvSite(mst.S_START_LOC);
|
end = LocationHelper.GetAgvSite(mst.S_END_LOC);
|
|
|
Console.WriteLine($"SendTask {mst.S_CODE}");
|
Console.WriteLine("start=" + start);
|
Console.WriteLine("end= " + end);
|
var dic = new Dictionary<string, string>();
|
dic.Add("Pri", mst.N_PRIORITY.ToString());
|
dic.Add("From", start.ToString());
|
dic.Add("To", end.ToString());
|
dic.Add("No", mst.S_CODE.Trim());// dic.Add("Ext1", "1"); dic.Add("Ext2", "CALLADDAGV"); dic.Add("N_CNTR_COUNT", "");
|
var res = NDC.AddNewOrder(5, dic);
|
if (res != null && (res.Res.ErrCode == 0 || res.Res.ErrCode == 50009))
|
{
|
//推送成功，修改任务优先级
|
mst.N_B_STATE = 1;
|
WCSHelper.UpdateStatus(mst);
|
result = true;
|
}
|
}
|
//else if (mst.N_SCHEDULE_TYPE == 5) {
|
// //调第三方接口
|
// var model = new HanAo.TaskInfoModel
|
// {
|
// requestPk = mst.S_CODE,
|
// frmPos = mst.S_START_LOC,
|
// toPos = mst.S_END_LOC,
|
// trkType = mst.S_OP_NAME == "入库" ? "1" : "2",
|
// contNo = mst.S_CNTR_CODE
|
// };
|
// if (HanAo.CreateOrder(model)) {
|
// mst.N_B_STATE = 1;
|
// WCSHelper.UpdateStatus(mst);
|
// }
|
//}
|
//else if (mst.N_SCHEDULE_TYPE == 3)
|
//{
|
// var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2p");
|
// if (code > 0)
|
// {
|
// 更新任务状态
|
// mst.N_B_STATE = 1;
|
// mst.S_EQ_TASK_CODE = code.ToString();
|
// WCSHelper.UpdateStatus(mst);
|
// WCSHelper.UpdateEQNo(mst);
|
|
// }
|
//}
|
|
//}
|
return result;
|
}
|
|
/// <summary>
|
/// 国自推送任务
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static bool SendGZTask(WCSTask mst)
|
{
|
var result = false;
|
var taskState = mst.S_B_STATE.Trim();
|
if (taskState == "等待")
|
{
|
Console.WriteLine($"任务mst {JsonConvert.SerializeObject(mst)}");
|
LogHelper.Info($"任务mst {JsonConvert.SerializeObject(mst)}", "任务");
|
var startLoc = LocationHelper.GetLoc(mst.S_START_LOC);
|
var endLoc = LocationHelper.GetLoc(mst.S_END_LOC);
|
if (startLoc != null && endLoc != null)
|
{
|
//"parameters": "{\"src\":\"a\",\"dst\":\"b\",\" carcode \":\"aaaaa\",\" orderid \":1}"
|
//src:起点, dst:终点，carcode:车号，orderid:
|
string src = $"\"src\":\"{startLoc.S_AGV_SITE}\","; ;
|
string dst = $"\"dst\":\"{endLoc.S_AGV_SITE}\"";
|
string parmeS = "{";
|
string parmeD = "}";
|
string parme = parmeS + src + dst + parmeD;
|
LogHelper.Info($"推送任务参数{parme}", "任务");
|
var res = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, parme);
|
if (res > 0)
|
{
|
//更新任务状态
|
mst.N_B_STATE = 1;
|
mst.S_EQ_TASK_CODE = res.ToString();
|
WCSHelper.UpdateStatus(mst);
|
WCSHelper.UpdateEQNo(mst);
|
|
////推送成功，修改任务状态
|
//TaskHelper.UpdateStatus(mst, "已推送");
|
////推送成功，修改国自ID
|
//TaskHelper.UpdateGzId(mst, res);
|
LogHelper.Info($"任务mst {mst.S_CODE}推送成功", "任务");
|
result = true;
|
}
|
}
|
|
|
}
|
else { result = true; }
|
return result;
|
}
|
|
|
/// <summary>
|
/// 创建搬运任务
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
/// <param name="taskType"></param>
|
/// <param name="cntrs"></param>
|
/// <param name="startLayer"></param>
|
/// <param name="endLayer"></param>
|
/// <param name="trayCarryCount"></param>
|
/// <param name="priority"></param>
|
/// <returns></returns>
|
public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1)
|
{
|
var result = false;
|
//批次号存托盘号，1~3个托盘
|
var trayCodes = string.Join(",", cntrs);
|
var taskNo = DateTime.Now.Ticks.ToString();
|
|
|
var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, trayCarryCount, startLayer, endLayer);
|
if (res)
|
{
|
result = true;
|
//任务创建成功，起点货位出库锁定，终点货位入库锁定
|
LocationHelper.LockLoc(start, 2);
|
LocationHelper.LockLoc(end, 1);
|
}
|
return result;
|
}
|
|
|
public static bool CreateTransport(string start, string end, string taskType, List<string> cntrs, int priority = 1)
|
{
|
var result = false;
|
//批次号存托盘号，1~3个托盘
|
var trayCodes = string.Join(",", cntrs);
|
var taskNo = DateTime.Now.Ticks.ToString();
|
|
|
var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes, 1, 1, 1);
|
if (res)
|
{
|
result = true;
|
LocationHelper.LockLoc(start, 2);
|
LocationHelper.LockLoc(end, 1);
|
|
}
|
return result;
|
}
|
|
internal static Result cancelTask1(cancleTaskParme model)
|
{
|
var result = new Result();
|
LogHelper.Info("cancelTask1取消任务信息：" + JsonConvert.SerializeObject(model), "API");
|
if (model == null)
|
{
|
|
result.success = false;
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
return result;
|
}
|
var task = WCSHelper.GetTask(model.taskNo);
|
if (task != null)
|
{
|
if (task.S_B_STATE.Trim() == "未执行")
|
{
|
//未执行直接修改状态为取消
|
TaskProcess.OperateStatus(task, 7);
|
WCSHelper.UpdateStatus(task, "取消");
|
result.success = true;
|
result.errMsg = "取消任务成功";
|
result.errCode = 0;
|
}
|
else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "完成")
|
{
|
|
if (GZRobot.CancelOrder(int.Parse(task.S_EQ_TASK_CODE)))
|
{
|
TaskProcess.OperateStatus(task, 7);
|
WCSHelper.Fail(task);
|
result.success = true;
|
result.errMsg = "国自取消任务成功";
|
result.errCode = 0;
|
}
|
else
|
{
|
result.success = false;
|
result.errMsg = "国自取消任务失败";
|
result.errCode = 1;
|
}
|
|
}
|
else
|
{
|
result.success = false;
|
result.errMsg = "任务已经结束";
|
result.errCode = 1;
|
}
|
}
|
else
|
{
|
result.success = false;
|
result.errMsg = "任务不存在";
|
result.errCode = 1;
|
}
|
LogHelper.Info("cancelTask1取消任务返回结果：" + JsonConvert.SerializeObject(result), "API");
|
return result;
|
}
|
|
|
#endregion
|
|
#region 杭氧
|
/// <summary>
|
/// 杭氧创建搬运任务
|
/// </summary>
|
/// <param name="start">起点</param>
|
/// <param name="end">终点</param>
|
/// <param name="taskType">任务类型</param>
|
/// <param name="cntrs">托盘号</param>
|
/// <param name="priority">优先级</param>
|
/// <param name="taskNo">作业编码</param>
|
/// <returns></returns>
|
public static bool HYCreateTransport(string start, string end, string taskType, string cntrs, string taskNo = "", int priority = 1)
|
{
|
var result = false;
|
//批次号存托盘号，1~3个托盘
|
var trayCodes = string.Join(",", cntrs);
|
//var taskNo = DateTime.Now.Ticks.ToString();
|
|
|
var res = WCSHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, trayCodes);
|
if (res)
|
{
|
result = true;
|
//任务创建成功，起点货位出库锁定，终点货位入库锁定
|
LocationHelper.LockLoc(start, 2);
|
LocationHelper.LockLoc(end, 1);
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 入库单新增
|
/// </summary>
|
/// <param name="model">入库单</param>
|
/// <returns></returns>
|
public static Result GetMaterialData(List<MES_Material> model)
|
{
|
Result result = new Result() { success = false, };
|
try
|
{
|
if (model == null)
|
{
|
result.errMsg = "入库单不可为空值！";
|
return result;
|
}
|
|
//foreach (var item in model.InOrderDetail)
|
//{
|
// var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
|
// if (itemType == null)
|
// {
|
// result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
|
// return result;
|
// }
|
// item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
|
//}
|
|
//var groupedInOrders = model.InOrderDetail
|
// .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
|
// .Select((group, index) => new InOrder
|
// {
|
// S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
|
// S_BS_NO = model.S_BS_NO,
|
// S_OP_TYPE = model.S_OP_TYPE,
|
// S_BS_TYPE = model.S_BS_TYPE,
|
// S_NOTE = model.S_NOTE,
|
// InOrderDetail = group.Select(detail =>
|
// {
|
// // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
|
// detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
|
// detail.S_BS_NO = model.S_BS_NO;
|
// return detail;
|
// }).ToList() // 分组后的明细
|
// })
|
// .ToList();
|
//var res = WMSHelper.CreateOrderIn(groupedInOrders);
|
//if (res)
|
//{
|
// result.success = true;
|
//}
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.success = false;
|
result.errMsg = ex.Message;
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
if (frame != null)
|
{
|
LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 入库单新增
|
/// </summary>
|
/// <param name="model">入库单</param>
|
/// <returns></returns>
|
public static Result GetInboundOrder(InOrder model)
|
{
|
Result result = new Result() { success = false, };
|
try
|
{
|
if (model == null || !model.InOrderDetail.Any())
|
{
|
result.errMsg = "入库单不可为空值！";
|
return result;
|
}
|
|
foreach (var item in model.InOrderDetail)
|
{
|
var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
|
if (itemType == null)
|
{
|
result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
|
return result;
|
}
|
item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
|
item.S_ITEM_NAME = itemType.S_ITEM_NAME;
|
}
|
|
var groupedInOrders = model.InOrderDetail
|
.GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
|
.Select((group, index) => new InOrder
|
{
|
S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
|
S_BS_NO = model.S_BS_NO,
|
S_OP_TYPE = model.S_OP_TYPE,
|
S_BS_TYPE = model.S_BS_TYPE,
|
S_NOTE = model.S_NOTE,
|
S_FACTORY = "HY001",
|
S_WH_CODE = "CK001",
|
S_AREA_CODE = group.Key.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
|
InOrderDetail = group.Select(detail =>
|
{
|
// 修改 group 中的 S_IO_NO 字段为 S_NO 的值
|
detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
|
detail.S_BS_NO = model.S_BS_NO;
|
return detail;
|
}).ToList() // 分组后的明细
|
})
|
.ToList();
|
var res = WMSHelper.CreateOrderIn(groupedInOrders);
|
if (res)
|
{
|
result.success = true;
|
}
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.success = false;
|
result.errMsg = ex.Message;
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
if (frame != null)
|
{
|
LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 出库单新增
|
/// </summary>
|
/// <param name="model">入库单</param>
|
/// <returns></returns>
|
public static Result GetOutboundOrder(OutOrder model)
|
{
|
Result result = new Result() { success = false };
|
try
|
{
|
if (model == null || !model.OutOrderDetail.Any())
|
{
|
result.errMsg = "出库单不可为空值！";
|
return result;
|
}
|
|
// 第一步：设置物料属性信息
|
foreach (var item in model.OutOrderDetail)
|
{
|
var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
|
if (itemType == null)
|
{
|
result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
|
return result;
|
}
|
item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
|
item.S_ITEM_NAME = itemType.S_ITEM_NAME;
|
item.C_CLEAN = itemType.C_CLEAN;
|
}
|
|
// 第二步：先按物料属性分组，再按是否清洗分组
|
var groupedOrders = model.OutOrderDetail
|
.GroupBy(detail => new
|
{
|
MaterialType = detail.S_EXT_ATTR1,
|
IsClean = detail.C_CLEAN
|
}) // 按物料属性和是否清洗双重分组
|
.Select((group, index) => new OutOrder
|
{
|
S_NO = $"{model.S_BS_NO}_{index + 1}",
|
S_BS_NO = model.S_BS_NO,
|
S_OP_TYPE = model.S_OP_TYPE,
|
S_OUT_TO = model.S_OUT_TO,
|
S_NOTE = model.S_NOTE,
|
S_BS_TYPE = "ERP",
|
S_FACTORY = "HY001",
|
S_WH_CODE = "CK001",
|
S_AREA_CODE = group.Key.MaterialType.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
|
C_CLEAN = group.Key.IsClean, // 添加是否清洗标记
|
OutOrderDetail = group.Select(detail =>
|
{
|
detail.S_OO_NO = $"{model.S_BS_NO}_{index + 1}";
|
detail.S_BS_NO = model.S_BS_NO;
|
return detail;
|
}).ToList()
|
})
|
.ToList();
|
|
// 第三步：调用创建出库单方法
|
var res = WMSHelper.CreateOrderOut(groupedOrders);
|
if (res)
|
{
|
result.success = true;
|
}
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.success = false;
|
result.errMsg = ex.Message;
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0);
|
if (frame != null)
|
{
|
LogHelper.Error($"GetOutboundOrder出库单新增出现错误！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return result;
|
}
|
}
|
|
///// <summary>
|
///// 获取作业创建入库任务
|
///// </summary>
|
///// <param name="mst"></param>
|
///// <returns></returns>
|
//internal static bool CreateInTask(WMSTask mst)
|
//{
|
// try
|
// {
|
// var result = false;
|
// var taskState = mst.S_B_STATE.Trim();
|
// if (taskState == "等待")
|
// {
|
// if (!string.IsNullOrEmpty(mst.S_START_LOC))
|
// {
|
// //杭氧所有库区
|
// var reservoirs = Settings.ReservoirAreas.ToList();
|
// if (!reservoirs.Any() || reservoirs == null)
|
// {
|
// LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
|
// return false;
|
// }
|
// if (mst.S_TYPE == "托盘转运")
|
// {
|
// var lxAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault().areaCode);
|
// if (lxAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxAnyLoc.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// }
|
// else
|
// {
|
// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
// if (rkAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// //标记为合托
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
|
// }
|
// else
|
// {
|
// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
// return false;
|
// }
|
// }
|
// }
|
// if (mst.S_TYPE == "托盘入库")
|
// {
|
// //1.查询下下库里面是否有要合托的托盘
|
// var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
|
// if (locMerge != null)
|
// {
|
// //（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
|
// var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
|
// if (anyLoc.Any())
|
// {
|
|
// foreach (var item in anyLoc)
|
// {
|
// //生成一条出库的任务
|
// var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
|
// if (relevancys == null)
|
// {
|
// LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
|
// continue;
|
// }
|
// //生成到合托区的任务
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// //（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
|
// WMSHelper.UpdateStatus(mst, 1);
|
// break;
|
// }
|
|
|
// }
|
// else
|
// {
|
// //（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
|
// //生成到入库缓存区的任务
|
// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
// if (rkAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// //标记为合托
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
|
// }
|
// else
|
// {
|
// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
// return false;
|
// }
|
// }
|
|
// }
|
// else
|
// {
|
// //2.如果没有要合托的托盘
|
// var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
|
// if (area == null)
|
// {
|
// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
// return false;
|
// }
|
// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
// if (anyLoc.Any())
|
// {
|
// //生成到接驳位的任务
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// }
|
// else
|
// {
|
// //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
|
// //生成到入库缓存区的任务
|
// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
// if (rkAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// //标记为不合托
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
// }
|
// else
|
// {
|
// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
// return false;
|
// }
|
|
// }
|
|
// }
|
// }
|
// if (mst.S_TYPE == "合托回库")
|
// {
|
// var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
|
// if (trayLst.Any())
|
// {
|
// //满托回库
|
// var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
|
// if (area == null)
|
// {
|
// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
// return false;
|
// }
|
// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
// if (anyLoc.Any())
|
// {
|
// //生成到接驳位的任务
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// }
|
// else
|
// {
|
// //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
|
// //生成到入库缓存区的任务
|
// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
// if (rkAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// //标记为不合托
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
// }
|
// else
|
// {
|
// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
// return false;
|
// }
|
|
// }
|
// }
|
// else
|
// {
|
// //空托回库
|
// var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
|
// if (area == null)
|
// {
|
// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
// return false;
|
// }
|
// //(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
|
// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
// if (anyLoc.Any())
|
// {
|
// //生成到接驳位的任务
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// }
|
// else
|
// {
|
// //生成到入库缓存区的任务
|
// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
// if (rkAnyLoc.Any())
|
// {
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// //标记为不合托
|
// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
// WMSHelper.UpdateStatus(mst, 1);
|
|
// }
|
// else
|
// {
|
// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
// return false;
|
// }
|
// }
|
// }
|
// }
|
// if (mst.S_TYPE == "料箱出库")
|
// {
|
|
// //满托回库
|
// var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
|
// if (area == null)
|
// {
|
// LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
|
// return false;
|
// }
|
// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
// if (anyLoc.Any())
|
// {
|
// //生成到接驳位的任务
|
// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
|
// if (!res)
|
// {
|
// LogHelper.Info("料箱出库任务创建失败！", "杭氧");
|
// return false;
|
// }
|
// WMSHelper.UpdateStatus(mst, 1);
|
// }
|
// else
|
// {
|
// LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
|
// }
|
// }
|
// }
|
// }
|
// else { result = true; }
|
// return result;
|
// }
|
// catch (Exception ex)
|
// {
|
// var st = new System.Diagnostics.StackTrace(ex, true);
|
// var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
// if (frame != null)
|
// {
|
// LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
|
// LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
// LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
// LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
// }
|
// return false;
|
// }
|
|
//}
|
|
#region 等待作业
|
|
/// <summary>
|
/// 获取作业创建入库任务
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
internal static bool CreateInTask(WMSTask mst)
|
{
|
try
|
{
|
if (mst.S_B_STATE.Trim() != "等待") return true;
|
if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;
|
|
var reservoirs = Settings.ReservoirAreas?.ToList();
|
if (reservoirs == null || !reservoirs.Any())
|
{
|
LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
|
return false;
|
}
|
|
switch (mst.S_TYPE)
|
{
|
case "托盘转运":
|
return HandlePalletTransport(mst, reservoirs);
|
case "托盘入库":
|
return HandlePalletStorage(mst, reservoirs);
|
case "合托回库":
|
return HandleMergeReturn(mst, reservoirs);
|
case "分拣回库":
|
return HandleMergeReturn(mst, reservoirs);
|
case "料箱出库":
|
return HandleBoxOutbound(mst, reservoirs);
|
case "发货暂存":
|
return PreShipmentStage(mst);
|
case "发货清洗":
|
return PreShipmentStage(mst);
|
case "发货装配":
|
return PreShipmentStage(mst);
|
default:
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
LogErrorDetails(ex);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 托盘转运
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="reservoirs"></param>
|
/// <returns></returns>
|
private static bool HandlePalletTransport(WMSTask mst, List<ReservoirArea> reservoirs)
|
{
|
var res = true;
|
var lxArea = reservoirs.FirstOrDefault(s => s.areaName == "料箱入库缓存位");
|
if (lxArea != null)
|
{
|
var lxLocations = LocationHelper.GetLocAreaList(lxArea.areaCode);
|
if (lxLocations.Any())
|
{
|
res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxLocations.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
}
|
|
var rkArea = reservoirs.FirstOrDefault(s => s.areaName == "入库缓存区");
|
if (rkArea == null) return false;
|
|
var rkLocations = LocationHelper.GetLocAreaList(rkArea.areaCode);
|
if (!rkLocations.Any())
|
{
|
LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
return false;
|
}
|
|
res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkLocations.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
//标记为合托
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
|
return true;
|
}
|
|
/// <summary>
|
/// 托盘入库
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="reservoirs"></param>
|
/// <returns></returns>
|
private static bool HandlePalletStorage(WMSTask mst, List<ReservoirArea> reservoirs)
|
{
|
var result = true;
|
var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
|
if (locMerge != null)
|
{
|
//（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
|
var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
|
if (anyLoc.Any())
|
{
|
foreach (var item in anyLoc)
|
{
|
//生成一条出库的任务
|
var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
|
if (relevancys == null)
|
{
|
LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
|
continue;
|
}
|
//生成到合托区的任务
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
|
return false;
|
}
|
res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
|
return false;
|
}
|
//（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
|
WMSHelper.UpdateStatus(mst, 1);
|
break;
|
}
|
}
|
else
|
{
|
//（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
|
//生成到入库缓存区的任务
|
var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
if (rkAnyLoc.Any())
|
{
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
//标记为合托
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
|
}
|
else
|
{
|
LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
return false;
|
}
|
}
|
|
}
|
else
|
{
|
//2.如果没有要合托的托盘
|
var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
|
if (area == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
return false;
|
}
|
//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
//生成到接驳位的任务
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
else
|
{
|
//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
|
//生成到入库缓存区的任务
|
var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
if (rkAnyLoc.Any())
|
{
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
//标记为不合托
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
}
|
else
|
{
|
LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
return false;
|
}
|
|
}
|
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 合托回库 || 分拣回库
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="reservoirs"></param>
|
/// <returns></returns>
|
private static bool HandleMergeReturn(WMSTask mst, List<ReservoirArea> reservoirs)
|
{
|
var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
|
if (trayLst.Any())
|
{
|
//满托回库
|
var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
|
if (area == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
return false;
|
}
|
//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
//生成到接驳位的任务
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
else
|
{
|
//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
|
//生成到入库缓存区的任务
|
var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
if (rkAnyLoc.Any())
|
{
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
//标记为不合托
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
}
|
else
|
{
|
LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
return false;
|
}
|
|
}
|
}
|
else
|
{
|
//空托回库
|
var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
|
if (area == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
return false;
|
}
|
//(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
//生成到接驳位的任务
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
else
|
{
|
//生成到入库缓存区的任务
|
var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
|
if (rkAnyLoc.Any())
|
{
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
//标记为不合托
|
ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
|
WMSHelper.UpdateStatus(mst, 1);
|
|
}
|
else
|
{
|
LogHelper.Info("入库缓存区没有空货位！", "杭氧");
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 料箱出库
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="reservoirs"></param>
|
/// <returns></returns>
|
private static bool HandleBoxOutbound(WMSTask mst, List<ReservoirArea> reservoirs)
|
{
|
var result = true;
|
var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
|
if (area == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
|
return false;
|
}
|
//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
//生成到接驳位的任务
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("料箱出库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
else
|
{
|
LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 发货暂存 || 发货清洗 || 发货装配 (暂时使用一个方法处理)
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
private static bool PreShipmentStage(WMSTask mst)
|
{
|
var locList = LocationHelper.GetLocAreaList(mst.S_END_AREA);
|
if (locList.Any())
|
{
|
var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info($"{mst.S_TYPE}入库任务创建失败！", "杭氧");
|
return false;
|
}
|
WMSHelper.UpdateStatus(mst, 1);
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 发货清洗
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
private static bool OutboundCleaning(WMSTask mst)
|
{
|
return true;
|
}
|
|
/// <summary>
|
/// 发货装配
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
private static bool OutboundAssembly(WMSTask mst)
|
{
|
return true;
|
}
|
#endregion
|
|
#region 执行作业
|
|
/// <summary>
|
/// 获取执行的作业创建任务
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
internal static bool exeCreateInTask(WMSTask mst)
|
{
|
try
|
{
|
if (mst.S_B_STATE.Trim() != "执行") return true;
|
if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;
|
|
var reservoirs = Settings.ReservoirAreas?.ToList();
|
if (reservoirs == null || !reservoirs.Any())
|
{
|
LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
|
return false;
|
}
|
|
switch (mst.S_TYPE)
|
{
|
case "配盘出库":
|
return PalletOutbound(mst);
|
default:
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
LogErrorDetails(ex);
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 配盘出库
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="reservoirs"></param>
|
/// <returns></returns>
|
private static bool PalletOutbound(WMSTask mst)
|
{
|
var relevancys = Settings.OutRelevancys.Where(s => s.conLoc == mst.S_END_LOC).FirstOrDefault();
|
if (relevancys == null)
|
{
|
LogHelper.Info($"Settings未查询到集货位{mst.S_END_LOC}对应的分拣位！", "杭氧");
|
return false;
|
}
|
var locList = LocationHelper.GetLocListEmptyFree(relevancys.sorLoc.ToList());
|
if (locList.Any())
|
{
|
var startLoc = WMSHelper.GetCntrLoc(mst.S_CNTR_CODE);
|
// 创建出库任务
|
var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
#endregion
|
|
|
|
|
/// <summary>
|
/// 错误日志记录
|
/// </summary>
|
/// <param name="ex">错误信息</param>
|
private static void LogErrorDetails(Exception ex)
|
{
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0);
|
if (frame == null) return;
|
|
var errorDetails = new StringBuilder()
|
.AppendLine($"错误信息: {ex.Message}")
|
.AppendLine($"文件名: {frame.GetFileName()}")
|
.AppendLine($"行号: {frame.GetFileLineNumber()}")
|
.AppendLine($"列号: {frame.GetFileColumnNumber()}")
|
.ToString();
|
|
LogHelper.Error("CreateInTask获取作业创建入库任务出现错误！" + errorDetails, ex);
|
}
|
|
|
|
|
|
/// <summary>
|
/// 循环入库缓存区查询合托工位和入库接驳位是否有空货位（创建任务）
|
/// </summary>
|
/// <returns></returns>
|
internal static bool BatchInWork()
|
{
|
try
|
{
|
bool res = false;
|
//杭氧所有库区
|
var reservoirs = Settings.ReservoirAreas.ToList();
|
if (!reservoirs.Any() || reservoirs == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到的杭氧库区！", "杭氧");
|
return false;
|
}
|
|
var rkAnyLoc = reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault();
|
if (rkAnyLoc == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到入库缓存区！", "杭氧");
|
return false;
|
}
|
|
//合托逻辑
|
var cntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "合托").FirstOrDefault();
|
if (cntrAbouts != null)
|
{
|
var area = reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault();
|
if (area != null)
|
{
|
//1.查询合托工位的状态
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
var list = WMSHelper.GetWmsTaskList("执行", cntrAbouts.S_CNTR_CODE);
|
if (list == null)
|
{
|
LogHelper.Info($"未查询到在执行中的作业:{cntrAbouts.S_CNTR_CODE}！", "杭氧");
|
return false;
|
}
|
//1.2创建码盘合托入库的任务，同时生成一个码盘合托出库的任务
|
//查询下要出库合托的托盘
|
var locMerge = WMSHelper.GetLocMerge(cntrAbouts.S_CNTR_CODE);
|
if (locMerge == null)
|
{
|
return false;
|
}
|
|
//生成一条出库的任务
|
var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
|
if (relevancys == null)
|
{
|
LogHelper.Info("Settings出现错误未查询到合托入库位对应的出库位！", "杭氧");
|
return false;
|
}
|
//生成到合托区的任务
|
res = TaskProcess.HYCreateTransport(cntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘合托入库", cntrAbouts.S_CNTR_CODE, list.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
|
return false;
|
}
|
res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, list.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
|
return false;
|
}
|
}
|
}
|
else
|
{
|
LogHelper.Info("Settings出现错误未查询到合托区！", "杭氧");
|
return false;
|
}
|
}
|
|
//不合托逻辑
|
var noCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "不合托").FirstOrDefault();
|
if (noCntrAbouts != null)
|
{
|
//2.查询入库接驳位的状态
|
var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
|
if (area != null)
|
{
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
var list = WMSHelper.GetWmsTaskList("执行", noCntrAbouts.S_CNTR_CODE);
|
if (list == null)
|
{
|
LogHelper.Info($"未查询到在执行中的作业:{noCntrAbouts.S_CNTR_CODE}！", "杭氧");
|
return false;
|
}
|
//2.2如果入库接驳位为空创建码盘接驳入库的任务
|
//生成到接驳位的任务
|
res = TaskProcess.HYCreateTransport(noCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", noCntrAbouts.S_CNTR_CODE, list.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
|
return false;
|
}
|
}
|
}
|
else
|
{
|
LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
|
return false;
|
}
|
}
|
|
//料箱合托逻辑
|
var lxCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "料箱合托").FirstOrDefault();
|
if (lxCntrAbouts != null)
|
{
|
//2.查询入库接驳位的状态
|
var area = reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault();
|
if (area != null)
|
{
|
var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
|
if (anyLoc.Any())
|
{
|
var list = WMSHelper.GetWmsTaskList("执行", lxCntrAbouts.S_CNTR_CODE);
|
if (list == null)
|
{
|
LogHelper.Info($"未查询到在执行中的作业:{lxCntrAbouts.S_CNTR_CODE}！", "杭氧");
|
return false;
|
}
|
//生成到接驳位的任务
|
res = TaskProcess.HYCreateTransport(lxCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "料箱缓存入库", lxCntrAbouts.S_CNTR_CODE, list.S_CODE);
|
if (!res)
|
{
|
LogHelper.Info("料箱缓存入库任务创建失败！", "杭氧");
|
return false;
|
}
|
}
|
}
|
else
|
{
|
LogHelper.Info("Settings出现错误未查询到料箱入库缓存位！", "杭氧");
|
return false;
|
}
|
}
|
|
return res;
|
}
|
catch (Exception ex)
|
{
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
if (frame != null)
|
{
|
LogHelper.Error($"BatchInWork循环入库缓存区出现错误！！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return false;
|
}
|
|
}
|
|
/// <summary>
|
/// WCS调用设备信号反馈
|
/// </summary>
|
/// <param name="model">请求参数</param>
|
/// <returns></returns>
|
public static async Task<Result> notifyDeviceSignal(List<Wcsmodel> model)
|
{
|
Result result = new Result() { success = false, };
|
try
|
{
|
foreach (var item in model)
|
{
|
if (string.IsNullOrEmpty(item.cntrNo))
|
{
|
result.errMsg = "托盘号为空！";
|
return result;
|
}
|
var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
|
if (list == null)
|
{
|
list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
|
}
|
if (list == null)
|
{
|
result.errMsg = "未查询到在等待中的作业！";
|
return result;
|
}
|
|
var inbound = new Inbound()
|
{
|
areaCode = list.S_END_AREA
|
};
|
var wh = new Warehouse(inbound);
|
var stored = await wh.StoreItemAsync();
|
if (stored == null)
|
{
|
result.errMsg = "立库区未查询到可用货位！";
|
return result;
|
}
|
|
var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
|
if (startLoc == null)
|
{
|
result.errMsg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
|
return result;
|
}
|
var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
|
if (!res)
|
{
|
result.errMsg = "入库任务创建失败！";
|
return result;
|
}
|
WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
|
ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
|
}
|
|
|
result.success = true;
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.success = false;
|
result.errMsg = ex.Message;
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
if (frame != null)
|
{
|
LogHelper.Error($"notifyDeviceSignalWCS调用设备信号反馈出现错误！！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return result;
|
}
|
}
|
|
/// <summary>
|
/// 根据配盘单生成出库任务
|
/// </summary>
|
/// <param name="distributionCntr">配盘单</param>
|
/// <returns></returns>
|
internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntr)
|
{
|
try
|
{
|
// 创建调度器
|
var scheduler = new DoubleDeepOutboundScheduler(distributionCntr);
|
|
var listOut = new List<Outbound>();
|
foreach (var item in distributionCntr)
|
{
|
listOut.Add(new Outbound
|
{
|
locCode = item.S_LOC_CODE,
|
areaCode = item.S_AREA_CODE,
|
endArea = item.S_EXIT_AREA_CODE,
|
endBit = item.S_EXIT_LOC_CODE,
|
trayCode = item.S_CNTR_CODE,
|
taskType = "配盘出库"
|
});
|
}
|
// 请求出库
|
var tasks = scheduler.GenerateOutboundTasks(listOut);
|
|
foreach (var item in tasks)
|
{
|
var wmsTask = new WMSTask();
|
if (string.IsNullOrEmpty(item.S_OP_CODE))
|
{
|
wmsTask = new WMSTask
|
{
|
S_CNTR_CODE = item.S_CNTR_CODE,
|
S_CODE = WMSHelper.GenerateTaskNo(),
|
S_START_LOC = item.S_START_LOC,
|
S_START_AREA = item.S_START_AREA,
|
S_END_LOC = item.S_END_LOC,
|
S_END_AREA = item.S_END_AREA,
|
S_START_WH = "CK001",
|
S_END_WH = "CK001",
|
N_B_STATE = 1,
|
S_B_STATE = "执行",
|
N_TYPE = 2,
|
S_TYPE = "配盘出库"
|
};
|
if (!WMSHelper.CreateWmsTask(wmsTask))
|
{
|
return false;
|
}
|
}
|
|
if (item.S_END_AREA == "LXLKQ")
|
{
|
// 创建出库任务
|
var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, wmsTask.S_CODE);
|
UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
|
if (!res)
|
{
|
LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
|
return false;
|
}
|
}
|
else
|
{
|
//根据分拣货位去查询配置，如果分拣区没有空货位就去出库分拣暂存区
|
var relevancys = Settings.OutRelevancys.Where(s => s.conLoc == item.S_END_LOC).FirstOrDefault();
|
if (relevancys == null)
|
{
|
LogHelper.Info($"Settings未查询到集货位{item.S_END_LOC}对应的分拣位！", "杭氧");
|
break;
|
}
|
var locList = LocationHelper.GetLocListEmptyFree(relevancys.sorLoc.ToList());
|
if (locList.Any())
|
{
|
// 创建出库任务
|
var res = TaskProcess.HYCreateTransport(item.S_START_LOC, locList.FirstOrDefault().S_CODE, item.S_TYPE, item.S_CNTR_CODE, wmsTask.S_CODE);
|
UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
|
if (!res)
|
{
|
LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
|
return false;
|
}
|
}
|
else
|
{
|
var reservoirs = Settings.ReservoirAreas.Where(s => s.areaName == "拣选缓存区").FirstOrDefault();
|
var lxLocations = LocationHelper.GetLocAreaList(reservoirs.areaCode);
|
if (lxLocations.Any())
|
{
|
// 创建出库任务
|
var res = TaskProcess.HYCreateTransport(item.S_START_LOC, lxLocations.FirstOrDefault().S_CODE, "配盘缓存", item.S_CNTR_CODE, wmsTask.S_CODE);
|
UpdateDistributionCntrState(1, 2, item.S_CNTR_CODE);
|
if (!res)
|
{
|
LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
|
return false;
|
}
|
}
|
}
|
}
|
}
|
return true;
|
}
|
catch (Exception ex)
|
{
|
var st = new System.Diagnostics.StackTrace(ex, true);
|
var frame = st.GetFrame(0); // 获取第一个堆栈帧
|
if (frame != null)
|
{
|
LogHelper.Error($"根据配盘单生成出库任务失败{ex.Message}！！", ex);
|
LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
|
LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
|
LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
|
}
|
return false;
|
}
|
|
}
|
|
#endregion
|
|
|
|
}
|
}
|
