using HH.WCS.ZhongCeJinTan.api;
|
using HH.WCS.ZhongCeJinTan.core;
|
using HH.WCS.ZhongCeJinTan.device;
|
using HH.WCS.ZhongCeJinTan.dispatch;
|
using HH.WCS.ZhongCeJinTan.util;
|
using HH.WCS.ZhongCeJinTan.wms;
|
using Newtonsoft.Json;
|
using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection;
|
using System.Security.Cryptography;
|
using System.Threading.Tasks;
|
using System.Web.UI.WebControls;
|
using static HH.WCS.ZhongCeJinTan.api.ApiModel;
|
using static System.Net.WebRequestMethods;
|
using System.IO;
|
using System.Net.Sockets;
|
using System.Text;
|
using System.ComponentModel;
|
using System.Data.SqlClient;
|
using System.Collections;
|
using System.Threading;
|
using S7.Net;
|
using static System.Runtime.CompilerServices.RuntimeHelpers;
|
using System.Web.UI.WebControls.WebParts;
|
using static HH.WCS.ZhongCeJinTan.util.Settings;
|
using System.Security.Policy;
|
using HH.WCS.Mobox3.ZhongCeJinTan.dispatch;
|
using S7.Net.Types;
|
using System.Web.Services.Description;
|
using Container = HH.WCS.ZhongCeJinTan.wms.Container;
|
using static HH.WCS.ZhongCeJinTan.wms.WcsModel;
|
using Top.Api;
|
using HH.WCS.ZhongCeJinTan;
|
|
namespace HH.WCS.ZhongCeJinTan.process
|
{
|
internal class TaskProcess
|
{
|
|
|
#region 任务相关
|
//--------------------------------------------------任务相关--------------------------------------------------
|
/// <summary>
|
/// 取货卸货完成，缓存位状态更新
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="v"></param>
|
internal static void CacheBitUpdate(WMSTask mst, bool load) {
|
|
var trayCarryCount = mst.N_CNTR_COUNT > 0 ? mst.N_CNTR_COUNT : 1;
|
if (load)
|
{
|
Console.WriteLine($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
|
LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_START_LOC}取货完成，起点解绑容器{mst.S_CNTR_CODE}");
|
LocationHelper.UnBindingLoc(mst.S_START_LOC, mst.S_CNTR_CODE.Split(',').ToList());
|
}
|
else
|
{
|
Console.WriteLine($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
|
LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
|
LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList());
|
}
|
|
}
|
|
/// <summary>
|
/// 任务取消，缓存位状态更新
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static void CacheBitCancelUpdate(WMSTask mst) {
|
|
LocationHelper.UnLockLoc(mst.S_START_LOC);
|
LocationHelper.UnLockLoc(mst.S_END_LOC);
|
|
|
}
|
|
|
|
/// <summary>
|
/// 安全请求
|
/// </summary>
|
/// <param name="no"></param>
|
/// <param name="state"></param>
|
/// <param name="forkliftNo"></param>
|
/// <param name="extData"></param>
|
internal static void OperateReq(string no, int state, string forkliftNo="", string extData="")
|
{
|
//1103呼叫空托 卸货 1104 呼叫空托 卸货完成
|
var mst = TaskHelper.GetTask(no);
|
if (state == 1103 || state == 1104)
|
{
|
LogHelper.Info($"任务号{no}，卸货请求：{state}", "安全交互");
|
if (mst != null)
|
{
|
DeviceProcess.XieLiao(mst, forkliftNo, state);
|
}
|
else
|
{
|
LogHelper.Info($"没找到任务{no}，交互请求失败", "安全交互");
|
}
|
}
|
else if (state == 1101 || state == 1102)
|
{
|
LogHelper.Info($"任务号{no}，取货请求：{state}", "安全交互");
|
if (mst != null)
|
{
|
DeviceProcess.QuLiao(mst, forkliftNo, state);
|
}
|
else
|
{
|
LogHelper.Info($"没找到任务{no}，交互请求失败", "安全交互");
|
}
|
}
|
else if (state == 1003)
|
{
|
var workFlow = TaskHelper.selectWorkFlowByType(mst.N_TYPE.ToString(), mst.TOOLSTYPE);
|
|
if (workFlow == null)
|
{
|
LogHelper.Info($"判断接驳位以及巷道是否可用，BUSI_TYpe:{mst.N_TYPE},没找到对应作业流程", "改道安全交互");
|
return;
|
}
|
|
var wcsTask = TaskHelper.GetTaskByWorkNo(mst.S_OP_CODE,"wcs");
|
if (wcsTask == null)
|
{
|
LogHelper.Info($"判断巷道可用失败，没找到对应{mst.S_OP_CODE}的wcs任务", "改道安全交互");
|
return;
|
}
|
//判断空托缓存、接驳位和巷道是否可用 不可用需要改道
|
changeBit(mst,wcsTask,workFlow);
|
}
|
else if (state == 1023 || state == 1025)
|
{
|
//开关关门申请
|
DeviceProcess.Door(mst, forkliftNo, state);
|
}
|
else if (state == 1004) {
|
LogHelper.Info($"等待交互，任务号={mst.S_CODE}", "安全交互");
|
|
var wcsCode = "";
|
|
if (mst.S_TYPE.Contains("入库")|| mst.S_TYPE.Contains("回库"))
|
{
|
wcsCode = mst.S_CODE.Replace(@"_1", "_2");
|
}
|
|
if (mst.S_TYPE.Contains("出库"))
|
{
|
wcsCode = mst.S_CODE.Replace(@"_2", "_1");
|
}
|
|
LogHelper.Info($"等待交互，查询校验任务号={wcsCode}", "安全交互");
|
//等待rfid校验
|
var rfidFlag = TaskHelper.GetRfid(wcsCode);
|
|
LogHelper.Info($"等待交互，任务号={mst.S_CODE}，RFID校验信息"+JsonConvert.SerializeObject(rfidFlag), "安全交互");
|
if (rfidFlag!=null)
|
{
|
if (rfidFlag.S_RESULT.Contains("成功"))
|
{
|
LogHelper.Info($"任务号={mst.S_CODE}，等待交管成功，修改参数6为1,4为0", "安全交互");
|
NDCApi.ChangeOrderParam(mst.S_CODE, 4, "0");
|
NDCApi.ChangeOrderParam(mst.S_CODE, 6, "1");
|
}
|
else {
|
var startSite = LocationHelper.GetAgvSiteZc(mst.S_START_LOC);
|
var endSite = LocationHelper.GetAgvSiteZc(mst.S_END_LOC);
|
LogHelper.Info($"任务{mst.S_CODE}RFID校验失败，改参数1为{startSite},改参数2为{endSite}，参数4为0，6为1", "安全交互");
|
NDCApi.ChangeOrderParam(mst.S_CODE, 1, startSite);
|
NDCApi.ChangeOrderParam(mst.S_CODE, 2, endSite);
|
NDCApi.ChangeOrderParam(mst.S_CODE, 4, "0");
|
Thread.Sleep(1000);
|
NDCApi.ChangeOrderParam(mst.S_CODE, 6, "2");
|
}
|
}
|
}
|
}
|
|
|
internal static bool CreateWmsWork(WmsWork work)
|
{
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
return db.Insertable<WmsWork>(work).ExecuteCommand() > 0;
|
}
|
catch (Exception ex)
|
{
|
Console.WriteLine(ex.Message);
|
throw;
|
}
|
}
|
|
|
/// <summary>
|
/// 任务状态更新处理
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="state"></param>
|
internal static void OperateStatus(WMSTask mst, int state)
|
{
|
if (state == 4)//取货完成
|
{
|
CacheBitUpdate(mst, true);
|
}
|
if (state == 6)//卸货完成
|
{
|
//接驳位不绑定
|
var safety = Settings.safetyLocations.Where(a => a.Area.Contains(mst.S_END_AREA)).FirstOrDefault();
|
if (safety != null) {
|
if (safety.type==1)
|
{
|
return;
|
}
|
}
|
//退库任务不绑定
|
if (LocationHelper.GetErroArea(mst.S_END_AREA)) {
|
return;
|
}
|
|
CacheBitUpdate(mst, false);
|
}
|
if (state == 7)
|
{
|
CacheBitCancelUpdate(mst);
|
}
|
}
|
|
|
|
private static object lockObj = new object();
|
|
|
|
private static object locLocker = new object();
|
|
internal static void changeBit(WMSTask task, WMSTask wcsTask, WorkFlow workFlow) {
|
|
var db = new SqlHelper<object>().GetInstance();
|
|
try
|
{
|
|
|
|
//空托入库判断空托出缓存表，有对应记录直接改道到缓存表终点
|
if (workFlow.FLOWCODE=="3") {
|
var kt = db.Queryable<MesKtTask>().Where(e => e.TOOLS_TPYE==task.TOOLSTYPE && e.Status=="N").OrderBy(a=>a.CreateDate).First();
|
if (kt == null)
|
{
|
LogHelper.Info($"当前任务{task.S_CODE}没找到空托出缓存记录", "改道安全交互");
|
}
|
else {
|
|
LogHelper.Info($"当前任务{task.S_CODE}找到空托出缓存记录:"+JsonConvert.SerializeObject(kt), "改道安全交互");
|
|
//查找给定终点
|
var end = LocationHelper.GetLoc(kt.Location_To);
|
if (end.S_LOCK_STATE=="无" && end.N_CURRENT_NUM==0)
|
{
|
//LogHelper.Info($"当前任务{task.S_CODE}改道终点信息" + JsonConvert.SerializeObject(end), "改道安全交互");
|
//if (end == null || end.S_LOCK_STATE != "无")
|
//{
|
// LogHelper.Info($"当前任务{task.S_CODE}改道终点失败，终点:{kt.Location_To},没找到或有锁", "改道安全交互");
|
//}
|
TaskHelper.Fail(wcsTask);
|
TaskProcess.OperateStatus(wcsTask, 7);
|
LocationHelper.LockLoc(end.S_CODE, "入库锁", 1);
|
db.BeginTran();
|
//改一段任务终点
|
task.S_END_LOC = end.S_CODE;
|
task.S_END_AREA = end.S_AREA_CODE;
|
task.S_END_AREA_NAME = end.S_AREA_Name;
|
|
db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA ,it.S_END_AREA_NAME}).ExecuteCommand();
|
kt.Status = "Y";
|
db.Updateable(kt).UpdateColumns(it => new { it.Status }).ExecuteCommand();
|
db.CommitTran();
|
var site = LocationHelper.GetAgvSiteZc(end.S_CODE);
|
LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为2，4为0", "改道安全交互");
|
NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
|
NDCApi.ChangeOrderParam(task.S_CODE, 4, "0");
|
Thread.Sleep(1000);
|
NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
|
return;
|
}
|
|
}
|
}
|
|
//判断巷道可用
|
var flag = true;
|
|
//判断接驳位可用
|
var flag1 = true;
|
|
if (workFlow.FLOWNAME.Contains("入库"))
|
{
|
|
List<Location> balanceConnectionList = new List<Location>();
|
|
var loc1 = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
|
//判断可用巷道
|
var rowdwa = db.Queryable<RoadWayEnable>().Where(x => x.areaCode == wcsTask.S_END_AREA && x.status == "0" && x.roadWay == loc1.N_ROADWAY.ToString()).First();
|
if (rowdwa == null)
|
{
|
LogHelper.Info($"当前任务{task.S_CODE}判断巷道可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}可用", "改道安全交互");
|
flag = false;
|
}
|
|
//判断可用接驳位
|
var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
|
var usableConnectionList = WcsTask.WcsPositionAvailable(task.S_CODE, connectionList);
|
|
|
if (usableConnectionList != null && usableConnectionList.code == "0")
|
{
|
balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);
|
|
foreach (var item in balanceConnectionList)
|
{
|
if (item.S_CODE.Contains(task.S_END_LOC))
|
{
|
|
flag1 = false;
|
LogHelper.Info($"当前任务{task.S_CODE}接驳位{item.S_CODE}可用", "改道安全交互");
|
break;
|
}
|
}
|
}
|
else
|
{
|
LogHelper.Info($"判断接驳位是否可用接口回复异常", "改道安全交互");
|
throw new Exception($"判断接驳位是否可用接口回复异常");
|
}
|
|
|
|
if (flag || flag1)
|
{
|
|
LogHelper.Info($"当前任务{task.S_CODE}接驳位{task.S_END_LOC}或者当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}不可用，需要改道", "改道安全交互");
|
Location connection = null;
|
|
|
Location end = null;
|
|
//立库均衡后货位集合
|
List<Location> balanceLocList = new List<Location>();
|
|
var endLoc = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
|
List<Location> endList;
|
if (!string.IsNullOrEmpty(workFlow.ZONECODE))
|
{
|
endList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
|
}
|
else
|
{
|
endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
|
}
|
|
|
balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
|
balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);
|
|
foreach (var item in balanceLocList)
|
{
|
if (item.S_LOCK_STATE == "无" && item.N_CURRENT_NUM == 0)
|
{
|
//LogHelper.Info($"改道安全交互item信息" + JsonConvert.SerializeObject(item), "改道安全交互");
|
foreach (var item1 in balanceConnectionList)
|
{
|
if (item1.CONNEC_ROADWAY == item.N_ROADWAY)
|
{
|
connection = item1;
|
|
end = item;
|
LogHelper.Info($"当前任务{task.S_CODE}寻找到可用接驳位{connection}", "改道安全交互");
|
break;
|
}
|
}
|
if (end != null)
|
{
|
LogHelper.Info($"当前任务{task.S_CODE}寻找到终点{end.S_CODE}", "改道安全交互");
|
break;
|
}
|
}
|
}
|
|
|
if (connection == null)
|
{
|
throw new Exception($"改道寻找不到可用接驳位");
|
}
|
|
LogHelper.Info($"当前任务{task.S_CODE}，当前巷道不可用，需要改道，新终点信息" + JsonConvert.SerializeObject(end), "改道安全交互");
|
if (end == null)
|
{
|
LogHelper.Info($"当前巷道不可用，终点库区{workFlow.ENDAREA},没找到终点", "改道安全交互");
|
throw new Exception($"终点库区{workFlow.ENDAREA},没找到终点");
|
}
|
LocationHelper.LockLoc(end.S_CODE, "入库锁", 1);
|
db.BeginTran();
|
endLoc.N_LOCK_STATE = 0;
|
endLoc.S_LOCK_STATE = "无";
|
db.Updateable(endLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
|
wcsTask.S_END_LOC = end.S_CODE;
|
db.Updateable(wcsTask).UpdateColumns(it => new { it.S_END_LOC }).ExecuteCommand();
|
db.CommitTran();
|
|
LocationHelper.LockLoc(connection.S_CODE, "入库锁", 1);
|
var endLoc1 = LocationHelper.GetLocOne(task.S_END_LOC);
|
endLoc1.N_LOCK_STATE = 0;
|
endLoc1.S_LOCK_STATE = "无";
|
db.BeginTran();
|
db.Updateable(endLoc1).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
|
//改一段任务终点
|
task.S_END_LOC = connection.S_CODE;
|
task.S_END_AREA = connection.S_AREA_CODE;
|
|
task.S_END_AREA_NAME = connection.S_AREA_Name;
|
db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA,it.S_END_AREA_NAME }).ExecuteCommand();
|
|
|
//改二段任务起点
|
wcsTask.S_START_LOC = connection.S_CODE;
|
wcsTask.S_START_AREA = connection.S_AREA_CODE;
|
|
wcsTask.S_START_AREA_NAME = connection.S_AREA_Name;
|
db.Updateable(wcsTask).UpdateColumns(it => new { it.S_START_LOC, it.S_START_AREA,it.S_START_AREA_NAME}).ExecuteCommand();
|
db.CommitTran();
|
|
var site = LocationHelper.GetAgvSiteZc(connection.S_CODE);
|
LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为2,4为1024", "改道安全交互");
|
NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
|
NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
|
Thread.Sleep(1000);
|
NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
|
|
//} else if (workFlow.FLOWNAME.Contains("出库")) {
|
// var endLoc = LocationHelper.GetLocOne(task.S_START_LOC);
|
// endLoc.N_LOCK_STATE = 3;
|
// endLoc.S_LOCK_STATE = "其他锁";
|
// db.BeginTran();
|
// db.Updateable(endLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
|
// task.S_START_LOC = loc.S_CODE;
|
// db.Updateable(task).UpdateColumns(it => new { it.S_START_LOC }).ExecuteCommand();
|
// db.CommitTran();
|
// LocationHelper.LockLoc(loc.S_CODE, "出库锁", 2);
|
//}
|
}
|
else {
|
LogHelper.Info($"当前任务{task.S_CODE}接驳位{task.S_END_LOC}可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}可用，不需要改道，直接修改参数6为2，4为1024", "改道安全交互");
|
NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
|
Thread.Sleep(1000);
|
NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
|
}
|
}
|
|
|
|
//if (workFlow.FLOWNAME.Contains("入库"))
|
//{
|
// var loc = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
|
// //查找可用巷道
|
// var rowdwa = db.Queryable<RoadWayEnable>().Where(x => x.areaCode == wcsTask.S_END_AREA && x.status == "0" && x.roadWay == loc.N_ROADWAY.ToString()).First();
|
// if (rowdwa == null)
|
// {
|
// LogHelper.Info($"判断巷道可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc.N_ROADWAY}可用,不需要改道", "改道安全交互");
|
// }
|
// else
|
// {
|
// LogHelper.Info($"当前巷道不可用，需要改道", "改道安全交互");
|
// if (workFlow.FLOWNAME.Contains("入库"))
|
// {
|
// var endLoc = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
|
|
// var endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
|
|
// var end = LocationHelper.FindEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
// LogHelper.Info($"当前巷道不可用，需要改道，新终点信息" + JsonConvert.SerializeObject(end), "改道安全交互");
|
|
|
// if (end == null)
|
// {
|
// LogHelper.Info($"当前巷道不可用，终点库区{workFlow.ENDAREA},没找到终点", "改道安全交互");
|
// throw new Exception($"终点库区{workFlow.ENDAREA},没找到终点");
|
// }
|
// LocationHelper.LockLoc(end.S_CODE, "入库锁", 1);
|
// db.BeginTran();
|
// endLoc.N_LOCK_STATE = 0;
|
// endLoc.S_LOCK_STATE = "无";
|
// db.Updateable(endLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
|
// wcsTask.S_END_LOC = end.S_CODE;
|
// db.Updateable(wcsTask).UpdateColumns(it => new { it.S_END_LOC }).ExecuteCommand();
|
// db.CommitTran();
|
|
// }
|
// }
|
//}
|
|
|
}
|
catch (Exception ex)
|
{
|
db.RollbackTran();
|
LogHelper.Info($"判断接驳位和巷道可用异常"+ex.Message, "改道安全交互");
|
}
|
|
}
|
|
|
|
/// <summary>
|
/// 新NDC推送任务
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static bool SendTask(WMSTask mst)
|
{
|
var start = "0";
|
var end = "0";
|
try
|
{
|
|
LogHelper.Info($"推送任务{mst.S_CODE}", "NDC");
|
|
|
if (mst.S_TYPE.Contains("出库"))
|
{
|
//查找对应作业，是接驳位就查询对应立库任务
|
|
|
var wmsWork = TaskHelper.GetWmsWork(mst.S_OP_CODE);
|
|
if (wmsWork==null)
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}", "NDC");
|
return false;
|
}
|
|
if (!string.IsNullOrEmpty(wmsWork.CONNECTION))
|
{
|
var wcsTask = TaskHelper.GetTaskByWork("wcs", mst.S_OP_CODE);
|
if (wcsTask == null)
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}对应的出库任务", "NDC");
|
return false;
|
}
|
|
if (wcsTask.S_B_STATE == "未执行" || wcsTask.S_B_STATE == "已推送")
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}，对应的Wcs出库任务未执行，暂不推送", "NDC");
|
return false;
|
}
|
|
//接驳位两个agv任务，a任务取货完成 推送b任务
|
var agvTask = LocationHelper.GetConnectionTask(wmsWork.CONNECTION,"agv");
|
|
LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，第一个agv任务信息"+JsonConvert.SerializeObject(agvTask), "NDC");
|
//if (agvTask==null)
|
//{
|
// LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，agv任务没找到，暂不推送", "NDC");
|
// return false;
|
//}
|
|
if (agvTask != null)
|
{
|
if (agvTask.S_B_STATE != "取货完成")
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，agv任务{agvTask.S_CODE},状态{agvTask.S_B_STATE}，暂不推送", "NDC");
|
return false;
|
}
|
}
|
}
|
|
|
}
|
|
|
start = LocationHelper.GetAgvSiteZc(mst.S_START_LOC);
|
end = LocationHelper.GetAgvSiteZc(mst.S_END_LOC);
|
|
LogHelper.Info($"推送任务{mst.S_CODE}，起点站点：{start}，终点站点：{end}", "NDC");
|
|
var ndcParme = new List<param>();
|
ndcParme.Add(new param() { name = "From", value = start.ToString() });
|
ndcParme.Add(new param() { name = "To", value = end.ToString() });
|
ndcParme.Add(new param() { name = "FUNC", value = "0" });
|
|
|
var work = TaskHelper.GetWmsWork(mst.S_OP_CODE);
|
if (work==null)
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}", "NDC");
|
return false;
|
}
|
|
if (string.IsNullOrEmpty(work.CONNECTION))
|
{
|
ndcParme.Add(new param() { name = "DATA", value = "0" });
|
}
|
else {
|
if (work.S_TYPE.Contains("入库") || work.S_TYPE.Contains("回库"))
|
{
|
ndcParme.Add(new param() { name = "DATA", value = "768" });
|
}
|
else {
|
ndcParme.Add(new param() { name = "DATA", value = "0" });
|
}
|
}
|
|
|
|
|
ndcParme.Add(new param() { name = "Ctype", value = "0" });
|
|
|
var res = NDCApi.AddOrderNew(1, mst.N_PRIORITY, mst.S_CODE, ndcParme);
|
|
if (res.err_code==0)
|
{
|
TaskHelper.UpdateStatus(mst, "已推送");
|
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
catch (Exception e)
|
{
|
LogHelper.Info($"推送任务{mst.S_CODE}异常，{e.Message}", "NDC");
|
return false;
|
}
|
}
|
|
|
|
/// <summary>
|
/// 创建搬运任务
|
/// </summary>
|
/// <param name="start"></param>
|
/// <param name="end"></param>
|
/// <param name="taskType"></param>
|
/// <param name="cntrs"></param>
|
/// <param name="startLayer"></param>
|
/// <param name="endLayer"></param>
|
/// <param name="trayCarryCount"></param>
|
/// <param name="priority"></param>
|
/// <returns></returns>
|
public static bool CreateTransport(string start, string end, string taskType, string cntrs, int startLayer, int endLayer, int trayCarryCount = 1, int priority = 1,string taskNo="") {
|
var result = false;
|
var res = TaskHelper.CreateTask(taskNo, start.Trim(), end.Trim(), taskType, priority, cntrs, trayCarryCount, startLayer, endLayer);
|
if (res) {
|
result = true;
|
//任务创建成功，起点货位出库锁定，终点货位入库锁定
|
LocationHelper.LockLoc(start, "出库锁", 2);
|
LocationHelper.LockLoc(end, "入库锁", 1);
|
}
|
return result;
|
}
|
|
internal static LocationRecordsResult LocationRecords(LocationRecordsParme model) {
|
var result = new LocationRecordsResult();
|
var db = new SqlHelper<object>().GetInstance();
|
|
return result;
|
}
|
|
|
|
internal static Result MesUdeItem(MesUdeItemParme model)
|
{
|
var result = new Result();
|
var db = new SqlHelper<object>().GetInstance();
|
try
|
{
|
if (string.IsNullOrEmpty(model.TurnCardNum))
|
{
|
LogHelper.Info("周转卡号 不允许为空", "修改物料");
|
throw new Exception("周转卡号 不允许为空");
|
}
|
var Item = db.Queryable<CntrItemRel>().Where(e => e.TurnCardNum == model.TurnCardNum)?.First();
|
if (Item == null)
|
{
|
LogHelper.Info("该周转卡号 未查询到指定物料信息", "修改物料");
|
throw new Exception("该周转卡号 未查询到指定物料信息");
|
}
|
db.BeginTran();
|
var B = db.Updateable<CntrItemRel>()
|
.SetColumnsIF(!string.IsNullOrEmpty(model.CHECK_INFO), it => it.S_ITEM_STATE == model.CHECK_INFO)
|
.SetColumnsIF(!string.IsNullOrEmpty(model.PROD_NO), it => it.S_ITEM_CODE == model.PROD_NO)
|
.SetColumnsIF(model.CURRENT_AMOUNT != 0, it => it.F_QTY == Convert.ToDecimal(model.CURRENT_AMOUNT))
|
.SetColumns(it => it.expireTime == Item.expireTime.AddHours(model.EXPIRED_REP))
|
.Where(x => x.TurnCardNum == model.TurnCardNum).ExecuteCommand();
|
if (B == 0)
|
{
|
db.RollbackTran();
|
LogHelper.Info("更新物料信息失败", "修改物料");
|
throw new Exception("更新物料信息失败");
|
}
|
db.CommitTran();
|
LogHelper.Info("修改物料完成", "修改物料");
|
|
result.errMsg = "修改物料完成";
|
result.errCode = 0;
|
result.success = true;
|
return result;
|
}
|
catch (Exception e)
|
{
|
db.RollbackTran();
|
LogHelper.Info("修改物料绑定异常:" + e.Message, "修改物料");
|
result.errMsg = "修改物料异常";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
}
|
|
|
|
internal static MesAreaSecItemReturn MesAreaSecItem(MesAreaSecItemParme model) {
|
|
var result = new MesAreaSecItemReturn();
|
var db = new SqlHelper<object>().GetInstance();
|
try
|
{
|
var ca = Expressionable.Create<Location, LocCntrRel, CntrItemRel>();
|
ca.AndIF(!string.IsNullOrEmpty(model.Location_From), (o, p, t) => o.S_AREA_CODE == model.Location_From);
|
ca.AndIF(!string.IsNullOrEmpty(model.TurnCardNum), (o, p, t) => t.TurnCardNum == model.TurnCardNum);
|
var lstCanOutL = db.Queryable<Location>().InnerJoin<LocCntrRel>((o, p) => o.S_CODE == p.S_LOC_CODE).InnerJoin<CntrItemRel>((o, p, t) => p.S_CNTR_CODE == t.S_CNTR_CODE)
|
.Where(ca.ToExpression()).Includes(e => e.LocCntrRel, p => p.CntrItemRel).ToList();
|
List<CntrItemRel> item = new List<CntrItemRel>();
|
foreach (var itm in lstCanOutL)
|
{
|
item.Add(itm?.LocCntrRel?.CntrItemRel);
|
}
|
|
result.Data = item;
|
result.Success = true;
|
result.AffectedRows = 1;
|
result.Code = 0;
|
result.Msg = "查询物料信息成功";
|
result.Status = 1;
|
return result;
|
}
|
catch (Exception)
|
{
|
result.Data = null;
|
result.Success = false;
|
result.AffectedRows = 1;
|
result.Code = 1;
|
result.Msg = "查询物料信息异常";
|
result.Status = 1;
|
return result;
|
}
|
}
|
|
|
/// <summary>
|
/// 解绑绑定物料信息
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result MesBindUnbind(BindUnbindParme model)
|
{
|
var result = new Result();
|
var db = new SqlHelper<object>().GetInstance();
|
|
try
|
{
|
if (model == null)
|
{
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
if (model.BUSI_TYPE != "100" && model.BUSI_TYPE != "200")
|
{
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
LogHelper.Info("绑定解绑判断状态码", "物料绑定解绑");
|
if (model.BUSI_TYPE == "100")
|
{
|
LogHelper.Info("绑定开始", "物料绑定解绑");
|
//先判断托盘码是否存在于数据库中
|
var TrayLocation = db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == model.TOOLS_NO).ToList();
|
if (TrayLocation.Count() > 0)
|
{
|
LogHelper.Info("查询到该工装托盘码已经绑定了货位信息", "物料绑定解绑");
|
throw new Exception("查询到该工装托盘码已经绑定了货位信息");
|
}
|
var TrayItems = db.Queryable<CntrItemRel>().Where(e => e.S_CNTR_CODE == model.TOOLS_NO).ToList();
|
if (TrayItems.Count() > 0)
|
{
|
LogHelper.Info("查询到该工装托盘码已经绑定了物料信息", "物料绑定解绑");
|
throw new Exception("查询到该工装托盘码已经绑定了物料信息");
|
}
|
var Tray = db.Queryable<Container>().Where(e => e.S_CODE == model.TOOLS_NO).ToList();
|
if (Tray.Count() > 0)
|
{
|
LogHelper.Info("查询到该工装托盘码已经绑定了容器信息", "物料绑定解绑");
|
throw new Exception("查询到该工装托盘码已经绑定了容器信息");
|
}
|
|
var Locations = db.Queryable<Location>().Where(e => e.S_CODE == model.LOCATION_CODE)?.First();
|
if (Locations == null)
|
{
|
LogHelper.Info("未查询到需要绑定的货位信息", "物料绑定解绑");
|
throw new Exception("未查询到需要绑定的货位信息");
|
}
|
if (Locations.S_LOCK_STATE != "无")
|
{
|
LogHelper.Info($"需要绑定的货位{Locations.S_CODE}的状态为{Locations.S_LOCK_STATE} 货位不可用", "物料绑定解绑");
|
throw new Exception($"需要绑定的货位{Locations.S_CODE}的状态为{Locations.S_LOCK_STATE} 货位不可用");
|
}
|
if (Locations.C_ENABLE != "Y")
|
{
|
LogHelper.Info($"需要绑定的货位{Locations.S_CODE}的启用状态为{Locations.C_ENABLE} 货位不可用", "物料绑定解绑");
|
throw new Exception($"需要绑定的货位{Locations.S_CODE}的启用状态为{Locations.C_ENABLE} 货位不可用");
|
}
|
if (Locations.N_CURRENT_NUM > 0)
|
{
|
LogHelper.Info($"需要绑定的货位{Locations.S_CODE}的当前容量为{Locations.N_CURRENT_NUM} 货位不可用", "物料绑定解绑");
|
throw new Exception($"需要绑定的货位{Locations.S_CODE}的当前容量为{Locations.N_CURRENT_NUM} 货位不可用");
|
}
|
var LocCnt = new LocCntrRel();
|
LocCnt.S_CNTR_CODE = model.TOOLS_NO;
|
LocCnt.S_LOC_CODE = model.LOCATION_CODE;
|
db.BeginTran();
|
var I = db.Updateable<Location>().SetColumns(it => new Location() { T_MODIFY = DateTime.Now, N_CURRENT_NUM = 1 }).Where(x => x.S_CODE == model.LOCATION_CODE).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"更新货位数量为1失败", "物料绑定解绑");
|
throw new Exception("更新货位数量为1失败");
|
}
|
I = db.Insertable(LocCnt).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"添加托盘货位表数据失败", "物料绑定解绑");
|
throw new Exception("添加托盘货位表数据失败");
|
}
|
var trayItemMstGuid = Guid.NewGuid().ToString();
|
|
//添加托盘
|
Container cntr = new Container();
|
cntr.S_CODE = model.TOOLS_NO;
|
cntr.C_ENABLE = "Y";
|
cntr.N_DETAIL_COUNT = 1;
|
cntr.S_TYPE = "";
|
|
|
//添加托盘物料关联表
|
CntrItemRel rel = new CntrItemRel();
|
rel.S_ITEM_CODE = model.PROD_NO;
|
rel.S_ITEM_NAME = model.PROD_BOM;
|
rel.S_CNTR_CODE = model.TOOLS_NO;
|
rel.S_BATCH_NO = "";
|
rel.TurnCardNum = model.TurnCardNum;
|
rel.Level = model.PROD_BOM;
|
rel.itemModel = model.PROD_NO;
|
|
var EXPIRED_TIME = model.EXPIRED_TIME.ToString();
|
if (EXPIRED_TIME == "0001/1/1 0:00:00")
|
{
|
rel.expireTime = model.SHELF_LIFE_TIME.AddHours(model.EXPIRED_REP);
|
LogHelper.Info($"失效时间为0001/1/1 0:00:00，修改为：{rel.expireTime}", "物料绑定解绑");
|
}
|
else {
|
rel.expireTime = model.EXPIRED_TIME;
|
}
|
|
|
rel.takeEffectTime = model.SHELF_LIFE_TIME.AddHours(-model.SHELF_REP); ;
|
rel.F_QTY = Convert.ToDecimal(model.CURRENT_AMOUNT);
|
rel.S_ITEM_STATE = model.CHECK_INFO;
|
rel.PRODUCTIONDATE = model.PRODUCE_TIME;
|
rel.T_INSTOCK = DateTime.Now;
|
rel.S_ITEM_SPEC = model.PROD_SPEC;
|
rel.F_SUM_QTY = Convert.ToDecimal(model.standardWeight);
|
rel.itemFeature = model.PROD_TECH;
|
if (!string.IsNullOrEmpty(model.PROD_NO))
|
{
|
var A = db.Insertable(rel).ExecuteCommand();
|
|
var C = db.Insertable(cntr).ExecuteCommand();
|
if (A == 0)
|
{
|
LogHelper.Info($"物料表添加失败", "物料绑定解绑");
|
throw new Exception("物料表添加失败");
|
}
|
}
|
db.CommitTran();
|
LogHelper.Info("绑定完成", "物料绑定解绑");
|
result.errMsg = "绑定完成";
|
result.errCode = 0;
|
result.success = true;
|
return result;
|
}
|
else
|
{
|
LogHelper.Info("解绑开始", "物料绑定解绑");
|
var ca = Expressionable.Create<Location, LocCntrRel, CntrItemRel>();
|
ca.AndIF(!string.IsNullOrEmpty(model.LOCATION_CODE), (o, p, t) => o.S_CODE == model.LOCATION_CODE);
|
ca.AndIF(!string.IsNullOrEmpty(model.TurnCardNum), (o, p, t) => t.TurnCardNum == model.TurnCardNum);
|
ca.AndIF(!string.IsNullOrEmpty(model.TOOLS_NO), (o, p, t) => p.S_CNTR_CODE == model.TOOLS_NO);
|
var Locations = db.Queryable<Location>().InnerJoin<LocCntrRel>((o, p) => o.S_CODE == p.S_LOC_CODE).InnerJoin<CntrItemRel>((o, p, t) => p.S_CNTR_CODE == t.S_CNTR_CODE).Where(ca.ToExpression()).Includes(e => e.LocCntrRel, p => p.CntrItemRel)?.First();
|
if (Locations == null)
|
{
|
LogHelper.Info($"未查询到需要解绑的货位信息", "物料绑定解绑");
|
throw new Exception("未查询到需要解绑的货位信息");
|
}
|
if (Locations.S_LOCK_STATE != "无")
|
{
|
|
LogHelper.Info($"需要解绑的货位{Locations.S_CODE}的状态为{Locations.S_LOCK_STATE} 货位不可解绑", "物料绑定解绑");
|
throw new Exception($"需要解绑的货位{Locations.S_CODE}的状态为{Locations.S_LOCK_STATE} 货位不可解绑");
|
}
|
db.BeginTran();
|
var I = db.Updateable<Location>().SetColumns(it => new Location() { T_MODIFY = DateTime.Now, N_CURRENT_NUM = 0 }).Where(x => x.S_CODE == Locations.S_CODE).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"更新货位数量为0失败", "物料绑定解绑");
|
throw new Exception("更新货位数量为0失败");
|
}
|
I = db.Deleteable<LocCntrRel>().Where(e => e.S_LOC_CODE == Locations.S_CODE && e.S_CNTR_CODE == Locations.LocCntrRel.S_CNTR_CODE).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"删除托盘货位表失败", "物料绑定解绑");
|
throw new Exception("删除托盘货位表失败");
|
}
|
I = db.Deleteable<CntrItemRel>().Where(e => e.S_CNTR_CODE == Locations.LocCntrRel.S_CNTR_CODE).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"删除托盘物料表失败", "物料绑定解绑");
|
throw new Exception("删除托盘物料表失败");
|
}
|
I = db.Deleteable<Container>().Where(e => e.S_CODE == Locations.LocCntrRel.S_CNTR_CODE).ExecuteCommand();
|
if (I == 0)
|
{
|
LogHelper.Info($"删除托盘表失败", "物料绑定解绑");
|
throw new Exception("删除托盘表失败");
|
}
|
db.CommitTran();
|
LogHelper.Info("绑定解绑", "结束");
|
result.errMsg = "解绑完成";
|
result.errCode = 0;
|
result.success = true;
|
return result;
|
}
|
}
|
catch (Exception e)
|
{
|
db.RollbackTran();
|
LogHelper.Info("物料绑定解绑异常:" + e.Message, "物料绑定解绑");
|
result.errMsg = "物料绑定解绑异常" + e.Message;
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
return result;
|
}
|
|
|
|
|
|
internal static Result cancelTask1(cancleTaskParme model) {
|
var result = new Result();
|
LogHelper.Info("cancelTask1取消任务信息：" + JsonConvert.SerializeObject(model), "取消");
|
if (model == null)
|
{
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
result.success =false;
|
return result;
|
}
|
|
try
|
{
|
var task = TaskHelper.GetTaskByWorkNo(model.task_no, "agv");
|
|
var wcsTask = TaskHelper.GetTaskByWorkNo(model.task_no, "wcs");
|
|
if (task != null)
|
{
|
LogHelper.Info($"cancelTask1取消agv任务{task.S_CODE}：", "取消");
|
if (task.S_B_STATE.Trim() == "未执行")
|
{
|
//未执行直接修改状态为取消
|
TaskHelper.opMesTask(task, 3);
|
TaskHelper.Fail(task);
|
TaskProcess.CacheBitCancelUpdate(task);
|
|
if (task.S_TYPE.Contains("入库") || task.S_TYPE.Contains("回库"))
|
{
|
ContainerHelper.delCntr(task.S_CNTR_CODE);
|
ContainerHelper.delCntrItem(task.S_CNTR_CODE);
|
|
}
|
result.errCode = 0;
|
result.errMsg = "取消成功";
|
result.success = true;
|
}
|
else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "失败" && task.S_B_STATE.Trim() != "完成")
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var qhflag = db.Queryable<WmsTaskAction>().Where(a => a.S_TASK_CODE == task.S_CODE && a.S_ACTION == "4").First();
|
|
|
if (qhflag != null)
|
{
|
LogHelper.Info($"该任务{task.S_CODE}已经取货完成", "取消");
|
result.errCode = 1;
|
result.errMsg = "任务已经取货完成，不允许取消";
|
result.success = false;
|
return result;
|
}
|
if (task.S_TYPE.Contains("入库") || task.S_TYPE.Contains("回库"))
|
{
|
ContainerHelper.delCntr(task.S_CNTR_CODE);
|
ContainerHelper.delCntrItem(task.S_CNTR_CODE);
|
ContainerHelper.delCntrLoc(task.S_CNTR_CODE);
|
}
|
|
TaskHelper.opMesTask(task, 3);
|
//已推送但是没有完成或者取消，通知hosttoagv
|
TaskHelper.Fail(task);
|
|
NDCApi.CancelOrder(task.S_CODE.Trim());
|
TaskProcess.CacheBitCancelUpdate(task);
|
|
result.errCode = 0;
|
result.errMsg = "取消成功";
|
result.success = true;
|
}
|
else
|
{
|
result.errCode = 1;
|
result.errMsg = "任务已经结束";
|
result.success = false;
|
}
|
}
|
else
|
{
|
result.errCode = 1;
|
result.errMsg = $"{model.task_no}任务不存在";
|
result.success = false;
|
}
|
|
if (wcsTask != null)
|
{
|
LogHelper.Info($"cancelTask1取消Wcs任务{wcsTask.S_CODE}", "取消");
|
if (wcsTask.S_B_STATE.Trim() == "未执行")
|
{
|
//未执行直接修改状态为取消
|
if (wcsTask.S_TYPE.Contains("入库") || wcsTask.S_TYPE.Contains("回库"))
|
{
|
ContainerHelper.delCntr(wcsTask.S_CNTR_CODE);
|
ContainerHelper.delCntrItem(wcsTask.S_CNTR_CODE);
|
}
|
TaskHelper.Fail(wcsTask);
|
TaskProcess.OperateStatus(wcsTask, 7);
|
result.errCode = 0;
|
result.errMsg = "取消成功";
|
result.success = true;
|
return result;
|
}
|
else
|
{
|
LogHelper.Info($"该任务{wcsTask.S_CODE}已经推送", "取消");
|
result.errCode = 1;
|
result.errMsg = "任务已经推送，不允许取消";
|
result.success = false;
|
return result;
|
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
|
LogHelper.Info("cancelTask1取消任务异常：" + ex.Message, "取消");
|
result.errCode = 1;
|
result.errMsg = "取消任务异常";
|
return result;
|
}
|
|
return result;
|
}
|
|
|
internal static Result completeTask1(cancleTaskParme model) {
|
LogHelper.Info("completeTask1强制完成任务：" + JsonConvert.SerializeObject(model), "API");
|
var result = new Result();
|
if (model == null)
|
{
|
result.success = false;
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
}
|
|
var task = TaskHelper.GetTask(model.task_no);
|
if (task != null)
|
{
|
if (task.S_B_STATE.Trim() == "未执行")
|
{
|
result.success = false;
|
result.errMsg = "任务未执行，不允许强制完成！";
|
result.errCode = 1;
|
|
}
|
else if (task.S_B_STATE.Trim() == "取消" && task.S_B_STATE.Trim() == "失败" && task.S_B_STATE.Trim() == "完成") {
|
result.success = false;
|
result.errMsg = "任务已取消或者完成，不允许强制完成！";
|
result.errCode = 1;
|
}
|
else if (task.S_B_STATE.Trim() != "未执行" && task.S_B_STATE.Trim() != "待推送")
|
{
|
TaskHelper.UpdateStatus(model.task_no.Trim(), "已完成");
|
|
}
|
else
|
{
|
result.success = false;
|
result.errMsg = "任务已结束";
|
result.errCode = 1;
|
}
|
}
|
else
|
{
|
result.success = false;
|
result.errMsg = "任务不存在";
|
result.errCode = 1;
|
}
|
return result;
|
}
|
|
|
/// <summary>
|
/// 安全交互
|
/// </summary>
|
public static bool Interaction(WMSTask wmsTask, int qx,string loc)
|
{
|
return false;
|
}
|
|
|
|
/// <summary>
|
/// 修改任务优先级
|
/// </summary>
|
internal static zcResult task1(taskParme model)
|
{
|
var result = new zcResult();
|
|
if (model == null)
|
{
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
return result;
|
}
|
var db = new SqlHelper<object>().GetInstance();
|
|
var task = TaskHelper.GetTask(model.taskNo);
|
if (task == null)
|
{
|
result.errMsg = "没找到该任务";
|
result.errCode = 1;
|
return result;
|
}
|
else {
|
if (task.S_B_STATE != "未执行")
|
{
|
result.errMsg = "任务已经推送";
|
result.errCode = 1;
|
return result;
|
}
|
|
try
|
{
|
db.BeginTran();
|
task.N_PRIORITY = model.priority;
|
db.Updateable(task).UpdateColumns(it => new { it.N_PRIORITY }).ExecuteCommand();
|
db.Ado.CommitTran();
|
LogHelper.Info($"修改优先级成功:任务号:{task.S_CODE}", "API1");
|
result.errMsg = "修改优先级成功";
|
result.errCode = 0;
|
return result;
|
}
|
catch (Exception e)
|
{
|
LogHelper.Info("修改优先级异常异常:" + e.Message, "API1");
|
result.errMsg = "修改优先级异常";
|
result.errCode = 1;
|
|
db.Ado.RollbackTran();
|
return result;
|
|
}
|
}
|
}
|
|
/// <summary>
|
/// 添加点到点任务
|
/// </summary>
|
internal static Result addTask1(PtpTaskParme model)
|
{
|
var result = new Result();
|
try
|
{
|
|
if (model == null)
|
{
|
result.errMsg = "参数为null";
|
result.errCode = 1;
|
return result;
|
}
|
|
var qd = "";
|
var zd = "";
|
string trayCode = "";
|
|
string taskNo = "";
|
|
if (string.IsNullOrEmpty(model.TOOLS_NO))
|
{
|
trayCode = TaskHelper.GenerateTrayNo();
|
}
|
else
|
{
|
trayCode = model.TOOLS_NO;
|
}
|
|
if (string.IsNullOrEmpty(model.task_no))
|
{
|
taskNo = TaskHelper.GenerateTaskNo();
|
}
|
else
|
{
|
taskNo = model.task_no;
|
}
|
|
if (string.IsNullOrEmpty(model.Location_From) || string.IsNullOrEmpty(model.Location_To)) {
|
result.errMsg = "起点或终点为空";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
|
var startLoc = LocationHelper.GetLocOne(model.Location_From);
|
if (startLoc != null)
|
{
|
if (startLoc.C_ENABLE=="Y" && startLoc.S_LOCK_STATE=="无")
|
{
|
qd = startLoc.S_CODE;
|
}
|
else
|
{
|
result.errMsg = "起点未启用或有锁";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
}
|
else {
|
result.errMsg = "没找到起点";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
var endLoc = LocationHelper.GetLocOne(model.Location_To);
|
if (endLoc != null)
|
{
|
if (endLoc.C_ENABLE == "Y" && endLoc.S_LOCK_STATE == "无")
|
{
|
zd = endLoc.S_CODE;
|
}
|
else
|
{
|
result.errMsg = "终点未启用或有锁";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
}
|
else {
|
result.errMsg = "没找到终点";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
var startTask = TaskHelper.GetTaskByStartLoc(qd);
|
if (startTask != null)
|
{
|
result.errMsg = "起点有执行中任务";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
var endTask = TaskHelper.GetTaskByEndLoc(zd);
|
if (endTask != null)
|
{
|
result.errMsg = "终点有执行中任务";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
|
//LogHelper.Info($"创建任务参数:start:{qd},end:{zd},trayCode:{trayCode},pri:{model.priority},taskNo:{taskNo}", "点到点");
|
|
|
var wmsWork = WMSHelper.GetWmsWorkByCntr(trayCode);
|
if (wmsWork != null)
|
{
|
LogHelper.Info($"起点{qd} 托盘{trayCode}已经创建作业，请勿重复申请", "点到点");
|
result.errMsg = "起点有托盘作业";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
else
|
{
|
var taskType = 20;
|
|
var operation = new WmsWork
|
{
|
// 作业号
|
S_CODE = model.task_no,
|
// 作业类型
|
N_TYPE = taskType,
|
// 作业类型
|
S_TYPE = "点到点",
|
// 起点货位
|
S_START_LOC = startLoc.S_CODE,
|
// 起点库区编码
|
S_START_AREA = startLoc.S_AREA_CODE,
|
// 终点货位
|
S_END_LOC = endLoc.S_CODE,
|
// 终点库区编码
|
S_END_AREA = endLoc.S_AREA_CODE,
|
// 容器编码
|
S_CNTR_CODE = trayCode,
|
// 作业定义名称
|
S_OP_DEF_NAME = WmsWork.GetOpName(taskType),
|
//优先级
|
N_PRIORITY = model.priority,
|
|
};
|
|
|
if (WMSHelper.CreateWmsWork(operation))
|
{
|
result.errMsg = "作业创建成功";
|
result.errCode = 0;
|
result.success = true;
|
return result;
|
}
|
else
|
{
|
result.errMsg = "作业创建失败";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
}
|
|
//TaskProcess.CreateTransport(qd, zd, "点到点", trayCode, 1, 1, 1, model.priority, taskNo);
|
|
|
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info($"创建点到点任务异常，"+ex.Message, "点到点");
|
result.errMsg = "任务创建异常";
|
result.errCode = 1;
|
result.success = false;
|
return result;
|
}
|
|
|
|
}
|
|
|
/// <summary>
|
/// 添加mes任务
|
/// </summary>
|
internal static Result addMesTaskInWorkArea(InWorkAreaParme model)
|
{
|
var result = new Result();
|
var TOOLSTYPE = "";
|
try
|
{
|
if (string.IsNullOrEmpty(model.BUSI_TYPE.ToString()))
|
{
|
LogHelper.Info("InWorkArea任务下发失败，缺少参数BUSI_TYPE。", "Mes任务下发");
|
throw new Exception("缺少参数BUSI_TYPE");
|
}
|
if (string.IsNullOrEmpty(model.PROD_NO))
|
{
|
LogHelper.Info("InWorkArea任务下发失败，缺少参数PROD_NO。", "Mes任务下发");
|
throw new Exception("缺少参数PROD_NO");
|
}
|
if (string.IsNullOrEmpty(model.Location_To))
|
{
|
LogHelper.Info("InWorkArea任务下发失败，终点为空。", "Mes任务下发");
|
throw new Exception("缺少终点Location_To");
|
}
|
if (string.IsNullOrEmpty(model.CHECK_INFO))
|
{
|
LogHelper.Info("InWorkArea任务下发失败，缺少参数CHECK_INFO。", "Mes任务下发");
|
throw new Exception("缺少参数CHECK_INFO");
|
}
|
if (string.IsNullOrEmpty(model.task_no))
|
{
|
LogHelper.Info("InWorkArea任务下发失败，缺少参数task_no。", "Mes任务下发");
|
throw new Exception("缺少参数task_no");
|
}
|
|
if (model.Task_type==2)
|
{
|
//呼叫胶料出库
|
|
|
|
var workFlow = TaskHelper.selectWorkFlowByType(model.BUSI_TYPE);
|
|
|
|
|
if (workFlow == null)
|
{
|
LogHelper.Info($"InWorkArea任务下发失败，BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程", "Mes任务下发");
|
throw new Exception($"BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程");
|
}
|
else
|
{
|
LogHelper.Info($"作业流程信息" + JsonConvert.SerializeObject(workFlow), "Mes任务下发");
|
}
|
|
//出库任务
|
|
//接驳位
|
var connection = "";
|
|
//接驳位库区
|
var connectionArea = "";
|
|
|
//查找给定终点
|
var end = LocationHelper.GetLoc(model.Location_To);
|
LogHelper.Info($"InWorkArea出库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
|
|
if (end == null)
|
{
|
LogHelper.Info($"InWorkArea出库任务下发失败，终点:{model.Location_To},没找到", "Mes任务下发");
|
throw new Exception($"终点:{model.Location_To},没找到");
|
}
|
|
|
var unlimitedLocation = TaskHelper.GetMesKtLoc();
|
|
//标记终点货位是否可以无限制下任务
|
var endLocFlag = true;
|
|
foreach (var item in unlimitedLocation)
|
{
|
//出库终点货位在配置里 可以无限制下任务
|
if (item.Loc.Contains(model.Location_To))
|
{
|
endLocFlag = false;
|
break;
|
}
|
}
|
|
if (endLocFlag)
|
{
|
var endTask = TaskHelper.GetTaskByEndLoc(model.Location_To);
|
if (endTask != null)
|
{
|
LogHelper.Info($"InWorkArea出库任务下发失败，终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}", "Mes任务下发");
|
throw new Exception($"终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}");
|
}
|
}
|
|
|
|
//查找起点
|
List<Location> strrtList;
|
|
Location start = null;
|
|
|
if (!string.IsNullOrEmpty(workFlow.ZONECODE))
|
{
|
strrtList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
|
}
|
else
|
{
|
strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
|
}
|
|
|
|
if (workFlow.FLOWCODE == "9")
|
{
|
//根据制品编号寻找立库区对应物料托盘
|
start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY, workFlow.CONNECTION);
|
if (start == null)
|
{
|
strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
|
var itemFlag = LocationHelper.FindStartcolByLoclistAndItemFlag(strrtList, model.PROD_NO, workFlow.STARTAREA);
|
LogHelper.Info($"InWorkArea满托出库任务没找到起点，校验是否有库存但是设备报警{itemFlag}", "Mes任务下发");
|
if (itemFlag)
|
{
|
result.errMsg = "满托出库作业有库存但设备报警";
|
result.errCode = 2001;
|
result.success = true;
|
return result;
|
}
|
}
|
|
|
LogHelper.Info($"InWorkArea出库任务下发起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
|
|
if (start == null)
|
{
|
LogHelper.Info($"InWorkArea出库任务下发失败，起点库区{workFlow.STARTAREA},没找到起点", "Mes任务下发");
|
throw new Exception($"起点库区{workFlow.STARTAREA},没找到起点");
|
}
|
|
|
|
|
//获取托盘码
|
var cntrCode = LocationHelper.GetLocCntrCode(start.S_CODE);
|
|
if (workFlow.SENDWCS == "Y")
|
{
|
|
//正式代码，调用接口寻找可用接驳位
|
var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
|
|
//根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
|
var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
|
foreach (var item in balanceConnectionList)
|
{
|
if (item.loc.CONNEC_ROADWAY == start.N_ROADWAY)
|
{
|
connection = item.loc.S_CODE;
|
connectionArea = item.loc.S_AREA_Name;
|
LogHelper.Info($"InWorkArea出库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
|
break;
|
}
|
}
|
|
if (connection == "")
|
{
|
LogHelper.Info($"InWorkArea出库任务下发寻找接驳位失败", "Mes任务下发");
|
throw new Exception($"InWorkArea出库任务下发寻找接驳位失败");
|
}
|
}
|
|
|
//起点终点查找成功，创建作业
|
|
var taskType = int.Parse(workFlow.FLOWCODE);
|
|
var operation = new WmsWork
|
{
|
// 作业号
|
S_CODE = model.task_no,
|
// 作业类型
|
N_TYPE = taskType,
|
// 作业类型
|
S_TYPE = workFlow.FLOWNAME,
|
// 起点货位
|
S_START_LOC = start.S_CODE,
|
// 起点库区编码
|
S_START_AREA = start.S_AREA_CODE,
|
//接驳位
|
CONNECTION = connection,
|
// 终点货位
|
S_END_LOC = end.S_CODE,
|
// 终点库区编码
|
S_END_AREA = end.S_AREA_CODE,
|
// 容器编码
|
S_CNTR_CODE = cntrCode,
|
// 作业定义名称
|
S_OP_DEF_NAME = workFlow.FLOWNAME,
|
//优先级
|
N_PRIORITY = model.Priority,
|
//工装类型
|
TOOLSTYPE = TOOLSTYPE,
|
//起点库区名称
|
S_START_AREA_NAME = start.S_AREA_Name,
|
//起点库区名称
|
S_END_AREA_NAME = end.S_AREA_Name,
|
//起点库区名称
|
CONNECTION_AREA = connectionArea
|
};
|
|
//创建作业
|
if (WMSHelper.CreateWmsWork(operation))
|
{
|
if (connection != "")
|
{
|
LocationHelper.LockLoc(operation.S_START_LOC, "出库锁", 2);
|
LocationHelper.LockLoc(operation.S_END_LOC, "入库锁", 1);
|
LocationHelper.LockLoc(operation.CONNECTION, "入库锁", 1);
|
}
|
|
|
LogHelper.Info($"InWorkArea出库作业创建成功{operation.S_CODE}", "Mes任务下发");
|
result.errMsg = "出库作业创建成功";
|
result.errCode = 0;
|
result.success = true;
|
return result;
|
}
|
else
|
{
|
LogHelper.Info($"InWorkArea出库任务下发创建作业失败", "Mes任务下发");
|
throw new Exception($"InWorkArea出库任务下发创建作业失败");
|
}
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info("InWorkArea任务下发异常" + ex.Message, "Mes任务下发");
|
result.errMsg = "InWorkArea任务下发异常" + ex.Message;
|
result.errCode = 1;
|
result.success = false;
|
throw;
|
}
|
|
return result;
|
}
|
|
|
/// <summary>
|
/// 添加mes任务
|
/// </summary>
|
internal static Result addMesTask(ZcInWorkAreaParme model) {
|
var result = new Result();
|
//保存到mes任务记录
|
MesTask mesRes = new MesTask()
|
{
|
task_no = model.task_no,
|
Task_type = model.Task_type,
|
TurnCardNum = model.TurnCardNum,
|
PROD_NO = model.PROD_NO,
|
PROD_TECH = model.PROD_TECH,
|
PROD_SPEC = model.PROD_SPEC,
|
PROD_BOM = model.PROD_BOM,
|
PROD_Feature = model.PROD_Feature,
|
TOOLS_NO = model.TOOLS_NO,
|
ST_AMOUNT = model.ST_AMOUNT,
|
CURRENT_AMOUNT = model.CURRENT_AMOUNT,
|
Location_From = model.Location_From,
|
Location_To = model.Location_To,
|
PRODUCE_TIME = model.PRODUCE_TIME,
|
SHELF_LIFE_TIME = model.SHELF_LIFE_TIME,
|
EXPIRED_TIME = model.EXPIRED_TIME,
|
SHELF_REP = model.SHELF_REP,
|
EXPIRED_REP = model.EXPIRED_REP,
|
CHECK_CODE = model.CHECK_CODE,
|
CHECK_INFO = model.CHECK_INFO,
|
Priority = model.Priority,
|
Data_status = model.Data_status,
|
CreateDate = DateTime.Now,
|
standardWeight = model.standardWeight,
|
BUSI_TYPE = model.BUSI_TYPE,
|
TOOLS_TPYE = model.TOOLS_TPYE,
|
};
|
|
try
|
{
|
//校验参数
|
if (string.IsNullOrEmpty(model.BUSI_TYPE))
|
{
|
LogHelper.Info( "ZCSendTask任务下发失败，缺少参数BUSI_TYPE。", "Mes任务下发");
|
throw new Exception("缺少参数BUSI_TYPE");
|
}
|
if (model.BUSI_TYPE == "1" && string.IsNullOrEmpty(model.TOOLS_TPYE))
|
{
|
LogHelper.Info("ZCSendTask任务下发失败，缺少参数TOOLS_TPYE。", "Mes任务下发");
|
throw new Exception("缺少参数TOOLS_TPYE");
|
}
|
if (string.IsNullOrEmpty(model.Location_From) && string.IsNullOrEmpty(model.Location_To))
|
{
|
LogHelper.Info("ZCSendTask任务下发失败，起点和终点同时为空。", "Mes任务下发");
|
throw new Exception("缺少起点Location_From或终点Location_To!");
|
}
|
if (!string.IsNullOrEmpty(model.Location_From) && !string.IsNullOrEmpty(model.Location_To))
|
{
|
LogHelper.Info("ZCSendTask任务下发失败，起点和终点同时有值。", "Mes任务下发");
|
throw new Exception("起点Location_From或终点Location_To 不能同时有参!");
|
}
|
if (string.IsNullOrEmpty(model.task_no) )
|
{
|
LogHelper.Info("ZCSendTask任务下发失败，缺少参数task_no。", "Mes任务下发");
|
|
throw new Exception("缺少参数task_no");
|
}
|
|
|
//var wmsWork = TaskHelper.GetTaskByCntrCode(model.TOOLS_NO);
|
|
if (!string.IsNullOrEmpty(model.TOOLS_NO))
|
{
|
var cntr = ContainerHelper.GetCntr(model.TOOLS_NO);
|
if (cntr != null)
|
{
|
LogHelper.Info($"托盘{model.TOOLS_NO}已经创建作业，请勿重复申请", "Mes任务下发");
|
throw new Exception($"托盘{model.TOOLS_NO}已经创建作业，请勿重复申请");
|
}
|
}
|
|
|
//托盘明细数量
|
var cntrCount = 1;
|
|
//作业流程
|
WorkFlow workFlow = null;
|
|
//工装类型
|
var TOOLSTYPE = "";
|
if (!string.IsNullOrEmpty(model.TOOLS_TPYE))
|
{
|
TOOLSTYPE = model.TOOLS_TPYE;
|
}
|
|
//入库按照工装和流程编号
|
if (model.Task_type == 1) {
|
workFlow = TaskHelper.selectWorkFlowByType(model.BUSI_TYPE, TOOLSTYPE);
|
}
|
else if (model.Task_type == 2)
|
{
|
//出库按照终点库区和流程编号
|
|
var end = LocationHelper.GetLoc(model.Location_To);
|
LogHelper.Info($"ZCSendTask出库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
|
|
if (end == null)
|
{
|
LogHelper.Info($"ZCSendTask出库任务下发失败，终点:{model.Location_To},没找到", "Mes任务下发");
|
throw new Exception($"终点:{model.Location_To},没找到");
|
}
|
|
workFlow = TaskHelper.selectWorkFlowByEndArea(model.BUSI_TYPE, end.S_AREA_CODE);
|
TOOLSTYPE = workFlow.TOOLSTYPE;
|
}
|
|
LogHelper.Info($"作业{model.task_no}，工装类型{TOOLSTYPE}", "Mes任务下发");
|
|
|
|
if (workFlow == null) {
|
LogHelper.Info($"ZCSendTask任务下发失败，BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程", "Mes任务下发");
|
throw new Exception($"BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程");
|
}
|
else{
|
LogHelper.Info($"作业流程信息" + JsonConvert.SerializeObject(workFlow), "Mes任务下发");
|
}
|
|
if (model.Task_type == 1)
|
{
|
//入库任务
|
|
|
//托盘码，空架子不发使用虚拟号，发了默认使用mes工装编号
|
var cntrCode = "";
|
|
if (!string.IsNullOrEmpty(model.TOOLS_NO))
|
{
|
cntrCode = model.TOOLS_NO;
|
}
|
|
|
|
//查找起点
|
var start = LocationHelper.GetLoc(model.Location_From);
|
LogHelper.Info($"ZCSendTask入库任务下发起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
|
|
|
if (start == null || start.S_LOCK_STATE != "无") {
|
LogHelper.Info($"ZCSendTask入库任务下发失败，起点:{model.Location_From},没找到或有锁", "Mes任务下发");
|
throw new Exception($"起点:{model.Location_From},没找到或有锁");
|
}
|
|
|
|
//查找终点
|
List<Location> endList;
|
|
Location end = null;
|
|
if (!string.IsNullOrEmpty(workFlow.ZONECODE))
|
{
|
endList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
|
}
|
else
|
{
|
endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
|
}
|
|
//立库均衡后货位集合
|
List<Location> balanceLocList = new List<Location>();
|
|
|
//接驳位
|
var connection = "";
|
|
//接驳位库区名称
|
var connectionArea = "";
|
|
//如果需要下发wcs立库，则需要寻找可用接驳位
|
if (workFlow.SENDWCS == "Y")
|
{
|
|
//正式代码，调用接口寻找可用接驳位
|
//var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
|
//var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
|
//if (usableConnectionList != null && usableConnectionList.code == "0")
|
//{
|
// var balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找可用接驳位" + JsonConvert.SerializeObject(balanceConnectionList), "Mes任务下发");
|
|
// if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2")
|
// {
|
// //满托入
|
// balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
|
// if (TOOLSTYPE == "25" || TOOLSTYPE == "35") {
|
// LogHelper.Info($"ZCSendTask入库任务工装是二合一库,需要物料均衡", "Mes任务下发");
|
// balanceLocList = LocationHelper.RoadWayBalance1ByItem(balanceLocList, model.PROD_NO);
|
// }
|
|
|
|
// }
|
// else if (workFlow.FLOWCODE == "3")
|
// {
|
// //空托入立库区
|
// cntrCount = 0;
|
// LogHelper.Info($"ZCSendTask入库任务,寻找立库区空货位", "Mes任务下发");
|
// balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
// }
|
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找终点数量{balanceLocList.Count}", "Mes任务下发");
|
|
// foreach (var item in balanceLocList)
|
// {
|
// if (item.S_LOCK_STATE == "无" && item.N_CURRENT_NUM == 0)
|
// {
|
// // LogHelper.Info($"ZCSendTask入库任务下发item信息" + JsonConvert.SerializeObject(item), "Mes任务下发");
|
// foreach (var item1 in balanceConnectionList)
|
// {
|
// if (item1.CONNEC_ROADWAY == item.N_ROADWAY)
|
// {
|
// connection = item1.S_CODE;
|
// connectionArea = item1.S_AREA_Name;
|
// end = item;
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
|
// break;
|
// }
|
// }
|
// if (end!=null)
|
// {
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找到终点{end.S_CODE}", "Mes任务下发");
|
// break;
|
// }
|
// }
|
// }
|
// if (connection == "")
|
// {
|
// LogHelper.Info($"ZCSendTask入库任务下发没找到接驳位", "Mes任务下发");
|
// throw new Exception($"ZCSendTask入库任务下发没找到接驳位");
|
// }
|
//}
|
//else
|
//{
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位接口失败", "Mes任务下发");
|
// throw new Exception($"ZCSendTask入库任务下发寻找接驳位接口失败");
|
//}
|
|
|
if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2" || workFlow.FLOWCODE == "5" || workFlow.FLOWCODE == "8" || workFlow.FLOWCODE == "11")
|
{
|
//满托入
|
|
if (TOOLSTYPE == "25" || TOOLSTYPE == "35")
|
{
|
LogHelper.Info($"ZCSendTask入库任务工装是二合一库,需要物料均衡", "Mes任务下发");
|
end = LocationHelper.FindBalanceEndcolByLocListItem(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no, model.PROD_NO);
|
|
}
|
else {
|
end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no);
|
}
|
|
}
|
else if (workFlow.FLOWCODE == "3" || workFlow.FLOWCODE == "10")
|
{
|
//空托入立库区
|
cntrCount = 0;
|
LogHelper.Info($"ZCSendTask入库任务,寻找立库区空货位", "Mes任务下发");
|
end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no);
|
}
|
|
if (end == null)
|
{
|
LogHelper.Info($"ZCSendTask入库任务{model.task_no}下发失败，终点库区{workFlow.ENDAREA},没找到终点巷道或接驳位不可用", "Mes任务下发");
|
throw new Exception($"{model.task_no}下发失败终点库区{workFlow.ENDAREA},没找到终点,巷道或接驳位不可用");
|
}
|
|
var jb = LocationHelper.GetConnectionByEnd(workFlow.CONNECTION, end.N_ROADWAY);
|
|
if (jb==null)
|
{
|
LogHelper.Info($"ZCSendTask入库任务下发库区{workFlow.CONNECTION}，巷道{end.N_ROADWAY},没找到接驳位", "Mes任务下发");
|
throw new Exception($"ZCSendTask入库任务下发库区{workFlow.CONNECTION}，巷道{end.N_ROADWAY},没找到接驳位");
|
}
|
|
|
connection = jb.S_CODE;
|
connectionArea = jb.S_AREA_Name;
|
|
|
}
|
else {
|
if (workFlow.FLOWCODE == "3")
|
{
|
end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
}
|
else if (workFlow.FLOWCODE == "2")
|
{
|
//85纤维 95钢丝一段任务入三层货架
|
end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
LogHelper.Info($"ZCSendTask入库任务85纤维 95钢丝一段任务入三层货架终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
}
|
else if (workFlow.FLOWCODE == "12")
|
{
|
//空架子入
|
end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
cntrCount = 0;
|
//生成空架子虚拟号
|
cntrCode = ContainerHelper.GenerateCntrNo();
|
}
|
else if (workFlow.FLOWCODE == "0")
|
{
|
//钢丝入库
|
end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
}
|
}
|
|
LogHelper.Info($"ZCSendTask入库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
|
if (end == null) {
|
LogHelper.Info($"ZCSendTask入库任务{model.task_no}下发失败，终点库区{workFlow.ENDAREA},没找到终点", "Mes任务下发");
|
throw new Exception($"{model.task_no}下发失败终点库区{workFlow.ENDAREA},没找到终点");
|
}
|
|
|
|
//添加托盘物料关联表
|
if (cntrCount != 0)
|
{
|
CntrItemRel rel = new CntrItemRel();
|
rel.S_ITEM_CODE = model.PROD_NO;
|
rel.S_ITEM_NAME = model.PROD_BOM;
|
rel.S_CNTR_CODE = model.TOOLS_NO;
|
rel.S_BATCH_NO = "";
|
rel.TurnCardNum = model.TurnCardNum;
|
rel.Level = model.PROD_BOM;
|
rel.itemModel = model.PROD_NO;
|
|
var EXPIRED_TIME = model.EXPIRED_TIME.ToString();
|
if (EXPIRED_TIME == "0001/1/1 0:00:00")
|
{
|
rel.expireTime = model.PRODUCE_TIME.AddHours(model.EXPIRED_REP);
|
LogHelper.Info($"失效时间为0001/1/1 0:00:00，修改为：{rel.expireTime}", "Mes任务下发");
|
}
|
else
|
{
|
rel.expireTime = model.EXPIRED_TIME;
|
}
|
|
var SHELF_LIFE_TIME = model.SHELF_LIFE_TIME.ToString();
|
if (SHELF_LIFE_TIME == "0001/1/1 0:00:00")
|
{
|
rel.takeEffectTime = model.PRODUCE_TIME.AddHours(-model.SHELF_REP);
|
LogHelper.Info($"生效时间为0001/1/1 0:00:00，修改为：{rel.takeEffectTime}", "Mes任务下发");
|
}
|
else
|
{
|
rel.takeEffectTime = model.SHELF_LIFE_TIME;
|
}
|
|
rel.F_QTY = Convert.ToDecimal(model.CURRENT_AMOUNT);
|
rel.S_ITEM_STATE = model.CHECK_INFO;
|
rel.PRODUCTIONDATE = model.PRODUCE_TIME;
|
rel.T_INSTOCK = DateTime.Now;
|
rel.S_ITEM_SPEC = model.PROD_SPEC;
|
rel.F_SUM_QTY = Convert.ToDecimal(model.standardWeight);
|
rel.itemFeature = model.PROD_TECH;
|
ContainerHelper.CreateCntrItem(rel);
|
}
|
|
|
|
//添加托盘
|
Container cntr1 = new Container();
|
cntr1.S_CODE = cntrCode;
|
cntr1.C_ENABLE = "Y";
|
cntr1.N_DETAIL_COUNT = cntrCount;
|
cntr1.S_TYPE = "";
|
|
LogHelper.Info($"添加容器信息" + JsonConvert.SerializeObject(cntr1), "Mes任务下发");
|
if (ContainerHelper.CreateCntr(cntr1))
|
{
|
LogHelper.Info($"添加容器信息成功", "Mes任务下发");
|
}
|
else {
|
LogHelper.Info($"添加容器信息失败", "Mes任务下发");
|
}
|
|
|
|
|
//起点终点查找成功，创建作业
|
|
var taskType = int.Parse(workFlow.FLOWCODE);
|
|
var operation = new WmsWork
|
{
|
// 作业号
|
S_CODE = model.task_no,
|
// 作业类型
|
N_TYPE = taskType,
|
// 作业类型
|
S_TYPE = workFlow.FLOWNAME,
|
// 起点货位
|
S_START_LOC = start.S_CODE,
|
// 起点库区编码
|
S_START_AREA = start.S_AREA_CODE,
|
//接驳位
|
CONNECTION = connection,
|
// 终点货位
|
S_END_LOC = end.S_CODE,
|
// 终点库区编码
|
S_END_AREA = end.S_AREA_CODE,
|
// 容器编码
|
S_CNTR_CODE = cntrCode,
|
// 作业定义名称
|
S_OP_DEF_NAME = workFlow.FLOWNAME,
|
//优先级
|
N_PRIORITY = model.Priority,
|
//工装类型
|
TOOLSTYPE = TOOLSTYPE,
|
//起点库区名称
|
S_START_AREA_NAME = start.S_AREA_Name,
|
//起点库区名称
|
S_END_AREA_NAME = end.S_AREA_Name,
|
//起点库区名称
|
CONNECTION_AREA = connectionArea,
|
};
|
|
//创建作业
|
if (WMSHelper.CreateWmsWork(operation))
|
{
|
if (connection != "")
|
{
|
LocationHelper.LockLoc(operation.S_START_LOC, "出库锁", 2);
|
LocationHelper.LockLoc(operation.S_END_LOC, "入库锁", 1);
|
LocationHelper.LockLoc(operation.CONNECTION, "其他锁", 3);
|
}
|
|
|
LogHelper.Info($"ZCSendTask入库作业创建成功{operation.S_CODE}", "Mes任务下发");
|
result.errMsg = "入库作业创建成功";
|
result.errCode = 0;
|
result.success = true;
|
mesRes.errCode = result.errCode;
|
mesRes.errMsg = result.errMsg;
|
//保存mes记录
|
CreatMesRes(mesRes);
|
return result;
|
}
|
else {
|
LogHelper.Info($"ZCSendTask入库任务下发创建作业失败", "Mes任务下发");
|
throw new Exception($"ZCSendTask入库任务下发创建作业失败");
|
}
|
|
|
}
|
else if (model.Task_type == 2)
|
{
|
//出库任务
|
|
//接驳位
|
var connection = "";
|
|
//接驳位库区
|
var connectionArea = "";
|
|
|
//查找给定终点
|
var end = LocationHelper.GetLoc(model.Location_To);
|
LogHelper.Info($"ZCSendTask出库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
|
|
if (end == null)
|
{
|
LogHelper.Info($"ZCSendTask出库任务下发失败，终点:{model.Location_To},没找到", "Mes任务下发");
|
throw new Exception($"终点:{model.Location_To},没找到");
|
}
|
|
|
var unlimitedLocation = TaskHelper.GetMesKtLoc();
|
|
//标记终点货位是否可以无限制下任务
|
var endLocFlag = true;
|
|
foreach (var item in unlimitedLocation)
|
{
|
//出库终点货位在配置里 可以无限制下任务
|
if (item.Loc.Contains(model.Location_To))
|
{
|
endLocFlag = false;
|
break;
|
}
|
}
|
|
if (endLocFlag)
|
{
|
var endTask = TaskHelper.GetTaskByEndLoc(model.Location_To);
|
if (endTask != null)
|
{
|
LogHelper.Info($"ZCSendTask出库任务下发失败，终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}", "Mes任务下发");
|
throw new Exception($"终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}");
|
}
|
}
|
|
|
|
//查找起点
|
List<Location> strrtList;
|
|
Location start = null;
|
|
|
if (!string.IsNullOrEmpty(workFlow.ZONECODE))
|
{
|
strrtList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
|
}
|
else
|
{
|
strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
|
}
|
|
|
|
if (workFlow.FLOWCODE == "9" || workFlow.FLOWCODE == "4" || workFlow.FLOWCODE == "6")
|
{
|
if (TOOLSTYPE == "85" || TOOLSTYPE == "95")
|
{
|
start = LocationHelper.FindStartcolByHjLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA);
|
LogHelper.Info($"ZCSendTask出库任务85纤维 95钢丝一段任务三层货架起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
|
}
|
else
|
{
|
//根据制品编号寻找立库区对应物料托盘
|
start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY,workFlow.CONNECTION);
|
if (start == null)
|
{
|
strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
|
var itemFlag = LocationHelper.FindStartcolByLoclistAndItemFlag(strrtList, model.PROD_NO, workFlow.STARTAREA);
|
LogHelper.Info($"ZCSendTask满托出库任务没找到起点，校验是否有库存但是设备报警{itemFlag}", "Mes任务下发");
|
if (itemFlag)
|
{
|
result.errMsg = "满托出库作业有库存但设备报警";
|
result.errCode = 2001;
|
result.success = true;
|
mesRes.errCode = result.errCode;
|
mesRes.errMsg = result.errMsg;
|
//保存mes记录
|
CreatMesRes(mesRes);
|
return result;
|
}
|
}
|
}
|
|
|
}
|
else if (workFlow.FLOWCODE == "7")
|
{
|
//寻找立库区空托
|
//start = LocationHelper.FindStartcolByLoclistAndcntr(strrtList, workFlow.STARTAREA);
|
//if (start == null)
|
//{
|
// strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
|
// var itemFlag = LocationHelper.FindStartcolByLoclistAndcntrFlag(strrtList, workFlow.STARTAREA);
|
// LogHelper.Info($"ZCSendTask空托出库任务没找到起点，校验是否有库存但是设备报警{itemFlag}", "Mes任务下发");
|
|
// if (itemFlag)
|
// {
|
// result.errMsg = "空托出库作业有库存但设备报警";
|
// result.errCode = 2001;
|
// result.success = true;
|
// return result;
|
// }
|
//}
|
|
//空托出先缓存到空托表
|
|
//先查询有没有同终点缓存的记录
|
|
if (endLocFlag)
|
{
|
var ktTask = TaskHelper.GetMesKtTask(end.S_CODE);
|
if (ktTask != null)
|
{
|
LogHelper.Info($"ZCSendTask空托出缓存失败,终点{end.S_CODE}已有缓存", "Mes任务下发");
|
throw new Exception($"ZCSendTask空托出缓存失败,终点{end.S_CODE}已有缓存");
|
}
|
}
|
|
|
|
MesKtTask req = new MesKtTask()
|
{
|
Location_From_Area = workFlow.STARTAREA,
|
Location_To = end.S_CODE,
|
Priority = model.Priority,
|
CreateDate = DateTime.Now,
|
BUSI_TYPE = model.BUSI_TYPE,
|
TOOLS_TPYE = TOOLSTYPE,
|
task_no = model.task_no,
|
Status = "N"
|
};
|
|
if (TaskHelper.CreateMesKtTask(req))
|
{
|
LogHelper.Info($"ZCSendTask空托出创建成功", "Mes任务下发");
|
result.errMsg = "空托出库缓存成功";
|
result.errCode = 0;
|
result.success = true;
|
mesRes.errCode = result.errCode;
|
mesRes.errMsg = result.errMsg;
|
//保存mes记录
|
CreatMesRes(mesRes);
|
return result;
|
}
|
else
|
{
|
LogHelper.Info($"ZCSendTask空托出缓存失败", "Mes任务下发");
|
throw new Exception($"ZCSendTask空托出缓存失败");
|
}
|
}
|
else if (workFlow.FLOWCODE == "5")
|
{
|
//寻找货架区空托
|
start = LocationHelper.FindStartcolByHjArea(strrtList, workFlow.STARTAREA);
|
LogHelper.Info($"ZCSendTask出库任务钢丝空托一段任务起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
|
}
|
|
|
LogHelper.Info($"ZCSendTask出库任务下发起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
|
|
if (start == null)
|
{
|
LogHelper.Info($"ZCSendTask出库任务下发失败，起点库区{workFlow.STARTAREA},没找到起点", "Mes任务下发");
|
throw new Exception($"起点库区{workFlow.STARTAREA},没找到起点");
|
}
|
|
|
|
|
//获取托盘码
|
var cntrCode = LocationHelper.GetLocCntrCode(start.S_CODE);
|
|
if (workFlow.SENDWCS == "Y")
|
{
|
|
//正式代码，调用接口寻找可用接驳位
|
var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
|
//var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
|
//if (usableConnectionList != null && usableConnectionList.code == "0")
|
//{
|
// foreach (var item in usableConnectionList.available)
|
// {
|
// var con = LocationHelper.GetLoc(item);
|
// if (con.C_ENABLE == "Y" && con.N_CURRENT_NUM < 2)
|
// {
|
// connection = con.S_CODE;
|
// connectionArea = con.S_AREA_Name;
|
// LogHelper.Info($"ZCSendTask出库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
|
// }
|
// }
|
//}
|
//else
|
//{
|
// LogHelper.Info($"ZCSendTask出库任务下发寻找接驳位失败", "Mes任务下发");
|
// throw new Exception($"ZCSendTask出库任务下发寻找接驳位失败");
|
//}
|
|
//根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
|
var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
|
foreach (var item in balanceConnectionList)
|
{
|
if (item.loc.CONNEC_ROADWAY==start.N_ROADWAY)
|
{
|
connection = item.loc.S_CODE;
|
connectionArea = item.loc.S_AREA_Name;
|
LogHelper.Info($"ZCSendTask出库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
|
break;
|
}
|
}
|
|
if (connection == "")
|
{
|
LogHelper.Info($"ZCSendTask出库任务下发寻找接驳位失败", "Mes任务下发");
|
throw new Exception($"ZCSendTask出库任务下发寻找接驳位失败");
|
}
|
}
|
|
|
//起点终点查找成功，创建作业
|
|
var taskType = int.Parse(workFlow.FLOWCODE);
|
|
var operation = new WmsWork
|
{
|
// 作业号
|
S_CODE = model.task_no,
|
// 作业类型
|
N_TYPE = taskType,
|
// 作业类型
|
S_TYPE = workFlow.FLOWNAME,
|
// 起点货位
|
S_START_LOC = start.S_CODE,
|
// 起点库区编码
|
S_START_AREA = start.S_AREA_CODE,
|
//接驳位
|
CONNECTION = connection,
|
// 终点货位
|
S_END_LOC = end.S_CODE,
|
// 终点库区编码
|
S_END_AREA = end.S_AREA_CODE,
|
// 容器编码
|
S_CNTR_CODE = cntrCode,
|
// 作业定义名称
|
S_OP_DEF_NAME = workFlow.FLOWNAME,
|
//优先级
|
N_PRIORITY = model.Priority,
|
//工装类型
|
TOOLSTYPE = TOOLSTYPE,
|
//起点库区名称
|
S_START_AREA_NAME = start.S_AREA_Name,
|
//起点库区名称
|
S_END_AREA_NAME = end.S_AREA_Name,
|
//起点库区名称
|
CONNECTION_AREA = connectionArea
|
};
|
|
//创建作业
|
if (WMSHelper.CreateWmsWork(operation))
|
{
|
if (connection!="")
|
{
|
LocationHelper.LockLoc(operation.S_START_LOC, "出库锁", 2);
|
LocationHelper.LockLoc(operation.S_END_LOC, "入库锁", 1);
|
LocationHelper.LockLoc(operation.CONNECTION, "入库锁", 1);
|
}
|
|
|
LogHelper.Info($"ZCSendTask出库作业创建成功{operation.S_CODE}", "Mes任务下发");
|
result.errMsg = "出库作业创建成功";
|
result.errCode = 0;
|
result.success = true;
|
mesRes.errCode = result.errCode;
|
mesRes.errMsg = result.errMsg;
|
//保存mes记录
|
CreatMesRes(mesRes);
|
return result;
|
}
|
else {
|
LogHelper.Info($"ZCSendTask出库任务下发创建作业失败", "Mes任务下发");
|
throw new Exception($"ZCSendTask出库任务下发创建作业失败");
|
}
|
|
}
|
else {
|
LogHelper.Info("ZCSendTask出库任务下发失败，Task_type不等于1或2", "Mes任务下发");
|
throw new Exception("Task_type不等于1或2");
|
}
|
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info("ZCSendTask任务下发异常"+ex.Message, "Mes任务下发");
|
result.errMsg = "ZCSendTask任务下发异常"+ex.Message;
|
result.errCode = 1;
|
result.success = false;
|
mesRes.errCode = result.errCode;
|
mesRes.errMsg = result.errMsg;
|
//保存mes记录
|
CreatMesRes(mesRes);
|
return result;
|
}
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
internal static bool CreatMesRes(MesTask model)
|
{
|
var newDb = new SqlHelper<object>().GetInstance();
|
return newDb.Insertable(model).ExecuteCommand()>0;
|
|
}
|
|
|
|
|
|
/// <summary>
|
/// 门安全交互
|
/// </summary>
|
internal static ReturnResult1 safetyDoor(doorInteraction model)
|
{
|
var res = new ReturnResult1();
|
|
if (model == null)
|
{
|
res.code = 1;
|
res.msg = "参数为null";
|
return res;
|
}
|
else
|
{
|
//开门 1 关门 4
|
if (DeviceProcess.Traffic(model.doorname, model.apply_code,true))
|
{
|
res.code = 0;
|
res.msg = "允许";
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "不允许";
|
}
|
}
|
|
return res;
|
}
|
|
/// <summary>
|
/// 门状态
|
/// </summary>
|
internal static ReturnResult1 selectDoorStatus1(doorInteraction model)
|
{
|
var res = new ReturnResult1();
|
|
if (model == null)
|
{
|
res.code = 1;
|
res.msg = "参数为null";
|
return res;
|
}
|
else
|
{
|
if (DeviceProcess.Traffic(model.doorname, model.apply_code, false))
|
{
|
res.code = 0;
|
res.msg = "成功";
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "失败";
|
}
|
return res;
|
}
|
}
|
|
|
/// <summary>
|
/// 安全交互
|
/// </summary>
|
internal static ReturnResult1 safetyInteraction1(Interaction model) {
|
var res = new ReturnResult1();
|
var wmsTask = new WMSTask();
|
if (model == null)
|
{
|
res.code = 0;
|
res.msg = "参数为null";
|
return res;
|
}
|
else
|
{
|
try
|
{
|
switch (model.apply_code)
|
{
|
case "1":
|
//取货请求进入
|
wmsTask = TaskHelper.GetTaskByKwName(model.station_name, true, model.orderid);
|
if (wmsTask != null)
|
{
|
//输送线需要安全交互
|
if (TaskProcess.Interaction(wmsTask, 1, model.station_name))
|
{
|
res.code = 0;
|
res.msg = "输送线允许进入";
|
return res;
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "输送线不允许进入";
|
return res;
|
}
|
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "没找到任务";
|
return res;
|
}
|
case "3":
|
//取货完成
|
wmsTask = TaskHelper.GetTaskByKwName(model.station_name, true, model.orderid);
|
if (wmsTask != null)
|
{
|
//输送线需要安全交互
|
if (TaskProcess.Interaction(wmsTask, 3, model.station_name))
|
{
|
res.code = 0;
|
res.msg = "取货完成通知成功";
|
return res;
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "取货完成通知成功";
|
return res;
|
}
|
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "没找到任务";
|
return res;
|
}
|
case "6":
|
//卸货完成
|
wmsTask = TaskHelper.GetTaskByKwName(model.station_name, false, model.orderid);
|
if (wmsTask != null)
|
{
|
//输送线需要安全交互
|
if (TaskProcess.Interaction(wmsTask, 6, model.station_name))
|
{
|
res.code = 0;
|
res.msg = "卸货完成通知成功";
|
return res;
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "卸货完成通知失败";
|
return res;
|
}
|
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "没找到任务";
|
return res;
|
}
|
case "4":
|
//取货离开动作
|
wmsTask = TaskHelper.GetTaskByKwName(model.station_name, true, model.orderid);
|
if (wmsTask != null)
|
{
|
//输送线需要安全交互
|
TaskProcess.Interaction(wmsTask, 4, model.station_name);
|
res.code = 0;
|
res.msg = "取货已经退出";
|
return res;
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "没找到任务";
|
return res;
|
}
|
case "5":
|
//卸货请求进入
|
wmsTask = TaskHelper.GetTaskByKwName(model.station_name, false, model.orderid);
|
if (wmsTask != null)
|
{
|
if (TaskProcess.Interaction(wmsTask, 5, model.station_name))
|
{
|
res.code = 0;
|
res.msg = "输送线允许进入";
|
return res;
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "输送线不允许进入";
|
return res;
|
}
|
}
|
else
|
{
|
res.code = 1;
|
res.msg = "没找到任务";
|
return res;
|
}
|
case "8":
|
//var db = new SqlHelper<object>().GetInstance();
|
////卸货离开动作
|
//if (model.station_name.Contains("SM"))
|
//{
|
// var task = TaskHelper.GetTaskByKwName1(model.orderid);
|
// if (task == null)
|
// {
|
// res.code = 1;
|
// res.msg = "没找到任务";
|
// return res;
|
// }
|
// else {
|
// LogHelper.Info("卸货离开动作", "任务");
|
// res.code = 0;
|
// res.msg = "卸货已经退出";
|
// return res;
|
// }
|
//}
|
|
|
|
LogHelper.Info("卸货离开动作", "任务");
|
res.code = 0;
|
res.msg = "卸货已经退出";
|
return res;
|
default:
|
break;
|
}
|
}
|
catch (Exception e)
|
{
|
LogHelper.Info("安全交互异常信息" + e.Message, "任务");
|
}
|
|
}
|
res.code = 0;
|
res.msg = "允许进入";
|
return res;
|
|
}
|
|
|
|
|
internal static void inPri(WMSTask mst)
|
{
|
LogHelper.Info($"任务{mst.S_CODE}进入inpri", "入库优先级");
|
var inprilist = TaskHelper.GetInPri();
|
var db = new SqlHelper<object>().GetInstance();
|
|
foreach (var item in inprilist)
|
{
|
|
LogHelper.Info("入库优先级记录信息"+JsonConvert.SerializeObject(item), "入库优先级");
|
|
if (item.Type=="0" && mst.S_TYPE.Contains("空托出"))
|
{
|
if (mst.S_END_LOC.Contains(item.OutEndLoc))
|
{
|
|
var task = db.Queryable<WMSTask>().Where(a => a.S_B_STATE.Trim() == "已推送" && a.S_SCHEDULE_TYPE.Contains("agv") && !a.S_TYPE.Contains("空托") && (a.S_TYPE.Contains("入库")|| a.S_TYPE.Contains("回库")) && a.S_START_LOC.Contains(item.InStartLoc)).First();
|
|
LogHelper.Info($"查找起点{item.InStartLoc}满托入库任务信息：" + JsonConvert.SerializeObject(task), "入库优先级");
|
if (task != null)
|
{
|
NDCApi.ChangeOrderPri(task.S_CODE, item.Pri);
|
}
|
|
}
|
}
|
|
|
if (item.Type == "1" && !mst.S_TYPE.Contains("空托") && mst.S_TYPE.Contains("出库"))
|
{
|
if (mst.S_END_LOC.Contains(item.OutEndLoc))
|
{
|
var task = db.Queryable<WMSTask>().Where(a => a.S_B_STATE.Trim() == "已推送" && a.S_SCHEDULE_TYPE.Contains("agv") && a.S_TYPE.Contains("空托入库") && a.S_START_LOC.Contains(item.InStartLoc)).First();
|
LogHelper.Info($"查找起点{item.InStartLoc}空托入库任务信息：" + JsonConvert.SerializeObject(task), "入库优先级");
|
if (task != null)
|
{
|
NDCApi.ChangeOrderPri(task.S_CODE, item.Pri);
|
}
|
}
|
}
|
|
}
|
LogHelper.Info($"任务{mst.S_CODE}，结束inpri", "入库优先级");
|
}
|
|
|
|
////如果需要下发wcs立库，则需要寻找可用接驳位
|
//if (workFlow.SENDWCS == "Y")
|
//{
|
|
// //正式代码，调用接口寻找可用接驳位
|
// var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
|
// var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
|
// if (usableConnectionList != null && usableConnectionList.code == "0")
|
// {
|
// //根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
|
// var balanceConnectionList = LocationHelper.GetBalanceConnectionList(usableConnectionList.available);
|
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找均衡接驳位" + JsonConvert.SerializeObject(balanceConnectionList), "Mes任务下发");
|
// foreach (var item in balanceConnectionList)
|
// {
|
// if (item.loc.N_CURRENT_NUM < 2)
|
// {
|
// connection = item.loc.S_CODE;
|
// connectionArea = item.loc.S_AREA_Name;
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
|
// break;
|
// }
|
// }
|
// }
|
// else
|
// {
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
|
// throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
|
// }
|
|
// if (connection == "")
|
// {
|
// LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
|
// throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
|
// }
|
//}
|
//if (workFlow.FLOWCODE == "1")
|
//{
|
// //满托入
|
// end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
//}
|
//else if (workFlow.FLOWCODE == "3")
|
//{
|
// if (TOOLSTYPE == "35" || TOOLSTYPE == "75")
|
// {
|
// //空托入 优先入缓存区，没有入立库区
|
// //var ktHcq = Settings.EmptyPalletBufferArea;
|
// cntrCount = 0;
|
// //var endList1 = LocationHelper.GetAllLocList1(ktHcq);
|
// //end = LocationHelper.FindEndcolByLoc(endList1, ktHcq);
|
// //LogHelper.Info($"ZCSendTask入库任务寻找空托缓存区终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
// //if (end == null)
|
// //{
|
// LogHelper.Info($"ZCSendTask入库任务没找到空托缓存区终点,寻找立库区空货位", "Mes任务下发");
|
// end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
// //}
|
// //else
|
// //{
|
// // connection = "";
|
// //}
|
// }
|
// else
|
// {
|
// end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
// }
|
//}
|
//else if (workFlow.FLOWCODE == "2")
|
//{
|
|
// //85纤维 95钢丝一段任务入三层货架
|
// if (TOOLSTYPE == "85" || TOOLSTYPE == "95")
|
// {
|
// end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
// LogHelper.Info($"ZCSendTask入库任务85纤维 95钢丝一段任务入三层货架终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
|
// }
|
// else
|
// {
|
// end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
|
// }
|
//}
|
//else if (workFlow.FLOWCODE == "12")
|
//{
|
// //空架子入
|
// end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
// cntrCount = 0;
|
// //生成空架子虚拟号
|
// cntrCode = ContainerHelper.GenerateCntrNo();
|
//}
|
//else if (workFlow.FLOWCODE == "0")
|
//{
|
// //钢丝入库
|
// end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
|
//}
|
|
|
public class signalInfo
|
{
|
public string info { get; set; }
|
public DateTime modify { get; set; }
|
}
|
|
|
#endregion
|
}
|
}
|
