using iWareCommon.Utils;
|
using iWareSda_QQJF.RGV.RgvService;
|
using iWareSda_QQJF.RgvModel;
|
using iWareSda_QQJF.SRM.SrmModel;
|
using iWareSda_QQJF.SRM.SrmService;
|
using iWareSda_QQJF.SRMTRAN.SrmTranService;
|
using iWareSda_QQJF.SrmTranModel;
|
using iWareSda_QQJF.WCSNEW.EDM;
|
using logtxtWrite;
|
using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.Globalization;
|
using System.Linq;
|
using System.Speech.Synthesis;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
namespace iWareSda_QQJF.WCSNEW
|
{
|
public class Helper
|
{
|
static List<int> tranIdByRgv2 = new List<int> { 20, 29, 10, 21, 22, 23, 24, 25, 26, 27, 28, 33, 34, 19 };//2号RGV负责输送线号(除中转台)
|
static List<int> tranIdByRgv1 = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 14, 15, 12 };//1号RGV负责输送线号
|
static List<int> tranIdByRgv3 = new List<int> { 49, 50, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 47 };//3号RGV负责输送线号
|
static List<int> tranIdByRgv4 = new List<int> { 44, 53, 54, 55, 56, 57, 58, 59, 60, 66, 67, 62, 63, 52 };//4号RGV负责输送线号
|
static List<int> needLeaveTran = new List<int> { 14, 15, 17, 20, 8, 9, 10, 21, 42, 43, 44, 53, 52, 50 };
|
/// <summary>
|
/// 判断RGV是否干涉
|
/// </summary>
|
/// <returns></returns>
|
public static bool IsTouch(int tranid, int rgvid)
|
{
|
using (Model edm = new Model())
|
{
|
TranLock tran = edm.TranLock.FirstOrDefault(x => x.TRANID == tranid);
|
if (tran.ISLOCK == 1 && tran.LOCKDEVICEID != rgvid)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 语音
|
/// </summary>
|
/// <param name="saying"></param>
|
public static void Speaking(string saying)
|
{
|
string say = saying;
|
Task task = new Task(() =>
|
{
|
SpeechSynthesizer speech = new SpeechSynthesizer();
|
speech.Volume = 100; //音量
|
CultureInfo keyboardCulture = System.Windows.Forms.InputLanguage.CurrentInputLanguage.Culture;
|
InstalledVoice neededVoice = speech.GetInstalledVoices(keyboardCulture).FirstOrDefault();
|
if (neededVoice == null)
|
{
|
say = "未知的操作";
|
}
|
else
|
{
|
speech.SelectVoice(neededVoice.VoiceInfo.Name);
|
}
|
|
speech.Speak(say);
|
});
|
task.Start();
|
}
|
|
/// <summary>
|
/// 音调
|
/// </summary>
|
/// <param name="saying"></param>
|
public static void Song(string saying, int length)
|
{
|
int hz = 0;
|
switch (saying)
|
{
|
case "a": hz = 262; break;
|
case "s": hz = 294; break;
|
case "d": hz = 330; break;
|
case "f": hz = 349; break;
|
case "g": hz = 392; break;
|
case "h": hz = 440; break;
|
case "j": hz = 494; break;
|
case "q": hz = 523; break;
|
case "w": hz = 587; break;
|
case "e": hz = 659; break;
|
case "r": hz = 698; break;
|
case "t": hz = 784; break;
|
case "y": hz = 880; break;
|
case "u": hz = 988; break;
|
case "1": hz = 1046; break;
|
case "2": hz = 1175; break;
|
case "3": hz = 1318; break;
|
case "4": hz = 1397; break;
|
case "5": hz = 1568; break;
|
case "6": hz = 1760; break;
|
case "7": hz = 1976; break;
|
}
|
Console.Beep(hz, length);
|
}
|
|
|
/// <summary>
|
/// 根据出口类型获取出库输送线
|
/// </summary>
|
/// <returns></returns>
|
public static int GetOutTran(int outType, string sourcePlace)
|
{
|
try
|
{
|
using (Model edm = new Model())
|
{
|
//获取每个口的任务占用数量
|
int tranNum1 = edm.TASK_TASK.Where(x => x.TOPLACE == "67" && x.HASFINISHED == 0).Count();//东分拣
|
int tranNum2 = edm.TASK_TASK.Where(x => x.TOPLACE == "51" && x.HASFINISHED == 0).Count();//东冲压1
|
int tranNum3 = edm.TASK_TASK.Where(x => x.TOPLACE == "64" && x.HASFINISHED == 0).Count();//东冲压2
|
int tranNum4 = edm.TASK_TASK.Where(x => x.TOPLACE == "34" && x.HASFINISHED == 0).Count();//西分拣
|
int tranNum5 = edm.TASK_TASK.Where(x => x.TOPLACE == "12" && x.HASFINISHED == 0).Count();//西空托盘
|
int tranNum6 = edm.TASK_TASK.Where(x => x.TOPLACE == "19" && x.HASFINISHED == 0).Count();//西焊装1
|
int tranNum7 = edm.TASK_TASK.Where(x => x.TOPLACE == "30" && x.HASFINISHED == 0).Count();//西焊装2
|
|
//比较任务占用数,选择小的(无故障的)
|
//根据出口类型分类
|
|
switch (outType)
|
{
|
case 1://1=西边焊接区
|
{
|
//if (tranNum6 <= tranNum7)
|
if (int.Parse(sourcePlace.Substring(0, 1)) > 5)//5号巷道以上走19
|
{
|
return 19;
|
}
|
else
|
{
|
return 30;
|
}
|
}
|
//case 2: return 34;//2=西边分拣区
|
//case 3: return 12;//3=西边空托盘出库
|
//case 4: return 67;//4=东边分拣区
|
case 5://5=东边冲压区
|
{
|
//if (tranNum2 <= tranNum3 && tranNum2 <= tranNum1)
|
if (int.Parse(sourcePlace.Substring(0, 1)) >= 5)//5号巷道以上走51
|
{
|
return 51;
|
}
|
else if (tranNum3 <= tranNum1)
|
{
|
return 64;
|
}
|
else
|
{
|
return 67;
|
}
|
}
|
case 6: return 0;//6=东边空托盘出库(无此情况)
|
default: return 0;
|
}
|
}
|
}
|
catch
|
{
|
return 0;
|
}
|
}
|
|
/// <summary>
|
/// 判断任务是否可以下发
|
/// </summary>
|
/// <param name="source"></param>
|
/// <param name="to"></param>
|
/// <param name="tasktype"></param>
|
/// <returns></returns>
|
public static bool TaskCouldSend(string source, string to, int tasktype, out int statusId, out int deviceId)
|
{
|
try
|
{
|
statusId = 0;
|
deviceId = 0;
|
|
iWareSda_QQJF.SRM.SrmService.SrmService srmService = new SRM.SrmService.SrmService();
|
iWareSda_QQJF.SRMTRAN.SrmTranService.SrmTranService tranService = new SRMTRAN.SrmTranService.SrmTranService();
|
|
//获取任务开始设备是否空闲
|
if (tasktype == 1)
|
{
|
if (!tranService.TranNotUse(int.Parse(source)))
|
{
|
statusId = 1;
|
deviceId = int.Parse(source);
|
return false;
|
}
|
}
|
else if (tasktype == 2 || tasktype == 3)
|
{
|
int srmid = int.Parse(source.Substring(0, 1));
|
if (!srmService.IsNotUse(srmid))
|
{
|
statusId = 1;
|
deviceId = srmid;
|
return false;
|
}
|
}
|
//获取使用的所有设备是否可用
|
|
return true;
|
}
|
catch (Exception e)
|
{
|
logtxt.txtWrite("类名:Helper/函数名:TaskCouldSend/ :" + e, 1);
|
}
|
|
statusId = 98;
|
deviceId = 0;
|
return false;
|
}
|
|
/// <summary>
|
/// 根据RGV选择防干涉安全目的地
|
/// </summary>
|
/// <param name="rgvId"></param>
|
/// <returns></returns>
|
public static int GetSafeTranId(int rgvId)
|
{
|
switch (rgvId)
|
{
|
case 1: return 7;
|
case 2: return 22;
|
case 3: return 41;
|
case 4: return 54;
|
default: return 0;
|
}
|
}
|
/// <summary>
|
/// 任务锁定输送线
|
/// </summary>
|
/// <param name="i"></param>
|
/// <param name="sourceLocal"></param>
|
/// <param name="toLocal"></param>
|
public static bool LockTran(int rgvId, long sourceLocal, long toLocal)
|
{
|
//加锁
|
using (Model edm = new Model())
|
{
|
int isSouth = 0;
|
int isEast = 0;
|
switch (rgvId)
|
{
|
case 2: isSouth = 1; isEast = 0; break;
|
case 1: isSouth = 0; isEast = 0; break;
|
case 3: isSouth = 0; isEast = 1; break;
|
case 4: isSouth = 1; isEast = 1; break;
|
default: break;
|
}
|
List<TranLock> tranList;
|
if (isSouth == 1)
|
{
|
tranList = edm.TranLock.Where(x => (x.LOCAL <= sourceLocal || x.LOCAL <= toLocal) && x.ISEAST == isEast).ToList();
|
}
|
else
|
{
|
tranList = edm.TranLock.Where(x => (x.LOCAL >= sourceLocal || x.LOCAL >= toLocal) && x.ISEAST == isEast).ToList();
|
}
|
foreach (var tran in tranList)
|
{
|
tran.ISLOCK = 1;
|
tran.ISERRORLOCK = 0;
|
tran.LOCKDEVICEID = rgvId;
|
}
|
//去除原先锁定但目前不用锁定的输送线
|
List<TranLock> unLock = edm.TranLock.Where(x => x.LOCKDEVICEID == rgvId).ToList();
|
foreach (var i in unLock)
|
{
|
if (!tranList.Contains(i))
|
{
|
i.ISLOCK = 0;
|
i.LOCKDEVICEID = 0;
|
}
|
}
|
//if (edm.SaveChanges() > 0)
|
//{
|
edm.SaveChanges();
|
return true;//有时锁定刚好就是一个不变
|
//}
|
//else
|
//{
|
// return false;
|
//}
|
}
|
}
|
|
/// <summary>
|
/// 根据输送线号获取相邻的输送线号
|
/// </summary>
|
/// <param name="tranid"></param>
|
public static int GetNextTran(int tranid)
|
{
|
switch (tranid)
|
{
|
//case 46: return 47;
|
//case 47: return 46;
|
//case 45: return 45;
|
case 47: return 46;
|
case 46: return 47;
|
case 45: return 68;
|
case 68: return 45;
|
case 48: return 49;
|
case 49: return 48;
|
case 61: return 62;
|
case 62: return 61;
|
case 65: return 66;
|
case 66: return 65;
|
case 32: return 33;
|
case 33: return 32;
|
case 15: return 14;
|
case 14: return 15;
|
case 20: return 19;
|
case 19: return 20;
|
case 34: return 34;
|
case 67: return 67;
|
case 30: return 29;
|
case 29: return 30;
|
case 12: return 11;
|
case 11: return 12;
|
case 64: return 63;
|
case 63: return 64;
|
case 51: return 50;
|
case 50: return 51;
|
|
|
default: return 0;
|
}
|
}
|
|
/// <summary>
|
/// 判断是否需要中转
|
/// </summary>
|
/// <param name="srmid"></param>
|
/// <param name="tranid"></param>
|
/// <returns></returns>
|
public static bool NeedTwoRgv(int srmid, int tranid, int tasktype)
|
{
|
RgvService rgvService = new RgvService();
|
bool isEast = GetIsEast(tranid);
|
int source = 0;
|
int to = 0;
|
if (tasktype == 1)
|
{
|
source = GetNextTran(tranid);
|
to = GetTranEnter(srmid, tasktype, isEast);
|
}
|
else if (tasktype == 2)
|
{
|
to = GetNextTran(tranid);
|
source = GetTranEnter(srmid, tasktype, isEast);
|
}
|
int rgv1 = 0;
|
int rgv2 = 0;
|
|
using (Model edm = new Model())
|
{
|
int sourceLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == source).LOCAL;
|
int toLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == to).LOCAL;
|
int centerLocal = 0;
|
if (isEast)
|
{
|
centerLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == 52).LOCAL;
|
rgv1 = 3;
|
rgv2 = 4;
|
}
|
else
|
{
|
centerLocal = edm.TranLock.FirstOrDefault(x => x.TRANID == 17).LOCAL;
|
rgv1 = 1;
|
rgv2 = 2;
|
}
|
if ((sourceLocal >= centerLocal && toLocal <= centerLocal) || (sourceLocal <= centerLocal && toLocal >= centerLocal))//需要中转台
|
{
|
bool rgvIsUse1 = rgvService.IsRgvUseful(rgv1);
|
bool rgvIsUse2 = rgvService.IsRgvUseful(rgv2);
|
|
if (rgvIsUse1 && rgvIsUse2)//设备非故障
|
{
|
return true;
|
}
|
else
|
{
|
if (!rgvIsUse1)
|
{
|
WZ.Useful.Commons.LogTextHelper.WriteLine("rgv1不可用", "", "");
|
}
|
else if (!rgvIsUse2)
|
{
|
WZ.Useful.Commons.LogTextHelper.WriteLine("rgv2不可用", "", "");
|
}
|
return false;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 根据起始目标计算调用RGV
|
/// </summary>
|
/// <param name="sourcePlace"></param>
|
/// <param name="toPlace"></param>
|
public static int GetRGVId(int sourcePlace, int toPlace)
|
{
|
RgvService rgvService = new RgvService();
|
int rgvid1 = 0;//第一优先级RGV
|
int rgvid2 = 0;//第二优先级RGV
|
int resultRgv = 0;
|
//获取排序两台RGV优先级
|
if (tranIdByRgv1.Contains(sourcePlace) || tranIdByRgv1.Contains(toPlace))
|
{
|
rgvid1 = 1;
|
rgvid2 = 2;
|
}
|
else if (tranIdByRgv2.Contains(sourcePlace) || tranIdByRgv2.Contains(toPlace))
|
{
|
rgvid1 = 2;
|
rgvid2 = 1;
|
}
|
else if (tranIdByRgv3.Contains(sourcePlace) || tranIdByRgv3.Contains(toPlace))
|
{
|
rgvid1 = 3;
|
rgvid2 = 4;
|
}
|
else if (tranIdByRgv4.Contains(sourcePlace) || tranIdByRgv4.Contains(toPlace))
|
{
|
rgvid1 = 4;
|
rgvid2 = 3;
|
}
|
else
|
{
|
return resultRgv;
|
}
|
using (Model edm = new Model())
|
{
|
TranLock sourceTran = edm.TranLock.FirstOrDefault(x => x.TRANID == sourcePlace);
|
TranLock toTran = edm.TranLock.FirstOrDefault(x => x.TRANID == sourcePlace);
|
|
//第一优先级RGV是否可用
|
if (rgvService.IsRgvUseful(rgvid1))
|
{
|
resultRgv = rgvid1;
|
}
|
//第二RGV是否可用
|
else
|
{
|
if (rgvService.IsRgvUseful(rgvid2))
|
{
|
resultRgv = rgvid2;
|
}
|
}
|
}
|
return resultRgv;
|
}
|
|
/// <summary>
|
/// 创建RGV任务
|
/// </summary>
|
/// <param name="TASK_TASK"></param>
|
/// <param name="srmTask"></param>
|
/// <param name="tranid"></param>
|
public static bool AddRGVTask(Model edm, TASK_TASK mainTask, int sourceTran, int toTran, int tasktype, RgvTask pretask, out int useRgv, out RgvTask task)
|
{
|
RgvTask rgvTask = new RgvTask();
|
rgvTask.TASK_TASK = mainTask;
|
rgvTask.ISRELEASED = 0;
|
rgvTask.HASFINISHED = 0;
|
rgvTask.PRERGVTASK = pretask;
|
int rgvid = Helper.GetRGVId(sourceTran, toTran);
|
useRgv = rgvid;
|
if (rgvid == 0)//设备不可用
|
{
|
task = null;
|
return false;
|
}
|
//int rgvTranid = GetTranEnter(srmId, mainTask.TASKTYPE, GetIsEast(tranid));
|
//int enterTranId = GetNextTran(tranid);
|
//Helper.GetRGVFromToAndId(rgvTranid, enterTranId, mainTask.TASKTYPE, out sourceplace, out toplace, out rgvid);
|
rgvTask.SOURCEPLACE = sourceTran;
|
rgvTask.TOPLACE = toTran;
|
rgvTask.USERGVID = rgvid;
|
rgvTask.TASKTYPE = tasktype;
|
if (rgvTask.TASKTYPE == 1 && rgvTask.PRERGVTASK != null)//是入库有搬运有前置任务说明是运行完能动堆垛机
|
{
|
if (mainTask.TASKTYPE == 1)
|
{
|
rgvTask.UPDATESRMTASK = 1;
|
}
|
}
|
edm.RgvTask.Add(rgvTask);
|
//输出使用的RGV编号及RGV任务号
|
//taskId = edm.RgvTask.OrderByDescending(x => x.ID).FirstOrDefault(x => x.MainTask.ID == mainTask.ID).ID;//取出此主任务下的最后生成的一条分RGV任务(就是刚刚那条)
|
task = rgvTask;
|
|
//中转台及其附近输送线避让任务
|
if (needLeaveTran.Contains(toTran))
|
{
|
int safeTran = Helper.GetSafeTranId(rgvid);
|
|
RgvTask rgvTaskLeave = new RgvTask();
|
rgvTaskLeave.TASK_TASK = mainTask;
|
rgvTaskLeave.ISRELEASED = 0;
|
rgvTaskLeave.HASFINISHED = 0;
|
rgvTaskLeave.PRERGVTASK = rgvTask;
|
rgvTaskLeave.SOURCEPLACE = toTran;
|
rgvTaskLeave.TOPLACE = safeTran;
|
rgvTaskLeave.USERGVID = rgvid;
|
rgvTaskLeave.TASKTYPE = 2;
|
edm.RgvTask.Add(rgvTaskLeave);
|
task = rgvTaskLeave;
|
}
|
|
return true;
|
}
|
|
/// <summary>
|
/// 设置任务为故障
|
/// </summary>
|
/// <param name="mainTask"></param>
|
public static void SetTaskOver(TASK_TASK mainTask, int deviceid)
|
{
|
Model edmAnother = new Model();
|
TASK_TASK mainTaskAnther = edmAnother.TASK_TASK.FirstOrDefault(x => x.ID == mainTask.ID);
|
mainTask.HASREADED = 1;
|
mainTask.HASFINISHED = 1;
|
mainTask.ISERROR = 1;
|
mainTask.ERRORDEVICEID = deviceid;
|
mainTask.ERRORMSG = 3;
|
edmAnother.SaveChanges();
|
}
|
|
/// <summary>
|
/// 根据巷道和任务类型,以及东西,筛选输入库巷道
|
/// </summary>
|
/// <param name="srmid"></param>
|
/// <param name="tasktype"></param>
|
public static int GetTranEnter(int srmid, int tasktype, bool isEast)
|
{
|
if (isEast)
|
{
|
if (tasktype == 1)
|
{
|
switch (srmid)
|
{
|
case 1: return 60;
|
case 2: return 58;
|
case 3: return 56;
|
case 4: return 54;
|
case 5: return 44;
|
case 6: return 42;
|
case 7: return 40;
|
case 8: return 38;
|
case 9: return 36;
|
default: return 0;
|
}
|
}
|
else if (tasktype == 2)
|
{
|
switch (srmid)
|
{
|
case 1: return 59;
|
case 2: return 57;
|
case 3: return 55;
|
case 4: return 53;
|
case 5: return 43;
|
case 6: return 41;
|
case 7: return 39;
|
case 8: return 37;
|
case 9: return 35;
|
default: return 0;
|
}
|
}
|
}
|
else
|
{
|
if (tasktype == 1)
|
{
|
switch (srmid)
|
{
|
case 1: return 27;
|
case 2: return 25;
|
case 3: return 23;
|
case 4: return 21;
|
case 5: return 9;
|
case 6: return 7;
|
case 7: return 5;
|
case 8: return 3;
|
case 9: return 1;
|
default: return 0;
|
}
|
}
|
else if (tasktype == 2)
|
{
|
switch (srmid)
|
{
|
case 1: return 28;
|
case 2: return 26;
|
case 3: return 24;
|
case 4: return 22;
|
case 5: return 10;
|
case 6: return 8;
|
case 7: return 6;
|
case 8: return 4;
|
case 9: return 2;
|
default: return 0;
|
}
|
}
|
}
|
return 0;
|
}
|
|
|
/// <summary>
|
/// 根据巷道和任务类型,以及东西,筛选输入库口
|
/// </summary>
|
/// <param name="srmid"></param>
|
/// <param name="tasktype"></param>
|
public static string GetSrmEnter(int srmid, int tasktype, bool isEast)
|
{
|
if (isEast)
|
{
|
if (tasktype == 1)
|
{
|
switch (srmid)
|
{
|
case 1: return "02-19-01";
|
case 2: return "03-20-01";
|
case 3: return "03-19-01";
|
case 4: return "03-21-01";
|
case 5: return "02-20-01";
|
case 6: return "03-20-01";
|
case 7: return "03-24-01";
|
case 8: return "03-25-01";
|
case 9: return "03-23-01";
|
default: return "";
|
}
|
}
|
else if (tasktype == 2)
|
{
|
switch (srmid)
|
{
|
case 1: return "01-19-01";
|
case 2: return "02-20-01";
|
case 3: return "02-19-01";
|
case 4: return "02-21-01";
|
case 5: return "01-20-01";
|
case 6: return "02-20-01";
|
case 7: return "02-24-01";
|
case 8: return "02-25-01";
|
case 9: return "02-23-01";
|
default: return "";
|
}
|
}
|
}
|
else
|
{
|
if (tasktype == 1)
|
{
|
switch (srmid)
|
{
|
case 1: return "01-01-01";
|
case 2: return "02-01-01";
|
case 3: return "02-01-01";
|
case 4: return "02-01-01";
|
case 5: return "01-01-01";
|
case 6: return "02-01-01";
|
case 7: return "02-01-01";
|
case 8: return "02-01-01";
|
case 9: return "02-01-01";
|
default: return "";
|
}
|
}
|
else if (tasktype == 2)
|
{
|
switch (srmid)
|
{
|
case 1: return "02-01-01";
|
case 2: return "03-01-01";
|
case 3: return "03-01-01";
|
case 4: return "03-01-01";
|
case 5: return "02-01-01";
|
case 6: return "03-01-01";
|
case 7: return "03-01-01";
|
case 8: return "03-01-01";
|
case 9: return "03-01-01";
|
default: return "";
|
}
|
}
|
}
|
return "";
|
}
|
|
|
/// <summary>
|
/// 根据输送线号获取是否为东部任务
|
/// </summary>
|
/// <param name="tranid"></param>
|
/// <returns></returns>
|
public static bool GetIsEast(int tranid)
|
{
|
switch (tranid)
|
{
|
case 46: return true;
|
case 47: return true;
|
case 45: return true;
|
case 48: return true;
|
case 49: return true;
|
case 61: return true;
|
case 62: return true;
|
case 65: return true;
|
case 66: return true;
|
case 67: return true;
|
case 63: return true;
|
case 64: return true;
|
case 51: return true;
|
case 50: return true;
|
case 68: return true;
|
|
case 32: return false;
|
case 33: return false;
|
case 34: return false;
|
case 15: return false;
|
case 14: return false;
|
case 19: return false;
|
case 20: return false;
|
case 29: return false;
|
case 30: return false;
|
case 11: return false;
|
case 12: return false;
|
default: return false;
|
}
|
}
|
|
/// <summary>
|
/// 切换RGV可用时,修改输送线所动状态(暂定推至末端)
|
/// </summary>
|
/// <param name="rgvId"></param>
|
public static void ResetTranLocal(int rgvId)
|
{
|
long local = 0;
|
switch (rgvId)
|
{
|
case 1: local = 74983 - WCS.safeLength; break;
|
case 2: local = 3874 + WCS.safeLength; break;
|
case 3: local = 72883 - WCS.safeLength; break;
|
case 4: local = 1876 + WCS.safeLength; break;
|
default: break;
|
}
|
|
Helper.LockTran(rgvId, local, local);
|
}
|
|
///// <summary>
|
///// 通过RGV任务删除关联任务
|
///// </summary>
|
///// <param name="RgvTaskId"></param>
|
///// <returns></returns>
|
//public static bool DeleteAllByRgvTaskId(int RgvTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
|
//{
|
// tranDoingId = new List<int>();
|
// rgvDoingId = new List<int>();
|
// srmDoingId = new List<int>();
|
|
// bool result = false;
|
// using (Model edm = new Model())
|
// {
|
// RgvTask rgvTask = edm.RgvTask.FirstOrDefault(x => x.ID == RgvTaskId);
|
// if (rgvTask != null)
|
// {
|
// MainTask mainTask = rgvTask.MainTask;
|
// result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);
|
|
// mainTask.HASFINISHED = 1;
|
// mainTask.ISERROR = 1;
|
// mainTask.ERRORMSG = 2;
|
// edm.SaveChanges();
|
// }
|
// return result;
|
// }
|
//}
|
|
///// <summary>
|
///// 通过堆垛机任务删除关联任务
|
///// </summary>
|
///// <param name="RgvTaskId"></param>
|
///// <returns></returns>
|
//public static bool DeleteAllBySrmTaskId(int SrmTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
|
//{
|
// tranDoingId = new List<int>();
|
// rgvDoingId = new List<int>();
|
// srmDoingId = new List<int>();
|
// bool result = false;
|
// using (Model edm = new Model())
|
// {
|
// SrmTask srmTask = edm.SrmTask.FirstOrDefault(x => x.ID == SrmTaskId);
|
// if (srmTask != null)
|
// {
|
// MainTask mainTask = srmTask.MainTask;
|
// result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);
|
|
// mainTask.HASFINISHED = 1;
|
// mainTask.ISERROR = 1;
|
// mainTask.ERRORMSG = 3;
|
// edm.SaveChanges();
|
|
// }
|
// return result;
|
// }
|
//}
|
|
///// <summary>
|
///// 通过输送线任务删除关联任务
|
///// </summary>
|
///// <param name="RgvTaskId"></param>
|
///// <returns></returns>
|
//public static bool DeleteAllByTranTaskId(int tranTaskId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
|
//{
|
// tranDoingId = new List<int>();
|
// rgvDoingId = new List<int>();
|
// srmDoingId = new List<int>();
|
// bool result = false;
|
// using (Model edm = new Model())
|
// {
|
// TranTask tranTask = edm.TranTask.FirstOrDefault(x => x.ID == tranTaskId);
|
// if (tranTask != null)
|
// {
|
// MainTask mainTask = tranTask.MainTask;
|
// result = DeleteAllTask(mainTask.TASKID, out tranDoingId, out rgvDoingId, out srmDoingId);
|
|
// mainTask.HASFINISHED = 1;
|
// mainTask.ISERROR = 1;
|
// mainTask.ERRORMSG = 1;
|
// edm.SaveChanges();
|
// }
|
// return result;
|
// }
|
//}
|
|
/// <summary>
|
/// 获取异常设备,并锁定
|
/// </summary>
|
/// <returns></returns>
|
public static void GetAlarmDevice(int mainId)
|
{
|
using (Model edm = new Model())
|
{
|
TASK_TASK task = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
|
List<RgvTask> rgvTaskList = edm.RgvTask.Where(x => x.FASTHERTASKID == task.ID).ToList();
|
int srmDevice = edm.SrmTask.FirstOrDefault(x => x.FASTHERTASKID == task.ID).USESRMID;
|
TranTask tranTask = edm.TranTask.FirstOrDefault(x => x.FASTHERTASKID == task.ID);
|
//默认异常
|
task.ISERROR = 1;
|
task.ERRORDEVICEID = 0;
|
task.ERRORMSG = 0;
|
//RGV
|
foreach (var i in rgvTaskList)
|
{
|
if (Rgv_CacheEntity.Rgvs[i.USERGVID - 1].ararm == 1)
|
{
|
task.ISERROR = 1;
|
task.ERRORDEVICEID = i.USERGVID;
|
task.ERRORMSG = 2;
|
}
|
}
|
|
//堆垛机
|
if (Srm_CacheEntity.Srms[srmDevice - 1].Ralarm == 1)
|
{
|
task.ISERROR = 1;
|
task.ERRORDEVICEID = srmDevice;
|
task.ERRORMSG = 3;
|
}
|
if (tranTask != null)
|
{
|
//输送线
|
if (SrmTran_CacheEntity.SrmTrans[tranTask.SOURCEPLACE - 1].state)
|
{
|
task.ISERROR = 1;
|
task.ERRORDEVICEID = tranTask.SOURCEPLACE;
|
task.ERRORMSG = 1;
|
}
|
else if (SrmTran_CacheEntity.SrmTrans[tranTask.TOPLACE - 1].state)
|
{
|
task.ISERROR = 1;
|
task.ERRORDEVICEID = tranTask.TOPLACE;
|
task.ERRORMSG = 1;
|
}
|
}
|
|
edm.SaveChanges();
|
}
|
|
}
|
|
/// <summary>
|
/// 删除所有关联任务
|
/// </summary>
|
/// <returns></returns>
|
public static bool DeleteAllTask(int mainId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId)
|
{
|
tranDoingId = new List<int>();
|
rgvDoingId = new List<int>();
|
srmDoingId = new List<int>();
|
|
using (Model edm = new Model())
|
{
|
TASK_TASK mainTask = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
|
if (mainTask != null)
|
{
|
List<SrmTask> srmTaskList = mainTask.SrmTask.ToList();
|
|
List<SrmTask> srmTaskDoingList = srmTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
foreach (var i in srmTaskDoingList)
|
{
|
int id = i.USESRMID;
|
//校验、防止误发
|
SRM.SrmService.SrmService srv = new SRM.SrmService.SrmService();
|
int taskid = JsonConvert.DeserializeObject<EntitySrmView>(srv.GetSrmInfo(id)).RtaskNO;
|
if (taskid == mainTask.ID)
|
{
|
srmDoingId.Add(id);
|
}
|
}
|
//edm.SrmTask.RemoveRange(srmTaskList);
|
foreach (var i in srmTaskList)
|
{
|
i.ISRELEASED = 1;
|
}
|
|
List<RgvTask> rgvTaskList = mainTask.RgvTask.ToList();
|
List<RgvTask> rgvTaskDoingList = rgvTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
foreach (var i in rgvTaskDoingList)
|
{
|
int id = i.USERGVID;
|
//校验、防止误发
|
RGV.RgvService.RgvService srv = new RGV.RgvService.RgvService();
|
int taskid = JsonConvert.DeserializeObject<EntityRgvView>(srv.GetRgvInfo(id)).taskId;
|
if (taskid == mainTask.ID)
|
{
|
rgvDoingId.Add(id);
|
}
|
}
|
//DeleteRgvTask(rgvTaskList);
|
foreach (var i in rgvTaskList)
|
{
|
i.ISRELEASED = 1;
|
}
|
//输送线当前任务删除(特殊处理)
|
List<TranTask> tranTaskList = mainTask.TranTask.ToList();
|
//List<TranTask> tranTaskDoingList = tranTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
if (mainTask.TASKTYPE == 1)
|
{
|
try
|
{
|
int sourceplace = int.Parse(mainTask.SOURCEPLACE);
|
TranTask tranTaskDoing = tranTaskList.OrderByDescending(x => x.ID).FirstOrDefault(x => x.SOURCEPLACE == sourceplace);
|
SRMTRAN.SrmTranService.SrmTranService srv = new SRMTRAN.SrmTranService.SrmTranService();
|
int taskIds = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.SOURCEPLACE)).taskId;
|
int taskIdt = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.TOPLACE)).taskId;
|
if (taskIds == mainTask.ID)
|
{
|
tranDoingId.Add(tranTaskDoing.SOURCEPLACE);
|
}
|
if (taskIdt == mainTask.ID)
|
{
|
tranDoingId.Add(tranTaskDoing.TOPLACE);
|
}
|
}
|
catch
|
{
|
|
}
|
}
|
|
//edm.TranTask.RemoveRange(tranTaskList);
|
foreach (var i in tranTaskList)
|
{
|
i.ISRELEASED = 1;
|
}
|
mainTask.HASFINISHED = 2;
|
mainTask.ISERROR = 1;
|
if (edm.SaveChanges() > 0)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 因RGV存在前置任务的分步删除
|
/// </summary>
|
/// <param name="rgvTaskList"></param>
|
public static void DeleteRgvTask(List<RgvTask> rgvTaskList)
|
{
|
//因为前置任务造成删除失败则分步删除
|
List<RgvTask> rgvTaskListFirstDelete = rgvTaskList.Where(x => x.PRETASK != null).ToList();
|
List<RgvTask> rgvTaskListSecondDelete = rgvTaskList.Where(x => x.PRETASK == null).ToList();
|
|
using (Model edm = new Model())
|
{
|
foreach (var i in rgvTaskListFirstDelete)
|
{
|
RgvTask rgvTask = edm.RgvTask.FirstOrDefault(x => x.ID == i.ID);
|
edm.RgvTask.Remove(rgvTask);
|
}
|
edm.SaveChanges();
|
}
|
|
using (Model edm2 = new Model())
|
{
|
foreach (var i in rgvTaskListSecondDelete)
|
{
|
RgvTask rgvTask = edm2.RgvTask.FirstOrDefault(x => x.ID == i.ID);
|
edm2.RgvTask.Remove(rgvTask);
|
}
|
edm2.SaveChanges();
|
}
|
}
|
|
|
/// 删除所有关联任务
|
/// </summary>
|
/// <returns></returns>
|
public static bool DeleteAllTask(int mainId, out List<int> tranDoingId, out List<int> rgvDoingId, out List<int> srmDoingId, out List<string> outPlace, out int dir)
|
{
|
tranDoingId = new List<int>();
|
rgvDoingId = new List<int>();
|
srmDoingId = new List<int>();
|
outPlace = new List<string>();
|
dir = 0;
|
using (Model edm = new Model())
|
{
|
TASK_TASK mainTask = edm.TASK_TASK.FirstOrDefault(x => x.ID == mainId);
|
//if (mainTask != null && ((mainTask.HASFINISHED != 1 && mainTask.TASKTYPE == 1) || mainTask.TASKTYPE == 2))
|
if (mainTask != null)
|
{
|
//确定东西
|
if (mainTask.RgvTask.FirstOrDefault() != null)
|
{
|
if (mainTask.RgvTask.FirstOrDefault().SOURCEPLACE <= 34)
|
{
|
dir = 0;
|
}
|
else
|
{
|
dir = 1;
|
}
|
}
|
|
List<SrmTask> srmTaskList = mainTask.SrmTask.ToList();
|
|
List<SrmTask> srmTaskDoingList = srmTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
foreach (var i in srmTaskDoingList)
|
{
|
int id = i.USESRMID;
|
//校验、防止误发
|
SRM.SrmService.SrmService srv = new SRM.SrmService.SrmService();
|
int taskid = JsonConvert.DeserializeObject<EntitySrmView>(srv.GetSrmInfo(id)).RtaskNO;
|
if (taskid == mainTask.ID)
|
{
|
srmDoingId.Add(id);
|
|
}
|
}
|
//删除库存
|
foreach (var i in srmTaskList)
|
{
|
List<BASE_PLACE_VS_CONTAINER> pvcList = edm.BASE_PLACE_VS_CONTAINER.Where(x => (x.BASE_PLACE.PLACE.Contains(i.SOURCEPLACE) || x.BASE_PLACE.PLACE.Contains(i.TOPLACE)) && x.BASE_PLACE.SRMID == i.USESRMID && x.CONTAINERID == i.TASK_TASK.CONTAINERID).ToList();
|
foreach (var j in pvcList)
|
{
|
outPlace.Add(j.BASE_PLACE.PLACE);
|
j.BASE_PLACE.ISLOCK = 1;//锁定
|
j.BASE_PLACE.ISFULL = 0;
|
j.ENABLE = 0;
|
j.STATUS = "OUT";
|
////删堵塞库存
|
List<int> tranId = new List<int>()
|
{
|
9,
|
8,
|
7,
|
6,
|
4,
|
3,
|
2
|
};
|
if ((j.BASE_PLACE.ROW == 1 || j.BASE_PLACE.ROW == 4) && tranId.Contains(j.BASE_PLACE.SRMID ?? 0))
|
{
|
int row = j.BASE_PLACE.ROW == 1 ? 2 : 3;
|
BASE_PLACE placeNext = edm.BASE_PLACE.FirstOrDefault(x => x.COL == j.BASE_PLACE.COL && x.LAYER == j.BASE_PLACE.LAYER && x.SRMID == j.BASE_PLACE.SRMID && x.ROW == row);
|
if (placeNext != null)
|
{
|
outPlace.Add(placeNext.PLACE);
|
placeNext.ISLOCK = 1;//锁定
|
if (placeNext.BASE_PLACE_VS_CONTAINER.Count != 0)//隔壁存在库存
|
{
|
BASE_PLACE_VS_CONTAINER pvc = placeNext.BASE_PLACE_VS_CONTAINER.FirstOrDefault(x => x.ENABLE == 1);
|
pvc.BASE_PLACE.ISFULL = 0;
|
pvc.ENABLE = 0;
|
pvc.STATUS = "OUT";
|
edm.BASE_PLACE_VS_CONTAINER.Remove(pvc);
|
}
|
}
|
}
|
edm.BASE_PLACE_VS_CONTAINER.Remove(j);
|
}
|
}
|
//edm.SrmTask.RemoveRange(srmTaskList);
|
foreach (var i in srmTaskList)
|
{
|
i.ISRELEASED = 1;
|
i.HASFINISHED = 1;
|
}
|
|
List<RgvTask> rgvTaskList = mainTask.RgvTask.ToList();
|
List<RgvTask> rgvTaskDoingList = rgvTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
foreach (var i in rgvTaskDoingList)
|
{
|
int id = i.USERGVID;
|
//校验、防止误发
|
RGV.RgvService.RgvService srv = new RGV.RgvService.RgvService();
|
int taskid = JsonConvert.DeserializeObject<EntityRgvView>(srv.GetRgvInfo(id)).taskId;
|
if (taskid == mainTask.ID)
|
{
|
rgvDoingId.Add(id);
|
}
|
}
|
//DeleteRgvTask(rgvTaskList);
|
foreach (var i in rgvTaskList)
|
{
|
i.ISRELEASED = 1;
|
}
|
//输送线当前任务删除(特殊处理)
|
List<TranTask> tranTaskList = mainTask.TranTask.ToList();
|
//List<TranTask> tranTaskDoingList = tranTaskList.Where(x => x.HASFINISHED == 0 && x.ISRELEASED == 1).ToList();
|
if (mainTask.TASKTYPE == 1)
|
{
|
try
|
{
|
int sourceplace = int.Parse(mainTask.SOURCEPLACE);
|
TranTask tranTaskDoing = tranTaskList.OrderByDescending(x => x.ID).FirstOrDefault(x => x.SOURCEPLACE == sourceplace);
|
SRMTRAN.SrmTranService.SrmTranService srv = new SRMTRAN.SrmTranService.SrmTranService();
|
int taskIds = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.SOURCEPLACE)).taskId;
|
int taskIdt = JsonConvert.DeserializeObject<EntitySrmTranView>(srv.GetSrmConveyorStationInfo(tranTaskDoing.TOPLACE)).taskId;
|
if (taskIds == mainTask.ID)
|
{
|
tranDoingId.Add(tranTaskDoing.SOURCEPLACE);
|
}
|
if (taskIdt == mainTask.ID)
|
{
|
tranDoingId.Add(tranTaskDoing.TOPLACE);
|
}
|
}
|
catch
|
{
|
|
}
|
}
|
|
//edm.TranTask.RemoveRange(tranTaskList);
|
foreach (var i in tranTaskList)
|
{
|
i.ISRELEASED = 1;
|
}
|
mainTask.HASREADED = 1;
|
mainTask.HASFINISHED = 2;
|
mainTask.ISERROR = 1;
|
mainTask.TASKSTATUS = "异常/取消";
|
//清空组盘数据
|
//查看当前任务是否为该器具的最后一条任务
|
TASK_TASK lastTask = edm.TASK_TASK.AsNoTracking().OrderByDescending(u => u.CREATETIME).FirstOrDefault(x => x.CONTAINERID == mainTask.CONTAINERID);
|
if (lastTask.ID == mainId)
|
{
|
List<BASE_CONTAINER_VS_ITEM> containerList = edm.BASE_CONTAINER_VS_ITEM.Where(x => x.CONTAINERID == mainTask.CONTAINERID).ToList();
|
edm.BASE_CONTAINER_VS_ITEM.RemoveRange(containerList);
|
if (edm.SaveChanges() > 0)
|
{
|
//记录删除托盘和物料绑定关系日志 【Editby shaoc,2023-03-07】
|
iWareSda_QQJF.WCSNEW.Helper.LogRemoveBASE_CONTAINER_VS_ITEM(containerList, "Helper.DeleteAllTask", "删除关联任务,根据堆垛机任务号删除任务");
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
else
|
{
|
if (edm.SaveChanges() > 0)
|
{
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 删除托盘和物料绑定关系 记录日志
|
/// </summary>
|
/// <param name="cviList"></param>
|
public static void LogRemoveBASE_CONTAINER_VS_ITEM(List<BASE_CONTAINER_VS_ITEM> cviList, string funName, string remark)
|
{
|
foreach (var item in cviList)
|
{
|
LogRemoveBASE_CONTAINER_VS_ITEM(item, funName, remark);
|
}
|
}
|
|
/// <summary>
|
/// 删除托盘和物料绑定关系 记录日志
|
/// </summary>
|
/// <param name="cviList"></param>
|
public static void LogRemoveBASE_CONTAINER_VS_ITEM(BASE_CONTAINER_VS_ITEM item, string funName, string remark)
|
{
|
var logTitle = "方法名:" + funName + ",删除原因:" + remark + ",";
|
try
|
{
|
//记录删除托盘和物料绑定关系日志 【Editby shaoc,2023-03-07】
|
Log4NetHelper.WriteInfoLog(LogType.RemoveBASE_CONTAINER_VS_ITEM,
|
logTitle +
|
"删除托盘和物料绑定关系 成功,cvi_id:" + item.ID + ",ITEMID:" + item.ITEMID + ",CONTAINERID:" + item.CONTAINERID
|
//+ ",CONTAINERNAME:" + item.BASE_CONTAINER.CONTAINERNAME
|
//+ ",ITEMNAME:" + item.BASE_ITEM.ITEMNAME
|
);
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(LogType.RemoveBASE_CONTAINER_VS_ITEM, logTitle + "记录删除托盘和物料关系失败:" + ex.Message + ",cvi_id:" + item.ID, ex);
|
}
|
}
|
|
|
}
|
}
|