public async Task ImportWorkLoad(JobPlan job)
{
var wlId = "INSGT-" + job.PartName.ToUpper() + "-" + DateTime.Now.ToString("yyMMddHHmm");
var file = AllocateFilename("work", "wkl");
var st = job.GetSimulatedStartingTimeUTC(1, 1).ToLocalTime();
var end = job.RouteEndingTimeUTC.ToLocalTime();
await WriteFile(file, string.Join("\n", new[] {
wlId,
st.ToString(DateFormat),
end.ToString(DateFormat),
job.Priority.ToString(),
"R-" + job.PartName,
job.UniqueStr,
"FMS-INSIGHT",
"/",
job.PartName,
"0",
job.GetPlannedCyclesOnFirstProcess(1).ToString(),
"/"
}));
await _plantHost.Send("imwrkl -w " + wlId + " -s -c -W " + file.CellPath);
}
private IEnumerable <BlackMaple.MachineFramework.MaterialToSendToExternalQueue> FindSendToExternalQueue(IEnumerable <LogMaterialAndPath> mats)
{
var ret = new List <BlackMaple.MachineFramework.MaterialToSendToExternalQueue>();
foreach (var mat in mats)
{
JobPlan job = GetJob(mat.Unique);
if (job != null)
{
var q = job.GetOutputQueue(process: mat.Mat.Process, path: mat.Path);
if (!string.IsNullOrEmpty(q) && _settings.ExternalQueues.ContainsKey(q))
{
ret.Add(new BlackMaple.MachineFramework.MaterialToSendToExternalQueue()
{
Server = _settings.ExternalQueues[q],
PartName = mat.PartName,
Queue = q,
Serial = _log.GetMaterialDetails(mat.Mat.MaterialID)?.Serial
});
}
}
}
return(ret);
}
public void NextPiece()
{
DateTime now = DateTime.UtcNow;
var job = new JobPlan("job1", 1);
job.PartName = "part1";
//set up a program
var inspProg = new JobInspectionData("insp1", "counter1", 3, TimeSpan.FromHours(11));
job.AddInspection(inspProg);
//set the count as zero, otherwise it chooses a random
InspectCount cnt = new InspectCount();
cnt.Counter = "counter1";
cnt.Value = 0;
cnt.LastUTC = DateTime.UtcNow.AddHours(-10);
_insp.SetInspectCounts(new InspectCount[] { cnt });
PalletLocation palLoc = new PalletLocation(PalletLocationEnum.Machine, "MC", 1);
_insp.NextPieceInspection(palLoc, "insp1");
_insp.CheckMaterialForNextPeiceInspection(palLoc, 1);
CheckCount("counter1", 0);
_insp.MakeInspectionDecisions(1, 1, new[] { inspProg }, now);
CheckCount("counter1", 1);
CheckDecision(1, "insp1", "counter1", true, now, true);
}
public void IgnoresAlreadyExistingDecrement()
{
// plan 50, completed 30, 5 in proc and 15 not yet started
_read.LoadSchedulesAndLoadActions().Returns(new MazakSchedulesAndLoadActions()
{
Schedules = new[] {
new MazakScheduleRow()
{
Id = 15,
Comment = MazakPart.CreateComment("uuuu", new[] { 1 }, manual: false),
PartName = "pppp:1",
PlanQuantity = 50,
CompleteQuantity = 30,
Processes = new List <MazakScheduleProcessRow> {
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 15,
FixQuantity = 1,
ProcessNumber = 1,
ProcessMaterialQuantity = 15,
ProcessExecuteQuantity = 5
}
}
}
}
});
var j = new JobPlan("uuuu", 1);
j.PartName = "pppp";
j.SetPlannedCyclesOnFirstProcess(path: 1, numCycles: 50);
_jobDB.AddJobs(new NewJobs()
{
Jobs = new List <JobPlan> {
j
}
}, null);
var now = DateTime.UtcNow.AddHours(-1);
_jobDB.AddNewDecrement(new[] {
new JobDB.NewDecrementQuantity()
{
JobUnique = "uuuu", Part = "pppp", Quantity = 3
}
}, now);
_decr.Decrement();
_write.Schedules.Should().BeNull();
_jobDB.LoadDecrementsForJob("uuuu").Should().BeEquivalentTo(new[] {
new InProcessJobDecrement()
{
DecrementId = 0,
TimeUTC = now,
Quantity = 3
}
});
}
public InProcessJob(JobPlan job) : base(job)
{
_completed = new int[base.NumProcesses][];
for (int proc = 1; proc <= base.NumProcesses; proc++)
{
_completed[proc - 1] = Enumerable.Repeat(0, base.GetNumPaths(proc)).ToArray();
}
}
public void SinglePathSingleProc()
{
// plan 50, completed 30, 5 in proc and 15 not yet started
_read.LoadSchedulesAndLoadActions().Returns(new MazakSchedulesAndLoadActions()
{
Schedules = new[] {
new MazakScheduleRow()
{
Id = 15,
Comment = MazakPart.CreateComment("uuuu", new[] { 1 }, false),
PartName = "pppp:1",
PlanQuantity = 50,
CompleteQuantity = 30,
Processes = new List <MazakScheduleProcessRow> {
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 15,
FixQuantity = 1,
ProcessNumber = 1,
ProcessMaterialQuantity = 15,
ProcessExecuteQuantity = 5
}
}
}
}
});
var j = new JobPlan("uuuu", 1);
j.PartName = "pppp";
j.SetPlannedCyclesOnFirstProcess(path: 1, numCycles: 50);
_jobDB.AddJobs(new NewJobs()
{
Jobs = new List <JobPlan> {
j
}
}, null);
var now = DateTime.UtcNow;
_decr.Decrement(now);
_write.Schedules.Count.Should().Be(1);
var sch = _write.Schedules[0];
sch.Id.Should().Be(15);
sch.PlanQuantity.Should().Be(35);
sch.Processes.Should().BeEmpty();
_jobDB.LoadDecrementsForJob("uuuu").Should().BeEquivalentTo(new[] {
new InProcessJobDecrement()
{
DecrementId = 0,
TimeUTC = now,
Quantity = 50 - 35
}
});
}
private static void AddDataFromJobDB(JobDB jobDB, JobPlan jobFromMazak)
{
var jobFromDb = jobDB.LoadJob(jobFromMazak.UniqueStr);
if (jobFromDb == null)
{
return;
}
jobFromMazak.RouteStartingTimeUTC = jobFromDb.RouteStartingTimeUTC;
jobFromMazak.RouteEndingTimeUTC = jobFromDb.RouteEndingTimeUTC;
jobFromMazak.ScheduleId = jobFromDb.ScheduleId;
jobFromMazak.AddInspections(jobFromDb.GetInspections());
jobFromMazak.HoldEntireJob = jobFromDb.HoldEntireJob;
foreach (var b in jobFromDb.ScheduledBookingIds)
{
jobFromMazak.ScheduledBookingIds.Add(b);
}
for (int proc = 1; proc <= jobFromMazak.NumProcesses; proc++)
{
for (int path = 1; path <= jobFromMazak.GetNumPaths(proc); path++)
{
if (proc > jobFromDb.NumProcesses || path > jobFromDb.GetNumPaths(proc))
{
continue;
}
jobFromMazak.SetSimulatedStartingTimeUTC(proc, path,
jobFromDb.GetSimulatedStartingTimeUTC(proc, path));
jobFromMazak.SetSimulatedAverageFlowTime(proc, path,
jobFromDb.GetSimulatedAverageFlowTime(proc, path));
jobFromMazak.SetSimulatedProduction(proc, path,
jobFromDb.GetSimulatedProduction(proc, path));
jobFromMazak.SetExpectedLoadTime(proc, path,
jobFromDb.GetExpectedLoadTime(proc, path));
jobFromMazak.SetExpectedUnloadTime(proc, path,
jobFromDb.GetExpectedUnloadTime(proc, path));
jobFromMazak.SetInputQueue(proc, path,
jobFromDb.GetInputQueue(proc, path));
jobFromMazak.SetOutputQueue(proc, path,
jobFromDb.GetOutputQueue(proc, path));
var mazakStops = jobFromMazak.GetMachiningStop(proc, path).ToList();
var dbStops = jobFromDb.GetMachiningStop(proc, path).ToList();
for (int i = 0; i < Math.Min(mazakStops.Count, dbStops.Count); i++)
{
mazakStops[i].StationGroup = dbStops[i].StationGroup;
mazakStops[i].ExpectedCycleTime = dbStops[i].ExpectedCycleTime;
}
}
}
}
private static void WriteOrderQty(XmlTextWriter xml, JobPlan j)
{
xml.WriteStartElement("OrderQuantity");
xml.WriteAttributeString("orderName", j.UniqueStr);
int qty = j.GetPlannedCyclesOnFirstProcess(1);
//qty /= j.PartsPerPallet(1, 1);
xml.WriteElementString("ProcessNumber", "1");
xml.WriteElementString("RemainQuantity", qty.ToString());
xml.WriteEndElement(); // OrderQuantity
}
private void AddBasicStopsWithProg(JobPlan job)
{
for (int proc = 1; proc <= job.NumProcesses; proc++)
{
for (int path = 1; path <= job.GetNumPaths(proc); path++)
{
job.AddLoadStation(proc, path, 1);
job.AddUnloadStation(proc, path, 1);
var stop = new JobMachiningStop("machine");
stop.Stations.Add(1);
stop.ProgramName = "1234";
job.AddMachiningStop(proc, path, stop);
}
}
}
private static void WriteOrder(XmlTextWriter xml, JobPlan j, bool onlyOrders)
{
string partName = onlyOrders ? j.PartName : j.UniqueStr;
xml.WriteStartElement("Order");
xml.WriteAttributeString("action", "ADD");
xml.WriteAttributeString("name", j.UniqueStr);
xml.WriteElementString("Comment", j.PartName);
xml.WriteElementString("PartName", partName);
xml.WriteElementString("Revision", "SAIL");
xml.WriteElementString("Quantity", j.GetPlannedCyclesOnFirstProcess(1).ToString());
xml.WriteElementString("Priority", j.Priority.ToString());
xml.WriteElementString("Status", "0");
xml.WriteEndElement(); // Order
}
public JobPlan CreateJob(string unique, int partID)
{
int numProc = 1;
foreach (var p in _procIDToPartID)
{
if (p.Value == partID)
{
numProc = Math.Max(numProc, _procIDToProcNum[p.Key]);
}
}
var job = new JobPlan(unique, numProc);
_byPartID.Add(partID, job);
return(job);
}
private void CheckInProcessMaterial(JobPlan jobPlan, IGrouping <string, ScheduleWithQueues> job, int proc)
{
string uniqueStr = job.Key;
var paths = job.Select(s => s.Procs[proc]);
foreach (var path in paths)
{
if (string.IsNullOrEmpty(path.InputQueue))
{
continue;
}
try
{
int matInQueue;
if (paths.Count() == 1)
{
// just check for parts with the correct unique and next process
matInQueue = _log.GetMaterialInQueue(path.InputQueue)
.Where(m => m.Unique == uniqueStr && FindNextProcess(m.MaterialID) == proc)
.Count()
;
}
else
{
// need a more complicated test involving path groups
matInQueue = _log.GetMaterialInQueue(path.InputQueue)
.Where(m => m.Unique == uniqueStr && DoesNextProcessAndPathGroupMatch(jobPlan, m, proc - 1, path.PathGroup))
.Count()
;
}
if (matInQueue != path.SchProcRow.ProcessMaterialQuantity)
{
path.TargetMaterialCount = matInQueue;
}
}
catch (UnableToFindPathGroup)
{
Log.Warning("Unable to calculate path group for material in queue for {job} process {proc}," +
" ignoring queue material updates to mazak schedule.", jobPlan.UniqueStr, proc);
}
}
}
private bool DoesNextProcessAndPathGroupMatch(JobPlan job, JobLogDB.QueuedMaterial qm, int proc, int pathGroup)
{
var matLog = _log.GetLogForMaterial(qm.MaterialID);
var lastProc =
matLog
.SelectMany(e => e.Material)
.Where(m => m.MaterialID == qm.MaterialID)
.Select(m => m.Process)
.DefaultIfEmpty(0)
.Max();
if (lastProc != proc)
{
return(false);
}
//now try and calculate path. Just check pallet.
var lastPallet =
matLog
.SelectMany(e => e.Material.Select(m => new { log = e, mat = m }))
.Where(x => x.mat.MaterialID == qm.MaterialID && x.mat.Process == proc)
.Select(x => x.log.Pallet)
.Where(x => !string.IsNullOrEmpty(x))
.DefaultIfEmpty("")
.First()
;
if (string.IsNullOrEmpty(lastPallet))
{
throw new UnableToFindPathGroup();
}
Log.Debug("Calculated last pallet {pal} for {@qm} and proc {proc}", lastPallet, qm);
for (int path = 1; path <= job.GetNumPaths(proc); path++)
{
if (job.HasPallet(proc, path, lastPallet))
{
return(job.GetPathGroup(proc, path) == pathGroup);
}
}
throw new UnableToFindPathGroup();
}
public void IgnoresManualSchedule()
{
// plan 50, completed 30, 5 in proc and 15 not yet started
_read.LoadSchedulesAndLoadActions().Returns(new MazakSchedulesAndLoadActions()
{
Schedules = new[] {
new MazakScheduleRow()
{
Id = 15,
Comment = MazakPart.CreateComment("uuuu", new[] { 1 }, manual: true),
PartName = "pppp:1",
PlanQuantity = 50,
CompleteQuantity = 30,
Processes = new List <MazakScheduleProcessRow> {
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 15,
FixQuantity = 1,
ProcessNumber = 1,
ProcessMaterialQuantity = 15,
ProcessExecuteQuantity = 5
}
}
}
}
});
var j = new JobPlan("uuuu", 1);
j.PartName = "pppp";
j.SetPlannedCyclesOnFirstProcess(path: 1, numCycles: 50);
_jobDB.AddJobs(new NewJobs()
{
Jobs = new List <JobPlan> {
j
}
}, null);
_decr.Decrement();
_write.Schedules.Should().BeNull();
_jobDB.LoadDecrementsForJob("uuuu").Should().BeEmpty();
}
private Dictionary <long, string> FindUnloadQueues(IEnumerable <LogMaterialAndPath> mats)
{
var ret = new Dictionary <long, string>();
foreach (var mat in mats)
{
JobPlan job = GetJob(mat.Unique);
if (job != null)
{
var q = job.GetOutputQueue(process: mat.Mat.Process, path: mat.Path);
if (!string.IsNullOrEmpty(q) && _settings.Queues.ContainsKey(q))
{
ret[mat.Mat.MaterialID] = q;
}
}
}
return(ret);
}
public ValueDataResponse <JobPlan> AddJobPlan(UpsertJobPlan jobPlans)
{
ValueDataResponse <JobPlan> response = new ValueDataResponse <JobPlan>();
try
{
JobPlan job = _mapper.Map <JobPlan>(jobPlans);
var result = _appContext.JobPlans.Add(job);
_appContext.SaveChanges();
foreach (var jtask in jobPlans.JobPlanTasks)
{
_appContext.JobTasks.Add(new JobTask {
Id = jtask.Id, JobPlanId = job.Id, Name = jtask.Name, Duration = jtask.Duration, AstTradeId = jtask.AstTradeId
});
}
_appContext.SaveChanges();
if (job != null)
{
response.Result = job;
response.IsSuccess = true;
response.AffectedRecords = 1;
response.EndUserMessage = "Job Plan Added Successfully";
}
else
{
response.IsSuccess = true;
response.AffectedRecords = 0;
response.EndUserMessage = "Job Plan Added Failed";
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.AffectedRecords = 0;
response.EndUserMessage = ex.InnerException == null ? ex.Message : ex.InnerException.Message;
response.Exception = ex;
}
return(response);
}
public void ErrorsOnMissingProgram()
{
//Test when processes have different pallet lists
var job1 = new JobPlan("Job1", 2, new int[] { 2, 2 });
job1.PartName = "Part1";
job1.SetPathGroup(1, 1, 1);
job1.SetPathGroup(1, 2, 2);
job1.SetPathGroup(2, 1, 1);
job1.SetPathGroup(2, 2, 2);
job1.AddProcessOnPallet(1, 1, "4");
job1.AddProcessOnPallet(1, 2, "10");
job1.AddProcessOnPallet(2, 1, "40");
job1.AddProcessOnPallet(2, 2, "100");
AddBasicStopsWithProg(job1);
var dset = CreateReadSet();
var log = new List <string>();
var pMap = ConvertJobsToMazakParts.JobsToMazak(
new JobPlan[] { job1 },
3,
dset,
new HashSet <string>(),
MazakDbType.MazakVersionE,
checkPalletsUsedOnce: false,
fmsSettings: new FMSSettings(),
errors: log
);
log.Should().BeEquivalentTo(new[] {
// one for each process
"Part Part1 program 1234 does not exist in the cell controller.",
"Part Part1 program 1234 does not exist in the cell controller."
});
}
public int AddJobPlan(JobPlan jobPlan)
{
string sql = @" INSERT INTO dbo.JobPlanDB
(
AutoID,
ID,
Title,
Author,
Description,
CreateTime,
ReferenceCount,
PlanType,
DeleteFlag,
AuthFlag,
PlanCategory,
PlanRepository
)
VALUES
(@AutoID, @ID, @Title, @Author, @Description, @CreateTime, @ReferenceCount, @PlanType, @DeleteFlag, @AuthFlag,
@PlanCategory, @PlanRepository) SELECT @@IDENTITY ";
return(ExcuteScalar(sql, jobPlan));
}
public List <JobPlan> GetJobPlan(string ccmasterid)
{
string[] readText = File.ReadAllLines(@"C:\Visual Studio 2015\Projects\SoloDashboard\Dashboard.Repository\TestData\JobPlan.csv");
List <JobPlan> jobplan = new List <JobPlan>();
int counter = 0;
foreach (var item in readText)
{
string[] record = item.Split('\t');
JobPlan plans = null;
if (counter > 0)
{
plans = new JobPlan();
plans.job = record[0] != null ? record[0].Trim() : "NA";
plans.scheduledactivity = record[1] != null ? record[1].Trim() : "NA";
plans.jcdescription = record[2] != null ? record[2].Trim() : "NA";
plans.part = record[3] != null ? record[3].Trim() : "NA";
plans.printflowform = record[4] != null ? record[4].Trim() : "NA";
plans.startdate = record[5] != null ? record[5].Trim() : "NA";
plans.enddate = record[6] != null ? record[6].Trim() : "NA";
plans.name = record[7] != null ? record[7].Trim() : "NA";
plans.previoustask = record[8] != null ? record[8].Trim() : "NA";
plans.nexttask = record[9] != null ? record[9].Trim() : "NA";
}
if (plans != null)
{
jobplan.Add(plans);
}
counter++;
}
return(jobplan);
}
public void ErrorsOnLongFixture()
{
//Test when processes have different pallet lists
var job1 = new JobPlan("Job1", 1, new int[] { 1 });
job1.PartName = "Part1";
job1.SetPathGroup(1, 1, 1);
job1.AddProcessOnPallet(1, 1, "4");
job1.SetFixtureFace(1, 1, "aaaaaaaaaaaaaaaaa", 1);
AddBasicStopsWithProg(job1);
var dset = CreateReadSet();
CreateProgram(dset, "1234");
var log = new List <string>();
Action act = () =>
ConvertJobsToMazakParts.JobsToMazak(
new JobPlan[] { job1 },
3,
dset,
new HashSet <string>(),
MazakDbType.MazakVersionE,
checkPalletsUsedOnce: false,
fmsSettings: new FMSSettings(),
errors: log
);
act
.Should()
.Throw <BadRequestException>()
.WithMessage(
"Fixture aaaaaaaaaaaaaaaaa:4 is too long to fit in the mazak databases"
);
}
public static void OffsetJob(JobPlan j, TimeSpan offset)
{
j.RouteStartingTimeUTC = j.RouteStartingTimeUTC.Add(offset);
j.RouteEndingTimeUTC = j.RouteEndingTimeUTC.Add(offset);
for (int proc = 1; proc <= j.NumProcesses; proc++)
{
for (int path = 1; path <= j.GetNumPaths(proc); path++)
{
j.SetSimulatedStartingTimeUTC(proc, path,
j.GetSimulatedStartingTimeUTC(proc, path).Add(offset)
);
var prod = new List <JobPlan.SimulatedProduction>();
foreach (var p in j.GetSimulatedProduction(proc, path))
{
prod.Add(new JobPlan.SimulatedProduction()
{
TimeUTC = p.TimeUTC.Add(offset),
Quantity = p.Quantity,
});
}
}
}
// not converted: hold patterns
}
public ValueDataResponse <JobPlan> UpdateJobPlan(UpsertJobPlan jobPlans)
{
ValueDataResponse <JobPlan> response = new ValueDataResponse <JobPlan>();
try
{
JobPlan job = _mapper.Map <JobPlan>(jobPlans);
var result = _appContext.JobPlans.Where(x => x.Id == job.Id).FirstOrDefault();
var jobtakss = _appContext.JobTasks.Where(x => x.JobPlanId == job.Id).ToList();
_appContext.JobTasks.RemoveRange(jobtakss);
_appContext.SaveChanges();
foreach (var jtask in jobPlans.JobPlanTasks)
{
_appContext.JobTasks.Add(new JobTask {
Id = jtask.Id, JobPlanId = job.Id, Name = jtask.Name, Duration = jtask.Duration, AstTradeId = jtask.AstTradeId
});
}
if (result != null)
{
result.Name = jobPlans.Name;
result.JobDescription = jobPlans.JobDescription;
result.JobReference = jobPlans.JobReference;
result.Duration = jobPlans.Duration;
result.SiteId = jobPlans.SiteId;
result.ProjectId = jobPlans.ProjectId;
result.TechnicianId = jobPlans.TechnicianId;
result.AssetGroupId = jobPlans.AssetGroupId;
result.StatusTypeId = jobPlans.StatusTypeId;
result.CreatedBy = jobPlans.CreatedBy;
result.CreatedDate = jobPlans.CreatedDate;
result.UpdatedBy = jobPlans.UpdatedBy;
result.UpdatedDate = jobPlans.UpdatedDate;
result.IsActive = jobPlans.IsActive;
}
_appContext.SaveChanges();
if (job != null)
{
response.Result = job;
response.IsSuccess = true;
response.AffectedRecords = 1;
response.EndUserMessage = "Job Plan Updated Successfully";
}
else
{
response.IsSuccess = true;
response.AffectedRecords = 0;
response.EndUserMessage = "Job Plan Updation Failed";
}
}
catch (Exception ex)
{
response.IsSuccess = false;
response.AffectedRecords = 0;
response.EndUserMessage = ex.InnerException == null ? ex.Message : ex.InnerException.Message;
response.Exception = ex;
}
return(response);
}
private JobPlan CreateJob()
{
var job1 = new JobPlan("Unique1", 2, new int[] { 2, 3 });
job1.PartName = "Job1";
job1.SetPlannedCyclesOnFirstProcess(1, 125);
job1.SetPlannedCyclesOnFirstProcess(2, 53);
job1.RouteStartingTimeUTC = DateTime.Parse("2019-10-22 20:24 GMT").ToUniversalTime();
job1.RouteEndingTimeUTC = job1.RouteStartingTimeUTC.AddHours(100);
job1.Archived = false;
job1.JobCopiedToSystem = true;
job1.ScheduleId = "Job1tag1245";
job1.HoldEntireJob.UserHold = true;
job1.HoldEntireJob.ReasonForUserHold = "test string";
job1.HoldEntireJob.HoldUnholdPatternStartUTC = job1.RouteStartingTimeUTC;
job1.HoldEntireJob.HoldUnholdPatternRepeats = true;
job1.HoldEntireJob.HoldUnholdPattern.Add(TimeSpan.FromMinutes(10));
job1.HoldEntireJob.HoldUnholdPattern.Add(TimeSpan.FromMinutes(18));
job1.HoldEntireJob.HoldUnholdPattern.Add(TimeSpan.FromMinutes(125));
job1.Priority = 164;
job1.Comment = "Hello there";
job1.CreateMarkerData = true;
job1.ScheduledBookingIds.Add("booking1");
job1.ScheduledBookingIds.Add("booking2");
job1.ScheduledBookingIds.Add("booking3");
job1.SetPartsPerPallet(1, 1, 10);
job1.SetPartsPerPallet(1, 2, 15);
job1.SetPartsPerPallet(2, 1, 20);
job1.SetPartsPerPallet(2, 2, 22);
job1.SetPartsPerPallet(2, 3, 23);
job1.SetPathGroup(1, 1, 64);
job1.SetPathGroup(1, 2, 74);
job1.SetPathGroup(2, 1, 12);
job1.SetPathGroup(2, 2, 88);
job1.SetPathGroup(2, 3, 5);
job1.SetInputQueue(1, 1, "in11");
job1.SetOutputQueue(1, 2, "out12");
job1.SetInputQueue(2, 1, "in21");
job1.SetOutputQueue(2, 3, "out23");
job1.SetSimulatedStartingTimeUTC(1, 1, DateTime.Parse("1/5/2011 11:34 PM GMT").ToUniversalTime());
job1.SetSimulatedStartingTimeUTC(1, 2, DateTime.Parse("2/10/2011 12:45 AM GMT").ToUniversalTime());
job1.SetSimulatedStartingTimeUTC(2, 1, DateTime.Parse("3/14/2011 2:03 AM GMT").ToUniversalTime());
job1.SetSimulatedStartingTimeUTC(2, 2, DateTime.Parse("4/20/2011 3:22 PM GMT").ToUniversalTime());
job1.SetSimulatedStartingTimeUTC(2, 3, DateTime.Parse("5/22/2011 4:18 AM GMT").ToUniversalTime());
job1.SetSimulatedAverageFlowTime(1, 1, TimeSpan.FromMinutes(0.5));
job1.SetSimulatedAverageFlowTime(1, 2, TimeSpan.FromMinutes(1.5));
job1.SetSimulatedAverageFlowTime(2, 1, TimeSpan.FromMinutes(2.5));
job1.SetSimulatedAverageFlowTime(2, 2, TimeSpan.FromMinutes(3.5));
job1.SetSimulatedAverageFlowTime(2, 3, TimeSpan.FromMinutes(4.5));
job1.AddProcessOnPallet(1, 1, "Pal2");
job1.AddProcessOnPallet(1, 1, "Pal5");
job1.AddProcessOnPallet(1, 2, "Pal4");
job1.AddProcessOnPallet(1, 2, "Pal35");
job1.AddProcessOnPallet(2, 1, "Pal12");
job1.AddProcessOnPallet(2, 1, "Pal64");
job1.AddProcessOnPallet(2, 2, "Hi");
job1.AddProcessOnPallet(2, 2, "Pal2");
job1.AddProcessOnPallet(2, 3, "Pal5");
job1.AddProcessOnPallet(2, 3, "OMG");
job1.SetFixtureFace(1, 1, "Fix1", 1);
job1.SetFixtureFace(1, 2, "ABC", 4);
job1.SetFixtureFace(2, 1, "Fix123", 6);
// 2, 2 has non-integer face, so should be ignored
job1.SetFixtureFace(2, 3, "Fix17", 7);
job1.AddLoadStation(1, 1, 35);
job1.AddLoadStation(1, 1, 64);
job1.AddLoadStation(1, 2, 785);
job1.AddLoadStation(1, 2, 15);
job1.AddLoadStation(2, 1, 647);
job1.AddLoadStation(2, 1, 474);
job1.AddLoadStation(2, 2, 785);
job1.AddLoadStation(2, 2, 53);
job1.AddLoadStation(2, 3, 15);
job1.SetExpectedLoadTime(1, 1, TimeSpan.FromSeconds(100));
job1.SetExpectedLoadTime(1, 2, TimeSpan.FromMinutes(53));
job1.SetExpectedLoadTime(2, 1, TimeSpan.FromHours(52));
job1.SetExpectedLoadTime(2, 2, TimeSpan.FromSeconds(98));
job1.SetExpectedLoadTime(2, 3, TimeSpan.FromSeconds(35));
job1.AddUnloadStation(1, 1, 75);
job1.AddUnloadStation(1, 1, 234);
job1.AddUnloadStation(1, 2, 53);
job1.AddUnloadStation(2, 1, 563);
job1.AddUnloadStation(2, 2, 2);
job1.AddUnloadStation(2, 2, 12);
job1.AddUnloadStation(2, 3, 32);
job1.SetExpectedUnloadTime(1, 1, TimeSpan.FromSeconds(13));
job1.SetExpectedUnloadTime(1, 2, TimeSpan.FromMinutes(12));
job1.SetExpectedUnloadTime(2, 1, TimeSpan.FromHours(63));
job1.SetExpectedUnloadTime(2, 2, TimeSpan.FromSeconds(73));
job1.SetExpectedUnloadTime(2, 3, TimeSpan.FromSeconds(532));
var route = new JobMachiningStop("Machine");
route.Stations.Add(12);
route.Stations.Add(23);
route.ProgramName = "Emily";
route.ExpectedCycleTime = TimeSpan.FromHours(1.2);
route.Tools["tool1"] = TimeSpan.FromMinutes(30);
route.Tools["tool2"] = TimeSpan.FromMinutes(35);
job1.AddMachiningStop(1, 1, route);
route = new JobMachiningStop("Other Machine");
route.Stations.Add(23);
route.Stations.Add(12);
route.ProgramName = "awef";
route.ExpectedCycleTime = TimeSpan.FromHours(2.8);
route.Tools["tool1"] = TimeSpan.FromMinutes(9);
route.Tools["tool33"] = TimeSpan.FromMinutes(42);
job1.AddMachiningStop(1, 2, route);
route = new JobMachiningStop("Test");
route.Stations.Add(64);
route.Stations.Add(323);
route.ProgramName = "Goodbye";
route.ExpectedCycleTime = TimeSpan.FromHours(6.3);
route.Tools["tool2"] = TimeSpan.FromMinutes(12);
route.Tools["tool44"] = TimeSpan.FromMinutes(99);
job1.AddMachiningStop(2, 1, route);
route = new JobMachiningStop("Test");
route.Stations.Add(32);
route.Stations.Add(64);
route.ProgramName = "wefq";
job1.AddMachiningStop(2, 2, route);
route = new JobMachiningStop("Test");
route.Stations.Add(245);
route.Stations.Add(36);
route.ProgramName = "dduuude";
job1.AddMachiningStop(2, 1, route);
route = new JobMachiningStop("Test");
route.Stations.Add(23);
route.Stations.Add(53);
route.ProgramName = "so cool";
job1.AddMachiningStop(2, 2, route);
job1.AddInspection(new JobInspectionData("Insp1", "counter1", 53, TimeSpan.FromMinutes(100), 12));
job1.AddInspection(new JobInspectionData("Insp2", "counter1", 12, TimeSpan.FromMinutes(64)));
job1.AddInspection(new JobInspectionData("Insp3", "abcdef", 175, TimeSpan.FromMinutes(121), 2));
job1.AddInspection(new JobInspectionData("Insp4", "counter2", 16.12, TimeSpan.FromMinutes(33)));
job1.AddInspection(new JobInspectionData("Insp5", "counter3", 0.544, TimeSpan.FromMinutes(44)));
job1.HoldMachining(1, 1).UserHold = false;
job1.HoldMachining(1, 1).ReasonForUserHold = "reason for user hold";
job1.HoldMachining(1, 1).HoldUnholdPatternRepeats = false;
job1.HoldMachining(1, 1).HoldUnholdPatternStartUTC = DateTime.Parse("2010/5/3 7:32 PM").ToUniversalTime();
job1.HoldMachining(1, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(5));
job1.HoldMachining(1, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(53));
job1.HoldMachining(1, 2).UserHold = true;
job1.HoldMachining(1, 2).ReasonForUserHold = "another reason for user hold";
job1.HoldMachining(1, 2).HoldUnholdPatternRepeats = true;
job1.HoldMachining(1, 2).HoldUnholdPatternStartUTC = DateTime.Parse("2010/5/12 6:12 PM").ToUniversalTime();
job1.HoldMachining(1, 2).HoldUnholdPattern.Add(TimeSpan.FromMinutes(84));
job1.HoldMachining(1, 2).HoldUnholdPattern.Add(TimeSpan.FromMinutes(1));
job1.HoldMachining(2, 1).UserHold = false;
job1.HoldMachining(2, 1).ReasonForUserHold = "oh my reason for user hold";
job1.HoldMachining(2, 1).HoldUnholdPatternRepeats = true;
job1.HoldMachining(2, 1).HoldUnholdPatternStartUTC = DateTime.Parse("2010/9/1 1:30 PM").ToUniversalTime();
job1.HoldMachining(2, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(532));
job1.HoldMachining(2, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(64));
job1.HoldLoadUnload(1, 1).UserHold = true;
job1.HoldLoadUnload(1, 1).ReasonForUserHold = "abcdef";
job1.HoldLoadUnload(1, 1).HoldUnholdPatternRepeats = true;
job1.HoldLoadUnload(1, 1).HoldUnholdPatternStartUTC = DateTime.Parse("2010/12/2 3:32 PM").ToUniversalTime();
job1.HoldLoadUnload(1, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(63));
job1.HoldLoadUnload(1, 1).HoldUnholdPattern.Add(TimeSpan.FromMinutes(7));
job1.HoldLoadUnload(1, 2).UserHold = false;
job1.HoldLoadUnload(1, 2).ReasonForUserHold = "agr";
job1.HoldLoadUnload(1, 2).HoldUnholdPatternRepeats = false;
job1.HoldLoadUnload(1, 2).HoldUnholdPatternStartUTC = DateTime.Parse("2010/6/1 3:12 PM").ToUniversalTime();
job1.HoldLoadUnload(1, 2).HoldUnholdPattern.Add(TimeSpan.FromMinutes(174));
job1.HoldLoadUnload(1, 2).HoldUnholdPattern.Add(TimeSpan.FromMinutes(83));
job1.HoldLoadUnload(2, 3).UserHold = true;
job1.HoldLoadUnload(2, 3).ReasonForUserHold = "erhagsad";
job1.HoldLoadUnload(2, 3).HoldUnholdPatternRepeats = false;
job1.HoldLoadUnload(2, 3).HoldUnholdPatternStartUTC = DateTime.Parse("2010/11/5 9:30 AM").ToUniversalTime();
job1.HoldLoadUnload(2, 3).HoldUnholdPattern.Add(TimeSpan.FromMinutes(32));
job1.HoldLoadUnload(2, 3).HoldUnholdPattern.Add(TimeSpan.FromMinutes(64));
return(job1);
}
/// Count up how many JobPaths have an earlier simulation start time and also share a fixture/face with the current job
private static int CountEarlierConflicts(JobPlan jobToCheck, int proc1path, IEnumerable <JobPlan> jobs)
{
var startT = jobToCheck.GetSimulatedStartingTimeUTC(process: 1, path: proc1path);
if (startT == DateTime.MinValue)
{
return(0);
}
// first, calculate the fixtures and faces used by the job to check
var group = jobToCheck.GetPathGroup(process: 1, path: proc1path);
var usedFixtureFaces = new HashSet <ValueTuple <string, string> >();
for (int proc = 1; proc <= jobToCheck.NumProcesses; proc++)
{
for (int path = 1; path <= jobToCheck.GetNumPaths(proc); path++)
{
if (jobToCheck.GetPathGroup(proc, path) != group)
{
continue;
}
var(plannedFix, plannedFace) = jobToCheck.PlannedFixture(proc, path);
if (string.IsNullOrEmpty(plannedFix))
{
continue;
}
usedFixtureFaces.Add((plannedFix, plannedFace.ToString()));
}
}
int earlierConflicts = 0;
// go through each other job and process 1 path
foreach (var otherJob in jobs)
{
for (var otherProc1Path = 1; otherProc1Path <= otherJob.GetNumPaths(process: 1); otherProc1Path++)
{
if (otherJob.UniqueStr == jobToCheck.UniqueStr && proc1path == otherProc1Path)
{
continue;
}
// see if the process 1 starting time is later and if so skip the remaining checks
var otherStart = otherJob.GetSimulatedStartingTimeUTC(process: 1, path: otherProc1Path);
if (otherStart == DateTime.MinValue)
{
goto checkNextPath;
}
if (otherStart >= startT)
{
goto checkNextPath;
}
var otherGroup = otherJob.GetPathGroup(process: 1, path: otherProc1Path);
//the job-path combo starts earlier than the job-path to check, but need to see if it conflicts.
// go through all processes matching the path group and if a fixture face matches,
// count it as a conflict.
for (var otherProc = 1; otherProc <= otherJob.NumProcesses; otherProc++)
{
for (var otherPath = 1; otherPath <= otherJob.GetNumPaths(otherProc); otherPath++)
{
if (otherJob.GetPathGroup(otherProc, otherPath) != otherGroup)
{
continue;
}
var(otherFix, otherFace) = otherJob.PlannedFixture(otherProc, otherPath);
if (usedFixtureFaces.Contains((otherFix, otherFace.ToString())))
{
earlierConflicts += 1;
goto checkNextPath;
}
}
}
checkNextPath :;
}
}
return(earlierConflicts);
}
private static void AddRoutingToJob(MazakSchedulesPartsPallets mazakData, MazakPartRow partRow, JobPlan job, IMachineGroupName machineGroupName, MazakPart.IProcToPath procToPath, MazakDbType mazakTy)
{
//Add routing and pallets
foreach (var partProcRow in partRow.Processes)
{
var path = procToPath.PathForProc(partProcRow.ProcessNumber);
job.SetPartsPerPallet(partProcRow.ProcessNumber, path, partProcRow.FixQuantity);
job.SetPathGroup(partProcRow.ProcessNumber, path, path);
job.SetHoldMachining(partProcRow.ProcessNumber, path, job.HoldMachining(partProcRow.ProcessNumber, path));
job.SetHoldLoadUnload(partProcRow.ProcessNumber, path, job.HoldLoadUnload(partProcRow.ProcessNumber, path));
//Routing
string fixStr = partProcRow.FixLDS;
string cutStr = partProcRow.CutMc;
string removeStr = partProcRow.RemoveLDS;
if (mazakTy != MazakDbType.MazakVersionE)
{
fixStr = ConvertStatIntV2ToV1(Convert.ToInt32(fixStr));
cutStr = ConvertStatIntV2ToV1(Convert.ToInt32(cutStr));
removeStr = ConvertStatIntV2ToV1(Convert.ToInt32(removeStr));
}
foreach (char c in fixStr)
{
if (c != '0')
{
job.AddLoadStation(partProcRow.ProcessNumber, path, int.Parse(c.ToString()));
}
}
foreach (char c in removeStr)
{
if (c != '0')
{
job.AddUnloadStation(partProcRow.ProcessNumber, path, int.Parse(c.ToString()));
}
}
JobMachiningStop routeStop = null;
foreach (char c in cutStr)
{
if (c != '0')
{
if (routeStop == null)
{
routeStop = new JobMachiningStop(machineGroupName.MachineGroupName);
job.AddMachiningStop(partProcRow.ProcessNumber, path, routeStop);
}
routeStop.Stations.Add(int.Parse(c.ToString()));
}
}
if (routeStop != null)
{
routeStop.ProgramName = partProcRow.MainProgram;
}
//Planned Pallets
foreach (var palRow in mazakData.Pallets)
{
if (palRow.PalletNumber > 0 &&
palRow.Fixture == partProcRow.Fixture &&
!job.HasPallet(partProcRow.ProcessNumber, path, palRow.PalletNumber.ToString()))
{
job.AddProcessOnPallet(partProcRow.ProcessNumber, path, palRow.PalletNumber.ToString());
}
}
}
}
private static void SchedulePart(
MazakWriteData transSet, int SchID, string mazakPartName, string mazakComment, int numProcess,
JobPlan part, int proc1path, int earlierConflicts, bool UseStartingOffsetForDueDate)
{
var newSchRow = new MazakScheduleRow();
newSchRow.Command = MazakWriteCommand.Add;
newSchRow.Id = SchID;
newSchRow.PartName = mazakPartName;
newSchRow.PlanQuantity = part.GetPlannedCyclesOnFirstProcess(proc1path);
newSchRow.CompleteQuantity = 0;
newSchRow.FixForMachine = 0;
newSchRow.MissingFixture = 0;
newSchRow.MissingProgram = 0;
newSchRow.MissingTool = 0;
newSchRow.MixScheduleID = 0;
newSchRow.ProcessingPriority = 0;
newSchRow.Comment = mazakComment;
if (UseStartingOffsetForDueDate)
{
if (part.GetSimulatedStartingTimeUTC(1, proc1path) != DateTime.MinValue)
{
var start = part.GetSimulatedStartingTimeUTC(1, proc1path);
newSchRow.DueDate = start.ToLocalTime().Date;
newSchRow.Priority = 91 + Math.Min(earlierConflicts, 9);
}
else
{
newSchRow.DueDate = DateTime.Today;
newSchRow.Priority = 91;
}
}
else
{
newSchRow.Priority = 75;
newSchRow.DueDate = DateTime.Parse("1/1/2008 12:00:00 AM");
}
bool entireHold = false;
if (part.HoldEntireJob != null)
{
entireHold = part.HoldEntireJob.IsJobOnHold;
}
bool machiningHold = false;
if (part.HoldMachining(1, proc1path) != null)
{
machiningHold = part.HoldMachining(1, proc1path).IsJobOnHold;
}
newSchRow.HoldMode = (int)HoldPattern.CalculateHoldMode(entireHold, machiningHold);
int matQty = newSchRow.PlanQuantity;
if (!string.IsNullOrEmpty(part.GetInputQueue(process: 1, path: proc1path)))
{
matQty = 0;
}
//need to add all the ScheduleProcess rows
for (int i = 1; i <= numProcess; i++)
{
var newSchProcRow = new MazakScheduleProcessRow();
newSchProcRow.MazakScheduleRowId = SchID;
newSchProcRow.ProcessNumber = i;
if (i == 1)
{
newSchProcRow.ProcessMaterialQuantity = matQty;
}
else
{
newSchProcRow.ProcessMaterialQuantity = 0;
}
newSchProcRow.ProcessBadQuantity = 0;
newSchProcRow.ProcessExecuteQuantity = 0;
newSchProcRow.ProcessMachine = 0;
newSchRow.Processes.Add(newSchProcRow);
}
transSet.Schedules.Add(newSchRow);
}
public void AddsSchedules()
{
//basic job
var job1 = new JobPlan("uniq1", 2, new int[] { 2, 2 });
job1.PartName = "part1";
job1.SetPathGroup(1, 1, 1);
job1.SetPathGroup(1, 2, 2);
job1.SetPathGroup(2, 1, 1);
job1.SetPathGroup(2, 2, 2);
job1.SetSimulatedStartingTimeUTC(1, 1, new DateTime(2018, 1, 9, 8, 7, 6, DateTimeKind.Local).ToUniversalTime());
job1.SetSimulatedStartingTimeUTC(1, 2, new DateTime(2018, 1, 2, 3, 4, 5, DateTimeKind.Local).ToUniversalTime());
job1.SetPlannedCyclesOnFirstProcess(1, 51);
job1.SetPlannedCyclesOnFirstProcess(2, 41);
job1.SetFixtureFace(1, 1, "fixA", 1);
job1.SetFixtureFace(1, 2, "fixA", 1);
job1.SetFixtureFace(2, 1, "fixA", 2);
job1.SetFixtureFace(2, 2, "fixA", 2);
//one with an input queue
var job2 = new JobPlan("uniq2", 2, new int[] { 2, 2 });
job2.PartName = "part2";
job2.SetPathGroup(1, 1, 1);
job2.SetPathGroup(1, 2, 2);
job2.SetPathGroup(2, 1, 1);
job2.SetPathGroup(2, 2, 2);
job2.SetSimulatedStartingTimeUTC(1, 1, new DateTime(2018, 2, 9, 8, 7, 6, DateTimeKind.Local).ToUniversalTime());
job2.SetSimulatedStartingTimeUTC(1, 2, new DateTime(2018, 2, 2, 3, 4, 5, DateTimeKind.Local).ToUniversalTime());
job2.SetPlannedCyclesOnFirstProcess(1, 12);
job2.SetPlannedCyclesOnFirstProcess(2, 42);
job2.SetInputQueue(1, 1, "aaa");
job2.SetInputQueue(1, 2, "bbb");
job2.SetFixtureFace(1, 1, "fixA", 2); // conflicts with both job1 paths
job2.SetFixtureFace(2, 2, "fixB", 2); // no conflicts
//a schedule which already exists
var job3 = new JobPlan("uniq3", 2, new int[] { 1, 1 });
job3.PartName = "part3";
job3.SetSimulatedStartingTimeUTC(1, 1, new DateTime(2018, 3, 9, 8, 7, 6, DateTimeKind.Local).ToUniversalTime());
job3.SetPlannedCyclesOnFirstProcess(1, 23);
// all the parts, plus a schedule for uniq3
var curData = new MazakSchedulesPartsPallets()
{
Parts = new[] {
new MazakPartRow()
{
PartName = "part1:6:1",
Comment = MazakPart.CreateComment("uniq1", new[] { 1, 1 }, false)
},
new MazakPartRow()
{
PartName = "part1:6:2",
Comment = MazakPart.CreateComment("uniq1", new[] { 2, 2 }, false)
},
new MazakPartRow()
{
PartName = "part2:6:1",
Comment = MazakPart.CreateComment("uniq2", new[] { 1, 1 }, false)
},
new MazakPartRow()
{
PartName = "part2:6:2",
Comment = MazakPart.CreateComment("uniq2", new[] { 2, 2 }, false)
},
new MazakPartRow()
{
PartName = "part3:6:1",
Comment = MazakPart.CreateComment("uniq3", new[] { 1, 1 }, false)
}
},
Schedules = new[] {
new MazakScheduleRow()
{
Id = 1,
PartName = "part3:6:1",
Comment = MazakPart.CreateComment("uniq3", new[] { 1, 1 }, false)
}
}
};
var actions = BuildMazakSchedules.AddSchedules(curData, new[] { job1, job2, job3 }, true);
actions.Parts.Should().BeEmpty();
actions.Fixtures.Should().BeEmpty();
actions.Pallets.Should().BeEmpty();
actions.Schedules.Should().BeEquivalentTo(new[]
{
//uniq1
new MazakScheduleRow()
{
Command = MazakWriteCommand.Add,
Id = 2,
PartName = "part1:6:1",
Comment = MazakPart.CreateComment("uniq1", new[] { 1, 1 }, false),
PlanQuantity = 51,
Priority = 91 + 1, // one earlier conflict
DueDate = new DateTime(2018, 1, 9, 0, 0, 0, DateTimeKind.Local),
Processes =
{
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 2,
ProcessNumber = 1,
ProcessMaterialQuantity = 51
},
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 2,
ProcessNumber = 2,
ProcessMaterialQuantity = 0
},
}
},
new MazakScheduleRow()
{
Command = MazakWriteCommand.Add,
Id = 3,
PartName = "part1:6:2",
Comment = MazakPart.CreateComment("uniq1", new[] { 2, 2 }, false),
PlanQuantity = 41,
Priority = 91,
DueDate = new DateTime(2018, 1, 2, 0, 0, 0, DateTimeKind.Local),
Processes =
{
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 3,
ProcessNumber = 1,
ProcessMaterialQuantity = 41
},
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 3,
ProcessNumber = 2,
ProcessMaterialQuantity = 0
},
}
},
//uniq2
new MazakScheduleRow()
{
Command = MazakWriteCommand.Add,
Id = 4,
PartName = "part2:6:1",
Comment = MazakPart.CreateComment("uniq2", new[] { 1, 1 }, false),
PlanQuantity = 12,
Priority = 91 + 2, // conflicts with 2 earlier
DueDate = new DateTime(2018, 2, 9, 0, 0, 0, DateTimeKind.Local),
Processes =
{
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 4,
ProcessNumber = 1,
ProcessMaterialQuantity = 0 // no material, input queue
},
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 4,
ProcessNumber = 2,
ProcessMaterialQuantity = 0
},
}
},
new MazakScheduleRow()
{
Command = MazakWriteCommand.Add,
Id = 5,
PartName = "part2:6:2",
Comment = MazakPart.CreateComment("uniq2", new[] { 2, 2 }, false),
PlanQuantity = 42,
Priority = 91,
DueDate = new DateTime(2018, 2, 2, 0, 0, 0, DateTimeKind.Local),
Processes =
{
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 5,
ProcessNumber = 1,
ProcessMaterialQuantity = 0 //no material, input queue
},
new MazakScheduleProcessRow()
{
MazakScheduleRowId = 5,
ProcessNumber = 2,
ProcessMaterialQuantity = 0
},
}
}
});
}
public List <JobPlan> GetJobPlan(string ccmasterid)
{
string selectCommand = $@"SELECT
job,
--jp.activitycode,
jp.scheduledactivity ,
at.jcdescription,
jp.part,
jp.printflowform,
jp.startdate,
jp.enddate,
s.name,jp.previoustask, jp.nexttask
FROM jobplan jp
INNER JOIN activitycode at ON at.jcmasterid = jp.activitycode
INNER JOIN schedulestatus s ON s.id = jp.status
WHERE job = '{ccmasterid}'
ORDER BY jp.activitycode";
try
{
using (NpgsqlDataAdapter data = new NpgsqlDataAdapter(selectCommand, ConnectionManager.GetMyNpgConnection()))
{
DataTable dt = new DataTable();
data.SelectCommand.CommandType = CommandType.Text;
var tasks = new List <JobPlan>();
data.Fill(dt);
if (dt.Rows.Count > 0) // this is the record returned from epace
{
for (int i = 0; i < dt.Rows.Count; i++)
{
DataRow dRow = dt.Rows[i];
var task = new JobPlan();
task.job = dRow["job"].ToString();
task.scheduledactivity = dRow["scheduledactivity"].ToString();
task.jcdescription = dRow["jcdescription"].ToString();
task.part = dRow["part"].ToString();
task.printflowform = dRow["printflowform"].ToString();
task.startdate = dRow["startdate"].ToString();
task.enddate = dRow["enddate"].ToString();
task.name = dRow["name"].ToString();
task.previoustask = dRow["previoustask"].ToString();
task.nexttask = dRow["nexttask"].ToString();
tasks.Add(task);
}
return(tasks);
}
return(tasks);
}
}
catch (NpgsqlException ex)
{
throw new Exception("Npgsql exception: " + ex.Message);
}
catch (Exception ex)
{
throw new Exception("Exception: " + ex.Message);
}
finally
{
ConnectionManager.CloseNpgSqlConnection();
}
}
public MazakPart(JobPlan j, int downID)
{
Job = j;
DownloadID = downID;
Processes = new List <MazakProcess>();
}
private List <MWI.LogEntry> CheckPendingLoads(int pallet, DateTime t, string foreignID, bool palletCycle, List <MWI.LogEntry> cycle)
{
var pending = _log.PendingLoads(pallet.ToString());
if (pending.Count == 0)
{
if (palletCycle)
{
bool hasCompletedUnload = false;
foreach (var e in cycle)
{
if (e.LogType == LogType.LoadUnloadCycle &&
e.StartOfCycle == false &&
e.Result == "UNLOAD")
{
hasCompletedUnload = true;
}
}
if (hasCompletedUnload)
{
_log.CompletePalletCycle(pallet.ToString(), t, foreignID);
}
else
{
Log.Debug("Skipping pallet cycle at time {time} because we detected a pallet cycle without unload", t);
}
}
return(cycle);
}
var mat = new Dictionary <string, IEnumerable <JobLogDB.EventLogMaterial> >();
foreach (var p in pending)
{
Log.Debug("Processing pending load {@pending}", p);
var s = p.Key.Split(',');
if (s.Length != 3)
{
continue;
}
string fullPartName = s[0];
string jobPartName = MazakPart.ExtractPartNameFromMazakPartName(fullPartName);
int proc;
int fixQty;
if (!int.TryParse(s[1], out proc))
{
proc = 1;
}
if (!int.TryParse(s[2], out fixQty))
{
fixQty = 1;
}
_mazakSchedules.FindSchedule(fullPartName, proc, out string unique, out int path, out int numProc);
JobPlan job = GetJob(unique);
var mats = new List <JobLogDB.EventLogMaterial>();
if (job != null && !string.IsNullOrEmpty(job.GetInputQueue(proc, path)))
{
// search input queue for material
Log.Debug("Searching queue {queue} for {unique}-{proc} to load",
job.GetInputQueue(proc, path), unique, proc);
// TODO: filter paths
var qs = _log.GetMaterialInQueue(job.GetInputQueue(proc, path)).Where(q => q.Unique == unique).ToList();
for (int i = 1; i <= fixQty; i++)
{
string face;
if (fixQty == 1)
{
face = proc.ToString();
}
else
{
face = proc.ToString() + "-" + i.ToString();
}
if (i <= qs.Count)
{
var qmat = qs[i - 1];
mats.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = qmat.MaterialID, Process = proc, Face = face
});
}
else
{
// not enough material in queue
Log.Warning("Not enough material in queue {queue} for {part}-{proc}, creating new material for {@pending}",
job.GetInputQueue(proc, path), fullPartName, proc, p);
mats.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = _log.AllocateMaterialID(unique, jobPartName, numProc),
Process = proc,
Face = face
});
}
}
}
else if (proc == 1)
{
// create new material
Log.Debug("Creating new material for unique {unique} process 1", unique);
for (int i = 1; i <= fixQty; i += 1)
{
string face;
if (fixQty == 1)
{
face = proc.ToString();
}
else
{
face = proc.ToString() + "-" + i.ToString();
}
mats.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = _log.AllocateMaterialID(unique, jobPartName, numProc),
Process = proc,
Face = face
});
}
}
else
{
// search on pallet in the previous process for material
Log.Debug("Searching on pallet for unique {unique} process {proc} to load into process {proc}", unique, proc - 1, proc);
var byFace = ParseMaterialFromPreviousEvents(
jobPartName: jobPartName,
proc: proc - 1,
fixQty: fixQty,
isUnloadEnd: false,
oldEvents: cycle);
for (int i = 1; i <= fixQty; i += 1)
{
string prevFace;
string nextFace;
if (fixQty == 1)
{
prevFace = (proc - 1).ToString();
nextFace = proc.ToString();
}
else
{
prevFace = (proc - 1).ToString() + "-" + i.ToString();
nextFace = proc.ToString() + "-" + i.ToString();
}
if (byFace.ContainsKey(prevFace))
{
var old = byFace[prevFace];
mats.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = old.MaterialID,
Process = proc,
Face = nextFace
});
}
else
{
//something went wrong, must create material
mats.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = _log.AllocateMaterialID(unique, jobPartName, numProc),
Process = proc,
Face = nextFace
});
Log.Warning("Could not find material on pallet {pallet} for previous process {proc}, creating new material for {@pending}",
pallet, proc - 1, p);
}
}
}
mat[p.Key] = mats;
}
_log.CompletePalletCycle(pallet.ToString(), t, foreignID, mat, generateSerials: true);
if (palletCycle)
{
return(cycle);
}
else
{
return(_log.CurrentPalletLog(pallet.ToString()));
}
}
