icewint/wcs_server_kate_suzhou
5
2
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

<fix>[normal]修改部分函数为主构造函数

Browse Source
This commit is contained in:
葛林强 2024-06-19 16:51:35 +08:00
parent e1d3acd92a
commit acd744e046
27 changed files with 233 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
WcsMain/Business/CirculationTask/CommonCirculation/ConnectPlcWithCirculation.cs
View File

@ -10,7 +10,6 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation] [Circulation]
public class ConnectPlcWithCirculation(ConnectPLCs connectPLCs) public class ConnectPlcWithCirculation(ConnectPLCs connectPLCs)
{ {
private readonly ConnectPLCs _connectPLCs = connectPLCs;
/// <summary> /// <summary>
/// 当plc断开时重新连接 PLC /// 当plc断开时重新连接 PLC
@ -23,7 +22,7 @@ public class ConnectPlcWithCirculation(ConnectPLCs connectPLCs)
{ {
// 如果处于未连接的状态则需要连接 // 如果处于未连接的状态则需要连接
/* 连接 PLC */ /* 连接 PLC */
bool isContinue = _connectPLCs.ConnectPlc(); bool isContinue = connectPLCs.ConnectPlc();
if (!isContinue) if (!isContinue)
{ {
return false; // 没有需要连接PLC可能，不需要接着继续检测了 return false; // 没有需要连接PLC可能，不需要接着继续检测了

15
WcsMain/Business/CirculationTask/CommonCirculation/DataClear.cs
View File

@ -9,7 +9,6 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation("数据清理")] [Circulation("数据清理")]
public class DataClear(ClearData clearData) public class DataClear(ClearData clearData)
{ {
private readonly ClearData _clearData = clearData;
/// <summary> /// <summary>
/// 定时清理无用数据, ---- 每隔10分钟清理一次 /// 定时清理无用数据, ---- 每隔10分钟清理一次
@ -21,31 +20,31 @@ public class DataClear(ClearData clearData)
try try
{ {
// 清理接口接收记录表 -- 保留多少天 // 清理接口接收记录表 -- 保留多少天
int apiAcceptCount = _clearData.ClearApiAcceptData(30); int apiAcceptCount = clearData.ClearApiAcceptData(30);
ConsoleLog.Tip(apiAcceptCount > 0, $"[数据清理]接口接收记录：{apiAcceptCount}"); ConsoleLog.Tip(apiAcceptCount > 0, $"[数据清理]接口接收记录：{apiAcceptCount}");
// 清理日志文件 -- 清理多少天之前 // 清理日志文件 -- 清理多少天之前
int logCount = _clearData.ClearLogFile(60); int logCount = clearData.ClearLogFile(60);
ConsoleLog.Tip(logCount > 0, $"[数据清理]日志文件：{logCount}"); ConsoleLog.Tip(logCount > 0, $"[数据清理]日志文件：{logCount}");
// 清理接口请求记录表 -- 保留多少天 // 清理接口请求记录表 -- 保留多少天
int apiRequestCount = _clearData.ClearApiRequestData(30); int apiRequestCount = clearData.ClearApiRequestData(30);
ConsoleLog.Tip(apiRequestCount > 0, $"[数据清理]接口请求记录：{apiRequestCount}"); ConsoleLog.Tip(apiRequestCount > 0, $"[数据清理]接口请求记录：{apiRequestCount}");
// 清理WCS任务备份表 -- 保留多少天 // 清理WCS任务备份表 -- 保留多少天
int apiWcsTaskCount = _clearData.ClearWcsTaskData(30); int apiWcsTaskCount = clearData.ClearWcsTaskData(30);
ConsoleLog.Tip(apiWcsTaskCount > 0, $"[数据清理]WCS任务备份记录：{apiWcsTaskCount}"); ConsoleLog.Tip(apiWcsTaskCount > 0, $"[数据清理]WCS任务备份记录：{apiWcsTaskCount}");
// 清理WMS任务表 -- 保留多少天 // 清理WMS任务表 -- 保留多少天
int apiWmsTaskCount = _clearData.ClearWmsTaskData(30); int apiWmsTaskCount = clearData.ClearWmsTaskData(30);
ConsoleLog.Tip(apiWmsTaskCount > 0, $"[数据清理]WMS任务记录：{apiWmsTaskCount}"); ConsoleLog.Tip(apiWmsTaskCount > 0, $"[数据清理]WMS任务记录：{apiWmsTaskCount}");
// 清理电子标签任务 // 清理电子标签任务
int clearElTagCount = _clearData.ClearElTagTaskData(30); int clearElTagCount = clearData.ClearElTagTaskData(30);
ConsoleLog.Tip(clearElTagCount > 0, $"[数据清理]电子标签任务记录：{apiWmsTaskCount}"); ConsoleLog.Tip(clearElTagCount > 0, $"[数据清理]电子标签任务记录：{apiWmsTaskCount}");
int clearConveyTaskCount = _clearData.ClearConveyTaskData(30); int clearConveyTaskCount = clearData.ClearConveyTaskData(30);
ConsoleLog.Tip(clearConveyTaskCount > 0, $"[数据清理]箱式线任务记录：{apiWmsTaskCount}"); ConsoleLog.Tip(clearConveyTaskCount > 0, $"[数据清理]箱式线任务记录：{apiWmsTaskCount}");
} }

3
WcsMain/Business/CirculationTask/CommonCirculation/HeartBeat.cs
View File

@ -6,12 +6,11 @@ namespace WcsMain.Business.CirculationTask.CommonCirculation;
[Circulation] [Circulation]
public class HeartBeat(ConveyOperation conveyOperation) public class HeartBeat(ConveyOperation conveyOperation)
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
[Circulation("输送机心跳", 1000)] [Circulation("输送机心跳", 1000)]
public bool ConveyHeartBeat() public bool ConveyHeartBeat()
{ {
_conveyOperation.WriteHeartBeat(); conveyOperation.WriteHeartBeat();
return true; return true;
} }

14
WcsMain/Business/CirculationTask/ElTag/LightElTag.cs
View File

@ -16,10 +16,6 @@ namespace WcsMain.Business.CirculationTask.ElTag;
public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation, AppElTagLocationDao elTagBaseDao) public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation, AppElTagLocationDao elTagBaseDao)
{ {
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly AtopOperation _atopOperation = atopOperation;
private readonly AppElTagLocationDao _elTagBaseDao = elTagBaseDao;
/// <summary> /// <summary>
/// 点亮电子标签 /// 点亮电子标签
/// </summary> /// </summary>
@ -27,7 +23,7 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
[Circulation("点亮电子标签")] [Circulation("点亮电子标签")]
public bool Light() public bool Light()
{ {
List<AppElTagTask>? tasks = _tagTaskDao.Query(new AppElTagTask { TaskStatus = (int)ElTagTaskStatusEnum.NeedLight }); List<AppElTagTask>? tasks = tagTaskDao.Query(new AppElTagTask { TaskStatus = (int)ElTagTaskStatusEnum.NeedLight });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常"); ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常");
@ -49,7 +45,7 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
if(tagInfo == default) if(tagInfo == default)
{ {
ConsoleLog.Warning($"【警告】电子标签：{tagTask.Location} 不存在，无法点亮"); ConsoleLog.Warning($"【警告】电子标签：{tagTask.Location} 不存在，无法点亮");
_tagTaskDao.Update(new AppElTagTask tagTaskDao.Update(new AppElTagTask
{ {
TaskId = tagTask.TaskId, TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Error, TaskStatus = (int)ElTagTaskStatusEnum.Error,
@ -71,17 +67,17 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation,
return LedColor.Red; return LedColor.Red;
}; };
}).Invoke(); }).Invoke();
var resultException = _atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum, lEDColor); var resultException = atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum, lEDColor);
if(resultException == default ) if(resultException == default )
{ {
ConsoleLog.Success($"点亮电子标签成功，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}"); ConsoleLog.Success($"点亮电子标签成功，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}");
_tagTaskDao.Update(new AppElTagTask tagTaskDao.Update(new AppElTagTask
{ {
TaskId = tagTask.TaskId, TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Lighting, TaskStatus = (int)ElTagTaskStatusEnum.Lighting,
LightTime = DateTime.Now, LightTime = DateTime.Now,
}); // 更新任务状态 }); // 更新任务状态
_elTagBaseDao.Update(new AppElTagLocation { Location = tagTask.Location, TaskId = tagTask.TaskId, LastLightTime = DateTime.Now }); // 更新点位状态，绑定任务 elTagBaseDao.Update(new AppElTagLocation { Location = tagTask.Location, TaskId = tagTask.TaskId, LastLightTime = DateTime.Now }); // 更新点位状态，绑定任务
return; return;
} }
ConsoleLog.Warning($"【警告】点亮电子标签失败，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}，异常信息：{resultException.Message}"); ConsoleLog.Warning($"【警告】点亮电子标签失败，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}，异常信息：{resultException.Message}");

8
WcsMain/Business/CirculationTask/ElTag/OffElTag.cs
View File

@ -21,10 +21,6 @@ namespace WcsMain.Business.CirculationTask.ElTag;
//[Circulation] //[Circulation]
public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation) public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
{ {
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly AtopOperation _atopOperation = atopOperation;
/// <summary> /// <summary>
/// 检验任务组内任务是否全部确认，若全部确认则熄灭所有标签 /// 检验任务组内任务是否全部确认，若全部确认则熄灭所有标签
@ -34,7 +30,7 @@ public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
public bool CheckTaskIsConfirmAll() public bool CheckTaskIsConfirmAll()
{ {
/* 查询已经确认的任务的任务组 */ /* 查询已经确认的任务的任务组 */
List<AppElTagTask>? tasks = _tagTaskDao.QueryRunningTask(); List<AppElTagTask>? tasks = tagTaskDao.QueryRunningTask();
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常"); ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常");
@ -77,7 +73,7 @@ public class OffElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
} }
} }
if (offTasks.Count < 1) return; if (offTasks.Count < 1) return;
_tagTaskDao.Update([.. offTasks]); // 更新状态为熄灭 tagTaskDao.Update([.. offTasks]); // 更新状态为熄灭
} }

1
WcsMain/Business/CirculationTask/ScanMethod.cs
View File

@ -8,7 +8,6 @@ namespace WcsMain.Business.CirculationTask;
//[Circulation] //[Circulation]
public class ScanMethod(DataBaseData dataBaseData) public class ScanMethod(DataBaseData dataBaseData)
{ {
private readonly DataBaseData _dataBaseData = dataBaseData;
//private static string[]? _scanId; //private static string[]? _scanId;

28
WcsMain/Business/CirculationTask/Stacker/CheckAccount.cs
View File

@ -16,10 +16,6 @@ namespace WcsMain.Business.CirculationTask.Stacker;
[Circulation()] [Circulation()]
public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent) public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent)
{ {
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
/// <summary> /// <summary>
/// PLC过账 /// PLC过账
/// </summary> /// </summary>
@ -28,7 +24,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
public bool CheckAccountTask() public bool CheckAccountTask()
{ {
var openStackers = CommonData.AppStackers.Open(); // 只获取开放的堆垛机 var openStackers = CommonData.AppStackers.Open(); // 只获取开放的堆垛机
List<TaskFeedBackEntity>? taskFeedBackEntities = _stackerOperation.GetTaskFeedBackData(20, openStackers); List<TaskFeedBackEntity>? taskFeedBackEntities = stackerOperation.GetTaskFeedBackData(20, openStackers);
if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1) if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1)
{ {
return true; return true;
@ -36,7 +32,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities) foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities)
{ {
if (taskFeedBackEntity.PlcId == 0) { continue; } if (taskFeedBackEntity.PlcId == 0) { continue; }
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId }); List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】堆垛机过账查询任务数据失败，和数据库服务器连接中断"); ConsoleLog.Error($"【异常】堆垛机过账查询任务数据失败，和数据库服务器连接中断");
@ -46,7 +42,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
if (wcsTasks.Count < 1) if (wcsTasks.Count < 1)
{ {
ConsoleLog.Warning($"【提示】堆垛机过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务"); ConsoleLog.Warning($"【提示】堆垛机过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务");
_stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账 stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
continue; // 任务无数据 continue; // 任务无数据
} }
var wcsTask = wcsTasks[0]; var wcsTask = wcsTasks[0];
@ -80,13 +76,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Warning($"【提示】过账区反馈：PlcId：{taskFeedBackEntity.PlcId} 已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}"); ConsoleLog.Warning($"【提示】过账区反馈：PlcId：{taskFeedBackEntity.PlcId} 已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账 string? cleanAccountErr = stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"【警告】取消任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"【警告】取消任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务异常动作 */ /* 执行 WMS 任务异常动作 */
_wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消"); wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
} }
@ -98,13 +94,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Tip($"【提示】过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}"); ConsoleLog.Tip($"【提示】过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}");
var cleanAccountErr = _stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账 var cleanAccountErr = stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"【警告】完成任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"【警告】完成任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务完成动作 */ /* 执行 WMS 任务完成动作 */
_wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成"); wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
} }
@ -117,13 +113,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void DoubleInFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void DoubleInFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Warning($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，卸货位置有货，任务号：{wcsTask.TaskId}"); ConsoleLog.Warning($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，卸货位置有货，任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账 string? cleanAccountErr = stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务异常动作 */ /* 执行 WMS 任务异常动作 */
_wcsTaskEvent.DoubleInTaskEvent(wcsTask, "卸货位置有货"); wcsTaskEvent.DoubleInTaskEvent(wcsTask, "卸货位置有货");
} }
/// <summary> /// <summary>
@ -134,13 +130,13 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void EmptyOutFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void EmptyOutFeedBackType(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，取货位置无货，任务号：{wcsTask.TaskId}"); ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，取货位置无货，任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账 string? cleanAccountErr = stackerOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务异常动作 */ /* 执行 WMS 任务异常动作 */
_wcsTaskEvent.EmptyOutTaskEvent(wcsTask, "取货位置无货"); wcsTaskEvent.EmptyOutTaskEvent(wcsTask, "取货位置无货");
} }
@ -152,7 +148,7 @@ public class CheckAccount(StackerOperation stackerOperation, AppWcsTaskDao wcsTa
private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity) private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity)
{ {
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}"); ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}");
_stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账 stackerOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
} }

94
WcsMain/Business/CirculationTask/Stacker/ExeTaskDoubleFork.cs
View File

@ -2,7 +2,6 @@
using WcsMain.Business.CommonAction; using WcsMain.Business.CommonAction;
using WcsMain.Common; using WcsMain.Common;
using WcsMain.DataBase.Dao; using WcsMain.DataBase.Dao;
using WcsMain.DataBase.MixDao;
using WcsMain.DataBase.TableEntity; using WcsMain.DataBase.TableEntity;
using WcsMain.DataService; using WcsMain.DataService;
using WcsMain.Enum.Stacker; using WcsMain.Enum.Stacker;
@ -10,7 +9,6 @@ using WcsMain.EquipOperation.Convey;
using WcsMain.EquipOperation.Entity.Stacker; using WcsMain.EquipOperation.Entity.Stacker;
using WcsMain.EquipOperation.Stacker; using WcsMain.EquipOperation.Stacker;
using WcsMain.ExtendMethod; using WcsMain.ExtendMethod;
using static Dm.net.buffer.ByteArrayBuffer;
namespace WcsMain.Business.CirculationTask.Stacker; namespace WcsMain.Business.CirculationTask.Stacker;
@ -23,12 +21,6 @@ public class ExeTaskDoubleFork(
StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent, StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent,
ConveyOperation conveyOperation, DataBaseData dataBaseData) ConveyOperation conveyOperation, DataBaseData dataBaseData)
{ {
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
/// <summary> /// <summary>
/// 执行堆垛机任务 /// 执行堆垛机任务
/// </summary> /// </summary>
@ -41,7 +33,7 @@ public class ExeTaskDoubleFork(
{ {
tasks.Add(Task.Factory.StartNew(() => tasks.Add(Task.Factory.StartNew(() =>
{ {
var stackerUseStatus = _stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int spare1); var stackerUseStatus = stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int spare1);
if (stackerUseStatus == StackerUseStatusEnum.Free) if (stackerUseStatus == StackerUseStatusEnum.Free)
{ {
/* 空闲时正常执行任务 */ /* 空闲时正常执行任务 */
@ -82,10 +74,10 @@ public class ExeTaskDoubleFork(
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
/* 检查入库站台是否允许取货 */ /* 检查入库站台是否允许取货 */
bool allowGetGoods = _conveyOperation.AllGetVehicle(stackerId.ToString()); bool allowGetGoods = conveyOperation.AllGetVehicle(stackerId.ToString());
if(!allowGetGoods) return false; // 入库站台不允许取货 if(!allowGetGoods) return false; // 入库站台不允许取货
/* 读取入库站台的条码 */ /* 读取入库站台的条码 */
var codes = _conveyOperation.ReadConveyCode(stackerId.ToString()); var codes = conveyOperation.ReadConveyCode(stackerId.ToString());
if(codes == default || codes.Count != 2) return false; if(codes == default || codes.Count != 2) return false;
/* 构造任务数据 */ /* 构造任务数据 */
bool isWriteTask = false; // 指示是否写入任务 bool isWriteTask = false; // 指示是否写入任务
@ -100,13 +92,13 @@ public class ExeTaskDoubleFork(
if (code == "NoRead") // 检查条码是否为 NoRead if (code == "NoRead") // 检查条码是否为 NoRead
{ {
/* 检查卸货站台是否允许卸货 */ /* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString()); bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货 if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */ /* 生成一个直接卸货出去的任务 */
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if(plcId == default || plcId == 0) continue; if(plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1); StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1);
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1); string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if(string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功 if(string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
@ -118,7 +110,7 @@ public class ExeTaskDoubleFork(
} }
continue; continue;
} }
var wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create }); var wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if(wcsTasks == default) // 查询任务失败 if(wcsTasks == default) // 查询任务失败
{ {
ConsoleLog.Exception($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 查找任务失败，和数据库服务器连接中断"); ConsoleLog.Exception($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 查找任务失败，和数据库服务器连接中断");
@ -127,14 +119,14 @@ public class ExeTaskDoubleFork(
if(wcsTasks.Count < 1) // 没有任务 if(wcsTasks.Count < 1) // 没有任务
{ {
/* 检查卸货站台是否允许卸货 */ /* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString()); bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货 if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */ /* 生成一个直接卸货出去的任务 */
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 没有找到对应任务"); ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 没有找到对应任务");
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default || plcId == 0) continue; if (plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo()); StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo());
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1); string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功 if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
@ -152,18 +144,18 @@ public class ExeTaskDoubleFork(
if(destinationLocationInfo == default) // 任务终点错误，理论上此处不应该出现异常 if(destinationLocationInfo == default) // 任务终点错误，理论上此处不应该出现异常
{ {
/* 检查卸货站台是否允许卸货 */ /* 检查卸货站台是否允许卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString()); bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) continue; // 出库站台不允许取货 if (!allowSetGoods) continue; // 出库站台不允许取货
/* 生成一个直接卸货出去的任务 */ /* 生成一个直接卸货出去的任务 */
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 无法识别的入库库位"); ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code} 无法识别的入库库位");
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default || plcId == 0) continue; if (plcId == default || plcId == 0) continue;
StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo()); StackerPlcTask errTask = StackerPlcTask.DefaultErrTask((int)plcId!, (int)stackerId!, i + 1, code.ToPlcVehicleNo());
string WriteTaskErrText = _stackerOperation.WriteTask(errTask, i + 1); string WriteTaskErrText = stackerOperation.WriteTask(errTask, i + 1);
if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功 if (string.IsNullOrEmpty(WriteTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{errTask}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "入库库位不正确"); wcsTaskEvent.ErrTaskEvent(wcsTask, "入库库位不正确");
isWriteTask = true; isWriteTask = true;
} }
else else
@ -173,16 +165,16 @@ public class ExeTaskDoubleFork(
continue; continue;
} }
/* 判断冲突货位是否有任务 */ /* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation); var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败 if (runningWcsTasks == default) continue; // 查询失败
if(runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待 if(runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */ /* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerInTask((int)stackerId!, i + 1, destinationLocationInfo); StackerPlcTask stackerTask = wcsTask.ToStackerInTask((int)stackerId!, i + 1, destinationLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1); string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功 if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{stackerTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，入库位置：{i + 1} 条码：{code}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始 wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
isWriteTask = true; isWriteTask = true;
} }
else else
@ -192,7 +184,7 @@ public class ExeTaskDoubleFork(
} }
if (isWriteTask) if (isWriteTask)
{ {
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认 string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机入库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}"); ConsoleLog.Info($"堆垛机入库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000); Thread.Sleep(1000);
} }
@ -208,9 +200,9 @@ public class ExeTaskDoubleFork(
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
/* 检查出库站台是否可以卸货 */ /* 检查出库站台是否可以卸货 */
bool allowSetGoods = _conveyOperation.AllSetVehicle(stackerId.ToString()); bool allowSetGoods = conveyOperation.AllSetVehicle(stackerId.ToString());
if (!allowSetGoods) return false; // 出库站台不允许取货 if (!allowSetGoods) return false; // 出库站台不允许取货
var wcsTasks = _wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Exception(string.Format("【异常】{0} 号堆垛机出库任务查询失败，与数据库连接异常", stackerId)); ConsoleLog.Exception(string.Format("【异常】{0} 号堆垛机出库任务查询失败，与数据库连接异常", stackerId));
@ -236,20 +228,20 @@ public class ExeTaskDoubleFork(
if (originLocationInfo == default) // 任务起点错误，理论上此处不应该出现异常 if (originLocationInfo == default) // 任务起点错误，理论上此处不应该出现异常
{ {
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，出库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的出库库位"); ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，出库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的出库库位");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "出库的库位不正确"); wcsTaskEvent.ErrTaskEvent(wcsTask, "出库的库位不正确");
continue; continue;
} }
/* 判断冲突货位是否有任务 */ /* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(originLocationInfo.InterveneLocation); var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(originLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败 if (runningWcsTasks == default) continue; // 查询失败
if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待 if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */ /* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerOutTask((int)stackerId!, i + 1, originLocationInfo); StackerPlcTask stackerTask = wcsTask.ToStackerOutTask((int)stackerId!, i + 1, originLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1); string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功 if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，出库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，出库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始 wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
writeTaskCount++; writeTaskCount++;
isWriteTask = true; isWriteTask = true;
} }
@ -260,7 +252,7 @@ public class ExeTaskDoubleFork(
} }
if (isWriteTask) if (isWriteTask)
{ {
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认 string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机出库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}"); ConsoleLog.Info($"堆垛机出库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000); Thread.Sleep(1000);
} }
@ -275,7 +267,7 @@ public class ExeTaskDoubleFork(
public bool ExecutePickTask(int? stackerId) public bool ExecutePickTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常");
@ -293,7 +285,7 @@ public class ExeTaskDoubleFork(
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -317,17 +309,17 @@ public class ExeTaskDoubleFork(
Weight = Convert.ToInt16(wcsTask.Weight), Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0, Code = wcsTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask); wcsTaskEvent.StartTaskEvent(wcsTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
@ -341,7 +333,7 @@ public class ExeTaskDoubleFork(
public bool ExecuteMoveTask(int? stackerId) public bool ExecuteMoveTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常");
@ -368,20 +360,20 @@ public class ExeTaskDoubleFork(
if (originLocationInfo == default || destinationLocationInfo == default) // 任务起点终点错误，理论上此处不应该出现异常 if (originLocationInfo == default || destinationLocationInfo == default) // 任务起点终点错误，理论上此处不应该出现异常
{ {
ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，移库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的库位"); ConsoleLog.Warning($"【警告】{stackerId} 号堆垛机，移库库位：{wcsTask.Origin} 条码：{wcsTask.VehicleNo} 无法识别的库位");
_wcsTaskEvent.ErrTaskEvent(wcsTask, "移库的库位不正确"); wcsTaskEvent.ErrTaskEvent(wcsTask, "移库的库位不正确");
continue; continue;
} }
/* 判断冲突货位是否有任务，起点终点都要判断 */ /* 判断冲突货位是否有任务，起点终点都要判断 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation, originLocationInfo.InterveneLocation); var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation, originLocationInfo.InterveneLocation);
if (runningWcsTasks == default) continue; // 查询失败 if (runningWcsTasks == default) continue; // 查询失败
if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待 if (runningWcsTasks.Count > 0) continue; // 存在冲突点位，等待
/* 下发任务 */ /* 下发任务 */
StackerPlcTask stackerTask = wcsTask.ToStackerMoveTask((int)stackerId!, originLocationInfo, destinationLocationInfo); StackerPlcTask stackerTask = wcsTask.ToStackerMoveTask((int)stackerId!, originLocationInfo, destinationLocationInfo);
string WriteStackerTaskErrText = _stackerOperation.WriteTask(stackerTask, i + 1); string WriteStackerTaskErrText = stackerOperation.WriteTask(stackerTask, i + 1);
if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功 if (string.IsNullOrEmpty(WriteStackerTaskErrText)) // 写入成功
{ {
ConsoleLog.Success($"{stackerId} 号堆垛机，移库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}"); ConsoleLog.Success($"{stackerId} 号堆垛机，移库位置：{i + 1} 条码：{wcsTask.VehicleNo}，写入任务成功，{stackerTask}");
_wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始 wcsTaskEvent.StartTaskEvent(wcsTask); // 任务开始
writeTaskCount++; writeTaskCount++;
isWriteTask = true; isWriteTask = true;
} }
@ -392,7 +384,7 @@ public class ExeTaskDoubleFork(
} }
if (isWriteTask) if (isWriteTask)
{ {
string confirmResult = _stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认 string confirmResult = stackerOperation.WriteTaskConfirm(stackerId); // 写入任务确认
ConsoleLog.Info($"堆垛机移库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}"); ConsoleLog.Info($"堆垛机移库任务写任务确认；信息：{(string.IsNullOrEmpty(confirmResult) ? "成功" : confirmResult)}");
Thread.Sleep(1000); Thread.Sleep(1000);
} }
@ -411,7 +403,7 @@ public class ExeTaskDoubleFork(
{ {
if (stackerId == default || plcId == 0) return false; if (stackerId == default || plcId == 0) return false;
/* 查找这个PlcId对应的wms任务 */ /* 查找这个PlcId对应的wms任务 */
List<AppWcsTask>? doubleInTasks = _wcsTaskDao.Select(new AppWcsTask { PlcId = plcId }); List<AppWcsTask>? doubleInTasks = wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
if (doubleInTasks == default) if (doubleInTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常");
@ -423,7 +415,7 @@ public class ExeTaskDoubleFork(
/* 判断这个任务是否出现卸货位置有货 */ /* 判断这个任务是否出现卸货位置有货 */
if(doubleTask.TaskStatus != (int)WcsTaskStatusEnum.doubleIn) { return false; } // 没有重复入库不执行下面方法 if(doubleTask.TaskStatus != (int)WcsTaskStatusEnum.doubleIn) { return false; } // 没有重复入库不执行下面方法
/* 查找这个任务的新任务 */ /* 查找这个任务的新任务 */
List<AppWcsTask>? newTasks = _wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)WcsTaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WcsTaskStatusEnum.create }); List<AppWcsTask>? newTasks = wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)WcsTaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WcsTaskStatusEnum.create });
if (newTasks == default) if (newTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常");
@ -437,26 +429,26 @@ public class ExeTaskDoubleFork(
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常");
_wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常"); wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
return false; return false;
} }
/* 判断冲突货位是否有任务 */ /* 判断冲突货位是否有任务 */
var runningWcsTasks = _wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation); var runningWcsTasks = wcsTaskDao.QueryTaskWithWcsLocation(destinationLocationInfo.InterveneLocation);
if (runningWcsTasks == default) return false; // 查询失败 if (runningWcsTasks == default) return false; // 查询失败
if (runningWcsTasks.Count > 0) return false; // 存在冲突点位，等待 if (runningWcsTasks.Count > 0) return false; // 存在冲突点位，等待
/* 下发任务 */ /* 下发任务 */
StackerPlcTask stackerTask = newTask.ToStackerInTask((int)stackerId!, forkId, destinationLocationInfo); StackerPlcTask stackerTask = newTask.ToStackerInTask((int)stackerId!, forkId, destinationLocationInfo);
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}");
_wcsTaskEvent.StartTaskEvent(newTask); wcsTaskEvent.StartTaskEvent(newTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
} }

58
WcsMain/Business/CirculationTask/Stacker/ExecuteWcsTask.cs
View File

@ -17,10 +17,6 @@ namespace WcsMain.Business.CirculationTask.Stacker;
//[Circulation(tags: ["stacker"])] //[Circulation(tags: ["stacker"])]
public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent) public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcsTaskDao, WCSTaskExecuteEvent wcsTaskEvent)
{ {
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly StackerOperation _stackerOperation = stackerOperation;
/// <summary> /// <summary>
/// 执行堆垛机任务 /// 执行堆垛机任务
/// </summary> /// </summary>
@ -30,7 +26,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
foreach (var stacker in CommonData.AppStackers.Open()) foreach (var stacker in CommonData.AppStackers.Open())
{ {
var stackerUseStatus = _stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int _); var stackerUseStatus = stackerOperation.StackerCanUse(stacker.StackerId, out int plcId, out int _);
if (stackerUseStatus == StackerUseStatusEnum.Free) if (stackerUseStatus == StackerUseStatusEnum.Free)
{ {
/* 空闲时正常执行任务 */ /* 空闲时正常执行任务 */
@ -69,7 +65,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
private bool ExecuteInTask(int? stackerId) private bool ExecuteInTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectInTaskWithStacker((int)stackerId!); // 此处方法内已经判断状态 var wcsTasks = wcsTaskDao.SelectInTaskWithStacker((int)stackerId!); // 此处方法内已经判断状态
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机入库任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机入库任务查询失败，与数据库连接异常");
@ -87,7 +83,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -111,17 +107,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight), Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0, Code = wcsTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入入库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入入库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask); wcsTaskEvent.StartTaskEvent(wcsTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入入库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入入库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
} }
@ -134,7 +130,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecuteOutTask(int? stackerId) public bool ExecuteOutTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机出库任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机出库任务查询失败，与数据库连接异常");
@ -152,7 +148,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -176,17 +172,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight), Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0, Code = wcsTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入出库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入出库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask); wcsTaskEvent.StartTaskEvent(wcsTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入出库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入出库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
@ -200,7 +196,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecutePickTask(int? stackerId) public bool ExecutePickTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectPickOutTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机拣选任务查询失败，与数据库连接异常");
@ -218,7 +214,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -242,17 +238,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight), Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0, Code = wcsTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入拣选任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask); wcsTaskEvent.StartTaskEvent(wcsTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入拣选任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
@ -266,7 +262,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
public bool ExecuteMoveTask(int? stackerId) public bool ExecuteMoveTask(int? stackerId)
{ {
if (stackerId == default) return false; if (stackerId == default) return false;
var wcsTasks = _wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!); var wcsTasks = wcsTaskDao.SelectMoveTaskWithStacker((int)stackerId!);
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机移库任务查询失败，与数据库连接异常");
@ -282,7 +278,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{wcsTask.TaskId}，Plc任务号：{wcsTask.PlcId} 无法执行，起点或者终点存在异常");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"起点或者终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -306,17 +302,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(wcsTask.Weight), Weight = Convert.ToInt16(wcsTask.Weight),
Code = wcsTask.PlcVehicleNo ?? 0, Code = wcsTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入移库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入移库任务成功，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}");
_wcsTaskEvent.StartTaskEvent(wcsTask); wcsTaskEvent.StartTaskEvent(wcsTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入移库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入移库任务失败，箱号：{wcsTask.VehicleNo}，PlcId：{wcsTask.PlcId}；{wcsTask.Origin} => {wcsTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(wcsTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
@ -332,7 +328,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
if (stackerId == default || plcId == 0) return false; if (stackerId == default || plcId == 0) return false;
/* 查找这个PlcId对应的wms任务 */ /* 查找这个PlcId对应的wms任务 */
List<AppWcsTask>? doubleInTasks = _wcsTaskDao.Select(new AppWcsTask { PlcId = plcId }); List<AppWcsTask>? doubleInTasks = wcsTaskDao.Select(new AppWcsTask { PlcId = plcId });
if (doubleInTasks == default) if (doubleInTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务检验失败，与数据库连接异常");
@ -342,7 +338,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
if (doubleInTasks.Count == 0) return false; // 找不到对应的PlcId的任务 if (doubleInTasks.Count == 0) return false; // 找不到对应的PlcId的任务
var doubleTask = doubleInTasks[0]; var doubleTask = doubleInTasks[0];
/* 查找这个任务的新任务 */ /* 查找这个任务的新任务 */
List<AppWcsTask>? newTasks = _wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)TaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WmsTaskStatusEnum.create }); List<AppWcsTask>? newTasks = wcsTaskDao.Select(new AppWcsTask { TaskId = doubleTask.TaskId, TaskType = (int)TaskTypeEnum.newTaskForDoubleIn, TaskStatus = (int)WmsTaskStatusEnum.create });
if (newTasks == default) if (newTasks == default)
{ {
ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常"); ConsoleLog.Error($"【异常】{stackerId} 号堆垛机重复入库任务新任务查询失败，与数据库连接异常");
@ -356,7 +352,7 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
{ {
// 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消 // 已经在接口内做了检查，按道理此处不会出错。直接返回异常，任务直接取消
ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常"); ConsoleLog.Warning($"【警告】任务号：{newTask.TaskId}，Plc任务号：{newTask.PlcId} 无法执行，新终点存在异常");
_wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常"); wcsTaskEvent.ErrTaskEvent(newTask, $"新终点存在异常");
return false; return false;
} }
StackerPlcTask stackerTask = new() StackerPlcTask stackerTask = new()
@ -380,17 +376,17 @@ public class ExecuteWcsTask(StackerOperation stackerOperation, AppWcsTaskDao wcs
Weight = Convert.ToInt16(newTask.Weight), Weight = Convert.ToInt16(newTask.Weight),
Code = newTask.PlcVehicleNo ?? 0, Code = newTask.PlcVehicleNo ?? 0,
}; };
var writeStackerTaskErrText = _stackerOperation.WriteTask(stackerTask); var writeStackerTaskErrText = stackerOperation.WriteTask(stackerTask);
if (string.IsNullOrEmpty(writeStackerTaskErrText)) if (string.IsNullOrEmpty(writeStackerTaskErrText))
{ {
ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}"); ConsoleLog.Success($"堆垛机：{stackerId} 写入重复入库新任务成功，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}");
_wcsTaskEvent.StartTaskEvent(newTask); wcsTaskEvent.StartTaskEvent(newTask);
return true; return true;
} }
else else
{ {
ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}"); ConsoleLog.Warning($"【警告】堆垛机：{stackerId} 写入重复入库新任务失败，箱号：{newTask.VehicleNo}，PlcId：{newTask.PlcId}；新目的地：{newTask.Destination}，异常信息：{writeStackerTaskErrText}");
_wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}"); wcsTaskEvent.ErrTaskEvent(newTask, $"写入任务失败，异常信息：{writeStackerTaskErrText}");
} }
return false; return false;
} }

19
WcsMain/Business/CirculationTask/StackerConvey/CheckAccount.cs
View File

@ -14,9 +14,6 @@ namespace WcsMain.Business.CirculationTask.StackerConvey;
[Circulation] [Circulation]
public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stackerConveyOperation, WCSTaskExecuteEvent wcsTaskEvent) public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stackerConveyOperation, WCSTaskExecuteEvent wcsTaskEvent)
{ {
private readonly WCSTaskExecuteEvent _wcsTaskEvent = wcsTaskEvent;
private readonly StackerConveyOperation _stackerConveyOperation = stackerConveyOperation;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary> /// <summary>
/// PLC过账 /// PLC过账
@ -25,12 +22,12 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
[Circulation("监控PLC地址，过账", 1000)] [Circulation("监控PLC地址，过账", 1000)]
public bool CheckAccountTask() public bool CheckAccountTask()
{ {
List<TaskFeedBackEntity>? taskFeedBackEntities = _stackerConveyOperation.GetConveyTaskFeedBackData(20); List<TaskFeedBackEntity>? taskFeedBackEntities = stackerConveyOperation.GetConveyTaskFeedBackData(20);
if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1) {return true; } if (taskFeedBackEntities == default || taskFeedBackEntities.Count < 1) {return true; }
foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities) foreach (TaskFeedBackEntity taskFeedBackEntity in taskFeedBackEntities)
{ {
if (taskFeedBackEntity.PlcId == 0) { continue; } if (taskFeedBackEntity.PlcId == 0) { continue; }
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId }); List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask() { PlcId = taskFeedBackEntity.PlcId });
if (wcsTasks == default) if (wcsTasks == default)
{ {
ConsoleLog.Error($"【异常】库前输送过账查询任务数据失败，和数据库服务器连接中断"); ConsoleLog.Error($"【异常】库前输送过账查询任务数据失败，和数据库服务器连接中断");
@ -40,7 +37,7 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
if (wcsTasks.Count < 1) if (wcsTasks.Count < 1)
{ {
ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务"); ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，无关联任务");
_stackerConveyOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账 stackerConveyOperation.ClearFeedBackData(taskFeedBackEntity); // 清除过账
continue; // 任务无数据 continue; // 任务无数据
} }
var wcsTask = wcsTasks[0]; var wcsTask = wcsTasks[0];
@ -67,13 +64,13 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void CancelTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}"); ConsoleLog.Warning($"【提示】库前输送过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经被取消，后续任务也一并取消,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账 string? cleanAccountErr = stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"[警告]取消任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务异常动作 */ /* 执行 WMS 任务异常动作 */
_wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消"); wcsTaskEvent.ErrTaskEvent(wcsTask, "任务被PLC取消");
} }
@ -84,13 +81,13 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask) private void CompleteTask(TaskFeedBackEntity taskFeedBackEntity, AppWcsTask wcsTask)
{ {
ConsoleLog.Tip($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}"); ConsoleLog.Tip($"[提示]过账区获取任务ID：{taskFeedBackEntity.PlcId}，任务已经完成,任务号：{wcsTask.TaskId}");
string? cleanAccountErr = _stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账 string? cleanAccountErr = stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
if (!string.IsNullOrEmpty(cleanAccountErr)) if (!string.IsNullOrEmpty(cleanAccountErr))
{ {
ConsoleLog.Warning($"[警告]完成任务清除过账区发生异常，信息：{cleanAccountErr}"); ConsoleLog.Warning($"[警告]完成任务清除过账区发生异常，信息：{cleanAccountErr}");
} }
/* 执行 WMS 任务完成动作 */ /* 执行 WMS 任务完成动作 */
_wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成"); wcsTaskEvent.CompleteTaskEvent(wcsTask, "PLC上报完成");
} }
@ -102,7 +99,7 @@ public class CheckAccount(AppWcsTaskDao wcsTaskDao, StackerConveyOperation stack
private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity) private void OtherTaskFeedBackType(TaskFeedBackEntity taskFeedBackEntity)
{ {
ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}"); ConsoleLog.Warning($"[警告]过账区获取任务ID：{taskFeedBackEntity.PlcId}，无法识别的过账类型：{taskFeedBackEntity.FeedBackType}");
_stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账 stackerConveyOperation.ResetFeedBackData(taskFeedBackEntity); // 清除过账
} }
} }

27
WcsMain/Business/CirculationTask/TaskData/ResolveWmsTask.cs
View File

@ -18,11 +18,6 @@ namespace WcsMain.Business.CirculationTask.TaskData;
[Circulation()] [Circulation()]
public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus, DataBaseData dataBaseData, TaskDao taskDao) public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus, DataBaseData dataBaseData, TaskDao taskDao)
{ {
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
private readonly TaskDao _taskDao = taskDao;
/// <summary> /// <summary>
/// 解析WMS任务 /// 解析WMS任务
/// </summary> /// </summary>
@ -30,7 +25,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
[Circulation("解析WMS任务，转换为WCS任务")] [Circulation("解析WMS任务，转换为WCS任务")]
public bool ResolveTask() public bool ResolveTask()
{ {
List<AppWmsTask>? needResolveTask = _wmsTaskDao.Select(new AppWmsTask() { TaskStatus = (int)WmsTaskStatusEnum.create }); List<AppWmsTask>? needResolveTask = wmsTaskDao.Select(new AppWmsTask() { TaskStatus = (int)WmsTaskStatusEnum.create });
if (needResolveTask == default) if (needResolveTask == default)
{ {
ConsoleLog.Error("【异常】解析Wms任务时拉取任务列表失败，与数据库连接中断"); ConsoleLog.Error("【异常】解析Wms任务时拉取任务列表失败，与数据库连接中断");
@ -52,7 +47,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
bool checkResult = CommonData.AppLocations.ExistWmsLocation(wmsTask.Origin, wmsTask.Destination); bool checkResult = CommonData.AppLocations.ExistWmsLocation(wmsTask.Origin, wmsTask.Destination);
if(!checkResult) if(!checkResult)
{ {
_wmsTaskDao.Update(new() wmsTaskDao.Update(new()
{ {
TaskId = wmsTask.TaskId, TaskId = wmsTask.TaskId,
TaskStatus = (int)WmsTaskStatusEnum.err, TaskStatus = (int)WmsTaskStatusEnum.err,
@ -61,7 +56,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
}); });
if(wmsTask.CreatePerson == StaticString.WMS) if(wmsTask.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskErr(wmsTask.TaskId, "不受支持的起点或终点"); sendWmsTaskStatus.SendTaskErr(wmsTask.TaskId, "不受支持的起点或终点");
} }
return; return;
} }
@ -108,7 +103,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin); AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination); AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; } if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if(plcId == default) { return; } if(plcId == default) { return; }
AppWcsTask wcsTask = new() AppWcsTask wcsTask = new()
{ {
@ -129,7 +124,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now, CreateTime = DateTime.Now,
}; };
/* 插入新任务同时更新 wms 任务为排队中 */ /* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask); string? errMessage = taskDao.CreateWcsTask(wcsTask);
if(string.IsNullOrWhiteSpace(errMessage)) if(string.IsNullOrWhiteSpace(errMessage))
{ {
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列"); ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -149,7 +144,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin); AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination); AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; } if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; } if (plcId == default) { return; }
AppWcsTask wcsTask = new() AppWcsTask wcsTask = new()
{ {
@ -169,7 +164,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now, CreateTime = DateTime.Now,
}; };
/* 插入新任务同时更新 wms 任务为排队中 */ /* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask); string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage)) if (string.IsNullOrWhiteSpace(errMessage))
{ {
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列"); ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -189,7 +184,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin); AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination); AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; } if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; } if (plcId == default) { return; }
AppWcsTask wcsTask = new() AppWcsTask wcsTask = new()
{ {
@ -209,7 +204,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now, CreateTime = DateTime.Now,
}; };
/* 插入新任务同时更新 wms 任务为排队中 */ /* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask); string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage)) if (string.IsNullOrWhiteSpace(errMessage))
{ {
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列"); ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");
@ -229,7 +224,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin); AppLocation? wcsOrigin = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Origin);
AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination); AppLocation? wcsDestination = CommonData.AppLocations.DetailWithWmsLocation(wmsTask.Destination);
if (wcsOrigin == default || wcsDestination == default) { return; } if (wcsOrigin == default || wcsDestination == default) { return; }
int? plcId = _dataBaseData.GetNewPlcTaskId(); int? plcId = dataBaseData.GetNewPlcTaskId();
if (plcId == default) { return; } if (plcId == default) { return; }
AppWcsTask wcsTask = new() AppWcsTask wcsTask = new()
{ {
@ -250,7 +245,7 @@ public class ResolveWmsTask(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsT
CreateTime = DateTime.Now, CreateTime = DateTime.Now,
}; };
/* 插入新任务同时更新 wms 任务为排队中 */ /* 插入新任务同时更新 wms 任务为排队中 */
string? errMessage = _taskDao.CreateWcsTask(wcsTask); string? errMessage = taskDao.CreateWcsTask(wcsTask);
if (string.IsNullOrWhiteSpace(errMessage)) if (string.IsNullOrWhiteSpace(errMessage))
{ {
ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列"); ConsoleLog.Info($"【提示】任务：{wmsTask.TaskId} 已经进入队列");

20
WcsMain/Business/CommonAction/ClearData.cs
View File

@ -12,55 +12,47 @@ public class ClearData(AppWmsTaskDao wmsTaskDao, AppWcsTaskDao wcsTaskDao, AppAp
AppApiAcceptDao apiAcceptDao, AppElTagTaskDao elTagTaskDao, AppConveyTaskDao conveyTaskDao) AppApiAcceptDao apiAcceptDao, AppElTagTaskDao elTagTaskDao, AppConveyTaskDao conveyTaskDao)
{ {
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
private readonly AppApiRequestDao _apiRequestDao = apiRequestDao;
private readonly AppApiAcceptDao _apiAcceptDao = apiAcceptDao;
private readonly AppElTagTaskDao _elTagTaskDao = elTagTaskDao;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/* 定时清除 WMS 任务表 */ /* 定时清除 WMS 任务表 */
/// <summary> /// <summary>
/// 清理超过一定时间的 WMS 任务表数据 /// 清理超过一定时间的 WMS 任务表数据
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
public int ClearWmsTaskData(int days) => _wmsTaskDao.ClearData(days); public int ClearWmsTaskData(int days) => wmsTaskDao.ClearData(days);
/* 定时清除 WCS 任务备份表 */ /* 定时清除 WCS 任务备份表 */
/// <summary> /// <summary>
/// 清理超过一定天数的 WCS 任务备份表数据 /// 清理超过一定天数的 WCS 任务备份表数据
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
public int ClearWcsTaskData(int days) => _wcsTaskDao.ClearData(days); public int ClearWcsTaskData(int days) => wcsTaskDao.ClearData(days);
/* 定时清除接口请求表 */ /* 定时清除接口请求表 */
/// <summary> /// <summary>
/// 清理接口发送信息表 /// 清理接口发送信息表
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
public int ClearApiRequestData(int days) => _apiRequestDao.ClearData(days); public int ClearApiRequestData(int days) => apiRequestDao.ClearData(days);
/* 定时清除接口接收表 */ /* 定时清除接口接收表 */
/// <summary> /// <summary>
/// 清理接口接收信息表 /// 清理接口接收信息表
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
public int ClearApiAcceptData(int days) => _apiAcceptDao.ClearData(days); public int ClearApiAcceptData(int days) => apiAcceptDao.ClearData(days);
/// <summary> /// <summary>
/// 清理多少天之前的电子标签任务 /// 清理多少天之前的电子标签任务
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
/// <returns></returns> /// <returns></returns>
public int ClearElTagTaskData(int days) => _elTagTaskDao.ClearData(days); public int ClearElTagTaskData(int days) => elTagTaskDao.ClearData(days);
/// <summary> /// <summary>
/// 清理输送线任务 /// 清理输送线任务
/// </summary> /// </summary>
/// <param name="days"></param> /// <param name="days"></param>
/// <returns></returns> /// <returns></returns>
public int ClearConveyTaskData(int days) => _conveyTaskDao.ClearData(days); public int ClearConveyTaskData(int days) => conveyTaskDao.ClearData(days);
/* 定时清除 日志文件 */ /* 定时清除 日志文件 */

22
WcsMain/Business/CommonAction/SendWmsTaskStatus.cs
View File

@ -14,8 +14,6 @@ namespace WcsMain.Business.CommonAction;
[Component] [Component]
public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApiPost) public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApiPost)
{ {
private readonly WmsWebApiPost _wmsWebApiPost = wmsWebApiPost;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
/// <summary> /// <summary>
/// 发送 WMS 任务异常 /// 发送 WMS 任务异常
@ -29,7 +27,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default; AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId }); List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}"); ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -54,7 +52,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
}; };
for (int i = 1; i <= count; i++) for (int i = 1; i <= count; i++)
{ {
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? ""); var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend) if (!response.IsSend)
{ {
ConsoleLog.Error($"【异常】发送WMS[任务异常]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}"); ConsoleLog.Error($"【异常】发送WMS[任务异常]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -87,7 +85,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default; AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId }); List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}"); ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -112,7 +110,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
}; };
for (int i = 1; i <= count; i++) for (int i = 1; i <= count; i++)
{ {
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? ""); var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend) if (!response.IsSend)
{ {
ConsoleLog.Error($"【异常】发送WMS[取货位置无货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}"); ConsoleLog.Error($"【异常】发送WMS[取货位置无货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -145,7 +143,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default; AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId }); List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}"); ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -170,7 +168,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
}; };
for (int i = 1; i <= count; i++) for (int i = 1; i <= count; i++)
{ {
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? ""); var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend) if (!response.IsSend)
{ {
ConsoleLog.Error($"【异常】发送WMS[卸货位置有货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}"); ConsoleLog.Error($"【异常】发送WMS[卸货位置有货]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -204,7 +202,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default; AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId }); List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}"); ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -229,7 +227,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
}; };
for (int i = 1; i <= count; i++) for (int i = 1; i <= count; i++)
{ {
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? ""); var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend) if (!response.IsSend)
{ {
ConsoleLog.Error($"【异常】发送WMS[开始执行]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}"); ConsoleLog.Error($"【异常】发送WMS[开始执行]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");
@ -262,7 +260,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
AppWmsTask? wmsTask = default; AppWmsTask? wmsTask = default;
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
List<AppWmsTask>? tasks = _wmsTaskDao.Select(new AppWmsTask { TaskId = taskId }); List<AppWmsTask>? tasks = wmsTaskDao.Select(new AppWmsTask { TaskId = taskId });
if (tasks == default) if (tasks == default)
{ {
ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}"); ConsoleLog.Error($"【异常】发送WMS任务状态时查询数据库失败，和数据库连接中断，任务号：{taskId}");
@ -287,7 +285,7 @@ public class SendWmsTaskStatus(AppWmsTaskDao wmsTaskDao, WmsWebApiPost wmsWebApi
}; };
for (int i = 1; i <= count; i++) for (int i = 1; i <= count; i++)
{ {
var response = _wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? ""); var response = wmsWebApiPost.HttpPost<SendWmsTaskStatusRequest, WmsResponse>(request, CommonData.AppConfig.SendWmsTaskStatusApiAddress ?? "");
if (!response.IsSend) if (!response.IsSend)
{ {
ConsoleLog.Error($"【异常】发送WMS[任务完成]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}"); ConsoleLog.Error($"【异常】发送WMS[任务完成]失败，发送次数：{i}，任务号：{wmsTask.TaskId}，参考信息：{response.RequestException?.Message}");

28
WcsMain/Business/CommonAction/WCSTaskExecuteEvent.cs
View File

@ -14,10 +14,6 @@ namespace WcsMain.Business.CommonAction;
[Component] [Component]
public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskStatus, AppLocationDao locationDao) public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskStatus, AppLocationDao locationDao)
{ {
private readonly AppLocationDao _locationDao = locationDao;
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly TaskDao _taskDao = taskDao;
/// <summary> /// <summary>
/// 任务执行异常触发事件 /// 任务执行异常触发事件
/// </summary> /// </summary>
@ -25,14 +21,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param> /// <param name="errText"></param>
public void ErrTaskEvent(AppWcsTask task, string errText) public void ErrTaskEvent(AppWcsTask task, string errText)
{ {
string errMsg = _taskDao.TaskErrAndCancelOtherTask(task, errText); string errMsg = taskDao.TaskErrAndCancelOtherTask(task, errText);
if (!string.IsNullOrEmpty(errMsg)) if (!string.IsNullOrEmpty(errMsg))
{ {
ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}"); ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
} }
if (task.CreatePerson == StaticString.WMS) if (task.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskErr(task.TaskId, errText); sendWmsTaskStatus.SendTaskErr(task.TaskId, errText);
} }
} }
@ -44,14 +40,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param> /// <param name="errText"></param>
public void EmptyOutTaskEvent(AppWcsTask task, string errText) public void EmptyOutTaskEvent(AppWcsTask task, string errText)
{ {
string errMsg = _taskDao.TaskErr(task, errText); string errMsg = taskDao.TaskErr(task, errText);
if (!string.IsNullOrEmpty(errMsg)) if (!string.IsNullOrEmpty(errMsg))
{ {
ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}"); ConsoleLog.Error($"【异常】任务异常更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
} }
if (task.CreatePerson == StaticString.WMS) if (task.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskEmptyOut(task.TaskId); sendWmsTaskStatus.SendTaskEmptyOut(task.TaskId);
} }
} }
@ -62,14 +58,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="errText"></param> /// <param name="errText"></param>
public void DoubleInTaskEvent(AppWcsTask task, string errText) public void DoubleInTaskEvent(AppWcsTask task, string errText)
{ {
string errMsg = _taskDao.TaskErr(task, errText); string errMsg = taskDao.TaskErr(task, errText);
if (!string.IsNullOrEmpty(errMsg)) if (!string.IsNullOrEmpty(errMsg))
{ {
ConsoleLog.Error($"【异常】卸货位置有货更新数据库失败，任务信息：{task}，参考信息：{errMsg}"); ConsoleLog.Error($"【异常】卸货位置有货更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
} }
if (task.CreatePerson == StaticString.WMS) if (task.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskDoubleIn(task.TaskId); sendWmsTaskStatus.SendTaskDoubleIn(task.TaskId);
} }
} }
@ -82,14 +78,14 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
/// <param name="task"></param> /// <param name="task"></param>
public void StartTaskEvent(AppWcsTask task) public void StartTaskEvent(AppWcsTask task)
{ {
string errMsg = _taskDao.StartTask(task); string errMsg = taskDao.StartTask(task);
if (!string.IsNullOrEmpty(errMsg)) if (!string.IsNullOrEmpty(errMsg))
{ {
ConsoleLog.Error($"【异常】任务开始更新数据库失败，任务信息：{task}，参考信息：{errMsg}"); ConsoleLog.Error($"【异常】任务开始更新数据库失败，任务信息：{task}，参考信息：{errMsg}");
} }
if (task.IsFirstTask() && task.CreatePerson == StaticString.WMS) if (task.IsFirstTask() && task.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskStart(task.TaskId); sendWmsTaskStatus.SendTaskStart(task.TaskId);
} }
} }
@ -110,7 +106,7 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
private void HandleTaskData(AppWcsTask task, string msg) private void HandleTaskData(AppWcsTask task, string msg)
{ {
string errMsg = _taskDao.ComlpeteTask(task, msg); string errMsg = taskDao.ComlpeteTask(task, msg);
if(!string.IsNullOrEmpty(errMsg)) if(!string.IsNullOrEmpty(errMsg))
{ {
ConsoleLog.Error($"【异常】PlcId：{task.PlcId} 任务完成失败，异常信息：{errMsg}"); ConsoleLog.Error($"【异常】PlcId：{task.PlcId} 任务完成失败，异常信息：{errMsg}");
@ -130,13 +126,13 @@ public class WCSTaskExecuteEvent(TaskDao taskDao, SendWmsTaskStatus sendWmsTaskS
switch (task.TaskType) switch (task.TaskType)
{ {
case (int)TaskTypeEnum.inTask: // 入库任务 case (int)TaskTypeEnum.inTask: // 入库任务
_locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo)); locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo));
break; break;
case (int)TaskTypeEnum.outTask: // 出库任务 case (int)TaskTypeEnum.outTask: // 出库任务
_locationDao.Update(AppLocation.CreateEmptyInstance(task.Origin)); locationDao.Update(AppLocation.CreateEmptyInstance(task.Origin));
break; break;
case (int)TaskTypeEnum.moveTask: // 移库任务 case (int)TaskTypeEnum.moveTask: // 移库任务
_locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo), AppLocation.CreateEmptyInstance(task.Origin)); locationDao.Update(AppLocation.CreateUsedInstance(task.Destination, task.VehicleNo), AppLocation.CreateEmptyInstance(task.Origin));
break; break;
} }
} }

7
WcsMain/Business/CommonAction/WMSApiResponseAction.cs
View File

@ -14,9 +14,6 @@ namespace WcsMain.Business.CommonAction;
public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao apiRequestDao) public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao apiRequestDao)
{ {
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppApiRequestDao _apiRequestDao = apiRequestDao;
/// <summary> /// <summary>
/// 当请求其他系统时触发本方法 /// 当请求其他系统时触发本方法
/// </summary> /// </summary>
@ -30,7 +27,7 @@ public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao ap
// 存库 // 存库
AppApiRequest insertData = new() AppApiRequest insertData = new()
{ {
RequestId = _dataBaseData.GetNewUUID(), RequestId = dataBaseData.GetNewUUID(),
RequestUrl = responseInfo.RequestUrl, RequestUrl = responseInfo.RequestUrl,
RequestMethod = responseInfo.RequestMethod, RequestMethod = responseInfo.RequestMethod,
IsSuccess = responseInfo.IsSend ? 1 : 0, IsSuccess = responseInfo.IsSend ? 1 : 0,
@ -41,7 +38,7 @@ public class WMSApiResponseAction(DataBaseData dataBaseData, AppApiRequestDao ap
UseTime = responseInfo.UseTime, UseTime = responseInfo.UseTime,
ErrMsg = responseInfo.RequestException?.Message, ErrMsg = responseInfo.RequestException?.Message,
}; };
_apiRequestDao.Insert(insertData); apiRequestDao.Insert(insertData);
} }
catch (Exception ex) catch (Exception ex)
{ {

16
WcsMain/Business/CommonAction/WmsTaskAction.cs
View File

@ -8,8 +8,6 @@ namespace WcsMain.Business.CommonAction;
[Component] [Component]
public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus) public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTaskStatus)
{ {
private readonly SendWmsTaskStatus _sendWmsTaskStatus = sendWmsTaskStatus;
private readonly AppWmsTaskDao _wmsTaskDao = wmsTaskDao;
/// <summary> /// <summary>
/// 重置WMS任务 /// 重置WMS任务
@ -20,7 +18,7 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns> /// <returns></returns>
public string ResetWmsTaskStatus(string? taskId, string? newDestination, string systemName) public string ResetWmsTaskStatus(string? taskId, string? newDestination, string systemName)
{ {
string resetErrMessage = _wmsTaskDao.ResetTaskWithTaskId(taskId, newDestination, $"任务被{systemName}重置"); string resetErrMessage = wmsTaskDao.ResetTaskWithTaskId(taskId, newDestination, $"任务被{systemName}重置");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 重置成功 if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 重置成功
// 重置失败，返回错误信息 // 重置失败，返回错误信息
return $"重置状态失败：任务号：{taskId}，参考异常信息：{resetErrMessage}"; return $"重置状态失败：任务号：{taskId}，参考异常信息：{resetErrMessage}";
@ -34,16 +32,16 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns> /// <returns></returns>
public string CompleteWmsTaskStatus(string? taskId, string sysName) public string CompleteWmsTaskStatus(string? taskId, string sysName)
{ {
List<AppWmsTask>? wmsTasks = _wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId }); List<AppWmsTask>? wmsTasks = wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
if (wmsTasks != default && wmsTasks.Count > 0) if (wmsTasks != default && wmsTasks.Count > 0)
{ {
AppWmsTask wmsTask = wmsTasks[0]; AppWmsTask wmsTask = wmsTasks[0];
if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS) if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskComplete(taskId); sendWmsTaskStatus.SendTaskComplete(taskId);
} }
} }
string resetErrMessage = _wmsTaskDao.CompleteTaskWithTaskId(taskId, $"【{sysName}】完成"); string resetErrMessage = wmsTaskDao.CompleteTaskWithTaskId(taskId, $"【{sysName}】完成");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 完成成功 if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 完成成功
return $"完成任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}"; return $"完成任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}";
} }
@ -56,16 +54,16 @@ public class WmsTaskAction(AppWmsTaskDao wmsTaskDao, SendWmsTaskStatus sendWmsTa
/// <returns></returns> /// <returns></returns>
public string DeleteWmsTaskStatus(string? taskId, string sysName) public string DeleteWmsTaskStatus(string? taskId, string sysName)
{ {
List<AppWmsTask>? wmsTasks = _wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId }); List<AppWmsTask>? wmsTasks = wmsTaskDao.Select(new AppWmsTask() { TaskId = taskId });
if (wmsTasks != default && wmsTasks.Count > 0) if (wmsTasks != default && wmsTasks.Count > 0)
{ {
AppWmsTask wmsTask = wmsTasks[0]; AppWmsTask wmsTask = wmsTasks[0];
if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS) if (sysName != StaticString.WMS && wmsTask.CreatePerson == StaticString.WMS)
{ {
_sendWmsTaskStatus.SendTaskErr(taskId, $"{sysName} 删除/取消"); sendWmsTaskStatus.SendTaskErr(taskId, $"{sysName} 删除/取消");
} }
} }
string resetErrMessage = _wmsTaskDao.DeleteTaskWithTaskId(taskId, $"【{sysName}】删除/取消"); string resetErrMessage = wmsTaskDao.DeleteTaskWithTaskId(taskId, $"【{sysName}】删除/取消");
if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 删除成功 if (string.IsNullOrEmpty(resetErrMessage)) return string.Empty; // 删除成功
return $"删除/取消任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}"; return $"删除/取消任务失败。任务号：{taskId}，参考异常信息：{resetErrMessage}";
} }

7
WcsMain/Business/Convey/ConnectPlcServe.cs
View File

@ -17,9 +17,6 @@ namespace WcsMain.Business.Convey;
[Component] [Component]
public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataHandler) public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataHandler)
{ {
private readonly AppTcpDao _tcpDao = tcpDao;
private readonly BaseConveyDataHandler _conveyDataHandler = conveyDataHandler;
public void SetBaseAction() public void SetBaseAction()
{ {
@ -41,7 +38,7 @@ public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataH
List<AppTcp>? tcps = default; List<AppTcp>? tcps = default;
while (true) while (true)
{ {
tcps = _tcpDao.Query(new AppTcp { TcpStatus = (int)TrueFalseEnum.TRUE, TcpType = (int)TcpType.PLC }); tcps = tcpDao.Query(new AppTcp { TcpStatus = (int)TrueFalseEnum.TRUE, TcpType = (int)TcpType.PLC });
if (tcps != default) break; if (tcps != default) break;
Thread.Sleep(5000); Thread.Sleep(5000);
continue; continue;
@ -89,7 +86,7 @@ public class ConnectPlcServe(AppTcpDao tcpDao, BaseConveyDataHandler conveyDataH
switch(header.MsgTag) switch(header.MsgTag)
{ {
case "GTROUTER": // plc向WCS请求路向 ---- 箱式线 case "GTROUTER": // plc向WCS请求路向 ---- 箱式线
_conveyDataHandler.GetRouter(tcpServe.DisplayName, msg); conveyDataHandler.GetRouter(tcpServe.DisplayName, msg);
return; return;

4
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/LoginGetData.cs
View File

@ -13,8 +13,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class LoginGetData(WmsWebApiPost wmsWebApiPost) : IBaseGetData public class LoginGetData(WmsWebApiPost wmsWebApiPost) : IBaseGetData
{ {
private readonly WmsWebApiPost _wmsWebApiPost = wmsWebApiPost;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -50,7 +48,7 @@ public class LoginGetData(WmsWebApiPost wmsWebApiPost) : IBaseGetData
} }
/* 发送 WMS 请求入库 */ /* 发送 WMS 请求入库 */
ApplyInRequest applyInRequest = new(area, code, msg); ApplyInRequest applyInRequest = new(area, code, msg);
var postResult = _wmsWebApiPost.HttpPost<ApplyInRequest, WmsResponse>(applyInRequest, CommonData.AppConfig.ApplyEnterApiAddress ?? ""); var postResult = wmsWebApiPost.HttpPost<ApplyInRequest, WmsResponse>(applyInRequest, CommonData.AppConfig.ApplyEnterApiAddress ?? "");
if(!postResult.IsSend || postResult.ResponseEntity == default) if(!postResult.IsSend || postResult.ResponseEntity == default)
{ {
ConsoleLog.Exception($"【异常】注册口：{area} 箱码:{msg} 请求入库发生异常，异常信息：{postResult.RequestException}"); ConsoleLog.Exception($"【异常】注册口：{area} 箱码:{msg} 请求入库发生异常，异常信息：{postResult.RequestException}");

22
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/Pick1StandOutC3.cs
View File

@ -18,10 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -31,9 +27,9 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +48,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +59,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +70,12 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
} }
} }
/* 判断条码有没有拣选任务 */ /* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create }); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default) if (conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断一区环线运行 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断一区环线运行
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +88,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -107,7 +103,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 不存在一号台任务，环线运行"); ConsoleLog.Warning($"【警告】一区出口：{area} 箱码：{msg} 不存在一号台任务，环线运行");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在一号台任务 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在一号台任务
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -120,7 +116,7 @@ public class Pick1StandOutC3(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Info($"一区出口：{area} 箱码：{msg} 存在一号台任务，移栽 1 号站台"); ConsoleLog.Info($"一区出口：{area} 箱码：{msg} 存在一号台任务，移栽 1 号站台");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在一号台任务 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在一号台任务
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"一区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/Pick2StandOutC4.cs
View File

@ -18,9 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// <param name="conveyTaskDao"></param> /// <param name="conveyTaskDao"></param>
public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary> /// <summary>
/// 扫码失败 /// 扫码失败
@ -31,9 +28,9 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 读码失败，环线继续，进入拣选一区 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 读码失败，环线继续，进入拣选一区
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +49,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +60,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +71,12 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
} }
} }
/* 判断条码有没有拣选任务 */ /* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create }); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default) if (conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选区 1 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选区 1
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +89,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); // 没有任务直接回库，走上层 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); // 没有任务直接回库，走上层
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -117,7 +114,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在 1~5 站台任务，前往拣选一区"); ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在 1~5 站台任务，前往拣选一区");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -134,7 +131,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 不存在6号台任务，环线运行"); ConsoleLog.Warning($"【警告】二区出口：{area} 箱码：{msg} 不存在6号台任务，环线运行");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在6号台任务 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 不存在6号台任务
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -147,7 +144,7 @@ public class Pick2StandOutC4(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在6号台任务，移栽 6 号站台"); ConsoleLog.Info($"二区出口：{area} 箱码：{msg} 存在6号台任务，移栽 6 号站台");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在6号台任务 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 存在6号台任务
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"二区出口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/PickStandGetData.cs
View File

@ -20,11 +20,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks> /// </remarks>
public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -34,9 +29,9 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}");
@ -55,7 +50,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -66,7 +61,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -77,12 +72,12 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
} }
} }
/* 判断条码有没有这个拣选站台的拣选任务 */ /* 判断条码有没有这个拣选站台的拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create, Location = area }); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create, Location = area });
if (conveyTasks == default) if (conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -95,7 +90,7 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -108,11 +103,11 @@ public class PickStandGetData(ConveyOperation conveyOperation, DataBaseData data
// 有拣选任务 // 有拣选任务
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove); ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk); string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk)) if (string.IsNullOrEmpty(errTextOk))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");
int updateResult = _conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved }); int updateResult = conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
if (updateResult < 1) if (updateResult < 1)
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败");

26
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/PickStandP5.cs
View File

@ -18,10 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// <param name="conveyTaskDao"></param> /// <param name="conveyTaskDao"></param>
public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -31,9 +27,9 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进站台 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 读码失败，移栽进站台
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 读码失败，写入PLC成功，{plcTask}");
@ -52,7 +48,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -63,7 +59,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -74,12 +70,12 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
} }
} }
/* 判断条码有没有拣选任务 */ /* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create}); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create});
if (conveyTasks == default) if (conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.LeftMove); // 连接中断去往拣选区
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -92,7 +88,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -107,11 +103,11 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove); ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.LeftMove);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk); string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk)) if (string.IsNullOrEmpty(errTextOk))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");
int updateResult = _conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved }); int updateResult = conveyTaskDao.Update(new AppConveyTask() { TaskId = conveyTask.TaskId, MoveTime = DateTime.Now, TaskStatus = (int)ConveyTaskStatusEnum.moved });
if (updateResult < 1) if (updateResult < 1)
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 更新移栽状态失败");
@ -141,7 +137,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{ {
ConsoleLog.Info($"拣选站台：{area} 箱码：{msg} 存在pick2区域的任务"); ConsoleLog.Info($"拣选站台：{area} 箱码：{msg} 存在pick2区域的任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -154,7 +150,7 @@ public class PickStandP5(ConveyOperation conveyOperation, DataBaseData dataBaseD
{ {
ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无 pick2 区域拣选任务"); ConsoleLog.Warning($"【警告】拣选站台：{area} 箱码：{msg} 无 pick2 区域拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.RightMove); // 右移栽出环线
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"拣选站台：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerInErr.cs
View File

@ -16,11 +16,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </summary> /// </summary>
public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -30,9 +25,9 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库异常口：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库异常口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -51,7 +46,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -62,7 +57,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
{ {
ConsoleLog.Warning($"【警告】入库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】入库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -73,13 +68,13 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
} }
} }
/* 查询任务 */ /* 查询任务 */
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create }); List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if (wcsTasks == default) if (wcsTasks == default)
{ {
// 数据库服务器连接失败 // 数据库服务器连接失败
ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 查询任务失败，请检查服务器网络"); ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 查询任务失败，请检查服务器网络");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -93,7 +88,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
// 不存在任务 // 不存在任务
ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 不存在入库任务"); ConsoleLog.Exception($"【异常】入库异常口：{area} 箱码：{msg} 不存在入库任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -111,7 +106,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
// 点位不存在 // 点位不存在
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试"); ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -123,7 +118,7 @@ public class StackerInErr(ConveyOperation conveyOperation, DataBaseData dataBase
ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0); ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0);
ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}");
ConveyPLCTask plcTaskOk = new(plcId, (short)router); ConveyPLCTask plcTaskOk = new(plcId, (short)router);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk); string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk)) if (string.IsNullOrEmpty(errTextOk))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

21
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerInSpliter.cs
View File

@ -19,9 +19,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks> /// </remarks>
public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppWcsTaskDao wcsTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppWcsTaskDao _wcsTaskDao = wcsTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
@ -32,9 +29,9 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.NoRead); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.NoRead);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if(string.IsNullOrEmpty(errText) ) if(string.IsNullOrEmpty(errText) )
{ {
ConsoleLog.Success($"入库分流：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 读码失败，写入PLC成功，{plcTask}");
@ -53,7 +50,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -64,7 +61,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
{ {
ConsoleLog.Warning($"【警告】入库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】入库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -75,13 +72,13 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
} }
} }
/* 查询任务 */ /* 查询任务 */
List<AppWcsTask>? wcsTasks = _wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create }); List<AppWcsTask>? wcsTasks = wcsTaskDao.Select(new AppWcsTask { VehicleNo = code, TaskStatus = (int)WcsTaskStatusEnum.create });
if(wcsTasks == default) if(wcsTasks == default)
{ {
// 数据库服务器连接失败 // 数据库服务器连接失败
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 查询任务失败，请检查服务器网络"); ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 查询任务失败，请检查服务器网络");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WmsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -95,7 +92,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
// 不存在任务 // 不存在任务
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 不存在入库任务，请重试"); ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 不存在入库任务，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -111,7 +108,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
// 点位不存在 // 点位不存在
ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试"); ConsoleLog.Exception($"【异常】入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 不存在，请重试");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.WcsErr);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -123,7 +120,7 @@ public class StackerInSpliter(ConveyOperation conveyOperation, DataBaseData data
ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0); ConveyRouterEnum router = (ConveyRouterEnum)(locationDetail.TunnelNo ?? 0);
ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg} 终点：{wcsTask.Destination} 巷道：{locationDetail.TunnelNo}");
ConveyPLCTask plcTaskOk = new(plcId, (short)router); ConveyPLCTask plcTaskOk = new(plcId, (short)router);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk); string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk)) if (string.IsNullOrEmpty(errTextOk))
{ {
ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}"); ConsoleLog.Success($"入库分流：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

23
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerOutC1.cs
View File

@ -18,11 +18,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
/// </remarks> /// </remarks>
public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
/// <summary> /// <summary>
/// 读码失败 /// 读码失败
/// </summary> /// </summary>
@ -32,9 +27,9 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 读码失败，写入PLC成功，{plcTask}");
@ -53,7 +48,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
/// <param name="routerMethodData"></param> /// <param name="routerMethodData"></param>
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -64,7 +59,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{ {
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -75,12 +70,12 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
} }
} }
/* 判断条码有没有拣选任务 */ /* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create }); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if(conveyTasks == default) if(conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -93,7 +88,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{ {
ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】出库分流：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -118,7 +113,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{ {
ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 存在 1~5 站台任务"); ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 存在 1~5 站台任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -131,7 +126,7 @@ public class StackerOutC1(ConveyOperation conveyOperation, DataBaseData dataBase
{ {
ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 不存在 1~5 站台任务"); ConsoleLog.Info($"出库分流：{area} 箱码：{msg} 不存在 1~5 站台任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库分流：{area} 箱码：{msg}，写入PLC成功，{plcTask}");

20
WcsMain/Business/Convey/HistoryDataHandler/HisGetData/StackerOutErrC2.cs
View File

@ -18,15 +18,11 @@ namespace WcsMain.Business.Convey.HistoryDataHandler.HisGetData;
public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataBaseData, AppConveyTaskDao conveyTaskDao) : IBaseGetData
{ {
private readonly ConveyOperation _conveyOperation = conveyOperation;
private readonly DataBaseData _dataBaseData = dataBaseData;
private readonly AppConveyTaskDao _conveyTaskDao = conveyTaskDao;
public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadFail(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId;
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库异常口：{area} 读码失败，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库异常口：{area} 读码失败，写入PLC成功，{plcTask}");
@ -38,7 +34,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData) public void ReadSuccess(string? disPlayName, string msg, string? area, AppRouterMethod routerMethodData)
{ {
int plcId = _dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId int plcId = dataBaseData.GetNewPlcTaskId() ?? StaticData.StaticInt.ErrPlcId; // 获取一个 plcId
(string code, string direction) = msg.FormatDir(); (string code, string direction) = msg.FormatDir();
/* 判断方向是否正确 */ /* 判断方向是否正确 */
string? routerDirection = routerMethodData.AllowDirection; string? routerDirection = routerMethodData.AllowDirection;
@ -49,7 +45,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}"); ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 方向：{direction} 方向不正确，允许的方向为：{routerDirection}");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -60,12 +56,12 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
} }
} }
/* 判断条码有没有拣选任务 */ /* 判断条码有没有拣选任务 */
List<AppConveyTask>? conveyTasks = _conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create }); List<AppConveyTask>? conveyTasks = conveyTaskDao.Query(new AppConveyTask { VehicleNo = code, TaskStatus = (int)ConveyTaskStatusEnum.create });
if (conveyTasks == default) if (conveyTasks == default)
{ {
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断"); ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 查询任务失败，和服务器连接中断");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台 ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Go); // 连接中断去往拣选站台
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -78,7 +74,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
{ {
ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 无拣选任务"); ConsoleLog.Warning($"【警告】出库异常口：{area} 箱码：{msg} 无拣选任务");
ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move); ConveyPLCTask plcTask = new(plcId, (short)ConveyRouterEnum.Move);
string errText = _conveyOperation.WriteTask(area, plcTask); string errText = conveyOperation.WriteTask(area, plcTask);
if (string.IsNullOrEmpty(errText)) if (string.IsNullOrEmpty(errText))
{ {
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}"); ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTask}");
@ -90,7 +86,7 @@ public class StackerOutErrC2(ConveyOperation conveyOperation, DataBaseData dataB
// 存在拣选任务 // 存在拣选任务
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg} 存在拣选任务"); ConsoleLog.Success($"出库异常口：{area} 箱码：{msg} 存在拣选任务");
ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.Go); ConveyPLCTask plcTaskOk = new(plcId, (short)ConveyRouterEnum.Go);
string errTextOk = _conveyOperation.WriteTask(area, plcTaskOk); string errTextOk = conveyOperation.WriteTask(area, plcTaskOk);
if (string.IsNullOrEmpty(errTextOk)) if (string.IsNullOrEmpty(errTextOk))
{ {
ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}"); ConsoleLog.Success($"出库异常口：{area} 箱码：{msg}，写入PLC成功，{plcTaskOk}");

7
WcsMain/Business/Convey/HistoryDataHandler/HistoryConveyDataHander.cs
View File

@ -17,9 +17,6 @@ namespace WcsMain.Business.Convey.HistoryDataHandler;
[Component] [Component]
public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, IComponentContext componentContext) public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, IComponentContext componentContext)
{ {
private readonly IComponentContext _componentContext = componentContext;
private readonly AppRouterMethodDao _routerMethodDao = routerMethodDao;
private Dictionary<string, IBaseGetData?>? methodConfig; private Dictionary<string, IBaseGetData?>? methodConfig;
private Dictionary<string, AppRouterMethod?>? areaBaseData; private Dictionary<string, AppRouterMethod?>? areaBaseData;
@ -70,7 +67,7 @@ public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, ICompon
lock (loadLock) lock (loadLock)
{ {
if (methodConfig != default && areaBaseData != default) return; if (methodConfig != default && areaBaseData != default) return;
List<AppRouterMethod>? appRouters = _routerMethodDao.Query(); List<AppRouterMethod>? appRouters = routerMethodDao.Query();
if (appRouters == default) return; if (appRouters == default) return;
methodConfig = []; methodConfig = [];
areaBaseData = []; areaBaseData = [];
@ -120,7 +117,7 @@ public class HistoryConveyDataHander(AppRouterMethodDao routerMethodDao, ICompon
List<object> arguments = []; List<object> arguments = [];
foreach (var parameter in parameters) foreach (var parameter in parameters)
{ {
object par = _componentContext.Resolve(parameter.ParameterType); object par = componentContext.Resolve(parameter.ParameterType);
arguments.Add(par); arguments.Add(par);
} }
return Activator.CreateInstance(type, [.. arguments]); return Activator.CreateInstance(type, [.. arguments]);