using iWareCommon;
|
using iWareCommon.Utils;
|
using iWareSql;
|
using System;
|
using System.Collections.Generic;
|
using System.Threading;
|
|
using iWareCC.SrmService;
|
using System.Linq;
|
using iWareSql.Orm;
|
using System.Threading.Tasks;
|
using iWareSql.DataAccess;
|
using iWareSql.Entity.ParamModel;
|
using Newtonsoft.Json;
|
using iWareCC.BLL;
|
using iWareCC.Common;
|
|
using iWareModel;
|
using iWareSql.DBModel;
|
using iWareCommon.Common.Globle;
|
using XiGang.Core.Model;
|
using iWareCC.Common.Helper;
|
|
namespace iWareCC
|
{
|
/// <summary>
|
/// 堆垛机任务服务线程类
|
/// </summary>
|
public class SrmTaskThreadService : DeviceThreadServiceHandle
|
{
|
private static string _namespace = "iWareCC.SrmTaskThreadService";
|
|
private SrmTaskThreadService() { }
|
public SrmTaskThreadService(iWareCommon.Utils.LogType logType)
|
{
|
base.currentLogType = logType;
|
}
|
public override void StartService()
|
{
|
Task.Run(() =>
|
{
|
try
|
{
|
//自动执行堆垛机任务线程
|
Log4NetHelper.WriteInfoLog(base.currentLogType, "自动执行堆垛机任务线程启动了");
|
//var srmList = new SrmService.SrmServiceClient().GetSrm_CacheEntity();
|
var srmList = FormCC.SrmDeviceList;
|
foreach (var x in srmList)
|
{
|
IssueTaskThread(x);
|
ConfirmFinishTaskThread(x);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(base.currentLogType, "SrmTaskThreadService线程启动出现异常", ex);
|
}
|
});
|
}
|
|
|
#region 线程处理
|
|
#region 自动执行堆垛机任务线程
|
|
/// <summary>
|
/// 自动执行堆垛机任务
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void IssueTask(object deviceId)
|
{
|
string errMsg1 = "", errMsg2 = "", errMsg3 = "", errMsg4 = "";
|
int i_deviceId = (int)deviceId;
|
while (true)
|
{
|
if ((int)deviceId == (int)EDevice.一号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_1 && SystemValue.isStartedModel)
|
{
|
IssueTaskHandle(i_deviceId, out errMsg1);
|
}
|
else if ((int)deviceId == (int)EDevice.二号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_2 && SystemValue.isStartedModel)
|
{
|
IssueTaskHandle(i_deviceId, out errMsg2);
|
}
|
else if ((int)deviceId == (int)EDevice.三号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_3 && SystemValue.isStartedModel)
|
{
|
IssueTaskHandle(i_deviceId, out errMsg3);
|
}
|
else if ((int)deviceId == (int)EDevice.四号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_4 && SystemValue.isStartedModel)
|
{
|
IssueTaskHandle(i_deviceId, out errMsg4);
|
}
|
SystemWarningMsg._lbl_Alert_DataProcess_BZ39_IssueInboundTask = errMsg1;
|
SystemWarningMsg._lbl_Alert_Srm2Release = errMsg2;
|
SystemWarningMsg._lbl_Alert_Srm3Release = errMsg3;
|
SystemWarningMsg._lbl_Alert_Srm4Release = errMsg4;
|
Thread.Sleep(2000);//2秒一次
|
}
|
}
|
|
/// <summary>
|
/// 自动执行堆垛机任务（线程）
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void IssueTaskHandle(int deviceId, out string errMsg)
|
{
|
errMsg = "";
|
string logHeader = "方法：DoSrmTaskByThead，参数deviceId：" + deviceId.ToString() + "===";
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("deviceId", deviceId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DoSrmTaskByThead", logDict);
|
#endregion
|
try
|
{
|
/*
|
* 执行发送给堆垛机的指令任务
|
* 1、验证根据设备号是否找到堆垛机
|
* 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
|
* 3、判断数据库中是否有可要下发的任务，如果有就下发+验证起始点和目标点是否正确
|
* 4、下发成功后，更新任务状态
|
*/
|
|
errMsg = "";
|
int int_deviceId = (int)deviceId;
|
|
|
|
//2、判断堆垛机是否可以下发新任务
|
bool isOk = ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg);
|
if (!isOk)
|
{
|
errMsg = "不允许下发新任务," + errMsg;
|
return;
|
}
|
|
using (DbModel dbModel = new DbModel())
|
{
|
//var srmTask = ValidateIsExistTaskToDispose(dbModel, int_deviceId, out errMsg, TaskExcuteTypeEnum.执行任务);
|
//if (srmTask == null)
|
//{//表示DB中没有任务要发送给堆垛机
|
// return;
|
//}
|
var srmTaskList = ValidateIsExistTaskToDisposeForIssued(dbModel, int_deviceId, out errMsg);
|
if (srmTaskList == null || srmTaskList.Count == 0)
|
{//表示DB中没有任务要发送给堆垛机
|
return;
|
}
|
foreach (var item in srmTaskList)
|
{
|
SingleIssueTaskHandle(item, exception, dbModel, int_deviceId, out errMsg);
|
if (!string.IsNullOrEmpty(errMsg))
|
{//说明报错了,继续走下一个循环
|
continue;
|
}
|
else
|
{//说明执行成功了，跳出循环
|
break;
|
}
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
errMsg = "异常,请联系管理员:" + ex.Message;
|
SysExceptionInfoHandler.GetExceptionInfoForError("自动执行堆垛机任务（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
}
|
}
|
|
/// <summary>
|
/// 单个堆垛机任务下发处理
|
/// </summary>
|
/// <param name="srmTask"></param>
|
/// <param name="exception"></param>
|
/// <param name="dbModel"></param>
|
/// <param name="int_deviceId"></param>
|
/// <param name="errMsg"></param>
|
private void SingleIssueTaskHandle(Task_Part srmTask, Base_SysExceptionInfo exception, DbModel dbModel, int int_deviceId, out string errMsg)
|
{
|
#region //3、判断数据库中是否有可要下发的任务，如果有就下发
|
|
DeviceTaskTypeEnum _DeviceTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), srmTask.TaskType.ToString());
|
|
//验证起始点和目标点是否正确
|
RealPlaceEntity realPlaceEntity = null;
|
if (!ValdiatePalceIsRight(dbModel, (int)srmTask.SourcePlace, (int)srmTask.ToPlace, ref realPlaceEntity))
|
{
|
errMsg = "验证起始点和目标点是否正确失败";
|
PartTaskHandler.WriteOperationRemarkForPartTask(srmTask.Id, errMsg);
|
return;
|
}
|
|
//验证目标点是否已经有库存 【EditBy shaocx,2022-04-15】
|
var isOk = ValidateIsHasStoreForToPlace(int_deviceId, srmTask.ToPlace, srmTask.RealToPlace, out errMsg);
|
if (!isOk)
|
{
|
errMsg = "不允许下发新任务," + errMsg;
|
PartTaskHandler.WriteOperationRemarkForPartTask(srmTask.Id, errMsg);
|
return;
|
}
|
|
#region 增加校验 [EditBy shaocx,2022-05-15]
|
|
//去掉这个验证 【EditBy shaocx,2022-05-19】
|
/*
|
Base_Station toPlaceObject = dbModel.Base_Station.Where(o => o.Id == (int)srmTask.ToPlace).FirstOrDefault();
|
if (toPlaceObject == null)
|
{
|
throw new Exception(string.Format("根据目标库位ID {0},{1}没有找到库位信息!", srmTask.ToPlace, srmTask.RealToPlace));
|
}
|
//*/
|
|
var sourcePlace = dbModel.Base_Station.Where(o => o.Id == srmTask.SourcePlace).FirstOrDefault();
|
if (sourcePlace == null)
|
{
|
throw new Exception(string.Format("根据库位号{0},{1}没有找到堆垛机的来源库位信息!", srmTask.SourcePlace.ToString(), srmTask.RealSourcePlace));
|
}
|
//要判断起点是否有库存，如果起点没有库存，则报错
|
var sourcePlaceStore = dbModel.V_AllStore.Where(x => x.StationId == sourcePlace.Id).FirstOrDefault();
|
if (sourcePlaceStore == null)
|
{
|
throw new Exception(string.Format("起点{0},{1}没有找到库存信息，无法下发堆垛机任务!任务号{2}", srmTask.SourcePlace.ToString(), srmTask.RealSourcePlace, srmTask.Id));
|
}
|
|
#endregion
|
|
//同一个关联任务的其他设备任务
|
var queryTaskState1 = (int)DeviceTaskStatusEnum.未开始;
|
//var queryTaskState2 = (int)DeviceTaskStatusEnum.已下发;
|
var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == srmTask.MainTaskId && x.TaskSequence < srmTask.TaskSequence
|
&& (x.TaskState == queryTaskState1)
|
).FirstOrDefault();
|
if (relevanceTask != null)
|
{
|
errMsg = string.Format("关联{0}任务未开始，所以堆垛机任务不允许下发！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
|
PartTaskHandler.WriteOperationRemarkForPartTask(srmTask.Id, errMsg);
|
return;
|
}
|
|
//去掉验证 【EditBy shaocx,2022-05-19】
|
/*
|
var validateIsAllowNewTaskForRgvStattion = ValidateIsAllowNewTaskForRgvStattion(dbModel, _DeviceTaskTypeEnum, srmTask.RealToPlace, ref errMsg);
|
if (!validateIsAllowNewTaskForRgvStattion)
|
{
|
PartTaskHandler.WriteOperationRemarkForPartTask(srmTask.Id, errMsg);
|
return;
|
}
|
//*/
|
|
|
var log = TaskRequestLogHandler.GetTask(srmTask.Id,
|
int_deviceId, srmTask.PlcTaskId, srmTask.RealSourcePlace,
|
srmTask.RealToPlace, "给堆垛机发送任务指令", "sys");
|
SdaResEntity sdaResult = new SdaResEntity();
|
try
|
{
|
if (MyExtendHelper.IsAllowSimulatorHandle(srmTask))
|
{
|
sdaResult.result = true;
|
}
|
else
|
{
|
if (Convert.ToInt32(srmTask.PlcTaskId) <= 0)
|
{
|
throw new Exception("任务号不能小于等于0，PlcTaskId：" + srmTask.PlcTaskId);
|
}
|
sdaResult = new SrmService.SrmServiceClient().SendSrmTask(int_deviceId, Convert.ToInt32(srmTask.PlcTaskId), srmTask.RealSourcePlace, srmTask.RealToPlace, (short)ESrmCmd.库内搬运);
|
}
|
if (sdaResult.result == false)
|
{//给堆垛机下发指令失败
|
exception.exceptionMsg = string.Format("发送指令给堆垛机失败,设备号{0},任务ID{1},起始位{2}，目标位{3},ContainerId{4}", int_deviceId,
|
Convert.ToInt32(srmTask.PlcTaskId), srmTask.RealSourcePlace, srmTask.RealToPlace, srmTask.SalverId);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
|
return;
|
}
|
else
|
{
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
|
SystemValueUtil.DelayExcuteForSrmTaskThreadService(int_deviceId, ThreadDirectionEnum.任务开始下发线程);
|
}
|
}
|
catch (Exception ex)
|
{
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, ex);
|
throw ex;
|
}
|
|
#endregion
|
|
|
//只更新着三个字段！
|
//任务完成后的库存转移工作
|
isOk = DealWithCurrentTaskWhenFinished(srmTask, dbModel);
|
if (isOk == false)
|
{
|
throw new Exception("DealWithCurrentTaskWhenFinished处理失败");
|
}
|
}
|
|
|
/// <summary>
|
/// 当前任务完成后进行状态修改
|
/// </summary>
|
/// <param name="currentTask">当前任务</param>
|
/// <returns></returns>
|
private bool DealWithCurrentTaskWhenFinished(Task_Part currentTask, DbModel dbModel)
|
{
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("currentTask.tackId", currentTask.Id);
|
logDict.Add("currentTask.plcTaskId", currentTask.PlcTaskId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DealWithCurrentTask", logDict);
|
#endregion
|
try
|
{
|
bool rtn = false;
|
var taskType = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), currentTask.TaskType.ToString());
|
switch (taskType)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
case DeviceTaskTypeEnum.空托转运到立体库:
|
rtn = DealFor_Srm_Store_In(currentTask, dbModel, taskType);//入库执行后增加库存
|
break;
|
case DeviceTaskTypeEnum.出库:
|
case DeviceTaskTypeEnum.立库空托到拆盘机入口:
|
rtn = DealFor_Srm_Store_Out(currentTask, dbModel, taskType);//出库
|
break;
|
default:
|
break;
|
}
|
|
|
|
//库存发生变化时,发送库存给MES
|
//switch (taskType)
|
//{
|
// case DeviceTaskTypeEnum22.配板原料入库:
|
// case DeviceTaskTypeEnum22.线下配板原料入库:
|
// case DeviceTaskTypeEnum22.配板余料回库:
|
// case DeviceTaskTypeEnum22.配板原料出库:
|
// case DeviceTaskTypeEnum22.人工出库:
|
// //MesBLL.SendSysnStockToMes();
|
// break;
|
// default:
|
// break;
|
//}
|
return rtn;
|
}
|
catch (Exception ex)
|
{
|
SysExceptionInfoHandler.GetExceptionInfoForError("当前任务完成后进行状态修改出现异常:" + ex.Message, ex, ref exception);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception);
|
throw ex;
|
}
|
}
|
|
/// <summary>
|
/// 入库任务处理
|
/// </summary>
|
/// <param name="currentTask"></param>
|
/// <returns></returns>
|
private bool DealFor_Srm_Store_In(Task_Part currentTask, DbModel dbModel, DeviceTaskTypeEnum taskType)
|
{
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("currentTask.tackId", currentTask.Id);
|
logDict.Add("currentTask.plcTaskId", currentTask.PlcTaskId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DealFor_Srm_Store_In", logDict);
|
#endregion
|
try
|
{
|
/**
|
* 1、当前任务状态修改为已完成
|
* 2、添加托盘和库位的绑定关系
|
* 3、变更库位状态
|
*/
|
#region 准备数据
|
|
#region 增加校验 [EditBy shaocx,2022-05-15]
|
|
Base_Station toPlaceObject = dbModel.Base_Station.Where(o => o.Id == (int)currentTask.ToPlace).FirstOrDefault();
|
if (toPlaceObject == null)
|
{
|
throw new Exception(string.Format("根据目标库位ID {0},{1}没有找到库位信息!", currentTask.ToPlace, currentTask.RealToPlace));
|
}
|
|
var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
|
if (sourcePlace == null)
|
{
|
throw new Exception(string.Format("根据库位号{0},{1}没有找到堆垛机的来源库位信息!", currentTask.SourcePlace.ToString(), currentTask.RealSourcePlace));
|
}
|
//要判断起点是否有库存，如果起点没有库存，则报错
|
var sourcePlaceStore = dbModel.V_AllStore.Where(x => x.StationId == sourcePlace.Id).FirstOrDefault();
|
if (sourcePlaceStore == null)
|
{
|
throw new Exception(string.Format("起点{0},{1}没有找到库存信息，无法下发堆垛机任务!这里任务号{2}", currentTask.SourcePlace.ToString(), currentTask.RealSourcePlace, currentTask.Id));
|
}
|
|
#endregion
|
|
|
toPlaceObject.IsHasTaskDoing = false;
|
toPlaceObject.IsFull = true;
|
StationHandler.SetPlaceLockStatus(false, SysGloble.WCSSystem, ref toPlaceObject, "堆垛机任务完成，入库任务处理，任务类型：" + taskType.ToString());
|
StationHandler.SetPlaceLockStatus(false, SysGloble.WCSSystem, ref sourcePlace, "堆垛机任务完成，入库任务处理，任务类型：" + taskType.ToString());
|
|
|
|
#endregion
|
|
return CommonTransForThreadFinish(dbModel, currentTask, "入库任务完成处理成功，任务类型：" + taskType.ToString(), sourcePlace, toPlaceObject, taskType);
|
}
|
catch (Exception ex)
|
{
|
SysExceptionInfoHandler.GetExceptionInfoForError("入库任务处理出现异常:" + ex.Message, ex, ref exception);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception);
|
|
throw ex;
|
}
|
}
|
|
|
|
/// <summary>
|
/// 出库任务处理
|
/// </summary>
|
/// <param name="currentTask"></param>
|
/// <returns></returns>
|
private bool DealFor_Srm_Store_Out(Task_Part currentTask, DbModel dbModel, DeviceTaskTypeEnum taskType)
|
{
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("currentTask.tackId", currentTask.Id);
|
logDict.Add("currentTask.plcTaskId", currentTask.PlcTaskId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DealFor_Srm_Store_Out", logDict);
|
#endregion
|
try
|
{
|
/**
|
* 1、当前任务状态修改为已完成
|
* 2、解除来源位置的托盘和库位的绑定关系
|
* 3、变更库位状态
|
*/
|
#region 准备数据
|
|
|
Base_Station toPlaceObject = dbModel.Base_Station.Where(o => o.Id == (int)currentTask.ToPlace).FirstOrDefault();
|
if (toPlaceObject == null)
|
{
|
throw new Exception(string.Format("根据库位ID {0}没有找到库位信息!", currentTask.ToPlace));
|
}
|
|
#region 3、变更库位状态
|
|
//目标的库位状态
|
|
toPlaceObject.IsHasTaskDoing = false;
|
toPlaceObject.IsFull = true;
|
StationHandler.SetPlaceLockStatus(false, SysGloble.WCSSystem, ref toPlaceObject, "堆垛机任务完成，出库任务处理");
|
|
//来源位置的库位状态
|
var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
|
if (sourcePlace == null)
|
{
|
throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.SourcePlace.ToString()));
|
}
|
sourcePlace.IsHasTaskDoing = false;
|
sourcePlace.IsFull = false;
|
StationHandler.SetPlaceLockStatus(false, SysGloble.WCSSystem, ref sourcePlace, "堆垛机任务完成，出库任务处理");
|
|
#endregion
|
|
#endregion
|
|
return CommonTransForThreadFinish(dbModel, currentTask, "出库任务处理成功", sourcePlace, toPlaceObject, taskType);
|
|
}
|
catch (Exception ex)
|
{
|
SysExceptionInfoHandler.GetExceptionInfoForError("出库任务处理出现异常:" + ex.Message, ex, ref exception);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception);
|
return false;
|
}
|
}
|
|
|
private bool CommonTransForThreadFinish(DbModel dbModel, Task_Part currentTask,
|
string business, Base_Station sourcePlace, Base_Station toPlaceObject, DeviceTaskTypeEnum taskType)
|
{
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("currentTask.tackId", currentTask.Id);
|
logDict.Add("currentTask.plcTaskId", currentTask.PlcTaskId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "CommonTransForThreadFinish", logDict);
|
#endregion
|
try
|
{
|
try
|
{
|
#region 当设备任务完成后，转移库存（注意：一定要在最后面执行!!）
|
|
try
|
{
|
TransferStoreWhenFinished(currentTask, dbModel, currentTask.SalverId, toPlaceObject, business, taskType, EDeviceType.堆垛机);
|
}
|
catch (Exception ex)
|
{
|
throw new Exception("转移库存时抛出异常,方法(TransferStoreWhenFinished),message:" + ex.Message, ex);
|
}
|
|
#endregion
|
|
UpdateMainTaskStatus(dbModel, currentTask.MainTaskId, currentTask.TaskType, "堆垛机任务完成时");
|
|
//4、下发成功后，更新任务状态
|
currentTask.IsReleased = true;
|
currentTask.ModifyBy = SysGloble.WCSSystem;
|
currentTask.ModifyTime = DateTime.Now;
|
currentTask.TaskState = (int)DeviceTaskStatusEnum.已下发;
|
currentTask.TaskStateName = DeviceTaskStatusEnum.已下发.ToString();
|
currentTask.OperationRemark = "任务已下发给设备";
|
currentTask.IssueTime = DateTime.Now;//下发时间
|
|
|
|
//注意：一定是先要保存数据库，才再跟plc交互！！！！！
|
int i = dbModel.SaveChanges();
|
if (i <= 0)
|
{
|
throw new Exception("更新的条数为" + i);
|
}
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
|
return true;
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
|
}
|
|
#endregion
|
|
#region 自动结束堆垛机任务线程
|
|
/// <summary>
|
/// 自动结束堆垛机任务线程
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void ConfirmFinishTask(object deviceId)
|
{
|
string errMsg1 = "", errMsg2 = "", errMsg3 = "", errMsg4 = "";
|
int i_deviceId = (int)deviceId;
|
while (true)
|
{
|
if ((int)deviceId == (int)EDevice.一号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_1_Finish && SystemValue.isStartedModel)
|
{
|
ConfirmFinishTaskHandle(i_deviceId, out errMsg1);
|
}
|
else if ((int)deviceId == (int)EDevice.二号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_2_Finish && SystemValue.isStartedModel)
|
{
|
ConfirmFinishTaskHandle(i_deviceId, out errMsg2);
|
}
|
else if ((int)deviceId == (int)EDevice.三号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_3_Finish && SystemValue.isStartedModel)
|
{
|
ConfirmFinishTaskHandle(i_deviceId, out errMsg3);
|
}
|
else if ((int)deviceId == (int)EDevice.四号堆垛机 && SystemValue.isAllowRuning_SrmTaskThreadService_4_Finish && SystemValue.isStartedModel)
|
{
|
ConfirmFinishTaskHandle(i_deviceId, out errMsg4);
|
}
|
SystemWarningMsg._lbl_Alert_Srm1ReleaseFinish = errMsg1;
|
SystemWarningMsg._lbl_Alert_Srm2ReleaseFinish = errMsg2;
|
SystemWarningMsg._lbl_Alert_Srm3ReleaseFinish = errMsg3;
|
SystemWarningMsg._lbl_Alert_Srm4ReleaseFinish = errMsg4;
|
Thread.Sleep(2000);//设置2秒一次
|
}
|
}
|
|
/// <summary>
|
/// 自动结束堆垛机任务线程（线程）
|
/// </summary>
|
/// <param name="srmName"></param>
|
public override void ConfirmFinishTaskHandle(int deviceId, out string errMsg)
|
{
|
errMsg = "";
|
string logHeader = "自动结束堆垛机任务线程（线程），设备号:" + deviceId;
|
#region 新增异常信息表 【EditBy shaocx,2020-01-20】
|
IDictionary<string, object> logDict = new Dictionary<string, object>();
|
logDict.Add("deviceId", deviceId);
|
Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "FinishSrmTaskByThead", logDict);
|
#endregion
|
try
|
{
|
/*
|
* 执行发送给堆垛机的指令任务
|
* 1、验证根据设备号是否找到堆垛机
|
* 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
|
* 3、判断数据库中是否有可要完成的任务，如果有判断是否跟堆垛机中的完成任务相符，如果相符就处理
|
* 4、更新任务状态
|
*/
|
int int_deviceId = (int)deviceId;
|
|
|
|
//SystemValueUtil.DelayExcuteForSrmTaskThreadService((int)deviceId, ThreadDirectionEnum.任务完成线程);
|
|
using (DbModel dbModel = new DbModel())
|
{
|
#region //3、判断数据库中是否有可要完成的任务，如果有判断是否跟堆垛机中的完成任务相符，如果相符就处理
|
var currentTask = ValidateIsExistTaskToDispose(dbModel, int_deviceId, out errMsg, TaskExcuteTypeEnum.结束任务);
|
if (currentTask == null)
|
{//表示DB中没有任务要发送给堆垛机
|
//注释以下代码，手动发的任务，不要自动确认
|
////可以完成 非系统发送的自动任务 [EditBy shaocx,2022-04-04]
|
//if (FormCC.IsSimulationPLC == false && FormCC.srmViewDict[int_deviceId].R_TaskFinish == 1 && FormCC.srmViewDict[int_deviceId].R_TaskNo > 0)
|
//{//只有当堆垛机是任务完成的时候
|
// ConfirmTaskFinishToSda(deviceId, FormCC.srmViewDict[int_deviceId].R_TaskNo);
|
//}
|
errMsg = "没有堆垛机任务数据要处理";
|
return;
|
}
|
|
#endregion
|
|
//2、判断设备是否任务完成
|
var isFinished = ValidateDeviceTaskIsFinsished(int_deviceId, currentTask, Convert.ToInt32(currentTask.PlcTaskId), (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), currentTask.TaskType.ToString()), currentTask.IsAllowSimulateExecute, out errMsg);
|
if (!isFinished) return;
|
|
|
////判断和堆垛机(或RGV)的连接任务是不是已经完成了
|
var queryTaskState1 = (int)DeviceTaskStatusEnum.未开始;
|
var queryTaskState2 = (int)DeviceTaskStatusEnum.已下发;
|
/*
|
//注释以下方法，因为出现了 某个任务MainTaskSequence 比他小，但是某个任务还未执行的问题 【EditBy shaocx,2022-04-28】
|
//同一个堆垛机的前面未结束的任务,且同种类型
|
var otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == int_deviceId
|
&& x.Id != currentTask.Id
|
&& (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
|
&& x.CreateTime < currentTask.CreateTime
|
).FirstOrDefault();
|
if (otherSrmTask != null)
|
{
|
errMsg = "上一个堆垛机任务未完成，所以堆垛机任务不允许完成！上一个堆垛机任务号:" + otherSrmTask.PlcTaskId + "，本次堆垛机任务号:" + currentTask.PlcTaskId;
|
return;
|
}
|
//*/
|
|
//同一个关联任务的其他设备任务
|
var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == currentTask.MainTaskId && x.TaskSequence < currentTask.TaskSequence
|
&& (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)).FirstOrDefault();
|
if (relevanceTask != null)
|
{
|
errMsg = string.Format("关联{0}任务未完成，所以堆垛机任务不允许完成！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
|
return;
|
}
|
|
|
//4、处理任务完成状态
|
var isOk = ConfirmTaskFinishToSrm(currentTask, "堆垛机任务完成", exception);
|
if (isOk)
|
{
|
//堆垛机完成了当前任务后进行任务状态的修改
|
ChangeTaskStateWhenTaskFinish(currentTask);
|
dbModel.SaveChanges();
|
}
|
|
}
|
}
|
catch (Exception ex)
|
{
|
errMsg = "出现异常:" + ex.Message;
|
SysExceptionInfoHandler.GetExceptionInfoForError("自动结束堆垛机任务线程（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
}
|
}
|
|
|
|
/// <summary>
|
/// 判断是人工发送给任务，单独给堆垛机发送任务完成信号
|
/// </summary>
|
/// <param name="deviceId"></param>
|
/// <param name="taskId"></param>
|
/// <returns></returns>
|
private bool ConfirmTaskFinishToSda(int deviceId, int taskId)
|
{
|
//任务完成处理成功，需要再给堆垛机发送任务完成确认信号
|
SdaResEntity sdaResult = new SdaResEntity();
|
try
|
{
|
sdaResult = new SrmService.SrmServiceClient().ConfirmTaskFinish(deviceId, taskId);
|
|
if (!sdaResult.result)
|
{
|
Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.DataProcess_BZ39_IssueInboundTask, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【失败】，设备号:" + deviceId + ",任务号:" + taskId);
|
return false;
|
}
|
else
|
{
|
Log4NetHelper.WriteInfoLog(iWareCommon.Utils.LogType.DataProcess_BZ39_IssueInboundTask, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【成功】，设备号:" + deviceId + ",任务号:" + taskId);
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(iWareCommon.Utils.LogType.DataProcess_BZ39_IssueInboundTask, "判断是人工发送的任务，单独给堆垛机发送任务完成信号，【异常】，设备号:" + deviceId + ",任务号:" + taskId + ",ex:" + ex.Message, ex);
|
throw ex;
|
}
|
}
|
|
#region 向堆垛机发送任务完成确认信号
|
|
|
/// <summary>
|
/// 向堆垛机发送任务完成确认信号
|
/// </summary>
|
/// <param name="currentTask"></param>
|
/// <param name="business"></param>
|
/// <param name="exception"></param>
|
/// <returns></returns>
|
private bool ConfirmTaskFinishToSrm(Task_Part currentTask, string business, Base_SysExceptionInfo exception)
|
{
|
//任务完成处理成功，需要再给堆垛机发送任务完成确认信号
|
SdaResEntity sdaResult = new SdaResEntity();
|
var log = TaskRequestLogHandler.GetTask(currentTask.Id,
|
(int)currentTask.DeviceId, currentTask.PlcTaskId, currentTask.RealSourcePlace.ToString(),
|
currentTask.RealToPlace.ToString(), "给堆垛机发送任务完成确信指令", "sys");
|
|
try
|
{
|
if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
|
{
|
sdaResult.result = true;
|
}
|
else
|
{
|
sdaResult = new SrmService.SrmServiceClient().ConfirmTaskFinish((int)currentTask.DeviceId, Convert.ToInt32(currentTask.PlcTaskId));
|
}
|
if (!sdaResult.result)
|
{
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult), log, null);
|
exception.exceptionMsg = string.Format(business + "，需要再给堆垛机发送任务完成确认信号失败，设备号{0} 任务号{1}", (int)currentTask.DeviceId, currentTask.PlcTaskId);
|
SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
|
return false;
|
}
|
else
|
{
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(sdaResult), log, null);
|
Log4NetHelper.WriteInfoLog(base.currentLogType, string.Format(business + "，再给堆垛机发送任务完成确认信号成功，设备号{0} 任务号{1}", (int)currentTask.DeviceId, currentTask.PlcTaskId));
|
return true;
|
}
|
}
|
catch (Exception ex)
|
{
|
TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult), log, ex);
|
throw ex;
|
}
|
}
|
|
#endregion
|
|
#endregion
|
|
#endregion
|
|
#region 公共处理
|
|
|
/// <summary>
|
/// 验证RGV站点上是否允许下发堆垛机新任务
|
/// </summary>
|
/// <param name="model"></param>
|
/// <param name="_DeviceTaskTypeEnum"></param>
|
/// <param name="realToPlace"></param>
|
/// <param name="errMsg"></param>
|
/// <returns>true:允许，false：不允许</returns>
|
private bool ValidateIsAllowNewTaskForRgvStattion(DbModel model, DeviceTaskTypeEnum _DeviceTaskTypeEnum, string realToPlace, ref string errMsg)
|
{
|
MainInOutFlagEnum _MainInOutFlagEnum = GetMainInOutFlagForSrm(_DeviceTaskTypeEnum);
|
if (_MainInOutFlagEnum == MainInOutFlagEnum.出库)
|
{
|
//判断目标点是否有光电占用
|
var rgv_stationCode = model.Base_Station.Where(x => x.SrmStationCode == realToPlace).First();
|
var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(rgv_stationCode.RgvStationCode);
|
if (isGD_HasCatogryForRgvStattion)
|
{
|
errMsg = "RGV出库口站点" + rgv_stationCode.RgvStationCode + "上面光电显示有货，不允许下发堆垛机的出库任务";
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 根据堆垛机任务类型判断出是出库还是入库
|
/// </summary>
|
/// <param name="_DeviceTaskTypeEnum"></param>
|
/// <returns></returns>
|
private MainInOutFlagEnum GetMainInOutFlagForSrm(DeviceTaskTypeEnum _DeviceTaskTypeEnum)
|
{
|
switch (_DeviceTaskTypeEnum)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
case DeviceTaskTypeEnum.空托转运到立体库:
|
return MainInOutFlagEnum.入库;
|
case DeviceTaskTypeEnum.立库空托到拆盘机入口:
|
case DeviceTaskTypeEnum.出库:
|
return MainInOutFlagEnum.出库;
|
}
|
throw new Exception("堆垛机不支持的任务类型" + _DeviceTaskTypeEnum.ToString());
|
}
|
|
/// <summary>
|
/// 更新主任务的状态
|
/// </summary>
|
/// <param name="edm"></param>
|
/// <param name="mainTaskId"></param>
|
/// <param name="srmTaskTypeValue"></param>
|
/// <param name="remark"></param>
|
private void UpdateMainTaskStatus(DbModel edm, int mainTaskId, int srmTaskTypeValue, string remark)
|
{
|
DeviceTaskTypeEnum srmTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), srmTaskTypeValue.ToString());
|
MainTaskStatusEnum changeTaskStatus = default(MainTaskStatusEnum);
|
switch (srmTaskTypeEnum)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
case DeviceTaskTypeEnum.空托转运到立体库:
|
changeTaskStatus = MainTaskStatusEnum.已完成;
|
MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
|
break;
|
}
|
}
|
|
/// <summary>
|
/// 堆垛机任务完成后修改任务状态
|
/// </summary>
|
/// <param name="currentTask"></param>
|
private void ChangeTaskStateWhenTaskFinish(Task_Part currentTask)
|
{
|
//堆垛机完成了当前任务后进行任务状态的修改
|
currentTask.FinishTime = DateTime.Now;//完成时间
|
currentTask.IsFinished = true;
|
currentTask.TaskState = (int)DeviceTaskStatusEnum.已完成;
|
currentTask.TaskStateName = DeviceTaskStatusEnum.已完成.ToString();
|
currentTask.OperationRemark = "已完成";
|
currentTask.ModifyTime = DateTime.Now;
|
currentTask.ModifyBy = SysGloble.WCSSystem;
|
//currentTask.IsLastTask = (int)EYesOrNo.否;//设置不是最新的任务
|
}
|
|
/// <summary>
|
/// 堆垛机任务完成后，根据堆垛机的任务类型去判断Base_Salver_V_Station 的State
|
/// </summary>
|
/// <param name="_DeviceTaskTypeEnum">堆垛机任务类型</param>
|
/// <param name="old_int_C_V_P_StateEnum">原先的Base_Salver_V_Station 的State</param>
|
/// <returns></returns>
|
private Salver_V_Station_StateEnum DeviceTaskTypeEnumToC_V_P_StateEnumWhenTaskFinish(DeviceTaskTypeEnum _DeviceTaskTypeEnum, int old_int_C_V_P_StateEnum)
|
{
|
Salver_V_Station_StateEnum old_C_V_P_StateEnum = (Salver_V_Station_StateEnum)Enum.Parse(typeof(Salver_V_Station_StateEnum), old_int_C_V_P_StateEnum.ToString());
|
Salver_V_Station_StateEnum _C_V_P_StateEnum = old_C_V_P_StateEnum;
|
switch (_DeviceTaskTypeEnum)
|
{
|
case DeviceTaskTypeEnum.组盘入库:
|
_C_V_P_StateEnum = Salver_V_Station_StateEnum.在库物料;
|
break;
|
//case DeviceTaskTypeEnum22.线下其他垛入库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库其他料;
|
// break;
|
//case DeviceTaskTypeEnum22.线下垫板垛入库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库垫板;
|
// break;
|
//case DeviceTaskTypeEnum22.成品料配板完成回库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库成品料;
|
// break;
|
//case DeviceTaskTypeEnum22.待拆垛回库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库待拆垛;
|
// break;
|
//case DeviceTaskTypeEnum22.桁架垫板垛入立库垫板库位:
|
//case DeviceTaskTypeEnum22.锯切垫板垛入立体库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.在库垫板;
|
// break;
|
//case DeviceTaskTypeEnum22.移库://移库，状态不变
|
//case DeviceTaskTypeEnum22.成品料上锯切线出库://成品料出库，状态不变
|
//case DeviceTaskTypeEnum22.垫板上料出库://垫板出库，状态不变
|
// _C_V_P_StateEnum = old_C_V_P_StateEnum;
|
// break;
|
//case DeviceTaskTypeEnum22.配板原料出库:
|
// _C_V_P_StateEnum = C_V_P_StateEnum.原料配板中;
|
// break;
|
//case DeviceTaskTypeEnum22.人工出库://出库后会将表Base_Salver_V_Station 清掉
|
// break;
|
}
|
return _C_V_P_StateEnum;
|
}
|
|
public override bool ValidateDeviceIsAllowSendTask(int int_deviceId, out string errMsg)
|
{
|
errMsg = "";
|
if (!base.ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg))
|
{
|
return false;
|
}
|
if (FormCC.IsSimulationPLC)
|
{
|
return true;
|
}
|
using (var srmService = new SrmService.SrmServiceClient())
|
{
|
SdaResEntity sdaResult = srmService.IsAllowSendTask(int_deviceId, out errMsg);
|
if (sdaResult.result == false)
|
{
|
errMsg = "非自动、有任务未确认或有报警，" + sdaResult.resMsg;
|
Log4NetHelper.WriteErrorLog(currentLogType, "验证堆垛机不可以下发新任务,int_deviceId:" + int_deviceId + ",sdaResultStr:" + JsonConvert.SerializeObject(sdaResult));
|
}
|
return sdaResult.result;
|
}
|
}
|
|
/// <summary>
|
/// 验证堆垛机是否自动
|
/// </summary>
|
/// <param name="int_deviceId"></param>
|
/// <returns></returns>
|
public override bool ValidateDeviceIsOK(int int_deviceId, Task_Part _task, int taskId, out string errMsg)
|
{
|
errMsg = "";
|
if (Wms_EquipmentSituationHandler.IsEquipmentBreakdown(int_deviceId).result)
|
{//如果设备已经设定为 故障状态，不允许下发任务！！！ [EditBy shaocx,2020-12-07]
|
errMsg = "设备被设为故障";
|
return false;
|
}
|
if (MyExtendHelper.IsAllowSimulatorHandle(_task))
|
{
|
errMsg = "模拟PLC";
|
return true;
|
}
|
using (var srmService = new SrmService.SrmServiceClient())
|
{
|
SdaResEntity sdaResult = srmService.IsReady(int_deviceId, out errMsg);
|
errMsg = sdaResult.resMsg;
|
return sdaResult.result;
|
}
|
}
|
|
/// <summary>
|
/// 验证堆垛机是否任务完成
|
/// </summary>
|
/// <param name="int_deviceId"></param>
|
/// <returns></returns>
|
public override bool ValidateDeviceTaskIsFinsished(int int_deviceId, Task_Part _task, int taskId, out string errMsg)
|
{
|
errMsg = "";
|
if (MyExtendHelper.IsAllowSimulatorHandle(_task))
|
{//模拟代码！发布时移除该代码
|
errMsg = "任务要求强制模拟完成";
|
return true;
|
}
|
|
SdaResEntity sdaResult = new SrmService.SrmServiceClient().IsTaskFinish(int_deviceId, taskId);
|
if (sdaResult.result == false)
|
{
|
errMsg = sdaResult.resMsg;
|
}
|
return sdaResult.result;
|
}
|
|
/// <summary>
|
/// 验证堆垛机是否任务完成
|
/// </summary>
|
/// <param name="int_deviceId"></param>
|
/// <returns></returns>
|
private bool ValidateDeviceTaskIsFinsished(int int_deviceId, Task_Part _task, int taskId, DeviceTaskTypeEnum _DeviceTaskTypeEnum, bool? isAllowSimulateExecute, out string errMsg)
|
{
|
errMsg = "";
|
if (MyExtendHelper.IsAllowSimulatorHandle(_task))
|
{
|
errMsg = "模拟PLC完成或任务要求强制模拟完成";
|
return true;
|
}
|
|
SdaResEntity sdaResult = new SrmService.SrmServiceClient().IsTaskFinish(int_deviceId, taskId);
|
if (sdaResult.result == false)
|
{
|
errMsg = "验证堆垛机是否任务完成 失败:" + JsonConvert.SerializeObject(sdaResult);
|
//Log4NetHelper.WriteErrorLog(currentLogType, "验证堆垛机是否任务完成 失败:" + JsonConvert.SerializeObject(sdaResult));
|
}
|
switch (_DeviceTaskTypeEnum)
|
{
|
//涉及到最后到输送线的任务，都要再加上输送线的任务是否完成
|
case DeviceTaskTypeEnum.组盘入库:
|
//using (var srmConveyorService = new SrmConveyorService.SrmConveyorServiceClient())
|
//{
|
// sdaResultStr = srmConveyorService.IsTaskFinish(taskId);
|
// sdaResult = JsonConvert.DeserializeObject<SdaResEntity>(sdaResultStr);
|
// if (sdaResult.result == false)
|
// {
|
// errMsg = "验证输送线是否任务完成 失败:" + sdaResultStr;
|
// Log4NetHelper.WriteErrorLog(currentLogType, "验证输送线是否任务完成 失败:" + sdaResultStr);
|
// }
|
//}
|
break;
|
}
|
|
return sdaResult.result;
|
}
|
|
#endregion
|
|
#region 私有方法
|
|
/// <summary>
|
/// 验证数据库中是否有任务要处理
|
/// </summary>
|
/// <typeparam name="Task_Part"></typeparam>
|
/// <param name="dbModel"></param>
|
/// <param name="int_deviceId">Rgv设备号</param>
|
/// <param name="errMsg"></param>
|
/// <param name="_TaskExcuteTypeEnum"></param>
|
/// <returns></returns>
|
private List<Task_Part> ValidateIsExistTaskToDisposeForIssued(DbModel dbModel, int int_deviceId, out string errMsg)
|
{
|
errMsg = "";
|
List<Task_Part> partList = new List<Task_Part>();
|
//看同一个设备，是否还有其他正在执行的任务！
|
var partTask = dbModel.Task_Part.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)DeviceTaskStatusEnum.已下发).
|
OrderBy(x => x.CreateTime).FirstOrDefault();//按照主任务的顺序升序
|
if (partTask != null)
|
{
|
errMsg = string.Format("deviceId={0}的正在执行任务,任务ID:" + partTask.Id + ",主任务:" + partTask.MainTaskNo + ",PLC任务号:" + partTask.PlcTaskId, int_deviceId);
|
return null;
|
}
|
|
//1、查询
|
var currTaskList = dbModel.Task_Part.Where(x => x.DeviceId == int_deviceId && x.TaskState == (int)DeviceTaskStatusEnum.未开始).ToList().OrderBy(x => x.CreateTime).ToList();//按照主任务优先级的升序排序
|
if (currTaskList == null || currTaskList.Count == 0)
|
{
|
errMsg = "没有需要处理的任务";
|
return null;
|
}
|
|
|
var firstTask = currTaskList.First();//第一个待执行的任务
|
partList.Add(firstTask);
|
//判断如果这个任务是出库任务的话，就再查询第一个待执行的入库任务
|
DeviceTaskTypeEnum _DeviceTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), firstTask.TaskType.ToString());
|
//查询 出库和入库的两个任务，优先执行出库任务 【EditBy shaocx,2022-05-09】
|
MainInOutFlagEnum _MainInOutFlagEnum = GetMainInOutFlagForSrm(_DeviceTaskTypeEnum);
|
if (_MainInOutFlagEnum == MainInOutFlagEnum.出库)
|
{
|
//查询第一个待执行的入库任务
|
var queryInOutFlag = (int)MainInOutFlagEnum.入库;
|
var fisrtTaskForIn = currTaskList.Where(x => x.InOutFlag == queryInOutFlag).ToList().OrderBy(x => x.CreateTime).FirstOrDefault();
|
if (fisrtTaskForIn != null)
|
{
|
partList.Add(fisrtTaskForIn);
|
}
|
}
|
return partList;
|
}
|
|
#endregion
|
}
|
}
|
