public static CurrentStatus Build(JobDB jobDB, JobLogDB log, FMSSettings fmsSettings, IMachineGroupName machineGroupName, IQueueSyncFault queueSyncFault, MazakDbType dbType, MazakAllData mazakData, DateTime utcNow)
{
//Load process and path numbers
Dictionary <string, int> uniqueToMaxPath;
Dictionary <string, int> uniqueToMaxProcess;
CalculateMaxProcAndPath(mazakData, out uniqueToMaxPath, out uniqueToMaxProcess);
var currentLoads = new List <LoadAction>(mazakData.LoadActions);
var curStatus = new CurrentStatus();
foreach (var k in fmsSettings.Queues)
{
curStatus.QueueSizes[k.Key] = k.Value;
}
if (mazakData.Alarms != null)
{
foreach (var alarm in mazakData.Alarms)
{
if (!string.IsNullOrEmpty(alarm.AlarmMessage))
{
curStatus.Alarms.Add(alarm.AlarmMessage);
}
}
}
if (queueSyncFault.CurrentQueueMismatch)
{
curStatus.Alarms.Add("Queue contents and Mazak schedule quantity mismatch.");
}
var jobsBySchID = new Dictionary <long, InProcessJob>();
var pathBySchID = new Dictionary <long, MazakPart.IProcToPath>();
foreach (var schRow in mazakData.Schedules)
{
if (!MazakPart.IsSailPart(schRow.PartName))
{
continue;
}
MazakPartRow partRow = null;
foreach (var p in mazakData.Parts)
{
if (p.PartName == schRow.PartName)
{
partRow = p;
break;
}
}
if (partRow == null)
{
continue;
}
//Parse data from the database
var partName = partRow.PartName;
int loc = partName.IndexOf(':');
if (loc >= 0)
{
partName = partName.Substring(0, loc);
}
string jobUnique = "";
MazakPart.IProcToPath procToPath = null;
bool manual = false;
if (!string.IsNullOrEmpty(partRow.Comment))
{
MazakPart.ParseComment(partRow.Comment, out jobUnique, out procToPath, out manual);
}
if (!uniqueToMaxProcess.ContainsKey(jobUnique))
{
continue;
}
int numProc = uniqueToMaxProcess[jobUnique];
int maxProc1Path = uniqueToMaxPath[jobUnique];
InProcessJob job;
//Create or lookup the job
if (curStatus.Jobs.ContainsKey(jobUnique))
{
job = curStatus.Jobs[jobUnique];
}
else
{
var jobPaths = new int[numProc];
for (int i = 0; i < numProc; i++)
{
jobPaths[i] = maxProc1Path;
}
job = new InProcessJob(jobUnique, numProc, jobPaths);
job.PartName = partName;
job.JobCopiedToSystem = true;
curStatus.Jobs.Add(jobUnique, job);
}
jobsBySchID.Add(schRow.Id, job);
pathBySchID.Add(schRow.Id, procToPath);
//Job Basics
job.SetPlannedCyclesOnFirstProcess(procToPath.PathForProc(proc: 1), schRow.PlanQuantity);
AddCompletedToJob(schRow, job, procToPath);
job.Priority = schRow.Priority;
if (((HoldPattern.HoldMode)schRow.HoldMode) == HoldPattern.HoldMode.FullHold)
{
job.HoldEntireJob.UserHold = true;
}
else
{
job.HoldEntireJob.UserHold = false;
}
AddRoutingToJob(mazakData, partRow, job, machineGroupName, procToPath, dbType);
}
var loadedJobs = new HashSet <string>();
foreach (var j in jobsBySchID.Values)
{
if (loadedJobs.Contains(j.UniqueStr))
{
continue;
}
loadedJobs.Add(j.UniqueStr);
AddDataFromJobDB(jobDB, j);
}
//Now add pallets
foreach (var palRow in mazakData.Pallets)
{
if (palRow.PalletNumber > 0 && !curStatus.Pallets.ContainsKey(palRow.PalletNumber.ToString()))
{
var palName = palRow.PalletNumber.ToString();
var palLoc = FindPalletLocation(machineGroupName, mazakData, dbType, palRow.PalletNumber);
//Create the pallet
PalletStatus status = new PalletStatus()
{
Pallet = palName,
CurrentPalletLocation = palLoc,
FixtureOnPallet = palRow.Fixture,
NumFaces = 1,
OnHold = false
};
curStatus.Pallets.Add(status.Pallet, status);
var oldCycles = log.CurrentPalletLog(palName);
//Add the material currently on the pallet
foreach (var palSub in mazakData.PalletSubStatuses)
{
if (palSub.PalletNumber != palRow.PalletNumber)
{
continue;
}
if (palSub.FixQuantity <= 0)
{
continue;
}
if (!jobsBySchID.ContainsKey(palSub.ScheduleID))
{
continue;
}
status.NumFaces = Math.Max(status.NumFaces, palSub.PartProcessNumber);
var job = jobsBySchID[palSub.ScheduleID];
var procToPath = pathBySchID[palSub.ScheduleID];
var matIDs = new Queue <long>(FindMatIDsFromOldCycles(oldCycles, job.UniqueStr, palSub.PartProcessNumber));
for (int i = 1; i <= palSub.FixQuantity; i++)
{
int face = palSub.PartProcessNumber;
long matID = -1;
if (matIDs.Count > 0)
{
matID = matIDs.Dequeue();
}
var matDetails = log.GetMaterialDetails(matID);
var inProcMat = new InProcessMaterial()
{
MaterialID = matID,
JobUnique = job.UniqueStr,
PartName = job.PartName,
Process = palSub.PartProcessNumber,
Path = procToPath.PathForProc(palSub.PartProcessNumber),
Serial = matDetails?.Serial,
WorkorderId = matDetails?.Workorder,
SignaledInspections =
log.LookupInspectionDecisions(matID)
.Where(x => x.Inspect)
.Select(x => x.InspType)
.Distinct()
.ToList(),
LastCompletedMachiningRouteStopIndex =
oldCycles.Any(
c => c.LogType == LogType.MachineCycle &&
!c.StartOfCycle &&
c.Material.Any(m => m.MaterialID == matID && m.Process == palSub.PartProcessNumber)
)
? (int?)0
: null,
Location = new InProcessMaterialLocation()
{
Type = InProcessMaterialLocation.LocType.OnPallet,
Pallet = status.Pallet,
Face = face
},
Action = new InProcessMaterialAction()
{
Type = InProcessMaterialAction.ActionType.Waiting
}
};
curStatus.Material.Add(inProcMat);
//check for unloading or transfer
var loadNext = CheckLoadOfNextProcess(currentLoads, job.UniqueStr, palSub.PartProcessNumber, palLoc);
var unload = CheckUnload(currentLoads, job.UniqueStr, palSub.PartProcessNumber, palLoc);
if (loadNext != null)
{
var start = FindLoadStartFromOldCycles(oldCycles, matID);
inProcMat.Action = new InProcessMaterialAction()
{
Type = InProcessMaterialAction.ActionType.Loading,
LoadOntoFace = palSub.PartProcessNumber + 1,
LoadOntoPallet = status.Pallet,
ProcessAfterLoad = palSub.PartProcessNumber + 1,
PathAfterLoad = procToPath.PathForProc(palSub.PartProcessNumber + 1),
ElapsedLoadUnloadTime = start != null ? (TimeSpan?)utcNow.Subtract(start.EndTimeUTC) : null
};
}
else if (unload != null)
{
var start = FindLoadStartFromOldCycles(oldCycles, matID);
inProcMat.Action = new InProcessMaterialAction()
{
Type =
palSub.PartProcessNumber == job.NumProcesses
? InProcessMaterialAction.ActionType.UnloadToCompletedMaterial
: InProcessMaterialAction.ActionType.UnloadToInProcess,
UnloadIntoQueue = job.GetOutputQueue(
process: palSub.PartProcessNumber,
path: procToPath.PathForProc(palSub.PartProcessNumber)),
ElapsedLoadUnloadTime = start != null ? (TimeSpan?)utcNow.Subtract(start.EndTimeUTC) : null
};
}
else
{
// detect if machining
var start = FindMachineStartFromOldCycles(oldCycles, matID);
if (start != null)
{
var machStop = job.GetMachiningStop(inProcMat.Process, inProcMat.Path).FirstOrDefault();
var elapsedTime = utcNow.Subtract(start.EndTimeUTC);
inProcMat.Action = new InProcessMaterialAction()
{
Type = InProcessMaterialAction.ActionType.Machining,
ElapsedMachiningTime = elapsedTime,
ExpectedRemainingMachiningTime =
machStop != null?machStop.ExpectedCycleTime.Subtract(elapsedTime) : TimeSpan.Zero
};
}
}
}
}
if (palLoc.Location == PalletLocationEnum.LoadUnload)
{
var start = FindLoadStartFromOldCycles(oldCycles);
var elapsedLoad = start != null ? (TimeSpan?)utcNow.Subtract(start.EndTimeUTC) : null;
AddLoads(log, currentLoads, status.Pallet, palLoc, elapsedLoad, curStatus);
AddUnloads(log, currentLoads, status, elapsedLoad, oldCycles, curStatus);
}
}
}
//now queued
var seenMatIds = new HashSet <long>(curStatus.Material.Select(m => m.MaterialID));
foreach (var mat in log.GetMaterialInAllQueues())
{
// material could be in the process of being loaded
if (seenMatIds.Contains(mat.MaterialID))
{
continue;
}
var matLogs = log.GetLogForMaterial(mat.MaterialID);
int lastProc = 0;
foreach (var entry in log.GetLogForMaterial(mat.MaterialID))
{
foreach (var entryMat in entry.Material)
{
if (entryMat.MaterialID == mat.MaterialID)
{
lastProc = Math.Max(lastProc, entryMat.Process);
}
}
}
var matDetails = log.GetMaterialDetails(mat.MaterialID);
curStatus.Material.Add(new InProcessMaterial()
{
MaterialID = mat.MaterialID,
JobUnique = mat.Unique,
PartName = mat.PartName,
Process = lastProc,
Path = 1,
Serial = matDetails?.Serial,
WorkorderId = matDetails?.Workorder,
SignaledInspections =
log.LookupInspectionDecisions(mat.MaterialID)
.Where(x => x.Inspect)
.Select(x => x.InspType)
.Distinct()
.ToList(),
Location = new InProcessMaterialLocation()
{
Type = InProcessMaterialLocation.LocType.InQueue,
CurrentQueue = mat.Queue,
QueuePosition = mat.Position,
},
Action = new InProcessMaterialAction()
{
Type = InProcessMaterialAction.ActionType.Waiting
}
});
}
var notCopied = jobDB.LoadJobsNotCopiedToSystem(DateTime.UtcNow.AddHours(-WriteJobs.JobLookbackHours), DateTime.UtcNow);
foreach (var j in notCopied.Jobs)
{
if (curStatus.Jobs.ContainsKey(j.UniqueStr))
{
//The copy to the cell succeeded but the DB has not yet been updated.
//The thread which copies jobs will soon notice and update the database
//so we can ignore it for now.
}
else
{
curStatus.Jobs.Add(j.UniqueStr, new InProcessJob(j));
}
}
foreach (var j in curStatus.Jobs)
{
foreach (var d in jobDB.LoadDecrementsForJob(j.Value.UniqueStr))
{
j.Value.Decrements.Add(d);
}
}
return(curStatus);
}
private void HandleMessage(MessageState state, CincronMessage msg, int repeatCount)
{
var queueChange = msg as CincronMessage.QueuePositionChange;
//machine cycle start. For now it is pallet rotating into machine
if (queueChange != null &&
queueChange.CurrentLocation.Location == PalletLocationEnum.Machine &&
queueChange.NewQueuePosition == "10010")
{
_log.RecordMachineStart(
mats: FindMaterial(queueChange.Pallet),
pallet: queueChange.Pallet,
statName: "MC",
statNum: queueChange.CurrentLocation.Num,
program: "",
timeUTC: queueChange.TimeUTC,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
}
//machine cycle end. StepNo changing to 5 signals cycle end.
var stepChange = msg as CincronMessage.PartNewStep;
if (stepChange != null && stepChange.StepNo == 5)
{
var machineCycleStart = FindMachineStart(_log.CurrentPalletLog(stepChange.Pallet));
if (machineCycleStart != null)
{
_log.RecordMachineEnd(
mats: machineCycleStart.Material.Select(JobLogDB.EventLogMaterial.FromLogMat),
pallet: stepChange.Pallet,
statName: "MC",
statNum: machineCycleStart.LocationNum,
program: "",
timeUTC: stepChange.TimeUTC,
result: "",
elapsed: stepChange.TimeUTC.Subtract(machineCycleStart.EndTimeUTC),
active: TimeSpan.Zero,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
}
}
//program end. FindMachineStart correctly returns null if we have already recorded
//cycle end.
var progEnd = msg as CincronMessage.ProgramFinished;
if (progEnd != null)
{
var machineCycleStart = FindMachineStart(_log.CurrentPalletLog(progEnd.Pallet));
if (machineCycleStart != null)
{
_log.RecordMachineEnd(
mats: machineCycleStart.Material.Select(JobLogDB.EventLogMaterial.FromLogMat),
pallet: progEnd.Pallet,
statName: "MC",
statNum: machineCycleStart.LocationNum,
program: "",
timeUTC: progEnd.TimeUTC,
result: "",
elapsed: progEnd.TimeUTC.Subtract(machineCycleStart.EndTimeUTC),
active: TimeSpan.Zero,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
}
}
//part completed message. Store in memory since typically there is an Unload Start event
//which happens right afterwords.
var comp = msg as CincronMessage.PartCompleted;
if (comp != null)
{
for (int i = 0; i < repeatCount; i++)
{
if (!state.PartCompletedMessagesBySetup.ContainsKey(comp.Setup))
{
state.PartCompletedMessagesBySetup[comp.Setup] = new List <CincronMessage.PartCompleted>();
}
state.PartCompletedMessagesBySetup[comp.Setup].Add(comp);
}
}
//move to unload. Store in memory, typically there is an UnloadStart event soon
if (queueChange != null &&
queueChange.CurrentLocation.Location == PalletLocationEnum.LoadUnload &&
queueChange.NewQueuePosition == "10010")
{
_log.RecordGeneralMessage(
mat: null,
pallet: queueChange.Pallet,
program: "PalletMoveToLoad",
result: queueChange.CurrentLocation.Num.ToString(),
timeUTC: queueChange.TimeUTC,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage);
}
//unload start. Use the completed parts and last unload station from the state.
var unloadStart = msg as CincronMessage.PartUnloadStart;
if (unloadStart != null)
{
var oldEvts = _log.CurrentPalletLog(unloadStart.Pallet);
var lul = FindLastLoadStation(oldEvts);
_log.RecordUnloadStart(
mats: CreateUnloadMaterial(state, unloadStart.Pallet, oldEvts),
pallet: unloadStart.Pallet,
lulNum: lul,
timeUTC: unloadStart.TimeUTC,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
state.PartCompletedMessagesBySetup.Clear();
}
var loadStart = msg as CincronMessage.PartLoadStart;
if (loadStart != null)
{
var oldEvts = _log.CurrentPalletLog(loadStart.Pallet);
var lul = FindLastLoadStation(oldEvts);
_log.RecordLoadStart(
mats: CreateLoadMaterial(loadStart),
pallet: loadStart.Pallet,
lulNum: lul,
timeUTC: loadStart.TimeUTC,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
}
//end of load and unload on step change to 2
if (stepChange != null && stepChange.StepNo == 2)
{
//create end unload, then pallet cycle, then end load.
var oldEvts = _log.CurrentPalletLog(stepChange.Pallet);
var loadStartCycle = FindLoadStart(oldEvts);
var unloadStartCycle = FindUnloadStart(oldEvts);
if (unloadStartCycle != null)
{
_log.RecordUnloadEnd(
mats: unloadStartCycle.Material.Select(JobLogDB.EventLogMaterial.FromLogMat),
pallet: stepChange.Pallet,
lulNum: unloadStartCycle.LocationNum,
timeUTC: stepChange.TimeUTC,
elapsed: stepChange.TimeUTC.Subtract(unloadStartCycle.EndTimeUTC),
active: TimeSpan.Zero,
foreignId: ForeignId(msg),
originalMessage: msg.LogMessage
);
}
var mats = new Dictionary <string, IEnumerable <JobLogDB.EventLogMaterial> >();
if (loadStartCycle != null)
{
_log.AddPendingLoad(
pal: stepChange.Pallet,
key: stepChange.Pallet,
load: loadStartCycle.LocationNum,
elapsed: stepChange.TimeUTC.Subtract(loadStartCycle.EndTimeUTC),
active: TimeSpan.Zero,
foreignID: ForeignId(msg)
);
mats[stepChange.Pallet] = loadStartCycle.Material.Select(JobLogDB.EventLogMaterial.FromLogMat);
}
_log.CompletePalletCycle(stepChange.Pallet, stepChange.TimeUTC, ForeignId(msg), mats, generateSerials: false);
}
}