using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using HH.WCS.JingyuNongfu.wms;
|
using HH.WCS.JingyuNongfu.util;
|
using SqlSugar.Extensions;
|
using Newtonsoft.Json;
|
using System.Reflection;
|
|
namespace HH.WCS.JingyuNongfu.process
|
{
|
/// <summary>
|
/// 成品流程
|
/// </summary>
|
internal class ProcessHelperCP
|
{
|
private static Dictionary<string, int> itemHeights = new Dictionary<string, int>();
|
|
static ProcessHelperCP()
|
{
|
new SqlHelper<object>().CreateTable(new List<Type> {
|
typeof(MoveOrderNotice),
|
typeof(InOutRecord),
|
typeof(PgZsjReportMesInfo),
|
typeof(PgFdjReportMesFeedInfo),
|
typeof(PgReportFluxInfo),
|
});
|
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<ItemInfo>().ToList();
|
if (list.Count > 0)
|
{
|
list.ForEach(a =>
|
{
|
if (!itemHeights.Keys.Contains(a.S_ITEM_NAME))
|
{
|
itemHeights.Add(a.S_ITEM_NAME, a.S_ITEM_LAYER);
|
}
|
});
|
}
|
}
|
|
/// <summary>
|
/// 根据物料信息获取托盘高度
|
/// </summary>
|
/// <param name="itemCode"></param>
|
/// <returns></returns>
|
internal static int GetTrayHeightByItem(string itemCode)
|
{
|
var result = 0;
|
if (itemHeights.Keys.Contains(itemCode))
|
{
|
result = itemHeights[itemCode];
|
}
|
else
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var itemInfo = db.Queryable<ItemInfo>().Where(a => a.S_ITEM_CODE == itemCode).First();
|
if (itemInfo != null)
|
{
|
result = itemInfo.S_ITEM_LAYER;
|
itemHeights.Add(itemCode, itemInfo.S_ITEM_LAYER);
|
}
|
}
|
|
return result;
|
}
|
|
|
/// <summary>
|
/// 获取物料二层高度
|
/// </summary>
|
/// <param name="itemName">物料名称</param>
|
/// <param name="itemLayer">物料层高</param>
|
/// <param name="irayType">托盘类型</param>
|
/// <returns></returns>
|
internal static int GetTrayHeight(string itemCode, string itemLayer, string irayType)
|
{
|
var result = 0;
|
//if (itemHeights.Keys.Contains(itemCode + "_" + itemLayer + "_" + itemLayer))
|
//{
|
// result = itemHeights[itemCode + "_" + itemLayer + "_" + itemLayer];
|
//}
|
//else
|
//{
|
var db = new SqlHelper<object>().GetInstance();
|
var itemInfo = db.Queryable<ItemInfo>().Where(a => a.S_ITEM_CODE == itemCode && a.S_ITEM_MODEL == itemLayer && a.S_TRAY_TYPE == irayType).First();
|
if (itemInfo != null)
|
{
|
result = itemInfo.S_ITEM_LAYER;
|
//itemHeights.Add(itemCode + "_" + itemLayer + "_" + itemLayer, itemInfo.S_ITEM_LAYER);
|
}
|
// }
|
|
return result;
|
}
|
|
/// <summary>
|
/// 获取物料层高
|
/// </summary>
|
/// <param name="trayCode"></param>
|
/// <returns></returns>
|
internal static int GetTrayHeightByTray(string trayCode)
|
{
|
var result = 0;
|
|
var db = new SqlHelper<object>().GetInstance();
|
|
|
var cntr = db.Queryable<Container>().Where(a => a.S_CNTR_CODE.Contains(trayCode)).Includes(a => a.CntrItemRel).First();
|
if (cntr != null && cntr.CntrItemRel != null)
|
{
|
//根据物料名称、物料层数、托盘类型找物料层高
|
result = GetTrayHeight(cntr.CntrItemRel.S_ITEM_CODE, cntr.CntrItemRel.S_ITEM_MODEL, cntr.S_TYPE);
|
}
|
else
|
{
|
LogHelper.Info("未获取cntr信息", "HosttoagvTask");
|
}
|
|
|
return result;
|
}
|
/// <summary>
|
/// 获取富勒物料层高
|
/// </summary>
|
/// <param name="trayCode"></param>
|
/// <returns></returns>
|
internal static int GetTrayHeightByTrayFL(string trayCode)
|
{
|
var result = 0;
|
int itemLayer = 0;
|
var db = new SqlHelper<object>().GetInstance();
|
|
var cntrfl = db.Queryable<ThirdPartTrayInfo>().Where(a => a.trayCode.Contains(trayCode)).First();
|
if (cntrfl != null)
|
{
|
itemLayer = int.Parse(cntrfl.itemLayer);
|
var cntr = db.Queryable<Container>().Where(a => a.S_CNTR_CODE.Contains(trayCode)).Includes(a => a.CntrItemRel).First();
|
if (cntr != null && cntr.CntrItemRel != null)
|
{
|
//根据物料名称、物料层数、托盘类型找物料层高
|
result = GetTrayHeight(cntr.CntrItemRel.S_ITEM_CODE, itemLayer.ToString(), cntr.S_TYPE);
|
}
|
}
|
else
|
{
|
LogHelper.Info("未找到富勒cntr信息", "HosttoagvTask");
|
|
}
|
|
return result;
|
}
|
|
/// <summary>
|
/// 成品下线
|
/// </summary>
|
/// <param name="workOrder"></param>
|
/// <param name="loc"></param>
|
/// <param name="height"></param>
|
internal static void InStock(WorkOrder1 workOrder, string loc)
|
{
|
try
|
{
|
//判断最大任务数,如果执行中的任务大于等于最大任务数，不生成任务
|
if (!TaskHelper.GetTaskByMaxtask(workOrder, loc))
|
{
|
LogHelper.Info($"执行中任务数量大于等于最大任务限制，不生成任务", "成品");
|
return;
|
}
|
//根据工单查询对应物料信息
|
var db = new SqlHelper<object>().GetInstance();
|
ItemInfo item = null;
|
if (workOrder.withCode == "是")
|
{
|
//使用富勒数据
|
// List<ThirdPartTrayInfo> trayInfos = GetThirdPartTrayInfo(workOrder.S_WorkNo);
|
List<ThirdPartTrayInfo> trayInfos = GetThirdPartTrayInfoByDeviceName(workOrder.S_PLineNo);
|
if (trayInfos.Count == 2)
|
{
|
workOrder.S_ItemLayer = trayInfos[0].itemLayer;
|
}
|
else
|
{
|
LogHelper.Info("未获取到富勒托盘号", "成品");
|
return;
|
}
|
}
|
if (workOrder.withCode == "是")
|
{
|
item = db.Queryable<ItemInfo>().Where(a => a.S_ITEM_CODE == workOrder.S_ItemCode && a.S_TRAY_TYPE == workOrder.S_TrayType && a.S_ITEM_MODEL == workOrder.S_ItemLayer.ToString()).First();
|
}
|
else
|
{
|
item = db.Queryable<ItemInfo>().Where(a => a.S_ITEM_NAME == workOrder.SQL_ItemName && a.S_TRAY_TYPE == workOrder.S_TrayType && a.S_ITEM_MODEL == workOrder.S_ItemLayer.ToString()).First();
|
}
|
var itemCode = "";
|
var itemName = "";
|
var itemTrayType = "";
|
var itemModel = "";
|
if (item != null)
|
{
|
itemCode = item.S_ITEM_CODE;
|
itemName = item.S_ITEM_NAME;
|
itemTrayType = item.S_TRAY_TYPE;
|
itemModel = item.S_ITEM_MODEL;
|
}
|
else
|
{
|
LogHelper.Info("未获取物料信息", "成品");
|
}
|
|
|
var listZones = new List<string> { };
|
if (!string.IsNullOrEmpty(workOrder.SQL_Area))
|
{
|
listZones.Add(workOrder.SQL_Area);
|
if (!string.IsNullOrEmpty(workOrder.SQL_Area1)) { listZones.Add(workOrder.SQL_Area1); }
|
if (!string.IsNullOrEmpty(workOrder.SQL_Area2)) { listZones.Add(workOrder.SQL_Area2); }
|
|
}
|
else
|
{
|
listZones.AddRange(GetZones(workOrder.SQL_ItemName));
|
}
|
//按物料名称查找库区
|
//var code1 = LocationHelper.GenerateCntrNo() + "_" + height;
|
//var code2 = LocationHelper.GenerateCntrNo() + "_" + height;
|
//var tray = $"{code1}-{code2}";
|
string tray = "";
|
string batchNo = "";
|
var count = "1";
|
if (workOrder.withCode == "是")
|
{
|
//使用富勒数据
|
// List<ThirdPartTrayInfo> trayInfos = GetThirdPartTrayInfo(workOrder.S_WorkNo);
|
List<ThirdPartTrayInfo> trayInfos = GetThirdPartTrayInfoByDeviceName(workOrder.S_PLineNo);
|
if (trayInfos.Count == 2)
|
{
|
tray = $"{trayInfos[0].trayCode},{trayInfos[1].trayCode}";
|
count = $"{trayInfos[0].trayNum},{trayInfos[1].trayNum}";
|
batchNo = trayInfos[0].batchNo + ',' + trayInfos[1].batchNo;
|
itemCode = $"{workOrder.S_ItemCode}";
|
}
|
else
|
{
|
Console.WriteLine("未获取到富勒托盘号");
|
return;
|
}
|
}
|
else
|
{
|
batchNo = DateTime.Now.ToString("yyyyMMdd") + workOrder.S_PLineNo;
|
}
|
|
|
Location end = null;
|
Console.WriteLine($"查找同品相 同设备 {itemCode} {batchNo}");
|
|
|
if (item == null)
|
{
|
Console.WriteLine("查询物料信息出错");
|
return;
|
}
|
int maxLayer = item.N_MaxLayer;
|
Console.WriteLine($"层数:{maxLayer}");
|
|
for (int i = 0; i < listZones.Count; i++)
|
{
|
LogHelper.Info("库区" + listZones[i], "成品");
|
//LogHelper.Info($"任务:{workOrder.S_PLineNo},产线{workOrder.S_WorkNo}", "成品");
|
//end = LocationHelper.GetLocation4InFinish(listZones[i], workOrder.SQL_ItemCode, workOrder.size);
|
end = GetLocation4InSameSrc(listZones[i], itemCode, batchNo, workOrder.S_TrayType, maxLayer);
|
if (end != null)
|
{
|
// LogHelper.Info($"方法（GetLocation4InSameSrc）选择货位{end.S_LOC_CODE}", "成品");
|
break;
|
}
|
}
|
if (end == null)
|
{
|
Console.WriteLine("查找空排");
|
for (int i = 0; i < listZones.Count; i++)
|
{
|
Console.WriteLine("库区" + listZones[i]);
|
end = GetLocation4InEmptyRow(listZones[i], workOrder.S_TrayType);
|
|
if (end != null)
|
{
|
// LogHelper.Info($"方法（GetLocation4InEmptyRow）选择货位{end.S_LOC_CODE}", "成品");
|
break;
|
}
|
}
|
}
|
//if (end == null)
|
//{
|
// Console.WriteLine($"查找同品相 不同设备 {itemCode} {batchNo}");
|
// for (int i = 0; i < listZones.Count; i++)
|
// {
|
// Console.WriteLine("库区" + listZones[i]);
|
// end = GetLocation4InAnySrc(listZones[i], itemCode, batchNo, workOrder.S_TrayType, maxLayer);
|
// if (end != null)
|
// {
|
// LogHelper.Info($"方法（GetLocation4InAnySrc）选择货位{end.S_LOC_CODE}", "成品");
|
// break;
|
// }
|
// }
|
//}
|
if (end != null)
|
{
|
LogHelper.Info($"任务:{workOrder.S_PLineNo},终点库区{end.S_LOC_CODE},物料编码{itemCode},批次号{batchNo},下线托盘类型{workOrder.S_TrayType},层数{maxLayer}", "HosttoagvTask");
|
//生成托盘号
|
string[] traylist = null;
|
if (workOrder.withCode != "是")
|
{
|
tray = $"{ContainerHelper.GenerateCntrNo()},{ContainerHelper.GenerateCntrNo()}";
|
traylist = tray.Split(',');
|
}
|
else
|
{
|
traylist = tray.Split(',');
|
}
|
int cg = 0;
|
|
//计算层高
|
if (end.N_CURRENT_NUM == 0)
|
{
|
cg = 1;
|
}
|
else if (end.N_CURRENT_NUM == 2)
|
{
|
cg = 2;
|
}
|
else if (end.N_CURRENT_NUM == 4)
|
{
|
cg = 3;
|
}
|
//判断任务终点有无相同任务
|
if (TaskHelper.GetTaskByEndandlayer(end.S_LOC_CODE, cg))
|
{
|
|
if (ContainerHelper.CreateCntrItem(traylist, itemCode, itemName, workOrder.S_TrayType, batchNo, count, itemModel, itemTrayType, workOrder.S_WorkNo))
|
{
|
//创建入库搬运任务
|
if (!TaskProcess.CreateTransport(loc, end.S_LOC_CODE, "成品下线", new List<string> { tray }, 1, cg, 1, 80, workOrder.S_WorkNo, workOrder.withCode))
|
{
|
//任务创建失败删除创建的托盘
|
if (ContainerHelper.DeleteCntrItem(tray.Split(',')))
|
{
|
LogHelper.Info($"任务创建失败删除托盘{tray}", "成品");
|
}
|
else
|
{
|
LogHelper.Info($"任务创建失败删除托盘{tray}失败", "成品");
|
}
|
}
|
|
}
|
}
|
else
|
{
|
LogHelper.Info($"任务终点{end.S_LOC_CODE},层高:{cg}有执行中的任务，不生成任务", "成品");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
|
throw ex;
|
}
|
|
}
|
/// <summary>
|
/// 顶升机下线
|
/// </summary>
|
/// <param name="workOrder"></param>
|
/// <param name="loc"></param>
|
internal static void DsjStock(string startLoc, string endLoc)
|
{
|
string bussType = "";
|
string cntrtype = "";
|
if (startLoc == "LYP-1-1")
|
{
|
|
bussType = "顶升机留样品下线";
|
cntrtype = "留样品";
|
}
|
else if (startLoc == "FL-1-1")
|
{
|
bussType = "顶升机废料下线";
|
cntrtype = "废料";
|
}
|
else if (startLoc == "ZX-1-1")
|
{
|
bussType = "顶升机空托下线";
|
cntrtype = "纸箱空托";
|
}
|
|
string tray = ContainerHelper.GenerateCntrNo();
|
try
|
{
|
|
if (ContainerHelper.CreateCntrItem(tray, cntrtype))
|
{
|
TaskProcess.CreateTransport(startLoc, endLoc, bussType, new List<string> { tray }, 1, 1, 1, 80);
|
}
|
}
|
catch (Exception ex)
|
{
|
|
LogHelper.Info($"DsjStock-Error:{ex.ToString()}", "顶升机");
|
}
|
|
}
|
|
/// <summary>
|
/// 获取富勒托盘数据
|
/// </summary>
|
/// <param name="workNo"></param>
|
/// <returns></returns>
|
private static List<ThirdPartTrayInfo> GetThirdPartTrayInfo(string workNo)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
return db.Queryable<ThirdPartTrayInfo>().Where(a => a.workNo == workNo).ToList();
|
}
|
|
|
/// <summary>
|
/// 获取富勒托盘数据
|
/// </summary>
|
/// <param name="workNo"></param>
|
/// <returns></returns>
|
private static List<ThirdPartTrayInfo> GetThirdPartTrayInfoByDeviceName(string deviceName)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
return db.Queryable<ThirdPartTrayInfo>().Where(a => a.deviceName == deviceName).ToList();
|
}
|
/// <summary>
|
/// 同品相 同设备 同批次 的可以入同一排
|
/// </summary>
|
/// <param name="area0"></param>
|
/// <param name="itemCode"></param>
|
/// <param name="trayType"></param>
|
/// <returns></returns>
|
public static Location GetLocation4InSameSrc(string area0, string itemCode, string itemBatch, string trayType, int maxLayer = 2)
|
{
|
Location result = null;
|
//string itemBatch = DateTime.Now.ToString("yyMMdd");
|
try
|
{
|
itemBatch = itemBatch.Split(',')[0];
|
var area = area0 + "_" + GetType(trayType);
|
LogHelper.Info("成品满托入库 GetLocation4InSameSrc:" + area, "成品");
|
bool flag = false;
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
|
if (flag)
|
{
|
LogHelper.Info($"当前库区{area}不可用，被其它尺寸托盘占用，直接返回");
|
return null;
|
}
|
//1.0 获取每一排最大的列
|
//1.1 判断当前数量是不是满的，如果是满的并且是最大列，需要排除
|
var listMaxCol = new SqlHelper<Location>().GetInstance().Queryable<Location>().Where(a => a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
//1.1 查到所有有托盘的排
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
// Console.WriteLine($"查到所有有托盘的排 {list.Count}");
|
// LogHelper.Info($"查到所有有托盘的排 {list.Count}", "HosttoagvTask");
|
////查询移库工单相同库区的数据
|
//var listykstart = db.Queryable<WorkOrder2>().Where(a => a.start_area== area0).ToList();
|
//var listykend = db.Queryable<WorkOrder2>().Where(a => a.end_area== area0).ToList();
|
|
if (list.Count > 0)
|
{
|
//1.2 查找其它尺寸有托盘或者锁定的排
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
LogHelper.Info("成品满托入库 GetLocation4InSameSrc:剩余排数" + list.Count, "成品");
|
var remove = false;
|
//排除已经锁定的货位 和 放满了且是最大列的货位
|
// LogHelper.Info("成品满托入库 GetLocation4InSameSrc:11111", "成品");
|
if (list[i].S_LOCK_STATE.Trim() != "无" || (list[i].N_CURRENT_NUM == 4 && listMaxCol.Count(a => a.S_LOC_CODE == list[i].S_LOC_CODE) > 0))
|
{
|
// Console.WriteLine($"排除已经锁定的货位 和 放满了且是最大列的货位 排{list[i].N_ROW}");
|
LogHelper.Info($"排除已经锁定的货位 和 放满了且是最大列的货位 排{list[i].N_ROW}", "成品");
|
remove = list.Remove(list[i]);
|
}
|
else
|
{
|
// LogHelper.Info("成品满托入库 GetLocation4InSameSrc:2222", "成品");
|
//排有锁也排除
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.S_LOCK_STATE.Trim() != "无").First();
|
if (other != null)
|
{
|
//Console.WriteLine($"排除有锁的排{list[i].N_ROW}");
|
LogHelper.Info($"排除有锁的排{list[i].N_ROW}", "成品");
|
remove = list.Remove(list[i]);
|
}
|
//LogHelper.Info("成品满托入库 GetLocation4InSameSrc:3333", "成品");
|
}
|
if (!remove)
|
{
|
//判断是否被其它库区占用了
|
|
// LogHelper.Info($"判断是否被其它库区占用了 {list[i].N_ROW}", "成品");
|
if (usedRows.Contains(list[i].N_ROW))
|
{
|
LogHelper.Info($"被其他库区占用{list[i].N_ROW}", "成品");
|
remove = list.Remove(list[i]);
|
|
}
|
|
}
|
}
|
//LogHelper.Info($"有托盘排数为{list.Count}","成品");
|
LogHelper.Info("成品满托入库 GetLocation4InSameSrc:开始计算排数" + list.Count, "成品");
|
if (list.Count > 0)
|
{
|
|
//1.3 遍历判断物料类型是否相同
|
//Console.WriteLine("遍历判断物料类型是否相同");
|
// LogHelper.Info($"遍历判断物料类型是否相同", "成品");
|
for (int i = 0; i < list.Count(); i++)
|
{
|
|
//Console.WriteLine($"货位{list[i].S_LOC_CODE} 物料{list[i].LocCntrRel.CntrItemRel.S_ITEM_CODE} 批次{list[i].LocCntrRel.CntrItemRel.S_BATCH_NO}");
|
//todo 还需要判断锁
|
#region 满托盘判断 物料信息相同，并且批次里面的设备相同
|
//var ssss = itemBatch.Substring(6).Trim();
|
if (list[i].LocCntrRel != null && list[i].LocCntrRel.CntrItemRel != null && list[i].LocCntrRel.CntrItemRel.S_ITEM_CODE.Trim() == itemCode && list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Contains(itemBatch.Substring(6).Trim()) && list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Length == itemBatch.Length)
|
{
|
|
// LogHelper.Info($"有托盘的货位{list[i].S_LOC_CODE} 当前数量={list[i].N_CURRENT_NUM} 容量={list[i].N_CAPACITY},入库数量={maxLayer}", "成品");
|
if (list[i].N_CAPACITY - list[i].N_CURRENT_NUM >= maxLayer)
|
{
|
|
//堆叠，判断批次里面的日期是不是相同的
|
//LogHelper.Info("堆叠，判断批次里面的日期是不是相同的", "成品");
|
// if (list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Trim() == itemBatch)
|
// {
|
|
result = list[i];
|
// Console.WriteLine("判断是不是单托");
|
//if (list[i].LocCntrRel.S_CNTR_CODE.Contains(','))
|
//{
|
// result = list[i];
|
//}
|
//else
|
//{
|
// //一层是单托，入库放后面一个位置
|
// Console.WriteLine("一层是单托，入库放后面一个位置");
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).First();
|
|
//}
|
|
// }
|
// else
|
// {
|
//排除批次不一样
|
//Console.WriteLine("批次不一样空一个位置");
|
// LogHelper.Info($" 货位{list[i].S_LOC_CODE}，货位批次号{list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Trim()}和任务批次号{itemBatch}不同，批次不一样空一个位置", "成品");
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > (list[i].N_COL + 1)).First();
|
//return null;
|
// }
|
}
|
else
|
{
|
//LogHelper.Info($"货位当前数量{list[i].N_CURRENT_NUM },存放数量{maxLayer}", "成品");
|
//选择后面空位，判断批次里面日期是不是相同的
|
// Console.WriteLine($"判断批次是不是相同的");
|
// if (list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Trim() == itemBatch)
|
// {
|
// LogHelper.Info($"S_AREA_CODE={area},N_ROW={list[i].N_ROW},N_COL>{list[i].N_COL}", "成品");
|
result = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == area.Trim() && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).OrderBy(a => a.N_COL).First();
|
//if (result != null)
|
//{
|
// LogHelper.Info($"{result.S_LOC_CODE}", "成品");
|
|
//}
|
//LogHelper.Info($"{list[i]}货位满，批次号相同找后一个空货位", "成品");
|
//}
|
// else
|
// {
|
//LogHelper.Info($"{list[i]}货位满，批次号不同，隔一个空位", "成品");
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > (list[i].N_COL + 1)).First();
|
//return null;
|
// }
|
}
|
|
if (result != null && (!string.IsNullOrEmpty(result.C_ENABLE) && result.C_ENABLE == "禁用"))
|
{
|
//禁用了选择后面一个货位
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE.Trim() != "禁用") && a.S_AREA_CODE == area && a.N_ROW == result.N_ROW && a.N_COL > result.N_COL).First();
|
|
//LogHelper.Info($"禁用选择后一个货位{result}", "成品");
|
}
|
if (result != null)
|
{
|
break;
|
}
|
|
//根据容器编码获取容器信息
|
var ctrlCode = list[i].LocCntrRel.CntrItemRel.S_CNTR_CODE.Trim();
|
var ctrl = ContainerHelper.GetCntr(ctrlCode);
|
//托盘类型不一样隔一排位置
|
if (ctrl.S_TYPE != trayType)
|
{
|
Console.WriteLine("托盘类型不一样隔一排");
|
break;
|
}
|
|
}
|
else
|
{
|
LogHelper.Info($"货位{list[i].S_LOC_CODE}不允许堆叠,托盘：{list[i].LocCntrRel.S_CNTR_CODE}，容器货品{list[i].LocCntrRel.CntrItemRel}，托盘物料编码{list[i].LocCntrRel.CntrItemRel.S_ITEM_CODE.Trim()},订单物料编码：{itemCode} ，批次号{list[i].LocCntrRel.CntrItemRel.S_BATCH_NO}是否含有{itemBatch.Substring(6).Trim()},物料编码长度{list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Length}是否相等{itemBatch.Length}，有与上一个货位不同的地方", "成品");
|
}
|
|
|
#endregion
|
|
}
|
}
|
else
|
{
|
LogHelper.Info($"有托盘的排数为0", "成品");
|
}
|
}
|
|
|
}
|
catch (Exception ex)
|
{
|
|
//Console.WriteLine("GetLocation4InFinish:" + ex.Message + ex.StackTrace);
|
LogHelper.Info("GetLocation4InSameSrc:" + ex.Message, "成品");
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 成品入库移库完成记录信息需要上报给富勒
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="move"></param>
|
internal static void AddTaskStatus(WMSTask mst, bool move = false)
|
{
|
try
|
{
|
//无码的不需要写入中间表
|
if (mst.S_CNTRS.Length != 25)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var model = new InOutRecord { TrayInfo = mst.S_CNTRS };
|
model.EndArea = mst.S_END_LOC.Substring(0, 1) + mst.S_END_LOC.Split('-')[1];
|
if (move)
|
{
|
model.IsMove = 1;
|
model.StartArea = mst.S_START_LOC.Substring(0, 1) + mst.S_START_LOC.Split('-')[1];
|
}
|
else
|
{
|
var cir = db.Queryable<Container>().Where(a => a.S_CNTR_CODE == mst.S_CNTRS).Includes(a => a.CntrItemRel).First();
|
if (cir != null && cir.CntrItemRel != null)
|
{
|
model.WorkOrder = cir.CntrItemRel.workOrder;
|
}
|
else
|
{
|
LogHelper.Info($"写入 InOutRecord 失败 托盘{mst.S_CNTRS}物料信息不存在");
|
}
|
}
|
var res = db.Insertable<InOutRecord>(model).ExecuteCommand();
|
}
|
|
}
|
catch (Exception ex)
|
{
|
|
LogHelper.Info($"写入 InOutRecord 失败{ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 查找空排
|
/// </summary>
|
/// <param name="area0"></param>
|
/// <param name="itemCode"></param>
|
/// <param name="itemBatch"></param>
|
/// <param name="trayType"></param>
|
/// <returns></returns>
|
public static Location GetLocation4InEmptyRow(string area0, string trayType)
|
{
|
Location result = null;
|
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine("成品满托入库 GetLocation4InEmptyRow:" + area);
|
//var usedRows = GetUsedRow(area0, GetType(trayType));
|
bool flag = false;
|
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
LogHelper.Info("usedRows信息" + JsonConvert.SerializeObject(usedRows), "成品");
|
|
if (flag) { return null; }
|
//todo 还需要判断锁
|
#region 查找所有数量是空的排
|
//Console.WriteLine("查找所有数量是空的排");
|
//2.0 简化查询只查每一排第一列
|
var list = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area).OrderBy(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList().Where(a => a.N_CURRENT_NUM == 0).ToList();
|
// LogHelper.Info($"库区编码:{area}", "成品");
|
if (list.Count > 0)
|
{
|
// LogHelper.Info($"list.Count:{list.Count},", "成品");
|
//2.1 选一个空排
|
for (int i = 0; i < list.Count; i++)
|
{
|
|
if (!usedRows.Contains(list[i].N_ROW))
|
{
|
//LogHelper.Info($"area0:{area0} llist[i].N_ROW:{list[i].N_ROW},GetType(trayType):{GetType(trayType)}", "成品");
|
//判断其它库区排是否有锁定
|
if (!CheckLockedRow(area0, GetType(trayType), list[i].N_ROW))
|
{
|
//LogHelper.Info($"area:{area},N_ROW :{list[i].N_ROW}", "成品");
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.S_LOCK_STATE.Trim() != "无").First();
|
//LogHelper.Info($"other:{other},list[i].S_LOCK_STATE.Trim() :{list[i].S_LOCK_STATE.Trim() }", "成品");
|
if (list[i].S_LOCK_STATE.Trim() == "无" && other == null)
|
{
|
//二次校验当前排所有货位都是空的，防止系统数据错乱
|
// LogHelper.Info($"i:{i} llist[i].N_ROW:{list[i].N_ROW},area:{area}", "成品");
|
var rowSumInfo = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW).Select(a => new { sum = SqlFunc.AggregateSum(a.N_CURRENT_NUM) }).First();
|
//LogHelper.Info($"rowSumInfo.sum:{rowSumInfo.sum}", "成品");
|
if (rowSumInfo.sum == 0)
|
{
|
result = list[i];
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
{
|
LogHelper.Info($"根据库区:{area},找不到空排", "成品");
|
}
|
#endregion
|
|
if (result != null && (!string.IsNullOrEmpty(result.C_ENABLE) && result.C_ENABLE == "禁用"))
|
{
|
//禁用了选择后面一个货位
|
//Console.WriteLine("禁用了选择后面一个货位");
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == result.N_ROW && (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE != "禁用") && a.N_COL > result.N_COL).First();
|
LogHelper.Info("货位信息" + JsonConvert.SerializeObject(result), "HosttoagvTask");
|
}
|
|
|
|
}
|
catch (Exception ex)
|
{
|
|
//Console.WriteLine("GetLocation4InFinish:" + ex.Message + ex.StackTrace);
|
LogHelper.Error("GetLocation4InEmptyRow:" + ex.Message, ex);
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 同品相 不同设备的可以入同一排
|
/// </summary>
|
/// <param name="area0"></param>
|
/// <param name="itemCode"></param>
|
/// <param name="itemBatch"></param>
|
/// <param name="trayType"></param>
|
/// <returns></returns>
|
public static Location GetLocation4InAnySrc(string area0, string itemCode, string itemBatch, string trayType, int maxLayer = 2)
|
{
|
Location result = null;
|
|
try
|
{
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine("成品满托入库 GetLocation4InAnySrc:" + area);
|
//var usedRows = GetUsedRow(area0, GetType(trayType));
|
bool flag = false;
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
if (flag) { return null; }
|
//1.0 获取每一排最大的列
|
//1.1 判断当前数量是不是满的，如果是满的并且是最大列，需要排除
|
var listMaxCol = new SqlHelper<Location>().GetInstance().Queryable<Location>().Where(a => a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
//1.1 查到所有有托盘的排
|
Console.WriteLine("查到所有有托盘的排 ");
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
if (list.Count > 0)
|
{
|
//1.2 查找其它尺寸有托盘或者锁定的排
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
var remove = false;
|
//排除已经锁定的货位 和 放满了且是最大列的货位
|
if (list[i].S_LOCK_STATE.Trim() != "无" || (list[i].N_CURRENT_NUM == 4 && listMaxCol.Count(a => a.S_LOC_CODE == list[i].S_LOC_CODE) > 0))
|
{
|
LogHelper.Info($"排除已经锁定的货位 和 放满了且是最大列的货位 排{list[i].N_ROW}", "成品");
|
remove = list.Remove(list[i]);
|
}
|
else
|
{
|
//排有锁也排除
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.S_LOCK_STATE.Trim() != "无").First();
|
if (other != null)
|
{
|
LogHelper.Info($"排除有锁的排{list[i].N_ROW}", "成品");
|
remove = list.Remove(list[i]);
|
}
|
}
|
if (!remove)
|
{
|
//判断是否被其它库区占用了
|
if (usedRows.Contains(list[i].N_ROW))
|
{
|
remove = list.Remove(list[i]);
|
LogHelper.Info($"被其他库区占用{list[i].N_ROW}", "成品");
|
}
|
}
|
}
|
Console.WriteLine($"有托盘排数为{list.Count}");
|
if (list.Count > 0)
|
{
|
|
//1.3 遍历判断物料类型是否相同
|
Console.WriteLine("遍历判断物料类型是否相同");
|
for (int i = 0; i < list.Count; i++)
|
{
|
//todo 还需要判断锁
|
#region 空托盘或者满托盘判断 ,如果是空托盘 托盘物料信息为空
|
if (list[i].LocCntrRel != null && list[i].LocCntrRel.CntrItemRel != null)
|
{
|
LogHelper.Info($"货位{list[i].S_LOC_CODE} 物料{list[i].LocCntrRel.CntrItemRel.S_ITEM_CODE} 批次{list[i].LocCntrRel.CntrItemRel.S_BATCH_NO}", "成品");
|
if (list[i].LocCntrRel.CntrItemRel.S_ITEM_CODE.Trim() == itemCode && list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Length == itemBatch.Length)
|
{
|
LogHelper.Info($"不同设备生产排;有托盘的货位{list[i].S_LOC_CODE} 当前数量={list[i].N_CURRENT_NUM} 容量={list[i].N_CAPACITY},入库数量={maxLayer}", "成品");
|
if (list[i].N_CAPACITY - list[i].N_CURRENT_NUM >= maxLayer)
|
{
|
//堆叠，判断批次是不是相同的，不是相同的放到后面
|
// Console.WriteLine("堆叠，判断批次里面日期是不是相同的，不是相同的放到后面");
|
//if (list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Substring(0, itemBatch.Length - 2) == itemBatch.Substring(0, itemBatch.Length - 2)) {
|
//判断是不是单托
|
result = list[i];
|
//Console.WriteLine("判断是不是单托");
|
//if (list[i].LocCntrRel.S_CNTR_CODE.Contains(','))
|
//{
|
// result = list[i];
|
//}
|
//else
|
//{
|
// //一层是单托，入库放后面一个位置
|
// Console.WriteLine("一层是单托，入库放后面一个位置");
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).First();
|
|
//}
|
//}
|
//else {
|
// //批次不一样空一个位置
|
// Console.WriteLine("批次不一样空一个位置");
|
// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > (list[i].N_COL + 1)).First();
|
|
//}
|
}
|
else
|
{
|
LogHelper.Info($"货位{list[i].S_LOC_CODE}满，选择后面货位", "成品");
|
//选择后面空位，判断批次是不是相同的，不是相同的放到后面
|
// LogHelper.Info("选择后面空位，判断批次是不是相同的，不是相同的放到后面", "成品");
|
if (list[i].LocCntrRel.CntrItemRel.S_BATCH_NO.Substring(0, itemBatch.Length - 2) == itemBatch.Substring(0, itemBatch.Length - 2))
|
{
|
result = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).OrderBy(a => a.N_COL).First();
|
|
LogHelper.Info($"{list[i]}货位满，批次号相同找后一个空货位", "成品");
|
}
|
else
|
{
|
LogHelper.Info($"{list[i]}货位满，批次号不同，隔一个空位", "成品");
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > (list[i].N_COL + 1)).First();
|
|
}
|
}
|
|
if (result != null && result.C_ENABLE != "禁用")
|
{
|
break;
|
}
|
|
//根据容器编码获取容器信息
|
var ctrlCode = list[i].LocCntrRel.CntrItemRel.S_CNTR_CODE.Trim();
|
var ctrl = ContainerHelper.GetCntr(ctrlCode);
|
//托盘类型不一样隔一排
|
if (ctrl.S_TYPE != trayType)
|
{
|
Console.WriteLine("托盘类型不一样隔一排");
|
break;
|
}
|
}
|
}
|
|
|
|
#endregion
|
|
}
|
}
|
}
|
|
if (result != null && (!string.IsNullOrEmpty(result.C_ENABLE) && result.C_ENABLE == "禁用"))
|
{
|
//禁用了选择后面一个货位
|
//Console.WriteLine("禁用了选择后面一个货位");
|
LogHelper.Info($"禁用货位{result.S_LOC_CODE},库区编码{area}，排{result.N_ROW}，列{result.N_COL}", "成品");
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE.Trim() != "禁用") && a.S_AREA_CODE == area && a.N_ROW == result.N_ROW && a.N_COL > result.N_COL).First();
|
|
// LogHelper.Info($"禁用选择后一个货位{result}", "成品");
|
|
|
}
|
}
|
catch (Exception ex)
|
{
|
|
//Console.WriteLine("GetLocation4InFinish:" + ex.Message + ex.StackTrace);
|
LogHelper.Error("GetLocation4InFinish:" + ex.Message, ex);
|
}
|
return result;
|
}
|
/// <summary>
|
/// 根据物料信息获取入库优先级
|
/// </summary>
|
/// <param name="ItemCode"></param>
|
/// <returns></returns>
|
/// <exception cref="NotImplementedException"></exception>
|
private static List<string> GetZones(string ItemName)
|
{
|
var list = new List<string>();
|
var db = new SqlHelper<object>().GetInstance();
|
var itemZonePris = db.Queryable<ItemZonePriInfo>().Where(a => a.S_ITEM_NAME == ItemName).ToList();
|
if (itemZonePris.Count > 0)
|
{
|
list = itemZonePris.OrderBy(a => a.S_PRIORITY).Select(a => a.S_AREA_CODE).ToList();
|
}
|
return list;
|
}
|
|
/// <summary>
|
/// 根据托盘类型获取库区后缀
|
/// </summary>
|
/// <param name="trayType"></param>
|
/// <returns></returns>
|
public static string GetType(string trayType)
|
{
|
var res = "";
|
switch (trayType)
|
{
|
case "集化板": res = "J"; break;
|
case "大板": res = "D"; break;
|
case "小板": res = "X"; break;
|
case "超托板": res = "C"; break;
|
case "集化板前后超托": res = "JC2"; break;
|
case "大板前后超托": res = "DC"; break;
|
case "小板前后超托": res = "XC"; break;
|
case "集化板四面超托": res = "JC4"; break;
|
}
|
return res;
|
}
|
|
|
/// <summary>
|
/// 根据库区和排号找托盘类型
|
/// </summary>
|
/// <param name="kq"></param>
|
/// <param name="row"></param>
|
/// <returns></returns>
|
public static string GetTypebyrow(string kq, int row)
|
{
|
var res = "";
|
string trayType = "";
|
var db = new SqlHelper<object>().GetInstance();
|
//string[] reslist = new string[] { "D", "J", "X", "JC2", "DC", "XC", "JC" };
|
foreach (var item in areaTypes)
|
{
|
var list = db.Queryable<Location>().Where(a => a.S_AREA_CODE == kq + "_" + item && a.N_ROW == row && a.N_CURRENT_NUM > 0).ToList();
|
if (list.Count > 0)
|
{
|
trayType = item;
|
break;
|
}
|
}
|
switch (trayType)
|
{
|
|
case "J": res = "集化板"; break;
|
case "D": res = "大板"; break;
|
case "X": res = "小板"; break;
|
case "C": res = "超托板"; break;
|
case "JC2": res = "集化板前后超托"; break;
|
case "DC": res = "大板前后超托"; break;
|
case "XC": res = "小板前后超托"; break;
|
case "JC4": res = "集化板四面超托"; break;
|
}
|
return res;
|
|
|
}
|
/// <summary>
|
/// 库区后缀
|
/// </summary>
|
private static List<string> areaTypes = new List<string> { "J", "D", "X", "JC2", "DC", "XC", "JC4", "C" };
|
public static List<string> GetOtherAreas(string baseArea, string size)
|
{
|
var res = new List<string>();
|
var at = GetType(size);
|
for (int i = 0; i < areaTypes.Count; i++)
|
{
|
if (areaTypes[i] != at)
|
{
|
res.Add(baseArea + "_" + areaTypes[i]);
|
}
|
}
|
return res;
|
}
|
|
/// <summary>
|
/// 获取被占用的排号
|
/// </summary>
|
/// <param name="area0"></param>
|
/// <param name="areaType"></param>
|
/// <param name="flag"></param>
|
/// <returns></returns>
|
private static List<int> GetUsedRow(string area0, string areaType, ref bool flag)
|
{
|
//如果当前库区是C，有任意库区任意排不是C整区不能入
|
//如果当前库区不是C，但是有任意排有C整区不能入
|
bool intercept = false;
|
var db = new SqlHelper<object>().GetInstance();
|
var res = new List<int>();
|
areaTypes.Where(b => b != areaType).ToList().ForEach(b =>
|
{
|
//判断库区排有没有被占用
|
var area = area0 + "_" + b;
|
//有托盘的其他库区的排要排除
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
if (list.Count > 0)
|
{
|
res.AddRange(list.Select(c => c.N_ROW).ToList());
|
//if (areaType == "C")
|
//{
|
// Console.WriteLine($"当前库区是{areaType}，JDX库区有托盘，不可用");
|
// intercept = true;
|
//}
|
//else
|
//{
|
// if (b == "C")
|
// {
|
// Console.WriteLine($"当前库区是{areaType}，C库区有托盘，不可用");
|
// intercept = true;
|
// }
|
//}
|
}
|
//有锁的其他库区的排要排除
|
var listsuo = db.Queryable<Location>().Where(a => a.S_LOCK_STATE != "无" && a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
if (listsuo.Count > 0)
|
{
|
res.AddRange(listsuo.Select(c => c.N_ROW).ToList());
|
|
}
|
});
|
flag = intercept;
|
|
//有移库任务的排也需要排除
|
var list1 = db.Queryable<WorkOrder2>().Where(a => (a.SQL_State == "执行中" || a.SQL_State == "暂停") && a.start_area == area0).ToList();
|
if (list1.Count > 0)
|
{
|
list1.ForEach(a =>
|
{
|
LogHelper.Info($"移库任务{a.SQL_WorkNo}：起点排{a.start_row}有移库任务", "成品");
|
res.Add(a.start_row);
|
// res.Add(a.end_row);
|
});
|
}
|
|
var list2 = db.Queryable<WorkOrder2>().Where(a => (a.SQL_State == "执行中" || a.SQL_State == "暂停") && a.end_area == area0).ToList();
|
if (list2.Count > 0)
|
{
|
list2.ForEach(a =>
|
{
|
LogHelper.Info($"移库任务{a.SQL_WorkNo}：终点排{a.end_row}有移库任务", "成品");
|
// res.Add(a.start_row);
|
res.Add(a.end_row);
|
});
|
}
|
return res;
|
}
|
private static bool CheckLockedRow(string area0, string areaType, int row)
|
{
|
var res = false;
|
areaTypes.Where(b => b != areaType).ToList().ForEach(b =>
|
{
|
//判断库区排有没有被占用
|
var area = area0 + "_" + b;
|
var db = new SqlHelper<object>().GetInstance();
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == row && a.S_LOCK_STATE.Trim() != "无").First();
|
if (other != null)
|
{
|
res = true;
|
}
|
});
|
return res;
|
|
}
|
|
|
internal static void CpAuto()
|
{
|
FinishedMoveAuto();
|
//EmptyAuto();
|
}
|
|
internal static void EmptyAuto()
|
{
|
//空框区zoneType=3 自动转运入库
|
var startZone = Settings.cpZones.Where(a => a.zoneType == 3).FirstOrDefault();
|
var db = new SqlHelper<object>().GetInstance();
|
var otherTaskCount = db.Queryable<WMSTask>().Count(a => a.S_TYPE == "空托转运入库" && a.S_B_STATE != "完成" && a.S_B_STATE != "取消");
|
if (otherTaskCount == 0 && startZone != null)
|
{
|
var listSize = new List<string> { "大板", "小板", "集化板" };
|
listSize.ForEach(s =>
|
{
|
|
var list1 = db.Queryable<CPEmptyIn>().OrderByDescending(a => a.priority).Where(a => a.cntrType == s).ToList();
|
if (list1.Count > 0)
|
{
|
list1.ForEach(a =>
|
{
|
var start = LocationHelper.GetLocation4OutEmptyNotStack(startZone.zone[0], a.startRow, s);
|
if (start != null)
|
{
|
Console.WriteLine("准备创建 自动转运入库");
|
//创建入库搬运任务
|
var cntrList = LocationHelper.GetLocCntr(start.S_LOC_CODE);
|
if (cntrList.Count > 0)
|
{
|
Console.WriteLine($"托盘类型 {cntrList[0].Container.S_TYPE}");
|
Location end = null;
|
//查找空托入库库区
|
List<CPEmptyIn> list = list1.Where(b => b.startRow == a.startRow).ToList();
|
if (list.Count > 0)
|
{
|
|
Console.WriteLine("查找空托盘排");
|
for (int i = 0; i < list.Count; i++)
|
{
|
end = GetLocation4EmptyCntrIn(list[i].endArea, list[i].endRow, cntrList[0].Container.S_TYPE);
|
if (end != null)
|
{
|
break;
|
}
|
}
|
//if (end == null) {
|
// Console.WriteLine("查找空排");
|
// for (int i = 0; i < list.Count; i++) {
|
// Console.WriteLine("库区" + list[i]);
|
// end = GetLocation4InEmptyRow(list[i].endArea, cntrList[0].Container.S_TYPE);
|
// if (end != null) {
|
// break;
|
// }
|
// }
|
//}
|
|
}
|
|
if (end != null)
|
{
|
TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "空托转运入库", new List<string> { cntrList[0].S_CNTR_CODE.Trim() }, 1, end.N_CURRENT_NUM + 1, 1, 80);
|
}
|
}
|
else
|
{
|
Console.WriteLine($"{start.S_LOC_CODE}未找到托盘");
|
}
|
}
|
else
|
{
|
Console.WriteLine("空托转运入库 起点没找到托盘");
|
}
|
});
|
}
|
|
});
|
|
}
|
}
|
|
private static List<CPEmptyIn> GetCPEmptyArea(string cntrType)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<CPEmptyIn>().OrderByDescending(a => a.priority).Where(a => a.cntrType == cntrType).ToList();
|
return list;
|
}
|
private static List<CPEmptyIn> GetCPEmptyArea(string cntrType, int startRow)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<CPEmptyIn>().OrderByDescending(a => a.priority).Where(a => a.cntrType == cntrType && a.startRow == startRow).ToList();
|
return list;
|
}
|
|
public static Location GetLocation4EmptyCntrIn(string area0, string trayType)
|
{
|
Location result = null;
|
//string itemBatch = DateTime.Now.ToString("yyMMdd");
|
try
|
{
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine("成品空托入库 GetLocation4EmptyCntrIn:" + area);
|
bool flag = false;
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
if (flag)
|
{
|
Console.WriteLine("当前库区不可用，被其它尺寸托盘占用，直接返回");
|
return null;
|
}
|
//1.0 获取每一排最大的列
|
//1.1 判断当前数量是不是满的，如果是满的并且是最大列，需要排除
|
var listMaxCol = new SqlHelper<Location>().GetInstance().Queryable<Location>().Where(a => a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
//1.1 查到所有有托盘的排
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
Console.WriteLine($"查到所有有托盘的排 {list.Count}");
|
if (list.Count > 0)
|
{
|
//1.2 查找其它尺寸有托盘或者锁定的排
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
var remove = false;
|
//排除已经锁定的货位 和 放满了且是最大列的货位
|
if (list[i].S_LOCK_STATE.Trim() != "无" || (list[i].N_CURRENT_NUM == list[i].N_CAPACITY && listMaxCol.Count(a => a.S_LOC_CODE == list[i].S_LOC_CODE) > 0))
|
{
|
Console.WriteLine($"排除已经锁定的货位 和 放满了且是最大列的货位 排{list[i].N_ROW}");
|
remove = list.Remove(list[i]);
|
}
|
else
|
{
|
//排有锁也排除
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.S_LOCK_STATE.Trim() != "无").First();
|
if (other != null)
|
{
|
Console.WriteLine($"排除有锁的排{list[i].N_ROW}");
|
remove = list.Remove(list[i]);
|
}
|
}
|
if (!remove)
|
{
|
//判断是否被其它库区占用了
|
Console.WriteLine("判断是否被其它库区占用了");
|
if (usedRows.Contains(list[i].N_ROW))
|
{
|
remove = list.Remove(list[i]);
|
}
|
}
|
}
|
Console.WriteLine($"有托盘排数为{list.Count}");
|
if (list.Count > 0)
|
{
|
|
//1.3 遍历判断物料类型是否相同
|
Console.WriteLine("遍历判断是不是空托盘");
|
for (int i = 0; i < list.Count; i++)
|
{
|
//todo 还需要判断锁
|
#region 满托盘判断 物料信息相同，并且批次里面的设备相同
|
if (list[i].LocCntrRel != null && list[i].LocCntrRel.CntrItemRel == null)
|
{
|
Console.WriteLine($"有托盘的货位{list[i].S_LOC_CODE} 当前数量={list[i].N_CURRENT_NUM} 容量={list[i].N_CAPACITY}");
|
if (list[i].N_CURRENT_NUM < list[i].N_CAPACITY)
|
{
|
result = list[i];
|
}
|
else
|
{
|
//选择后面空位
|
result = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).OrderBy(a => a.N_COL).First();
|
}
|
|
if (result != null && result.C_ENABLE != "禁用")
|
{
|
break;
|
}
|
|
}
|
|
|
#endregion
|
}
|
}
|
}
|
|
if (result != null && (!string.IsNullOrEmpty(result.C_ENABLE) && result.C_ENABLE == "禁用"))
|
{
|
//禁用了选择后面一个货位
|
//Console.WriteLine("禁用了选择后面一个货位");
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == result.N_ROW && (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE != "禁用") && a.N_COL > result.N_COL).First();
|
}
|
}
|
catch (Exception ex)
|
{
|
|
//Console.WriteLine("GetLocation4InFinish:" + ex.Message + ex.StackTrace);
|
LogHelper.Error("GetLocation4EmptyCntrIn:" + ex.Message, ex);
|
}
|
return result;
|
}
|
|
public static Location GetLocation4EmptyCntrIn(string area0, int row, string trayType)
|
{
|
Location result = null;
|
//string itemBatch = DateTime.Now.ToString("yyMMdd");
|
try
|
{
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine($"成品空托入库 GetLocation4EmptyCntrIn:{area} - {row}");
|
bool flag = false;
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
if (flag)
|
{
|
Console.WriteLine("当前库区不可用，被其它尺寸托盘占用，直接返回");
|
return null;
|
}
|
if (!usedRows.Contains(row))
|
{
|
//
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.N_ROW == row && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).ToList();
|
if (list.Count(a => a.S_LOCK_STATE != "无") == 0)
|
{
|
//没有锁
|
if (list.Count > 0)
|
{
|
var last = list.OrderByDescending(a => a.N_COL).FirstOrDefault();
|
if (last.LocCntrRel != null && last.LocCntrRel.CntrItemRel == null)
|
{
|
//是空托盘
|
if (last.N_CURRENT_NUM == 1)
|
{
|
result = last;
|
}
|
else
|
{
|
result = db.Queryable<Location>().Where(a => a.N_ROW == row && a.S_AREA_CODE == area && a.N_COL > last.N_COL).OrderBy(a => a.N_COL).First();
|
}
|
}
|
}
|
else
|
{
|
//当前排没有托盘是空排，判断有没有被其它库区锁定
|
if (!CheckLockedRow(area0, GetType(trayType), row))
|
{
|
//没有锁住入最小位置
|
result = db.Queryable<Location>().Where(a => a.N_ROW == row && a.S_AREA_CODE == area).OrderBy(a => a.N_COL).First();
|
}
|
|
|
}
|
if (result != null && (!string.IsNullOrEmpty(result.C_ENABLE) && result.C_ENABLE == "禁用"))
|
{
|
//禁用了选择后面一个货位
|
//Console.WriteLine("禁用了选择后面一个货位");
|
result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE == area && a.N_ROW == result.N_ROW && (string.IsNullOrEmpty(a.C_ENABLE) || a.C_ENABLE != "禁用") && a.N_COL > result.N_COL).First();
|
}
|
|
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
|
//Console.WriteLine("GetLocation4InFinish:" + ex.Message + ex.StackTrace);
|
LogHelper.Error("GetLocation4EmptyCntrIn:" + ex.Message, ex);
|
}
|
return result;
|
}
|
|
private static bool CheckStartRow(string baseArea, int row, string size)
|
{
|
//判断起点库区排有托盘
|
bool res = false;
|
var area = baseArea + "_" + GetType(size);
|
var db = new SqlHelper<object>().GetInstance();
|
|
res = db.Queryable<Location>().Count(l => l.S_AREA_CODE == area && l.N_ROW == row && l.N_CURRENT_NUM > 0) > 0;
|
return res;
|
}
|
private static bool CheckEndRow(string baseArea, int row, string size)
|
{
|
//判断终点库区排有相同托盘，或者没有其他托盘
|
bool res = false;
|
var area = baseArea + "_" + GetType(size);
|
var db = new SqlHelper<object>().GetInstance();
|
res = db.Queryable<Location>().Count(l => l.S_AREA_CODE == area && l.N_ROW == row && l.N_CURRENT_NUM > 0) > 0;
|
if (!res)
|
{
|
//终点排没有托盘，判断是否有其他尺寸的托盘
|
LogHelper.Info($"移库任务:终点排没有托盘，判断是否有其他尺寸的托盘");
|
var list = GetOtherAreas(baseArea, size);
|
var res1 = true;
|
for (int i = 0; i < list.Count; i++)
|
{
|
|
res1 = db.Queryable<Location>().Count(l => l.S_AREA_CODE == list[i] && l.N_ROW == row && l.N_CURRENT_NUM > 0) == 0;
|
if (!res1)
|
{
|
LogHelper.Info($"移库任务:库区{list[i]},排{row}，存在托盘");
|
break;
|
}
|
}
|
res = res1;
|
}
|
|
|
return res;
|
}
|
|
|
|
/// <summary>
|
/// 移库
|
/// </summary>
|
internal static void FinishedMoveAuto()
|
{
|
try
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
//检查
|
var listUnlock = db.Queryable<WorkOrder2>().Where(a => a.SQL_State == "已完成" && a.IsUnlock != "1").ToList();
|
|
|
if (listUnlock.Count > 0)
|
{
|
listUnlock.ForEach(a =>
|
{
|
//根据起点排，起点库区查询托盘类型
|
string tptype = GetTypebyrow(a.start_area, a.start_row);
|
var startArea = a.start_area + "_" + GetType(tptype);
|
var endArea = a.end_area + "_" + GetType(tptype);
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
if (a.IsUnlock != "1")
|
{
|
//手动移库货位解锁上报
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
}
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
});
|
}
|
var list = db.Queryable<WorkOrder2>().Where(a => a.SQL_State == "执行中").ToList();
|
if (list.Count > 0)
|
{
|
|
//判断是否有其它任务相同起点排或者相同终点排，如果有优先级更高，当前工单不做
|
//Console.WriteLine("成品移库，判断是否有其它任务相同起点排或者相同终点排，如果有优先级更高，当前工单不做");
|
list.ForEach(a =>
|
{
|
//根据起点排，起点库区查询托盘类型
|
string tptype = GetTypebyrow(a.start_area, a.start_row);
|
//var other = list.OrderByDescending(b => b.priority).Where(b => b.S_ID != a.S_ID && ((b.start_area == a.start_area && b.start_row == a.start_row) || (b.end_area == a.end_area && b.end_row == a.end_row))).FirstOrDefault();
|
//if (other == null || (a.priority > other.priority || (a.priority == other.priority && a.T_CREATE < other.T_CREATE))) {
|
//准备移库
|
var startArea = a.start_area + "_" + GetType(tptype);
|
var endArea = a.end_area + "_" + GetType(tptype);
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row, false);
|
|
//判断是否有执行中的任务
|
if (IsTask(a.SQL_WorkNo))
|
{
|
//判断起点排是否有正确托盘、终点排有托盘，如果没托盘是否有其他尺寸托
|
if (!CheckStartRow(a.start_area, a.start_row, tptype))
|
{
|
a.note = $"起点库区、排没有找到{tptype}托盘";
|
a.SQL_State = "已完成";
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
//货位解锁上报
|
LogHelper.Info($"移库任务:{a.SQL_WorkNo}=> 起点库区、排没有找到{tptype}托盘,任务改成完成");
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
return;
|
}
|
}
|
|
if (!CheckEndRow(a.end_area, a.end_row, tptype))
|
{
|
a.note = $"终点库区、排有其他尺寸托盘";
|
a.SQL_State = "已完成";
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
//货位解锁上报
|
LogHelper.Info($"移库任务:{a.SQL_WorkNo}=> 终点库区、排有其他尺寸托盘,任务改成完成");
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
return;
|
}
|
|
|
//起点排的货位全部查询
|
Console.WriteLine("准备移库");
|
if (a.current >= a.number)
|
{
|
a.note = $"已经完成入库数量";
|
a.SQL_State = "已完成";
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
//货位解锁上报
|
LogHelper.Info($"移库任务:{a.SQL_WorkNo}=> 已经完成入库数量,任务改成完成");
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
return;
|
}
|
var listStarts = new SqlHelper<Location>().GetList(b => b.S_AREA_CODE.Trim() == startArea && b.N_ROW == a.start_row);
|
|
|
if (listStarts.Count > 0 && listStarts.Count(b => b.S_LOCK_STATE.Trim() != "无") == 0)
|
{
|
//列从大到小找一个满托
|
//Console.WriteLine("列从大到小找一个满托");
|
var start = listStarts.OrderByDescending(l => l.N_COL).Where(l => l.N_CURRENT_NUM > 0).FirstOrDefault();
|
if (start != null)
|
{
|
var cntrList = LocationHelper.GetLocCntr(start.S_LOC_CODE);
|
var cntr = cntrList.OrderByDescending(c => c.T_CREATE).Take(2).ToList();
|
var cirStart = ContainerHelper.GetCntrItemRel(cntr[0].S_CNTR_CODE);
|
// string tp = cntr.ToString();
|
string tp = string.Join(",", cntr.Select(t => t.S_CNTR_CODE).ToArray());
|
//查找终点
|
//Console.WriteLine("查找终点");
|
var listEnds = new SqlHelper<Location>().GetList(b => b.S_AREA_CODE.Trim() == endArea && b.N_ROW == a.end_row);// && b.C_ENABLE != "禁用"
|
|
if (listEnds.Count > 0 && listStarts.Count(b => b.S_LOCK_STATE.Trim() != "无") == 0 && listEnds.Count(b => b.S_LOCK_STATE.Trim() != "无") == 0)
|
{
|
//从大到小找个满的，然后选择后面一个空位
|
//Console.WriteLine("从大到小找个满的");
|
var full = listEnds.OrderByDescending(l => l.N_COL).Where(l => l.N_CURRENT_NUM > 0).FirstOrDefault();
|
if (full == null)
|
{
|
var end = listEnds.Where(loc => loc.C_ENABLE != "禁用").OrderBy(loc => loc.N_COL).FirstOrDefault();
|
int cg = 0;
|
//计算层高
|
if (end.N_CURRENT_NUM == 0)
|
{
|
cg = 1;
|
}
|
else if (end.N_CURRENT_NUM == 2)
|
{
|
cg = 2;
|
}
|
else if (end.N_CURRENT_NUM == 4)
|
{
|
cg = 3;
|
}
|
//创建任务
|
//Console.WriteLine("没有满托，选一个最小的空位");
|
TaskProcess.CreateTransport(start.S_LOC_CODE, end.S_LOC_CODE, "成品移库", new List<string> { tp.Trim() }, cntrList.Count / 2, cg, 1, 1, a.SQL_WorkNo);
|
a.current++;
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.current, it.T_MODIFY }).ExecuteCommand();
|
//货位锁定上报
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, true, startArea, endArea, a.start_row, a.end_row);
|
|
}
|
else
|
{
|
var cntrFull = LocationHelper.GetLocCntr(full.S_LOC_CODE);
|
var cirEnd = ContainerHelper.GetCntrItemRel(cntrFull[0].S_CNTR_CODE);
|
if (cirStart[0].S_ITEM_CODE.Trim() != cirEnd[0].S_ITEM_CODE.Trim())
|
{
|
//物料信息不一样，直接结束工单
|
//Console.WriteLine("物料信息不一样，直接结束工单");
|
a.note = "物料信息不一样，工单结束";
|
a.SQL_State = "已完成";
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
LogHelper.Info($"移库任务:{a.SQL_WorkNo}=> 物料信息不一样，工单结束,任务改成完成");
|
//货位解锁上报
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
}
|
else
|
{
|
//判断批次是不是一样
|
//if (cirStart[0].S_BATCH_NO.Substring(0, 6) == cirEnd[0].S_BATCH_NO.Substring(0, 6)) {
|
//Console.WriteLine("批次一样");
|
//判断满托位有几个托盘，如果是4个托盘，直接找后一位
|
if (cntrFull.Count == 4)
|
{
|
//Console.WriteLine("货位满了，选择后一个货位");
|
var after = listEnds.OrderBy(loc => loc.N_COL).Where(loc => loc.N_COL > full.N_COL && loc.C_ENABLE != "禁用").FirstOrDefault();
|
//创建任务
|
if (after != null)
|
{
|
int cg = 0;
|
//计算层高
|
if (after.N_CURRENT_NUM == 0)
|
{
|
cg = 1;
|
}
|
else if (after.N_CURRENT_NUM == 2)
|
{
|
cg = 2;
|
}
|
else if (after.N_CURRENT_NUM == 4)
|
{
|
cg = 3;
|
}
|
TaskProcess.CreateTransport(start.S_LOC_CODE, after.S_LOC_CODE, "成品移库", new List<string> { tp.Trim() }, cntrList.Count / 2, cg, 1, 1, a.SQL_WorkNo);
|
|
a.current++;
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.current, it.T_MODIFY }).ExecuteCommand();
|
//货位锁定上报
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, true, startArea, endArea, a.start_row, a.end_row);
|
}
|
}
|
else
|
{
|
//如果是1个托盘，要判断是单托还是双托
|
//Console.WriteLine("如果是1个托盘，要判断是单托还是双托");
|
//if (cntrFull[0].S_CNTR_CODE.Contains(','))
|
// {
|
|
//创建任务
|
//Console.WriteLine("双托，可以卸货");
|
|
int cg = 0;
|
//计算层高
|
if (full.N_CURRENT_NUM == 0)
|
{
|
cg = 1;
|
}
|
else if (full.N_CURRENT_NUM == 2)
|
{
|
cg = 2;
|
}
|
else if (full.N_CURRENT_NUM == 4)
|
{
|
cg = 3;
|
}
|
TaskProcess.CreateTransport(start.S_LOC_CODE, full.S_LOC_CODE, "成品移库", new List<string> { tp.Trim() }, cntrList.Count / 2, cg, 1, 1, a.SQL_WorkNo);
|
a.current++;
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.current, it.T_MODIFY }).ExecuteCommand();
|
//货位锁定上报
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, true, startArea, endArea, a.start_row, a.end_row);
|
// }
|
//else
|
//{
|
// //单托不可以卸货
|
// //Console.WriteLine("单托不可以卸货，选择后一个货位");
|
// var after = listEnds.OrderBy(loc => loc.N_COL).Where(loc => loc.N_COL > full.N_COL && loc.C_ENABLE != "禁用").FirstOrDefault();
|
// //创建任务
|
// if (after != null)
|
// {
|
// TaskProcess.CreateTransport(start.S_LOC_CODE, after.S_LOC_CODE, "成品移库", new List<string> { cntr.S_CNTR_CODE.Trim() }, cntrList.Count, 1);
|
// a.current++;
|
// a.T_MODIFY = DateTime.Now;
|
// db.Updateable(a).UpdateColumns(it => new { it.current, it.T_MODIFY }).ExecuteCommand();
|
// }
|
// else
|
// {
|
// //终点排满了，自动结束
|
// //Console.WriteLine("终点满了或不可入，工单结束");
|
// a.note = "终点满了或不可入，工单结束";
|
// a.SQL_State = "已完成";
|
// a.IsUnlock = "1";
|
// a.T_MODIFY = DateTime.Now;
|
// db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
// AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
// }
|
//}
|
|
}
|
//}
|
//else {
|
// //批次不一样，空一格
|
// //Console.WriteLine("批次不一样，空一格");
|
// var after = listEnds.OrderBy(loc => loc.N_COL).Where(loc => loc.N_COL > (full.N_COL + 1) && loc.C_ENABLE != "禁用").FirstOrDefault();
|
// if (after != null) {
|
// TaskProcess.CreateTransport(start.S_LOC_CODE, after.S_LOC_CODE, "成品移库", new List<string> { cntr.S_CNTR_CODE.Trim() }, cntrList.Count, 1);
|
// }
|
// else {
|
// //终点排满了，自动结束
|
// //Console.WriteLine("终点满了或不可入，工单结束");
|
// a.note = "终点满了或不可入，工单结束";
|
// a.SQL_State = "已完成";
|
// a.IsUnlock = "1";
|
// db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock }).ExecuteCommand();
|
// AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
// }
|
|
//}
|
|
}
|
|
}
|
}
|
}
|
else
|
{
|
if (IsTask(a.SQL_WorkNo))
|
{
|
//起点排没有托盘了，更新工单状态为完成
|
a.note = "起点没托盘，工单结束";
|
a.SQL_State = "已完成";
|
a.IsUnlock = "1";
|
a.T_MODIFY = DateTime.Now;
|
db.Updateable(a).UpdateColumns(it => new { it.SQL_State, it.note, it.IsUnlock, it.T_MODIFY }).ExecuteCommand();
|
AddMoveOrderNotice(a.SQL_WorkNo, startArea, a.start_row, endArea, a.end_row);
|
//货位解锁上报
|
LogHelper.Info($"移库任务:{a.SQL_WorkNo}=> 起点没托盘，工单结束,任务改成完成");
|
YiKuUnLockRow(a.start_area + "-" + a.start_row.ToString() + "," + a.end_area + "-" + a.end_row.ToString(), a.SQL_WorkNo, false, startArea, endArea, a.start_row, a.end_row);
|
}
|
|
}
|
}
|
|
|
|
});
|
}
|
}
|
catch (Exception ex)
|
{
|
//Console.WriteLine("FinishedMoveAuto:" + ex.Message);
|
LogHelper.Error("FinishedMoveAuto:" + ex.Message, ex);
|
}
|
}
|
|
private static void AddMoveOrderNotice(string moveOrder, string start_area, int start_row, string end_area, int end_row, bool complete = true)
|
{
|
var db = new SqlHelper<object>().GetInstance();
|
var start = db.Queryable<Location>().Where(a => a.S_AREA_CODE == start_area && a.N_ROW == start_row).First();
|
var end = db.Queryable<Location>().Where(a => a.S_AREA_CODE == end_area && a.N_ROW == end_row).First();
|
if (start != null && end != null)
|
{
|
var startArea = start.S_LOC_CODE.Substring(0, 1) + start.N_ROW;
|
var endArea = end.S_LOC_CODE.Substring(0, 1) + end.N_ROW;
|
var old = db.Queryable<MoveOrderNotice>().Where(a => a.OrderNo == moveOrder).First();
|
if (!complete)
|
{
|
if (old == null)
|
{
|
old = new MoveOrderNotice { OrderNo = moveOrder };
|
old.StartArea = startArea;
|
old.EndArea = endArea;
|
db.Insertable<MoveOrderNotice>(old).ExecuteCommand();
|
}
|
}
|
else
|
{
|
if (old != null)
|
{
|
old.State = 1;
|
old.IsNotice = 0;
|
db.Updateable<MoveOrderNotice>(old).UpdateColumns(it => new { it.State, it.IsNotice }).ExecuteCommand();
|
}
|
}
|
}
|
|
}
|
|
internal static Location GetLocation4EmptyCntrOut(string size)
|
{
|
Location start = null;
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<CPEmptyOut>().ToList();
|
if (list.Count > 0)
|
{
|
for (int i = 0; i < list.Count; i++)
|
{
|
start = GetLocation4EmptyOut(list[i].area, list[i].row, size);
|
if (start != null)
|
{
|
break;
|
}
|
}
|
}
|
return start;
|
}
|
public static Location GetLocation4EmptyOut(string area0, string trayType)
|
{
|
Location result = null;
|
|
try
|
{
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine("成品空托出库 GetLocation4EmptyOut:" + area);
|
//var usedRows = GetUsedRow(area0, GetType(trayType));
|
bool flag = false;
|
var usedRows = GetUsedRow(area0, GetType(trayType), ref flag);
|
if (flag) { return null; }
|
//1.0 获取每一排最大的列
|
//1.1 判断当前数量是不是满的，如果是满的并且是最大列，需要排除
|
var listMaxCol = new SqlHelper<Location>().GetInstance().Queryable<Location>().Where(a => a.S_AREA_CODE == area).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
//1.1 查到所有有托盘的排
|
Console.WriteLine("查到所有有托盘的排 ");
|
var db = new SqlHelper<object>().GetInstance();
|
var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE == area).Includes(a => a.LocCntrRel, a => a.CntrItemRel).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
|
if (list.Count > 0)
|
{
|
//1.2 查找其它尺寸有托盘或者锁定的排
|
for (int i = list.Count - 1; i >= 0; i--)
|
{
|
var remove = false;
|
//排除已经锁定的货位
|
if (list[i].S_LOCK_STATE.Trim() != "无")
|
{
|
remove = list.Remove(list[i]);
|
}
|
else
|
{
|
//排有锁也排除
|
var other = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == list[i].N_ROW && a.S_LOCK_STATE.Trim() != "无").First();
|
if (other != null)
|
{
|
//Console.WriteLine($"排除有锁的排{list[i].N_ROW}");
|
remove = list.Remove(list[i]);
|
}
|
}
|
if (!remove)
|
{
|
//判断是否被其它库区占用了
|
if (usedRows.Contains(list[i].N_ROW))
|
{
|
remove = list.Remove(list[i]);
|
}
|
}
|
}
|
Console.WriteLine($"有托盘排数为{list.Count}");
|
if (list.Count > 0)
|
{
|
|
//1.3 遍历判断物料类型是否相同
|
Console.WriteLine("遍历判断是否为空托盘");
|
for (int i = 0; i < list.Count; i++)
|
{
|
if (list[i].LocCntrRel != null && list[i].LocCntrRel.CntrItemRel == null)
|
{
|
result = list[i];
|
if (result != null)
|
{
|
break;
|
}
|
}
|
|
}
|
}
|
}
|
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Error("GetLocation4EmptyOut:" + ex.Message, ex);
|
}
|
return result;
|
}
|
|
public static Location GetLocation4EmptyOut(string area0, int row, string trayType)
|
{
|
Location result = null;
|
|
try
|
{
|
var area = area0 + "_" + GetType(trayType);
|
Console.WriteLine($"成品空托出库 GetLocation4EmptyOut: {area} - {row}");
|
var list = new SqlHelper<Location>().GetInstance().Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == row && a.N_CURRENT_NUM > 0).Includes(a => a.LocCntrRel, a => a.CntrItemRel).ToList();
|
if (list.Count > 0 && list.Count(a => a.S_LOCK_STATE != "无") == 0)
|
{
|
//当前排没有锁
|
//判断托盘类型是否一致
|
var start = list.OrderByDescending(a => a.N_COL).FirstOrDefault();
|
if (start.LocCntrRel != null && start.LocCntrRel.CntrItemRel == null)
|
{
|
result = start;
|
}
|
}
|
|
}
|
catch (Exception ex)
|
{
|
LogHelper.Error("GetLocation4EmptyOut:" + ex.Message, ex);
|
}
|
return result;
|
}
|
|
|
|
|
/// <summary>
|
/// 移库 上报锁定或解锁库位（排）
|
/// </summary>
|
/// <param name="Row"></param>
|
public static void YiKuUnLockRow(string row, string worno, bool state, string startarea, string endarea, int startrow, int endrow)
|
{
|
// var db = new SqlHelper<object>().GetInstance();
|
//检查
|
//var Startloc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == startarea && a.N_ROW == startrow).ToList();
|
//var Endloc = db.Queryable<Location>().Where(a => a.S_AREA_CODE == endarea && a.N_ROW == endrow).ToList();
|
|
// 第一次生成任务上报锁定货位
|
// 接触货位判断是不是生成过货位
|
// 排锁上报格式：库区加排号 如：(C04-1)
|
|
if (state)
|
{
|
//判断是否第一条任务，第一条任务上报锁定排
|
var task = TaskHelper.GetTaskBySrcNo(worno);
|
if (task.Count == 1)
|
{
|
//移库锁定货位上报
|
TaskProcess.AreaRowLockState(row, state);
|
#region 排锁 弃用
|
//移库起点终点排添加移库锁
|
//Startloc.ForEach(a =>
|
//{
|
// LocationHelper.LockLoc(a.S_LOC_CODE, "移库锁");
|
//});
|
//Endloc.ForEach(a =>
|
//{
|
// LocationHelper.LockLoc(a.S_LOC_CODE, "移库锁");
|
//});
|
#endregion
|
|
|
}
|
}
|
else
|
{
|
//判断是否创建任务，创建任务上传解锁排
|
var task = TaskHelper.GetTaskBySrcNo(worno);
|
if (task.Count >= 1)
|
{
|
//移库解锁定货位上报
|
TaskProcess.AreaRowLockState(row, state);
|
#region 排锁 弃用
|
//移库起点终点排解锁
|
//Startloc.ForEach(a =>
|
//{
|
// LocationHelper.LockLoc(a.S_LOC_CODE, "无");
|
//});
|
//Endloc.ForEach(a =>
|
//{
|
// LocationHelper.LockLoc(a.S_LOC_CODE, "无");
|
//});
|
#endregion
|
|
}
|
}
|
|
}
|
|
/// <summary>
|
/// 根据移库单号判断移库任务是否全部完成
|
/// </summary>
|
/// <param name="worno"></param>
|
/// <returns></returns>
|
public static bool IsTask(string worno)
|
{
|
bool res = true;
|
var db = new SqlHelper<object>().GetInstance();
|
|
//判断是否有未完成的任务
|
var task = TaskHelper.GetTaskBySrcNo(worno);
|
List<WMSTask> taskbystate = task.FindAll(a => a.S_B_STATE != "完成").ToList();
|
taskbystate = taskbystate.FindAll(a => a.S_B_STATE != "强制完成").ToList();
|
if (taskbystate.Count > 0)
|
{
|
res = false;
|
}
|
|
return res;
|
}
|
}
|
}
|
