using HH.WCS.JiaTong.device;
|
using HH.WCS.JiaTong.dispatch;
|
using HH.WCS.JiaTong.LISTA.models;
|
using HH.WCS.JiaTong.process;
|
using HH.WCS.JiaTong.util;
|
using HH.WCS.JiaTong.wms;
|
using Newtonsoft.Json;
|
using NLog.Fluent;
|
using S7.Net;
|
using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection.Emit;
|
using System.Runtime.CompilerServices;
|
using System.ServiceModel;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using System.Web.UI.WebControls;
|
using static HH.WCS.JiaTong.api.ApiModel;
|
using static HH.WCS.JiaTong.api.OtherModel;
|
using static HH.WCS.JiaTong.LISTA.process.HttpModel;
|
|
namespace HH.WCS.JiaTong.api
|
{
|
/// <summary>
|
/// api接口辅助类
|
/// </summary>
|
public class ApiHelper
|
{
|
static ApiHelper()
|
{
|
|
}
|
|
|
#region 佳通合肥接口业务
|
|
|
public static object _lockCreateTask = new object();
|
public static object _lockCreateItem = new object();
|
/// <summary>
|
/// 立库任务下发=》创建任务
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result Createtask(CreateTask model)
|
{
|
Result result = new Result() { code = "0", msg = "创建成功" };
|
if (model == null)
|
{
|
LogHelper.Info($"Createtask==> 参数为null");
|
result.code = "1";
|
result.msg = "参数为null值，请检查参数格式";
|
AddErrorInfo("下发参数为null", result.msg);
|
return result;
|
}
|
partData partData = model.partData;
|
taskData taskData = model.taskData;
|
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
string CntrCode = "";//托盘编码
|
string ItemCode = "";//物料编码
|
if (partData != null)
|
{
|
CntrCode = partData.rfid;//托盘编码
|
ItemCode = partData.partNumber;//物料编码
|
}
|
string Start = ""; //取货点
|
string End = "";
|
string note = ""; //立库下发任务需要通知mes接口物料到位，用备注自动进行区分
|
//根据物料获取对应库区
|
#region 根据任务来源字段判断库区来源来源
|
//var iteminfo = db.Queryable<TN_Material>().Where(a => a.S_ITEM_CODE.Trim() == ItemCode).First();
|
//if (iteminfo != null)
|
//{
|
// //LogHelper.Info($"Createtask==>物料数据:{JsonConvert.SerializeObject(iteminfo)}");
|
// areacode = iteminfo.S_WH_CODE;
|
//}
|
|
//if (string.IsNullOrEmpty(areacode))
|
//{
|
// LogHelper.Info($"Createtask==>根据物料编码:{ItemCode}未能找到物料来源，需同步物料数据");
|
// result.code = "1";
|
// result.msg = $"根据物料编码:{ItemCode}未能找到物料来源，需同步物料数据";
|
// AddErrorInfo("寻找出库区失败", result.msg);
|
// return result;
|
//}
|
|
int n_type = 0; //任务来源 1.密炼立库 3.预备库 ,4.原材料库
|
string Source = "";
|
switch (taskData.source)
|
{
|
case "ML":
|
n_type = 1;
|
Source = "密炼";
|
break;
|
case "YBK":
|
n_type = 3;
|
Source = "预备库";
|
break;
|
case "YCL":
|
n_type = 4;
|
Source = "原材料";
|
break;
|
}
|
Console.WriteLine($"Createtask==>任务来源:{n_type}");
|
if (n_type == 0)
|
{
|
result.code = "1";
|
result.msg = $"任务来源:{taskData.source}属于未定义库区，请检查物料来源是否属于约定字段";
|
AddErrorInfo("任务来源未定义", result.msg);
|
return result;
|
}
|
|
|
#endregion
|
|
Location endloc = new Location();
|
Location startloc = new Location();
|
lock (_lockCreateTask)
|
{
|
if (taskData.taskType == 1) //出库流程，通过物料机台计算线边货位
|
{
|
note = "出库";
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
//创建托盘物料绑定信息，并计算终点货位
|
Start = taskData.pickStation;
|
if (CreateCntrIteminfo(partData, taskData))
|
{
|
endloc = Computeloc(CntrCode, taskData.dropStation, taskData.carrierType);
|
if (endloc != null)
|
{
|
End = endloc.S_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"机台编码:{taskData.dropStation}，未找到可用货位";
|
AddErrorInfo("寻找出库货位失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建托盘物料信息失败";
|
AddErrorInfo("创建托盘失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"Putin==> 任务起点:{taskData.pickStation}找不到对应货位，请检查货位表";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (taskData.taskType == 2)//入库流程，直接使用起点货位和终点货位生成任务，起点需要有托盘
|
{
|
note = "入库";
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = startloc.S_CODE;
|
var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).OrderBy(a => a.T_CREATE).FirstOrDefault();
|
if (CntrRel != null)
|
{
|
if (CntrRel.S_CNTR_CODE != partData.rfid)
|
{
|
result.code = "1";
|
result.msg = $"根据起点：{Start}获取托盘:{CntrRel.S_CNTR_CODE}与下发托盘：{partData.rfid}不一致，请检查托盘码是否正确";
|
AddErrorInfo("托盘码校检失败", result.msg, Source);
|
return result;
|
}
|
else
|
{
|
CntrCode = CntrRel.S_CNTR_CODE;
|
}
|
|
}
|
//else
|
//{
|
// result.code = "1";
|
// result.msg = $"根据起点{Start},未找到托盘货位绑定关系";
|
// AddErrorInfo("托盘查找失败", result.msg, Source);
|
// return result;
|
//}
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (taskData.taskType == 3)//移库流程，直接使用起点货位和终点货位生成任务，
|
{
|
note = "出库";
|
//创建托盘物料绑定信息，并计算终点货位
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = taskData.pickStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点{taskData.dropStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (taskData.taskType == 4)//原材料库需要判断是否需要分配电梯任务,创建分档任务
|
{
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = taskData.pickStation;
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
|
//判断楼层是否相等，如果不相同需要生成分段任务进行电梯调用
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE).First();
|
var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE).First();
|
if (startArea == null || endArea == null)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点：{endloc.S_AREA_CODE}未找到对应库区";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
if (startArea.N_FLOOR == endArea.N_FLOOR)
|
{
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
|
S_EQ_NO = taskData.taskNum,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
N_CNTR_COUNT = 1,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_PRIORITY = taskData.priority,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
S_WMS_NO = taskData.wmsTaskNo,
|
Z_TYPE = n_type,
|
|
|
};
|
LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
// LocationHelper.LockLoc(End, 2);
|
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (startArea.N_FLOOR != endArea.N_FLOOR)
|
{
|
//楼层电梯分配
|
var elevatorLoc = LocationHelper.GetElevatorLoc();
|
|
if (elevatorLoc != null)
|
{ //创建wcs分段任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "电梯1",
|
S_EQ_NO = taskData.taskNum,
|
S_START_LOC = Start,
|
S_END_LOC = elevatorLoc.S_CODE,
|
N_CNTR_COUNT = 1,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = elevatorLoc.S_WH_CODE,
|
S_END_AREA = elevatorLoc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_PRIORITY = taskData.priority,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
S_WMS_NO = taskData.wmsTaskNo,
|
Z_TYPE = n_type,
|
S_MES_NO = taskData.mesTaskNo
|
};
|
var wcsTask1 = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "电梯2",
|
S_EQ_NO = taskData.taskNum,
|
S_START_LOC = elevatorLoc.S_CODE,
|
S_END_LOC = End,
|
N_CNTR_COUNT = 1,
|
S_START_WH = elevatorLoc.S_WH_CODE,
|
S_START_AREA = elevatorLoc.S_AREA_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_PRIORITY = taskData.priority,
|
S_WMS_NO = taskData.wmsTaskNo,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
Z_TYPE = n_type,
|
S_MES_NO = taskData.mesTaskNo
|
|
};
|
LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
|
if (WCSHelper.CreateTask(wcsTask) && WCSHelper.CreateTask(wcsTask1))
|
{
|
|
// LocationHelper.LockLoc(Start, 1);
|
//LocationHelper.LockLoc(End, 2);
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
|
|
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
}
|
else if (taskData.taskType == 5)//移库流程，直接使用起点货位和终点货位生成任务，并绑定托盘
|
{
|
note = "出库";
|
//创建托盘物料绑定信息，并计算终点货位
|
if (CreateCntrIteminfo(partData, taskData))
|
{
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = taskData.pickStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点{taskData.dropStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建托盘物料信息失败";
|
AddErrorInfo("创建托盘失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
//暂存位回库
|
else if (taskData.taskType == 6)//入库流程，直接使用起点货位和终点货位生成任务
|
{
|
note = "入库";
|
//根据托盘号找货位
|
var CntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == partData.rfid).First();
|
if (CntrRel != null)
|
{
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == CntrRel.S_LOC_CODE).First();
|
if (startloc != null)
|
{
|
Start = startloc.S_CODE;
|
CntrCode = CntrRel.S_CNTR_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据托盘{partData.rfid},未找到托盘货位绑定关系";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
//点对库区
|
else if (taskData.taskType == 7)//异常位
|
{
|
note = "异常库区入库";
|
//创建托盘物料绑定信息，并计算终点货位
|
if (CreateCntrIteminfo(partData, taskData))
|
{
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = taskData.pickStation;
|
}
|
var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == taskData.dropStation).ToList();
|
if (EndLocs.Count > 0)
|
{
|
endloc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
|
if (endloc != null)
|
{
|
End = endloc.S_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"终点库区：{taskData.dropStation}无可用货位";
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点库区：{taskData.dropStation},未找到对应货位";
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建托盘物料信息失败";
|
AddErrorInfo("创建托盘失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (taskData.taskType == 8)//叠盘机空托回库
|
{
|
note = "空托回库";//井松空托回库，需要与叠盘机安全交互
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
|
if (startloc != null)
|
{
|
Start = startloc.S_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点:{taskData.pickStation},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
|
if (endloc != null)
|
{
|
End = taskData.dropStation;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点:{End},找不到对应货位，请检查货位表";
|
AddErrorInfo("货位查找失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
LogHelper.Info($"Createtask==> 任务类型有误");
|
result.code = "1";
|
result.msg = "任务类型：{taskData.taskType}不在规定范围内";
|
AddErrorInfo("任务类型错误", result.msg, Source);
|
}
|
if (taskData.taskType != 4)
|
{
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg);
|
return result;
|
}
|
var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE.Trim()).First();
|
var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE.Trim()).First();
|
if (startArea == null || endArea == null)
|
{
|
LogHelper.Info($"起点：{JsonConvert.SerializeObject(startArea)}");
|
LogHelper.Info($"终点：{JsonConvert.SerializeObject(endArea)}");
|
result.code = "1";
|
result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点{endloc.S_AREA_CODE}未找到对应库区";
|
AddErrorInfo("库区查找失败", result.msg);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
|
S_EQ_NO = taskData.taskNum,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
N_CNTR_COUNT = 1,
|
S_START_WH = startloc.S_WH_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_PRIORITY = taskData.priority,
|
Z_TYPE = n_type,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
S_WMS_NO = taskData.wmsTaskNo,
|
S_NOTE = note,
|
S_MES_NO = taskData.mesTaskNo
|
|
};
|
LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
// LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
}
|
}
|
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("Createtask Error：" + ex.ToString() + "行号:" + ex.StackTrace, ex);
|
return result;
|
}
|
|
|
}
|
|
/// <summary>
|
/// 预备库任务状态下发
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result MstStateInquire(MstStateInquire model)
|
{
|
Result result = new Result() { code = "200", msg = "状态下发成功" };
|
var db = new SqlHelper<object>().GetInstance();
|
if (model == null)
|
{
|
LogHelper.Info($"MstStateInquire==> 参数为null");
|
result.code = "1";
|
result.msg = "参数为null值，请检查参数格式";
|
AddErrorInfo("参数为空", result.msg);
|
return result;
|
}
|
try
|
{
|
//找到任务，修改任务状态
|
var task = db.Queryable<WCSTask>().Where(a => a.S_EQ_NO.Trim() == model.taskNum).First();
|
if (task != null)
|
{
|
task.S_NOTE = model.taskStatus;
|
db.Updateable<Container>(task).ExecuteCommand();
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据下发任务号{model.taskNum}未找到对应任务";
|
AddErrorInfo("未找到任务", result.msg);
|
return result;
|
}
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("TrayItembind Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 原材料库安全交互通知行走
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result AllowThrough(AllowThrough model)
|
{
|
Result result = new Result() { code = "0", msg = "状态下发成功" };
|
if (model == null)
|
{
|
LogHelper.Info($"AllowThrough==> 参数为null");
|
result.code = "1";
|
result.msg = "参数为null值，请检查参数格式";
|
AddErrorInfo("参数为空", result.msg, "", model.task_no);
|
return result;
|
}
|
|
var db = new SqlHelper<object>().GetInstance();
|
try
|
{
|
string[] state = new string[] { "取消", "失败", "错误", "完成" };
|
if (model.type == "1")
|
{
|
//找到任务
|
var task = db.Queryable<WCSTask>().Where(a => a.S_START_LOC.Trim() == model.loc && !state.Contains(a.S_B_STATE)).ToList();
|
if (task.Count > 0)
|
{
|
foreach (var item in task)
|
{
|
var taskAction = db.Queryable<TaskAction>().Where(a => a.S_TASK_CODE == item.S_CODE).OrderByDescending(a => a.T_CREATE).First();
|
if (taskAction.N_ACTION_CODE == 1101)
|
{
|
NDCApi.ChangeOrderParam(item.S_CODE.Trim(), 6, "1");
|
return result;
|
}
|
result.code = "1";
|
result.msg = $"根据下发货位{model.loc}未找到对应申请取货状态任务";
|
AddErrorInfo("未找到任务", result.msg, "", model.task_no);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据下发货位{model.loc}未找到对应任务";
|
AddErrorInfo("未找到任务", result.msg, "", model.task_no);
|
return result;
|
}
|
}
|
else if (model.type == "2")
|
{
|
//找到任务
|
var task = db.Queryable<WCSTask>().Where(a => a.S_END_LOC.Trim() == model.loc && !state.Contains(a.S_B_STATE)).ToList();
|
if (task.Count > 0)
|
{
|
foreach (var item in task)
|
{
|
var taskAction = db.Queryable<TaskAction>().Where(a => a.S_TASK_CODE == item.S_CODE).OrderByDescending(a => a.T_CREATE).First();
|
if (taskAction.N_ACTION_CODE == 1103)
|
{
|
NDCApi.ChangeOrderParam(item.S_CODE.Trim(), 6, "1");
|
return result;
|
}
|
}
|
result.code = "1";
|
result.msg = $"根据下发货位{model.loc}未找到对应申请卸货状态任务";
|
AddErrorInfo("未找到任务", result.msg, "", model.task_no);
|
return result;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据下发货位{model.loc}未找到对应任务";
|
AddErrorInfo("未找到任务", result.msg, "", model.task_no);
|
return result;
|
}
|
}
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("AllowThrough Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 产出信息
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result TrayItembind(TrayItembind model)
|
{
|
|
Result result = new Result() { code = "200", msg = "产出信息下发成功" };
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg);
|
return result;
|
}
|
lock (_lockCreateItem)
|
{
|
try
|
{
|
|
//创建托盘数据绑定关系
|
if (ContainerHelper.CreateCntrItem(model.Rfid, model.PartNumber, model.PartDesc, model.LotNumber, model.Weight, model.Qty, model.ProductionTime, model.MaturityTime))
|
{
|
//创建成功流程
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "产出信息下发失败，托盘物料绑定关系创建失败";
|
AddErrorInfo("创建绑定关系失败", result.msg, "Mes");
|
return result;
|
}
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("TrayItembind Error：" + ex.ToString(), ex);
|
return result;
|
}
|
}
|
|
|
|
}
|
|
/// <summary>
|
/// 入平库
|
/// </summary>
|
/// <param name="model"></param>
|
/// <param name="n_type">0:pda下发任务，5:mes下发任务</param>
|
/// <returns></returns>
|
internal static Result Putin(Putin model, int n_type)
|
{
|
Result result = new Result() { code = "200", msg = "入平库任务下发成功" };
|
string Source = "Mes";
|
if (n_type == 0)
|
{
|
Source = "PDA";
|
}
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
var db = new SqlHelper<object>().GetInstance();
|
Location loc = new Location();
|
|
string Start = model.InitialLocation; //起点货位
|
string itemcode = model.PartNumber; //物料编码
|
string areacode = "";
|
try
|
{
|
|
#region 入库检查托盘物料表有无数据
|
var cntritem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
if (cntritem == null)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，托盘:{model.Rfid}无绑定物料数据";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("托盘绑定物料数据为空", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 判断托盘绑定货位是否和下发绑定起点相同,如果没绑定托盘则绑定托盘
|
var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
if (CntrLoc != null)
|
{
|
if (CntrLoc.S_LOC_CODE != Start)
|
{
|
|
result.code = "1";
|
result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("托盘绑定位置不同", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
LocationHelper.BindingLoc(Start, new List<string> { model.Rfid });
|
//LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
|
//result.code = "1";
|
//result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
|
//AddErrorInfo("查找托盘货位失败", result.msg);
|
//return result;
|
}
|
// Console.WriteLine("查询货位绑定关系");
|
//判断托盘与货位是否有绑定关系，如果没有则进行绑定
|
// var cntrloc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
// Console.WriteLine($"获取绑定关系:{JsonConvert.SerializeObject(cntrloc)}");
|
//if (cntrloc == null)
|
//{
|
// // Console.WriteLine("绑定托盘");
|
// List<string> cntrs = new List<string>() { model.Rfid };
|
|
// LocationHelper.BindingLoc(Start, cntrs);
|
//}
|
//else
|
//{
|
|
// if (cntrloc.S_LOC_CODE != Start)
|
// {
|
|
// LogHelper.Info($"Putin==>托盘:{model.Rfid}已和货位{cntrloc.S_LOC_CODE}有绑定关系");
|
// result.code = "1";
|
// result.msg = $"托盘:{model.Rfid}已和货位{cntrloc.S_LOC_CODE}有绑定关系";
|
// }
|
|
//}
|
#endregion
|
|
#region 根据起点货位的仓库编码 获取平库编码,并计算入库货位
|
string End = "";
|
var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
|
if (startloc != null)
|
{
|
//根据仓库 计算库区
|
var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
|
if (whcode != null)
|
{
|
areacode = whcode.PMK;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
|
loc = StorageCompute(itemcode, areacode);
|
|
if (loc != null)
|
{
|
End = loc.S_CODE;
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"库区:{areacode}无可用货位";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"任务起点:{Start}找不到对应货位，请检查货位表";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 创建任务
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点:{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg, Source);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "入平库",
|
S_EQ_NO = model.TaskNumber,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = loc.S_WH_CODE,
|
S_END_AREA = loc.S_AREA_CODE,
|
N_CNTR_COUNT = 1,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = model.Rfid,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
Z_TYPE = n_type
|
};
|
LogHelper.Info("创建入平库任务：" + JsonConvert.SerializeObject(wcsTask));
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
//LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
#endregion
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("Putin Error：" + ex.ToString(), ex);
|
return result;
|
}
|
}
|
|
/// <summary>
|
/// 出平库
|
/// </summary>
|
/// <param name="model"></param>
|
/// <param name="n_type">0:pda下发任务，5:mes下发任务</param>
|
/// <returns></returns>
|
internal static Result PutOut(PutOut model, int n_type)
|
{
|
Result result = new Result() { code = "200", msg = "出平库任务下发成功" };
|
string Source = "Mes";
|
if (n_type == 0)
|
{
|
Source = "PDA";
|
}
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
|
#region 变量
|
string Start = "";
|
string End = "";
|
string CntrCode = "";
|
|
string itemcode = model.PartNumber;
|
string cntrType = "";
|
string areacode = "";
|
var db = new SqlHelper<object>().GetInstance();
|
#endregion
|
try
|
{
|
|
#region 根据物料编码规则 计算出库库区
|
//粉料从平库出库，其他物料需要从暂存区出库
|
var locJt = db.Queryable<Location>().Where(a => a.S_AREA_CODE == model.WorkCenter).First();
|
if (locJt == null)
|
{
|
result.code = "1";
|
result.msg = $"根据机台编码：{model.WorkCenter}未找到对应货位";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
//根据仓库 计算库区
|
var whcode = Settings.wareLoc.Where(a => a.AreaCode == locJt.S_WH_CODE).FirstOrDefault();
|
if (whcode != null)
|
{
|
if (model.PartNumber.StartsWith("4X"))
|
{
|
areacode = whcode.PMK;
|
cntrType = "PM";
|
}
|
else
|
{
|
if (model.PartNumber.StartsWith("3"))
|
{
|
cntrType = "RC";
|
areacode = whcode.ZCW;
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("物料编码格式错误", result.msg, Source);
|
return result;
|
}
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点库区仓库编码：{locJt.S_WH_CODE}未找到对应配置文件";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 根据物料编码计算出库货位，送往线边位置
|
var Endloc = new Location();
|
//根据物料编码计算出库货位
|
var loc = airlift(areacode, itemcode, model.PartLevel);
|
if (loc != null)
|
{
|
Start = loc.S_CODE;
|
//根据出库货位找到绑定托盘，获取入机台货位
|
var CntrRel = LocationHelper.GetLocCntrRel(loc.S_CODE).FirstOrDefault();
|
CntrCode = CntrRel.S_CNTR_CODE;
|
Endloc = Computeloc(CntrCode, model.WorkCenter, cntrType);
|
if (Endloc != null)
|
{
|
End = Endloc.S_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"Computeloc==》根据机台编码：{model.WorkCenter},工装类型：{cntrType} 未找到空货位数据，请检查货位表";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"任务物料:{itemcode}找不到对应库存";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 任务创建
|
if (string.IsNullOrEmpty(Start))
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点";
|
return result;
|
}
|
if (string.IsNullOrEmpty(End))
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的卸货点";
|
return result;
|
}
|
if (loc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg, Source);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "出平库",
|
S_EQ_NO = model.TaskNumber,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
S_START_WH = loc.S_WH_CODE,
|
S_START_AREA = loc.S_AREA_CODE,
|
S_END_WH = Endloc.S_WH_CODE,
|
S_END_AREA = Endloc.S_AREA_CODE,
|
N_CNTR_COUNT = 1,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
Z_TYPE = n_type
|
|
};
|
LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
LogHelper.Info("创建任务成功");
|
//LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
|
#endregion
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("PutOut Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
public static object _lockEmpty = new object();
|
/// <summary>
|
/// 空工装回库
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result Empty(Empty model)
|
{
|
Result result = new Result() { code = "200", msg = "空工装回库任务下发成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
|
#region 变量
|
var db = new SqlHelper<object>().GetInstance();
|
string Start = model.InitialLocation;
|
string itemcode = "";
|
int endlayer = 1;
|
Location loc = new Location();
|
string areacode = "";
|
WCSTask mst = new WCSTask();
|
List<WCSTask> msts = new List<WCSTask>();
|
#endregion
|
|
try
|
{
|
lock (_lockEmpty)
|
{
|
#region 判断托盘绑定货位是否和下发绑定起点相同
|
//var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
//if (CntrLoc != null)
|
//{
|
// if (CntrLoc.S_LOC_CODE != Start)
|
// {
|
// LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}");
|
// result.code = "1";
|
// result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
|
// AddErrorInfo("托盘绑定位置不同", result.msg);
|
// return result;
|
// }
|
//}
|
//else
|
//{
|
// LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
|
// result.code = "1";
|
// result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
|
// AddErrorInfo("查找托盘货位失败", result.msg);
|
// return result;
|
//}
|
#endregion
|
|
#region 根据货位楼层判断，3楼去往叠盘位 其他的回库
|
var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
|
if (startloc != null)
|
{
|
if (startloc.N_LAYER == 3)
|
{
|
//叠盘货位计算叠盘货位
|
var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE && a.C_ENABLE == "Y").ToList();
|
if (dploc.Count > 0)
|
{
|
// LogHelper.Info($"获取叠盘货位:{JsonConvert.SerializeObject(dploc)}");
|
loc = dploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
|
if (loc == null)
|
{
|
LogHelper.Info($"三楼货位叠盘位，都已经有锁或者已经叠满，请检查货位状态");
|
result.code = "1";
|
result.msg = $"叠盘货位不可用，终点库区没有可用货位，请检查锁状态和数量";
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
else
|
{
|
endlayer = loc.N_CURRENT_NUM + 1;
|
}
|
}
|
else
|
{
|
// LogHelper.Info($"根据货位楼层：{startloc.N_LAYER}，仓库编码：{startloc.S_WH_CODE}，货位备注：叠盘，未找到叠盘货位");
|
result.code = "1";
|
result.msg = $"叠盘货位不可用，未找到可叠盘货位";
|
LogHelper.Info($"根据货位备注：叠盘，货位楼层:{startloc.N_LAYER},货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
}
|
else if (startloc.S_NOTE == "PB")
|
{
|
//找块胶堆叠区
|
var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE && a.C_ENABLE == "Y").ToList();
|
if (KjDploc.Count > 0)
|
{
|
loc = KjDploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
|
if (loc == null)
|
{
|
LogHelper.Info($"片胶堆叠位，都已经有锁或者已经叠满，请检查货位状态");
|
result.code = "1";
|
result.msg = $"叠盘货位不可用，终点库区没有可用货位，请检查锁状态和数量";
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
else
|
{
|
endlayer = loc.N_CURRENT_NUM + 1;
|
}
|
}
|
else
|
{
|
LogHelper.Info($"根据货位备注：片胶堆叠位,货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
|
result.code = "1";
|
result.msg = $"叠盘货位不可用";
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
#region 根据起点货位类型，获得回库库区
|
//根据仓库 计算库区
|
var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
|
if (whcode != null)
|
{
|
if (string.IsNullOrEmpty(startloc.S_NOTE))
|
{
|
areacode = whcode.PMK;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
|
LogHelper.Info($" {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
//回库货位计算库区货位
|
loc = StorageCompute(itemcode, areacode);
|
if (loc == null)
|
{
|
loc = emptyRow(areacode);
|
if (loc == null)
|
{
|
result.code = "1";
|
result.msg = $"库区：{areacode}没有可用货位";
|
LogHelper.Info($" {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
// LogHelper.Info($"库区：{areacode}没有可用货位");
|
}
|
}
|
//else
|
//{
|
|
// result.code = "1";
|
// result.msg = $"库区:{areacode}无可用货位";
|
// LogHelper.Info($"{result.msg}");
|
// AddErrorInfo("查找货位失败", result.msg, Source);
|
// return result;
|
//}
|
}
|
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
|
LogHelper.Info($"{result.msg}");
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 创建任务
|
if (startloc != null && loc != null)
|
{
|
if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点货位状态{startloc.N_LOCK_STATE},起点货位状态：{loc.N_LOCK_STATE}";
|
AddErrorInfo("货位有锁", result.msg);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "空工装回库",
|
S_EQ_NO = model.TaskNumber,
|
S_START_LOC = startloc.S_CODE,
|
S_END_LOC = loc.S_CODE,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = loc.S_WH_CODE,
|
S_END_AREA = loc.S_AREA_CODE,
|
N_CNTR_COUNT = 1,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = model.Rfid,
|
N_START_LAYER = 1,
|
N_END_LAYER = endlayer,
|
Z_TYPE = 5
|
};
|
LogHelper.Info("创建空托回库任务：" + JsonConvert.SerializeObject(wcsTask));
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
//LocationHelper.LockLoc(startloc.S_CODE, 2);
|
//LocationHelper.LockLoc(loc.S_CODE, 1);
|
// 空托回库判断托盘有无绑定物料信息 如果有则删除
|
var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).ExecuteCommand(); }
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
#endregion
|
}
|
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("空托回库 Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
return result;
|
}
|
|
public static object _lockcallfixture = new object();
|
|
/// <summary>
|
/// 空工装呼叫
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result callfixture(callfixture model)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
Result result = new Result() { code = "200", msg = "空工装呼叫任务下发成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
|
#region 变量
|
string Start = "";
|
string End = model.TargetLocation;
|
|
string areacode = "";
|
string cntrcode = "";
|
Location startloc = new Location();
|
// startloc = LocationHelper.GetLocByAreacode(areacode, model.CarrierType);
|
#endregion
|
|
try
|
{
|
lock (_lockcallfixture)
|
{
|
#region 根据仓库编码判断库区 并计算出库货位
|
var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
|
//根据仓库 计算库区
|
if (endloc != null)
|
{
|
var whcode = Settings.wareLoc.Where(a => a.AreaCode == endloc.S_WH_CODE).FirstOrDefault();
|
if (whcode != null)
|
{
|
areacode = whcode.PMK;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据起点仓库编码：{endloc.S_WH_CODE}未找到对应配置文件";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
|
//计算出库托盘
|
startloc = LocationHelper.GetLocByAreacode(areacode, model.CarrierType);
|
if (startloc != null)
|
{
|
var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
|
if (cntr != null)
|
{
|
Start = cntr.S_LOC_CODE;
|
cntrcode = cntr.S_CNTR_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"创建空工装呼叫任务==>根据货位{endloc.S_CODE}未找到托盘货位绑定关系";
|
LogHelper.Info($"callfixture:{result.msg}");
|
AddErrorInfo("查找托盘失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"创建空工装呼叫任务==>根据库区：{areacode}，托盘类型：{model.CarrierType}找不到对应空托";
|
LogHelper.Info($"callfixture:{result.msg}");
|
AddErrorInfo("查找托盘失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"任务起点:{End}找不到对应货位，请检查货位表";
|
LogHelper.Info($"callfixture:{result.msg}");
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
#endregion
|
|
#region 创建任务
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "空工装呼叫",
|
S_EQ_NO = model.TaskNumber,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_CNTR_COUNT = 1,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = cntrcode,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
Z_TYPE = 5,
|
S_NOTE = "粉料"
|
};
|
LogHelper.Info("创建呼叫空托任务：" + JsonConvert.SerializeObject(wcsTask));
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
//LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
return result;
|
#endregion
|
}
|
|
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("callfixture Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
|
}
|
|
public static object _lockItemBack = new object();
|
/// <summary>
|
/// 余料返回
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result ItemBack(ItemBack model)
|
{
|
Result result = new Result() { code = "200", msg = "余料返回任务下发成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
|
}
|
|
#region 变量
|
var db = new SqlHelper<object>().GetInstance();
|
string Start = model.InitialLocation;
|
string End = "";
|
string itemcode = model.PartNumber;
|
Location loc = new Location();
|
string areacode = "";
|
WCSTask mst = new WCSTask();
|
List<WCSTask> msts = new List<WCSTask>();
|
#endregion
|
|
try
|
{
|
lock (_lockItemBack)
|
{
|
#region 余料返回根据托盘找出库任务
|
//余料返回根据托盘找出库任务
|
//msts = WCSHelper.GetTaskBycntrcode(model.Rfid);
|
//if (msts.Count() > 0)
|
//{
|
// msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
|
// mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
|
//}
|
//if (mst != null)
|
//{
|
// areacode = mst.S_START_AREA;
|
//}
|
//else
|
//{
|
// result.code = "1";
|
// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
|
// AddErrorInfo("查找任务失败", result.msg);
|
// return result;
|
//}
|
//if (string.IsNullOrEmpty(areacode))
|
//{
|
// LogHelper.Info($"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空");
|
// result.code = "1";
|
// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
|
// AddErrorInfo("查找库区失败", result.msg);
|
// return result;
|
//}
|
#endregion
|
|
#region 判断托盘绑定货位是否和下发绑定起点相同
|
var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
if (CntrLoc != null)
|
{
|
if (CntrLoc.S_LOC_CODE != Start)
|
{
|
|
result.code = "1";
|
result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("托盘绑定位置不同", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
if (db.Insertable(new LocCntrRel() { S_CNTR_CODE = model.Rfid, S_LOC_CODE = Start }).ExecuteCommand() <= 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，托盘:{model.Rfid}绑定货位{Start}失败";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("托盘绑定货位失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
#endregion
|
|
#region 根据物料编码 判断回库还是回到对应暂存区
|
var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
|
if (startloc != null)
|
{
|
var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
|
if (whcode != null)
|
{
|
//粉料直接回库，其他物料需要去对应的暂存区
|
#region 根据物料判断回库库区
|
if (model.PartNumber.StartsWith("4X"))
|
{
|
areacode = whcode.PMK;
|
//loc = StorageCompute(itemcode, areacode);
|
//if (loc == null)
|
//{
|
// loc = emptyRow(areacode);
|
//}
|
}
|
else
|
{
|
|
|
if (model.PartNumber.StartsWith("3"))
|
{
|
areacode = whcode.ZCW;
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
|
LogHelper.Info($"ItemBack：{result.msg}");
|
AddErrorInfo("物料编码格式错误", result.msg, Source);
|
return result;
|
}
|
|
|
}
|
#endregion
|
|
|
var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).ToList();
|
//查找货位库区
|
if (EndLocs.Count > 0)
|
{
|
//loc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
|
loc = FindEndcolByLocList(EndLocs);
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据终点库区：{areacode},未找到对应货位";
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
|
if (loc != null)
|
{
|
End = loc.S_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"库区:{areacode}无可用货位";
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
|
LogHelper.Info($"Putin==> {result.msg}");
|
AddErrorInfo("查找库区失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
else
|
{
|
|
result.code = "1";
|
result.msg = $"货位:{Start}找不到对应货位";
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
|
#endregion
|
|
#region 创建任务
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "余料返回",
|
S_EQ_NO = model.TaskNumber,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = loc.S_WH_CODE,
|
S_END_AREA = loc.S_AREA_CODE,
|
N_CNTR_COUNT = 1,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = model.Rfid,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
Z_TYPE = 5
|
|
};
|
LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
//LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
//创建任务成功 更新余料信息
|
var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
|
if (CntrItem != null)
|
{
|
CntrItem.F_WEIGHT = model.LotList[0].Weight.ToString();
|
CntrItem.S_BS_TYPE = "余料";
|
CntrItem.F_QTY = float.Parse(model.LotList[0].qty);
|
CntrItem.S_ITEM_STATE = model.LotList[0].QualityStatus;
|
|
db.Updateable(CntrItem).UpdateColumns(a => new { a.F_WEIGHT, a.S_BS_TYPE }).ExecuteCommand();
|
}
|
else
|
{
|
var cir = new CntrItemDetail
|
{
|
S_CNTR_CODE = model.Rfid,
|
S_ITEM_CODE = itemcode,
|
S_ITEM_NAME = model.PartNumber,
|
S_ITEM_SPEC = model.PartDesc,
|
F_QTY = float.Parse(model.LotList[0].qty),
|
S_BS_TYPE = "余料",
|
F_WEIGHT = model.LotList[0].Weight.ToString(),
|
S_ITEM_STATE = model.LotList[0].QualityStatus,
|
D_EXP_DATE = model.LotList[0].MaturityTime,
|
D_PRD_DATE = model.LotList[0].ProductionTime
|
};
|
db.Insertable<CntrItemDetail>(cir).ExecuteCommand();
|
}
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
#endregion
|
}
|
|
|
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("ItemBack Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 线边库存查询
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result<Iteminquire> itemqtyfind(RequestList<itemqtyfind> model)
|
{
|
|
Result<Iteminquire> result = new Result<Iteminquire>()
|
{
|
code = "200",
|
msg = "线边库存查询成功"
|
|
};
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
|
}
|
List<Iteminquire> iteminquires = new List<Iteminquire>();
|
|
try
|
{
|
model.data.ForEach(a =>
|
{
|
// string purpose = "线边";
|
Iteminquire iteminquire = new Iteminquire() { PartNumber = a.PartNumber, Qty = 0 };
|
//根据物料查询所有线体托盘数量
|
|
//var cntrlist = ContainerHelper.GetItemCntrRel(a.PartNumber);
|
//var loccntrlist = LocationHelper.GetLocListBycntrs(cntrlist.Select(b => b.S_CNTR_CODE).ToList());
|
//var loclist = LocationHelper.GetLocListBytype(loccntrlist.Select(b => b.S_LOC_CODE).ToList(), new string[] { "FLPK" });
|
|
iteminquire.Qty = LocationHelper.GetItemQtyByAre(new string[] { "FLPK" }, a.PartNumber);
|
|
iteminquires.Add(iteminquire);
|
|
});
|
result.data = iteminquires;
|
|
return result;
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = ex.ToString();
|
LogHelper.Error("itemqtyfind Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
|
}
|
|
/// <summary>
|
/// 物料主数据创建
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result add(add model)
|
{
|
Result result = new Result() { code = "200", msg = "物料主数据创建成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
if (db.Queryable<TN_Material>().Where(a => a.S_ITEM_CODE == model.PartNumber).Count() > 0)
|
{
|
result.code = "1";
|
result.msg = $"物料编码:{model.PartNumber}的物料主数据已存在";
|
// AddErrorInfo("物料主数据已存在", result.msg, Source);
|
LogHelper.Info($"add:{result.msg}");
|
return result;
|
}
|
TN_Material itemInfo = new TN_Material();
|
itemInfo.S_ITEM_CODE = model.PartNumber;
|
itemInfo.ITEM_TYPE = model.PartClass;
|
itemInfo.S_ITEM_NAME = model.PartDesc;
|
itemInfo.REMARK1 = model.StewingTime;
|
itemInfo.REMARK2 = model.OverdueTime;
|
itemInfo.S_MP_TYPE = model.Unit;
|
if (db.Insertable<TN_Material>(itemInfo).ExecuteCommand() > 0)
|
{
|
LogHelper.Info($"add:物料编码:{model.PartNumber}的物料主数据已同步");
|
}
|
;
|
return result;
|
}
|
catch (Exception ex)
|
{
|
result.code = "1";
|
result.msg = $"物料主数据创建失败 错误信息：{ex}";
|
LogHelper.Error("add Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
/// <summary>
|
/// 点对点任务创建
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result CreatTask(CreatTask model)
|
{
|
Result result = new Result() { code = "200", msg = "点对点任务创建成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
string Start = ""; //取货点
|
var db = new SqlHelper<object>().GetInstance();
|
// string CntrCode = model.partData.rfid;//托盘编码
|
// string ItemCode = model.partData.partNumber;//物料编码
|
string End = "";
|
string CntrCode = "";
|
Location endloc = new Location();
|
Location startloc = new Location();
|
try
|
{
|
startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == model.InitialLocation).First();
|
if (startloc != null)
|
{
|
Start = model.InitialLocation;
|
var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).FirstOrDefault();
|
if (CntrRel != null)
|
{
|
CntrCode = CntrRel.S_CNTR_CODE;
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，根据起点{model.InitialLocation}未找到对应货位绑定托盘托盘";
|
AddErrorInfo("查找托盘失败", result.msg, Source);
|
return result;
|
}
|
}
|
endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == model.TargetLocation).First();
|
if (endloc != null)
|
{
|
End = model.TargetLocation;
|
}
|
#region 创建任务
|
if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{Start}有锁";
|
AddErrorInfo("货位有锁", result.msg);
|
return result;
|
}
|
//创建wcs任务
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
// S_TYPE = model.taskData.taskType.ToString(),
|
// S_EQ_NO = model.taskData.taskNum,
|
S_START_LOC = Start,
|
S_END_LOC = End,
|
N_CNTR_COUNT = 1,
|
S_START_WH = startloc.S_WH_CODE,
|
S_START_AREA = startloc.S_AREA_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = CntrCode,
|
N_START_LAYER = 1,
|
N_END_LAYER = 1,
|
// N_TYPE = n_type
|
|
|
};
|
LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
//LocationHelper.LockLoc(Start, 2);
|
//LocationHelper.LockLoc(End, 1);
|
LogHelper.Info("创建任务成功");
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
#endregion
|
|
return result;
|
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = $"物料主数据创建失败 错误信息：{ex}";
|
LogHelper.Error("点对点任务 Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 创建电梯搬运任务
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result CreatelevatorTask(ElevatorModel model)
|
{
|
Result result = new Result() { code = "200", msg = "电梯搬运任务创建成功" };
|
string Source = "WMS";
|
if (model.Data == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
|
var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == model.Data.start_loc_code).First();
|
|
var endloc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.Data.end_loc_code && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").First();
|
|
|
//判断楼层是否相等，如果不相同需要生成分段任务进行电梯调用
|
if (startloc != null && endloc != null)
|
{
|
if (startloc.N_LOCK_STATE != 0)
|
{
|
result.code = "1";
|
result.msg = $"创建任务失败，起点{startloc.S_CODE}有锁，电梯有其他任务，请等待电梯任务完成";
|
AddErrorInfo("货位有锁", result.msg, Source);
|
return result;
|
}
|
var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
|
if (cntr == null)
|
{
|
|
result.code = "1";
|
result.msg = $"起点{model.Data.start_loc_code}未查询绑定托盘";
|
LogHelper.Info($"callfixture:创建空工装呼叫任务==>{result.msg}");
|
AddErrorInfo("查找托盘失败", result.msg, Source);
|
return result;
|
}
|
|
// var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE).First();
|
//var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE).First();
|
|
//string dtcode = "DT-01";
|
////楼层电梯分配
|
//var Diantiloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == dtcode).First();
|
//if (Diantiloc == null)
|
//{
|
// result.code = "1";
|
// result.msg = $"创建任务失败，根据货位编码:{dtcode}未找到电梯货位";
|
// AddErrorInfo("查找货位失败", result.msg, Source);
|
// return result;
|
//}
|
|
//根据任务数量判断送往哪个电梯 （具体电梯流程根据现场电梯数量）
|
var elevatorLoc = LocationHelper.GetElevatorLoc();
|
|
var wcsTask = new WCSTask
|
{
|
S_CODE = WCSHelper.GenerateTaskNo(),
|
S_TYPE = "电梯2",
|
S_EQ_NO = model.Data.task_no,
|
S_START_LOC = elevatorLoc.S_CODE,
|
S_END_LOC = endloc.S_CODE,
|
N_CNTR_COUNT = 1,
|
S_START_WH = elevatorLoc.S_WH_CODE,
|
S_START_AREA = elevatorLoc.S_AREA_CODE,
|
S_END_WH = endloc.S_WH_CODE,
|
S_END_AREA = endloc.S_AREA_CODE,
|
N_SCHEDULE_TYPE = 1,
|
S_CNTR_CODE = cntr.S_CNTR_CODE,
|
N_END_LAYER = 1,
|
Z_TYPE = 6
|
};
|
|
|
if (WCSHelper.CreateTask(wcsTask))
|
{
|
LogHelper.Info("创建任务成功");
|
var device = Settings.deviceInfos.Where(a => a.TN_Location == startloc.S_CODE).FirstOrDefault();
|
var loc = LocationHelper.GetLocByLoc(endloc.S_CODE);
|
if (device == null)
|
{
|
LogHelper.Info($"根据任务起点:{startloc.S_CODE},未找到对应电梯配置文件");
|
}
|
if (loc == null)
|
{
|
LogHelper.Info($"根据任务起点:{endloc.S_CODE},未找到对应货位");
|
}
|
if (device != null && loc != null)
|
{
|
int value = 0;
|
if (loc.N_LAYER == 1) value = 1;
|
else if (loc.N_LAYER == 2) value = 3;
|
else if (loc.N_LAYER == 3) value = 5;
|
|
ModbusHelper.WriteSingleRegister(40089, value, device.address, 1024);
|
ModbusHelper.WriteSingleRegister(40102, 1, device.address, 1024);
|
}
|
|
//LocationHelper.LockLoc(startloc.S_CODE, 2);
|
//LocationHelper.LockLoc(endloc.S_CODE, 1);
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"任务创建失败";
|
AddErrorInfo("任务创建失败", result.msg, Source);
|
return result;
|
}
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = "创建任务失败，未找到对应的取货点或卸货点";
|
return result;
|
}
|
return result;
|
|
}
|
catch (Exception ex)
|
{
|
|
result.code = "1";
|
result.msg = $"电梯搬运任务创建失败 错误信息：{ex}";
|
LogHelper.Error("点对点任务 Error：" + ex.ToString(), ex);
|
return result;
|
}
|
|
}
|
|
/// <summary>
|
/// 货位信息上传
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result UploadLoc(List<LocList> model)
|
{
|
|
Result result = new Result() { code = "200", msg = "货位信息上传成功" };
|
String Source = "MES";
|
RequestList<UploadLoc> result1 = new RequestList<UploadLoc>();
|
List<UploadLoc> listuploadloc = new List<UploadLoc>();
|
var db = new SqlHelper<object>().GetInstance();
|
foreach (var item in model)
|
{
|
var loc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == item.Location).First();
|
if (loc != null)
|
{
|
UploadLoc upload = new UploadLoc();
|
//获取时间戳
|
var time = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();
|
result1.RequestId = "杭叉AGV" + time;
|
result1.UseToken = "iFQ5fExGrLYLXliHYWzs";
|
upload.LocationNum = loc.S_CODE;
|
upload.Type = loc.S_TYPE;
|
upload.WorkCenter = loc.S_AREA_CODE;
|
upload.Warehouse = loc.S_AREA_CODE;
|
listuploadloc.Add(upload);
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"货位上传失败，根据货位编码{item.Location}未找到对应的货位信息";
|
AddErrorInfo("查找货位失败", result.msg, Source);
|
return result;
|
}
|
}
|
result1.data = listuploadloc;
|
HttpHelper httpHelper = new HttpHelper();
|
// Result result = new Result();
|
string date = JsonConvert.SerializeObject(result1);
|
var url = Settings.tableUrls.Find(a => a.id == 6);
|
if (url != null)
|
{
|
LogHelper.Info($"任务回报：地址:{url}，内容：{date}");
|
var r = httpHelper.MesWebPost(url.url, date);
|
result = JsonConvert.DeserializeObject<Result>(r);
|
if (result.code == "200")
|
{
|
LogHelper.Info($"物料到位回报成功");
|
}
|
else
|
{
|
LogHelper.Info($"物料到位回报失败=>msg:{result.msg}");
|
result.code = "1";
|
result.msg = result.msg;
|
}
|
|
}
|
else
|
{
|
LogHelper.Info($"物料到位回报失败=>回报地址没有配置");
|
result.code = "1";
|
result.msg = $"物料到位回报失败=>回报地址没有配置";
|
AddErrorInfo("地址错误", result.msg, Source);
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 库位清空
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result ClearLocCntr(ClearTask model)
|
{
|
Result result = new Result() { code = "200", msg = "库位清除成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
string loc = model.LocationNum;
|
var db = new SqlHelper<object>().GetInstance();
|
lock (_lockCreateItem)
|
{
|
try
|
{
|
var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
|
if (location != null)
|
{
|
var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).First();
|
|
if (loccntr != null)
|
{
|
string cntrcode = loccntr.S_CNTR_CODE;
|
var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
|
if (CntrItem != null)
|
{
|
//清除托盘物料绑定关系
|
db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE.Trim() == CntrItem.S_CNTR_CODE).ExecuteCommand();
|
}
|
else
|
{
|
LogHelper.Info($"ClearLocCntr 托盘{cntrcode}无物料绑定关系");
|
}
|
if (LocationHelper.UnBindingLoc(loc, new List<string>() { cntrcode }))
|
{
|
LogHelper.Info($"清除托盘货位关系成功");
|
}
|
|
}
|
else
|
{
|
LogHelper.Info($"ClearLocCntr 货位{loc}无托盘货位绑定关系");
|
}
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据货位:{loc}找不到货位关系";
|
AddErrorInfo("货位为空", result.msg, Source);
|
return result;
|
}
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info($"ClearLocCntr Error：{ex}");
|
db.Ado.CommitTran();
|
result.code = "1";
|
result.msg = $"Error：{ex}";
|
return result;
|
|
}
|
}
|
|
|
|
return result;
|
}
|
/// <summary>
|
/// 库位清空
|
/// </summary>
|
/// <param name="model"></param>
|
/// <returns></returns>
|
internal static Result ClearLoc(ClearTask model)
|
{
|
Result result = new Result() { code = "200", msg = "库位清除成功" };
|
string Source = "MES";
|
if (model == null)
|
{
|
result.code = "1";
|
result.msg = "参数为null";
|
AddErrorInfo("参数为空", result.msg, Source);
|
return result;
|
}
|
string loc = model.LocationNum;
|
var db = new SqlHelper<object>().GetInstance();
|
try
|
{
|
var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
|
if (location != null)
|
{
|
var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).ToList();
|
if (loccntr.Count > 0)
|
{
|
foreach (var item in loccntr)
|
{
|
string cntrcode = item.S_CNTR_CODE;
|
LocationHelper.UnBindingLoc(loc, new List<string>() { cntrcode });
|
var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
|
if (CntrItem != null)
|
{
|
db.Deleteable<Container>().Where(it => it.S_CODE == item.S_CNTR_CODE).ExecuteCommand();
|
// db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
|
if (db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE == cntrcode).ExecuteCommand() > 0)
|
{
|
LogHelper.Info($"ClearLoc 库位清除成功");
|
}
|
else
|
{
|
LogHelper.Info($"ClearLoc 库位清除失败");
|
result.code = "1";
|
result.msg = "库位清除失败";
|
AddErrorInfo("库位清除失败", result.msg, Source);
|
return result;
|
}
|
}
|
else
|
{
|
LogHelper.Info($"库区清空=》托盘:{cntrcode}无物料数据");
|
|
}
|
}
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $" ClearLoc 货位{loc}无托盘货位绑定关系";
|
AddErrorInfo("库位清除失败", result.msg, Source);
|
return result;
|
|
}
|
|
}
|
else
|
{
|
result.code = "1";
|
result.msg = $"根据货位:{loc}找不到货位关系";
|
AddErrorInfo("货位为空", result.msg, Source);
|
return result;
|
}
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info($"ClearLoc Error：{ex}");
|
db.Ado.CommitTran();
|
result.code = "1";
|
result.msg = $"Error：{ex}";
|
return result;
|
|
}
|
|
return result;
|
}
|
/// <summary>
|
/// 设备状态上报
|
/// </summary>
|
/// <returns></returns>
|
internal static DeviceInfoModel Device()
|
{
|
var db = new SqlHelper<HangChaAGV>().GetInstance();
|
DeviceInfoModel device = new DeviceInfoModel();
|
|
List<DeviceInfos> deviceInfos = new List<DeviceInfos>();//叠盘机报错信息
|
// List<AgvInfos> agvInfos = new List<AgvInfos>();//agv报错信息
|
|
//获取内存中叠盘机的报错信息
|
foreach (var dpjInfo in DeviceProcess.DpjInfoDirectory)
|
{
|
deviceInfos.Add(new DeviceInfos() { Device = dpjInfo.Value.DeviceName, DeviceInfo = dpjInfo.Value.ErrorInfo });
|
}
|
// device.DeviceInfos = deviceInfos;
|
//获取车辆报警信息
|
var agvDeviceInfo = db.Queryable<HangChaAGV>().ToList();
|
if (agvDeviceInfo.Count > 0)
|
{
|
device.AgvQty = agvDeviceInfo.Count;
|
device.AgvErrorQty = agvDeviceInfo.FindAll(a => a.agvErrCode != "0" || a.agvErrCode != "0" || a.faildCode != "0").Count;
|
device.AgvChargeQty = agvDeviceInfo.FindAll(a => a.agvErrCode == "1").Count;
|
device.AgvRunQty = agvDeviceInfo.FindAll(a => a.agvErrCode == "1").Count;
|
foreach (var agv in agvDeviceInfo)
|
{
|
string agvErrorInfo = GetAgvAlarmSendCodeTwo(agv.agvErrCode, agv.errCode2, agv.faildCode);
|
deviceInfos.Add(new DeviceInfos() { AgvNo = agv.agvNo, AgvInfo = agvErrorInfo });
|
}
|
}
|
device.DeviceInfos = deviceInfos;
|
|
return device;
|
}
|
|
/// <summary>
|
/// agv小车故障码处理
|
/// </summary>
|
/// <param name="errCode1">错误码1</param>
|
/// <param name="errCode2">错误码2</param>
|
/// <param name="faildCode">错误码3</param>
|
/// <returns></returns>
|
private static string GetAgvAlarmSendCodeTwo(string errCode1, string errCode2, string faildCode)
|
{
|
string result = "";
|
//将报警信息整合
|
string binSW1 = Convert.ToString(int.Parse(errCode1), 2).PadLeft(22, '0');
|
string binSW2 = Convert.ToString(int.Parse(errCode1), 2).PadLeft(20, '0');
|
string binFc = Convert.ToString(int.Parse(errCode1), 2).PadLeft(16, '0');
|
var arr1 = binSW1.ToArray();
|
var arr2 = binSW2.ToArray();
|
var arr3 = binFc.ToArray();
|
|
for (int i = 0; i <= arr1.Length; i++)
|
{
|
if (arr1[i] == '1')
|
{
|
var ErrorInfo = Settings.agvErrorCode1.Where(a => a.ErrorCode == i).FirstOrDefault();
|
if (ErrorInfo != null)
|
{
|
result = result + "," + $"{ErrorInfo.ErrorInfo}";
|
}
|
|
}
|
}
|
for (int i = 0; i <= arr2.Length; i++)
|
{
|
if (arr1[i] == '1')
|
{
|
var ErrorInfo = Settings.agvErrorCode2.Where(a => a.ErrorCode == i).FirstOrDefault();
|
if (ErrorInfo != null)
|
{
|
result = result + "," + $"{ErrorInfo.ErrorInfo}";
|
}
|
|
}
|
}
|
for (int i = 0; i <= arr3.Length; i++)
|
{
|
if (arr1[i] == '1')
|
{
|
var ErrorInfo = Settings.agvFaildCode.Where(a => a.ErrorCode == i).FirstOrDefault();
|
if (ErrorInfo != null)
|
{
|
result = result + "," + $"{ErrorInfo.ErrorInfo}";
|
}
|
|
}
|
}
|
return result;
|
}
|
#endregion
|
|
#region 合肥佳通业务方法
|
|
|
/// <summary>
|
/// 托盘入库算法
|
/// </summary>
|
/// <param name="itemcode"></param>
|
/// <param name="areacode"></param>
|
/// <returns></returns>
|
internal static Location StorageCompute(string itemcode, string areacode)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
Location result = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == 0 && a.S_AREA_CODE.Trim() == areacode && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").First();
|
//查询所有有托盘的排没锁的排
|
// var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE.Trim() == areacode && a.N_LOCK_STATE == 0).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
// if (list.Count > 0)
|
//{
|
// for (int i = 0; i < list.Count; i++)
|
// {
|
// LogHelper.Info($"有托盘排号{list[i].N_ROW}，物料编码{itemcode},库区{areacode}");
|
// //查询货位绑定托盘
|
// var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == list[i].S_CODE).First();
|
// if (cntr != null)
|
// {
|
// //查询托盘物料信息
|
// var iteminfo = ContainerHelper.GetCntrItemRel(cntr.S_CNTR_CODE).FirstOrDefault();
|
|
// if (string.IsNullOrEmpty(itemcode))//空托入库
|
// {
|
// if (iteminfo == null)
|
// {
|
// //物料相同入货位后一位货位
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL && a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM == 0).First();
|
// }
|
// }
|
// else//满拖入库
|
// {
|
// if (iteminfo != null)
|
// {
|
// if (iteminfo.S_ITEM_CODE == itemcode)
|
// {
|
// //物料相同入货位后一位货位
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL && a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM == 0).First();
|
|
// }
|
// }
|
// }
|
// if (result != null)
|
// {
|
// return result;
|
// }
|
// }
|
// else
|
// {
|
// LogHelper.Info($"根据货物编码{list[i].S_CODE}未找到托盘货位绑定关系");
|
// }
|
// }
|
//}
|
return result;
|
}
|
|
|
/// <summary>
|
/// 根据物料计算托盘出库
|
/// </summary>
|
/// <param name="areacode"></param>
|
/// <param name="itemcode"></param>
|
/// <param name="level">物料等级</param>
|
/// <returns></returns>
|
internal static Location airlift(string areacode, string itemcode, string level = "")
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
Location result = null;
|
//根据物料编码获取货位信息
|
#region 废弃
|
//if (string.IsNullOrEmpty(itemcode))
|
//{
|
// //获取库区所有有托盘的货位
|
// var loclist = LocationHelper.GetLocListAny(areacode).FindAll(a => a.N_CURRENT_NUM == 1);
|
// //LogHelper.Info($"获取库区{areacode}数量为1的货位{JsonConvert.SerializeObject(loclist)}");
|
// //根据货位获取托盘
|
// var loccntrlist = LocationHelper.GetLocListByLoc(loclist.Select(a => a.S_CODE).ToList());
|
// List<Location> locs = new List<Location>();
|
// // LogHelper.Info($"获取库区{areacode}数量为1的托盘{JsonConvert.SerializeObject(loccntrlist)}");
|
// //排除所有有物料的托盘
|
// foreach (var item in loccntrlist)
|
// {
|
// var list = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == item.S_CNTR_CODE).First();
|
// if (list == null)
|
// {
|
// LogHelper.Info($"获取库区{areacode}的空托{JsonConvert.SerializeObject(item.S_CNTR_CODE)}");
|
// var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == item.S_CNTR_CODE).First();
|
// var loc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == item.S_LOC_CODE).First();
|
// locs.Add(loc);
|
// }
|
// }
|
// LogHelper.Info($"获取库区{areacode}的空托货位{JsonConvert.SerializeObject(locs)}，计算出库货位");
|
|
// if (locs.Count > 0)
|
// {
|
// result = FindStartcolByLoclist(loclist);
|
// }
|
// else
|
// {
|
// LogHelper.Info($"airlift==> 根据库区编码：{areacode},找不到空托");
|
// }
|
|
//}
|
//else
|
//{
|
// var cntrlist = ContainerHelper.GetItemCntrRel(itemcode).FindAll(a => a.LEV == level);
|
// var loccntrlist = LocationHelper.GetLocListBycntrs(cntrlist.Select(a => a.S_CNTR_CODE).ToList());
|
// var loclist = LocationHelper.GetLocListByloc(loccntrlist.Select(a => a.S_LOC_CODE).ToList(), areacode);
|
// if (loclist.Count() > 0)
|
// {
|
// //判断所处库区的货位是否是可出排
|
// // loclist = loclist.FindAll(a => a.S_AREA_CODE == areacode);
|
// result = FindStartcolByLoclist(loclist);
|
// }
|
// else
|
// {
|
// LogHelper.Info($"airlift==> 根据库区编码：{areacode},物料编码：{itemcode}找不到对应出库货位");
|
// }
|
//}
|
|
#endregion
|
var loc = LocationHelper.GetLocByItemCode(areacode, itemcode, level);
|
LogHelper.Info($"airlift=>根据库区编码:{areacode}，物料编码:{itemcode},物料等级计算出有托盘货位{JsonConvert.SerializeObject(loc)}");
|
// result = FindStartcolByLoclist(loc);
|
if (loc.Count > 0)
|
{
|
result = loc.OrderByDescending(a => a.N_COL).First();
|
}
|
|
LogHelper.Info($"airlift=>可用货位为：{JsonConvert.SerializeObject(result)}");
|
return result;
|
}
|
|
/// <summary>
|
/// 找空排
|
/// </summary>
|
/// <param name="areacode"></param>
|
/// <returns></returns>
|
internal static Location emptyRow(string areacode)
|
{
|
Location result = null;
|
var db = new SqlHelper<object>().GetInstance();
|
|
LogHelper.Info($"根据库区编码：{areacode},查找空排货位");
|
//查找所有数量是空的排;
|
//简化查询只查每一排第一列
|
var list = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).OrderBy(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList().Where(a => a.N_CURRENT_NUM == 0).FirstOrDefault();
|
if (list != null)
|
{
|
result = list;
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 立库任务下发创建托盘物料绑定关系
|
/// </summary>
|
internal static bool CreateCntrIteminfo(partData partData, taskData taskData)
|
{
|
if (partData == null && taskData == null)
|
{
|
LogHelper.Info($"CreateCntrIteminfo==> 立库任务下发参数有空，创建物料托盘绑定关系失败");
|
return false;
|
}
|
else
|
{
|
return ContainerHelper.CreateCntrItem(taskData.pickStation, partData.rfid, partData.partNumber, partData.partDesc, partData.partType, taskData.carrierType, partData.lotNumber, taskData.wmsLot, partData.weight, partData.unit,
|
taskData.tyreType, taskData.supplier, taskData.receiveLot, taskData.subpool, partData.productionTime, partData.maturityTime, taskData.level);
|
}
|
|
}
|
|
//internal static bool CreateCntrLoc(taskData taskData)
|
//{
|
// if ( taskData == null)
|
// {
|
// LogHelper.Info($"CreateCntrIteminfo==> 立库任务下发参数有空，创建物料托盘绑定关系失败");
|
// return false;
|
// }
|
// else
|
// {
|
// LocationHelper.BindingLoc(taskData.pickStation,new List<string>() { taskData.rfid });
|
|
// }
|
|
//}
|
private static object _lockLocation = new object();
|
/// <summary>
|
/// 根据托盘编码，机台编码，工装类型计算机台线边区域
|
/// </summary>
|
/// <param name="cntrcode">托盘编码</param>
|
/// <param name="jtcode">机台编码</param>
|
/// <param name="cntrType">托盘类型</param>
|
/// <returns></returns>
|
internal static Location Computeloc(string cntrcode, string jtcode, string cntrType)
|
{
|
Location End = new Location();
|
var db = new SqlHelper<object>().GetInstance();
|
|
|
// var location = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
|
|
lock (_lockLocation)
|
{
|
var loc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == jtcode.Trim() && a.S_NOTE == cntrType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y").First();
|
if (loc != null)
|
{
|
End = loc;
|
}
|
else
|
{
|
LogHelper.Info($"Computeloc==》根据机台分组：{jtcode},工装类型：{cntrType} 未找到空货位数据，请检查货位表");
|
}
|
|
}
|
return End;
|
}
|
|
/// <summary>
|
/// 合肥佳通添加报错信息表数据
|
/// </summary>
|
/// <param name="errorInfo">错误</param>
|
/// <param name="taskno">任务号</param>
|
/// <param name="areacode">库区编码</param>
|
/// <param name="remake">错误信息</param>
|
/// <returns></returns>
|
public static bool AddErrorInfo(string errorInfo, string remake, string areacode = "", string taskno = "")
|
{
|
bool result = false;
|
var db = new SqlHelper<object>().GetInstance();
|
try
|
{
|
var error = new ErrorInfo
|
{
|
ERRORMESSAGE = errorInfo,
|
TASKNO = taskno,
|
AREACODE = areacode,
|
REMAKE = remake,
|
};
|
if (result = db.Insertable<ErrorInfo>(error).ExecuteCommand() > 0)
|
{
|
|
}
|
//else
|
//{
|
// //添加失败重新添加
|
// AddErrorInfo(errorInfo, remake, areacode, taskno);
|
//}
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Info($"AddErrorInfo Error:{ex.Message}");
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 找终点空货位
|
/// </summary>
|
/// <param name="locations"></param>
|
/// <returns></returns>
|
internal static Location FindEndcolByLocList(List<Location> locations)
|
{
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
Location end = null;
|
//根据终点货位找空闲货位
|
var rows = locations.Select(a => a.N_ROW).Distinct().ToList();
|
for (int i = 0; i < rows.Count; i++)
|
{
|
var rowList = locations.Where(r => r.N_ROW == rows[i]).ToList();
|
if (rowList.Count(a => a.N_CURRENT_NUM == 0) > 0)
|
{
|
Location other = null;
|
//当前排没有锁并且有空位置
|
//先找满位，然后后面一层要么是空，要么不存在
|
other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").FirstOrDefault();
|
//if (full == null)
|
//{
|
// //没有满位，那就找最小的空位
|
// other = rowList.OrderBy(a => a.N_LAYER).FirstOrDefault();
|
//}
|
//else
|
//{
|
// other = rowList.OrderBy(a => a.N_LAYER).Where(a => a.N_LAYER > full.N_LAYER).FirstOrDefault();
|
//}
|
//if (other != null && (!string.IsNullOrEmpty(other.C_ENABLE) && other.C_ENABLE == "禁用"))
|
//{
|
// //禁用了选择后面一个货位
|
// other = db.Queryable<Location>().OrderBy(a => a.N_LAYER).Where(a => (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE.Trim() != "禁用") && a.S_AREA_CODE == other.S_AREA_CODE && a.N_ROW == other.N_ROW && a.N_COL > other.N_COL).First();
|
// //LogHelper.Info($"禁用选择后一个货位{result}", "成品");
|
//}
|
if (other != null)
|
{
|
end = other;
|
break;
|
|
}
|
|
}
|
}
|
return end;
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
|
}
|
|
/// <summary>
|
/// 找起点满货位
|
/// </summary>
|
/// <param name="locations"></param>
|
/// <returns></returns>
|
internal static Location FindStartcolByLoclist(List<Location> locations)
|
{
|
try
|
{
|
Location start = null;
|
var rowsStart = locations.Select(a => a.N_ROW).Distinct().ToList();
|
for (int i = 0; i < rowsStart.Count; i++)
|
{
|
var rowList = locations.Where(r => r.N_ROW == rowsStart[i]).ToList().OrderByDescending(a => a.N_COL);
|
//当前排没有锁并且有满货位
|
if (rowList.Count(a => a.S_LOCK_STATE.Trim() != "无") == 0 && rowList.Count(a => a.N_CURRENT_NUM == 1) > 0)
|
{
|
Location other = null;
|
|
//找到最大的满位，如果有就直接出
|
var full = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 1).FirstOrDefault();
|
if (full != null)
|
{
|
other = full;
|
}
|
|
if (other != null)
|
{
|
start = other;
|
break;
|
}
|
}
|
}
|
return start;
|
}
|
catch (Exception)
|
{
|
|
throw;
|
}
|
|
}
|
|
|
#endregion
|
|
internal static CodeInfo GetCodeInfo(string code, string org)
|
{
|
//return new CodeInfo { Fitemid_XK=code, FSourceNo="123456"};
|
CodeInfo result = null;
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance(Settings.SqlServer1);
|
var nameP = new SugarParameter("@FBarCode", code);
|
var orgP = new SugarParameter("@Forg", org);
|
//var ageP = new SugarParameter("@age", null, true);//设置为output
|
//var dt = db.Ado.UseStoredProcedure().GetDataTable("sp_school", nameP, ageP);//返回dt
|
result = db.Ado.UseStoredProcedure().SqlQuery<CodeInfo>("WMS_FBarCode", nameP, orgP).First();//返回List
|
Console.WriteLine($"读存储过程成功,result={result}");
|
}
|
catch (Exception ex)
|
{
|
Console.WriteLine(ex.Message);
|
}
|
return result;
|
}
|
|
|
static object AGVDeviceReceiveLock = new object();
|
|
/// <summary>
|
/// AGV状态处理
|
/// </summary>
|
/// <param name="forkliftNo"></param>
|
/// <param name="battery"></param>
|
/// <param name="agvCurrTaskInfo"></param>
|
/// <param name="errCode"></param>
|
/// <param name="errCode2"></param>
|
/// <param name="faildCode"></param>
|
internal static void AGVDeviceReceiveSet(string forkliftNo, string battery, string errCode, string errCode2, string faildCode)
|
{
|
lock (AGVDeviceReceiveLock)
|
{
|
|
var db = new SqlHelper<HangChaAGV>().GetInstance();
|
var agvDeviceInfo = db.Queryable<HangChaAGV>().Where(a => a.agvNo.Trim() == forkliftNo).First();
|
if (agvDeviceInfo == null)
|
{
|
var agvInfo = new HangChaAGV()
|
{
|
agvNo = forkliftNo,
|
agvBattery = battery,
|
// agvCurrTaskInfo = agvCurrTaskInfo,
|
agvErrCode = errCode,
|
errCode2 = errCode2,
|
faildCode = faildCode
|
};
|
db.Insertable(agvInfo).ExecuteCommand();
|
}
|
else
|
{
|
//判断中间表信息有无变化，无变化不更新中间表
|
if (agvDeviceInfo.agvErrCode == errCode && agvDeviceInfo.errCode2 == errCode2 && agvDeviceInfo.faildCode == faildCode)
|
{
|
return;
|
}
|
agvDeviceInfo.agvBattery = battery;
|
// agvDeviceInfo.agvCurrTaskInfo = agvCurrTaskInfo;
|
agvDeviceInfo.agvErrCode = errCode;
|
agvDeviceInfo.errCode2 = errCode2;
|
agvDeviceInfo.faildCode = faildCode;
|
// agvDeviceInfo.ext1 = "0";
|
//agvDeviceInfo.agvRunStatus = agvDeviceInfo.agvRunStatus?.Trim() == "1" ? "1" : "";
|
//if (int.Parse(agvDeviceInfo.agvBattery) >= 1000)
|
// agvDeviceInfo.agvRunStatus = "";
|
db.Updateable(agvDeviceInfo).UpdateColumns(a => new
|
{ a.agvBattery, a.agvCurrTaskInfo, a.agvErrCode, a.errCode2, a.faildCode, a.agvRunStatus }).ExecuteCommand();
|
}
|
}
|
}
|
|
#region 数据模型
|
|
#endregion
|
public class AddTaskModel
|
{
|
public string From { get; set; }
|
public string To { get; set; }
|
public string No { get; set; }
|
}
|
public class TN_LocationModel
|
{
|
public string TN_Location { get; set; }
|
}
|
public class CodeInfo
|
{
|
/// <summary>
|
/// 生产订单内码
|
/// </summary>
|
public string FInterID { get; set; }
|
/// <summary>
|
/// 生产订单编号
|
/// </summary>
|
public string FSourceNo { get; set; }
|
/// <summary>
|
/// 批号
|
/// </summary>
|
public string FGMPBatchNo { get; set; }
|
public string FState { get; set; }
|
/// <summary>
|
/// 物料编码（内码就是编码）
|
/// </summary>
|
public string Fitemid_XK { get; set; }
|
/// <summary>
|
/// 分录id
|
/// </summary>
|
public string Fentryid { get; set; }
|
}
|
public class NoteInfo : CodeInfo
|
{
|
public string WmsBillNo { get; set; }
|
}
|
}
|
}
|
