Updated original job handler with Vica's work.

2 files changed, 299 insertions, 69 deletions

diff --git a/Software/Visual_Studio/Tango.Integration/Operation/JobHandler.cs b/Software/Visual_Studio/Tango.Integration/Operation/JobHandler.cs
index 098118eaa..fce815bc3 100644
--- a/Software/Visual_Studio/Tango.Integration/Operation/JobHandler.cs
+++ b/Software/Visual_Studio/Tango.Integration/Operation/JobHandler.cs
@@ -327,10 +327,255 @@ namespace Tango.Integration.Operation
 
         #region Private Methods
 
+        //protected virtual void InvalidateJobProgress(JobStatus s)
+        //{
+        //    JobStatus = s;
+        //    bool invalidProgress = false;
+
+        //    if (_last_progress != s.Progress)
+        //    {
+        //        if (s.Progress <= PROGRESS_REPORT_RANGE_METERS || s.Progress >= Status.TotalProgress - PROGRESS_REPORT_RANGE_METERS)
+        //        {
+        //            LogManager.Log($"Updating job progress {s.Progress}/{Status.TotalProgress}...");
+        //        }
+        //        else if (!loggedContinueMessage)
+        //        {
+        //            loggedContinueMessage = true;
+        //            LogManager.Log($"Progress logging will continue {PROGRESS_REPORT_RANGE_METERS} meters before completion...");
+        //        }
+        //    }
+
+        //    if (s.Progress < 0)
+        //    {
+        //        LogManager.Log($"Invalid job progress received '{s.Progress}'.", LogCategory.Error);
+        //        invalidProgress = true;
+        //    }
+
+        //    if (s.Progress > Status.TotalProgress)
+        //    {
+        //        LogManager.Log($"Invalid job progress received '{s.Progress}' while total progress is '{Status.TotalProgress}'.", LogCategory.Error);
+        //        invalidProgress = true;
+        //    }
+
+        //    if (s.Progress < _last_progress)
+        //    {
+        //        LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
+        //        invalidProgress = true;
+        //    }
+
+        //    if (invalidProgress)
+        //    {
+        //        return;
+        //    }
+
+        //    _last_progress = s.Progress;
+
+        //    //Job Status
+        //    if (IsCanceled)
+        //    {
+        //        Status.IsCanceled = IsCanceled;
+        //        RaiseStatusChanged();
+        //        return;
+        //    }
+
+        //    List<Segment> unit_segments = new List<Segment>();
+        //    double delta = s.Progress - Status.Progress;
+
+        //    Status.Progress = s.Progress;
+        //    Status.RemainingTime = Status.TotalTime - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
+        //    Status.RemainingProgress = Status.TotalProgress - Status.Progress;
+
+        //    if (Status.SettingUpProgress < Status.SettingUpTotalProgress)
+        //    {
+        //        Status.SettingUpProgress += delta;
+        //    }
+        //    else
+        //    {
+        //        if (Status.IsSettingUp && Status.Progress > 0)
+        //        {
+        //            Status.IsSettingUp = false;
+        //        }
+
+        //        Status.ProgressMinusSettingUp += delta;
+        //    }
+
+        //    if (s.Progress < Job.LengthIncludingNumberOfUnits || _mode == JobHandlerModes.SettingUp)
+        //    {
+        //        Status.ProgressWithoutFinalization += delta;
+
+        //        unit_segments = _effectiveSegments.ToList();
+
+        //        if (Job.EnableInterSegment && Job.NumberOfUnits > 1 && Status.RemainingUnits > 1)
+        //        {
+        //            unit_segments.Add(Job.CreateInterSegment(Job.InterSegmentLength));
+        //        }
+
+        //        if (unit_segments.Count != Status.CurrentUnitSegments.Count)
+        //        {
+        //            Status.CurrentUnitSegments = unit_segments;
+        //        }
+
+        //        Status.CurrentUnitTotalProgress = Status.RemainingUnits > 1 && Job.EnableInterSegment ? Job.Length + (Job.InterSegmentLength) : Job.Length;
+
+        //        if (_mode == JobHandlerModes.Finalization)
+        //        {
+        //            Status.CurrentUnitProgress += delta;
+        //        }
+        //        else
+        //        {
+        //            if (!Status.IsSettingUp)
+        //            {
+        //                Status.CurrentUnitProgress += delta;
+        //            }
+        //        }
+
+        //        if (Status.CurrentUnitProgress >= Status.CurrentUnitTotalProgress)
+        //        {
+        //            Status.CurrentUnitProgress = 0;
+        //            Status.CurrentUnit++;
+        //        }
+
+        //        Status.RemainingUnits = Job.NumberOfUnits - Status.CurrentUnit;
+
+        //        if (s.Message != _lastStatusMessage && s.Message != String.Empty)
+        //        {
+        //            Status.Message = s.Message;
+        //        }
+        //        else
+        //        {
+        //            Status.Message = null;
+        //        }
+
+        //        _lastStatusMessage = s.Message;
+
+        //        RaiseStatusChanged();
+
+        //        //Segments Completion
+
+        //        if (Status.CurrentUnit > _last_unit)
+        //        {
+        //            foreach (var segment in Status.CurrentUnitSegments)
+        //            {
+        //                segment.Started = false;
+        //                segment.Completed = false;
+        //            }
+
+        //            if (Job.NumberOfUnits > 1)
+        //            {
+        //                RaiseUnitCompleted(_last_unit);
+        //            }
+        //        }
+
+        //        _last_unit = Status.CurrentUnit;
+
+
+        //        for (int i = 0; i < Status.CurrentUnitSegments.Count; i++)
+        //        {
+        //            Segment segment = Status.CurrentUnitSegments[i];
+        //            double previousSegmentsLengthWithThis = Status.CurrentUnitSegments.Take(i + 1).Sum(x => x.LengthWithFactor);
+        //            TimeSpan segmentsDuration = Job.TranslateProgressToTime(previousSegmentsLengthWithThis, ProcessParameters);
+        //            TimeSpan segmentRemainingTime = segmentsDuration - Job.TranslateProgressToTime(Status.CurrentUnitProgress, ProcessParameters);
+
+        //            if (i == 0 && Status.CurrentUnitProgress > 0)
+        //            {
+        //                if (!segment.Started)
+        //                {
+        //                    segment.Started = true;
+        //                    RaiseSegmentStarted(segment);
+        //                }
+        //            }
+
+        //            if (Status.CurrentUnitProgress >= previousSegmentsLengthWithThis)
+        //            {
+        //                if (!segment.Completed)
+        //                {
+        //                    segment.Completed = true;
+        //                    RaiseSegmentCompleted(segment);
+        //                }
+
+        //                if (i < Status.CurrentUnitSegments.Count - 1)
+        //                {
+        //                    if (!Status.CurrentUnitSegments[i + 1].Started)
+        //                    {
+        //                        Status.CurrentUnitSegments[i + 1].Started = true;
+        //                        RaiseSegmentStarted(Status.CurrentUnitSegments[i + 1]);
+        //                    }
+        //                }
+        //            }
+
+        //            if (segment.Started && !segment.Completed)
+        //            {
+        //                segment.RemainingTime = segmentRemainingTime;
+        //            }
+        //        }
+
+
+        //        //Set Segment Completion for All Segments List
+        //        for (int i = 0; i < Status.Segments.Count; i++)
+        //        {
+        //            Segment segment = Status.Segments[i];
+        //            double previousSegmentsLengthWithThis = Status.Segments.Take(i + 1).Sum(x => x.LengthWithFactor);
+        //            TimeSpan segmentsDuration = Job.TranslateProgressToTime(previousSegmentsLengthWithThis, ProcessParameters);
+        //            TimeSpan segmentRemainingTime = segmentsDuration - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
+
+        //            segment.Progress = Math.Min(Math.Max((previousSegmentsLengthWithThis - segment.Length - Status.Progress) * -1, 0), segment.Length);
+
+        //            if (i == 0 && Status.Progress > 0)
+        //            {
+        //                if (!segment.Started)
+        //                {
+        //                    segment.Started = true;
+        //                    Status.CurrentSegment = segment;
+        //                }
+        //            }
+
+        //            if (Status.Progress >= previousSegmentsLengthWithThis)
+        //            {
+        //                if (!segment.Completed)
+        //                {
+        //                    segment.Completed = true;
+        //                }
+
+        //                if (i < Status.Segments.Count - 1)
+        //                {
+        //                    if (!Status.Segments[i + 1].Started)
+        //                    {
+        //                        Status.Segments[i + 1].Started = true;
+        //                        Status.CurrentSegment = Status.Segments[i + 1];
+        //                    }
+        //                }
+        //            }
+
+        //            if (segment.Started && !segment.Completed)
+        //            {
+        //                segment.RemainingTime = segmentRemainingTime;
+        //            }
+        //        }
+        //    }
+        //    else
+        //    {
+        //        //Finalizing
+        //        if (!_finalizing)
+        //        {
+        //            _finalizing = true;
+        //            Status.IsFinalizing = true;
+        //            var last_Segment = _effectiveSegments.Last().Clone();
+        //            last_Segment.Length = ProcessParameters.DryerBufferLengthMeters;
+        //            Status.CurrentUnitSegments = new List<Segment> { last_Segment };
+        //            Status.CurrentUnitTotalProgress = last_Segment.Length;
+        //            Status.CurrentUnitProgress = 0;
+        //            Status.ProgressWithoutFinalization = Status.TotalProgressWithoutFinalization;
+        //            RaiseFinalizing();
+        //        }
+
+        //        Status.CurrentUnitProgress += delta;
+        //        Status.FinalizingProgress += delta;
+        //    }
+        //}
+
         protected virtual void InvalidateJobProgress(JobStatus s)
         {
             JobStatus = s;
-            bool invalidProgress = false;
 
             if (_last_progress != s.Progress)
             {
@@ -348,62 +593,76 @@ namespace Tango.Integration.Operation
             if (s.Progress < 0)
             {
                 LogManager.Log($"Invalid job progress received '{s.Progress}'.", LogCategory.Error);
-                invalidProgress = true;
+                return;
             }
 
             if (s.Progress > Status.TotalProgress)
             {
                 LogManager.Log($"Invalid job progress received '{s.Progress}' while total progress is '{Status.TotalProgress}'.", LogCategory.Error);
-                invalidProgress = true;
+                return;
             }
 
             if (s.Progress < _last_progress)
             {
                 LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
-                invalidProgress = true;
-            }
-
-            if (invalidProgress)
-            {
-                return;
             }
 
             _last_progress = s.Progress;
 
-            //Job Status
-            if (IsCanceled)
-            {
-                Status.IsCanceled = IsCanceled;
-                RaiseStatusChanged();
-                return;
-            }
-
             List<Segment> unit_segments = new List<Segment>();
-            double delta = s.Progress - Status.Progress;
 
             Status.Progress = s.Progress;
             Status.RemainingTime = Status.TotalTime - Job.TranslateProgressToTime(Status.Progress, ProcessParameters);
             Status.RemainingProgress = Status.TotalProgress - Status.Progress;
 
-            if (Status.SettingUpProgress < Status.SettingUpTotalProgress)
+            if (s.Progress < Status.SettingUpTotalProgress || Status.SettingUpProgress < Status.SettingUpTotalProgress)
             {
-                Status.SettingUpProgress += delta;
+                Status.SettingUpProgress = Math.Min(s.Progress, this.Status.SettingUpTotalProgress);
+                Status.IsSettingUp = true;
             }
-            else
+            if (s.Progress >= Status.SettingUpTotalProgress)
             {
                 if (Status.IsSettingUp && Status.Progress > 0)
                 {
                     Status.IsSettingUp = false;
                 }
 
-                Status.ProgressMinusSettingUp += delta;
+                Status.ProgressMinusSettingUp = s.Progress - this.Status.SettingUpTotalProgress;
             }
 
+            int units = (int)Math.Max(Job.NumberOfUnits, 1);
+
             if (s.Progress < Job.LengthIncludingNumberOfUnits || _mode == JobHandlerModes.SettingUp)
             {
-                Status.ProgressWithoutFinalization += delta;
+                Status.ProgressWithoutFinalization = s.Progress;
 
                 unit_segments = _effectiveSegments.ToList();
+                Status.CurrentUnitProgress = 0.0;
+                double previousUnitsLengthWithoutThis = 0.0;
+                for (int index = 0; index < units; ++index)
+                {
+                    Status.CurrentUnit = index;
+                    double unitLength = !Job.EnableInterSegment || index >= units - 1 ? Job.Length : Job.Length + Job.InterSegmentLength;
+                    if (_mode == JobHandlerModes.Finalization)
+                    {
+                        if (s.Progress < unitLength + previousUnitsLengthWithoutThis)
+                        {
+                            Status.CurrentUnitProgress = s.Progress - previousUnitsLengthWithoutThis;
+                            break;
+                        }
+                    }
+                    else if (s.Progress <= previousUnitsLengthWithoutThis + unitLength + Status.SettingUpProgress)
+                    {
+                        if (!Status.IsSettingUp)
+                        {
+                            Status.CurrentUnitProgress = s.Progress - previousUnitsLengthWithoutThis - this.Status.SettingUpProgress;
+                            break;
+                        }
+                        break;
+                    }
+                    previousUnitsLengthWithoutThis += unitLength;
+                }
+                Status.RemainingUnits = this.Job.NumberOfUnits - this.Status.CurrentUnit;
 
                 if (Job.EnableInterSegment && Job.NumberOfUnits > 1 && Status.RemainingUnits > 1)
                 {
@@ -417,26 +676,6 @@ namespace Tango.Integration.Operation
 
                 Status.CurrentUnitTotalProgress = Status.RemainingUnits > 1 && Job.EnableInterSegment ? Job.Length + (Job.InterSegmentLength) : Job.Length;
 
-                if (_mode == JobHandlerModes.Finalization)
-                {
-                    Status.CurrentUnitProgress += delta;
-                }
-                else
-                {
-                    if (!Status.IsSettingUp)
-                    {
-                        Status.CurrentUnitProgress += delta;
-                    }
-                }
-
-                if (Status.CurrentUnitProgress >= Status.CurrentUnitTotalProgress)
-                {
-                    Status.CurrentUnitProgress = 0;
-                    Status.CurrentUnit++;
-                }
-
-                Status.RemainingUnits = Job.NumberOfUnits - Status.CurrentUnit;
-
                 if (s.Message != _lastStatusMessage && s.Message != String.Empty)
                 {
                     Status.Message = s.Message;
@@ -448,10 +687,10 @@ namespace Tango.Integration.Operation
 
                 _lastStatusMessage = s.Message;
 
+
                 RaiseStatusChanged();
 
                 //Segments Completion
-
                 if (Status.CurrentUnit > _last_unit)
                 {
                     foreach (var segment in Status.CurrentUnitSegments)
@@ -509,7 +748,6 @@ namespace Tango.Integration.Operation
                     }
                 }
 
-
                 //Set Segment Completion for All Segments List
                 for (int i = 0; i < Status.Segments.Count; i++)
                 {
@@ -568,8 +806,8 @@ namespace Tango.Integration.Operation
                     RaiseFinalizing();
                 }
 
-                Status.CurrentUnitProgress += delta;
-                Status.FinalizingProgress += delta;
+                Status.CurrentUnitProgress = s.Progress - Job.LengthIncludingNumberOfUnits;
+                Status.FinalizingProgress = s.Progress - Status.TotalProgressWithoutFinalization;
             }
         }
 
diff --git a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
index 27dfa2ebe..e646ee51e 100644
--- a/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
+++ b/Software/Visual_Studio/Utilities/Tango.JobProgressTester.UI/JobHandler2.cs
@@ -20,44 +20,36 @@ namespace Tango.JobProgressTester.UI
 
         protected override void InvalidateJobProgress(JobStatus s)
         {
-            //base.InvalidateJobProgress(s); //Vica: Remove this and create new implementation.
             JobStatus = s;
-            bool invalidProgress = false;
 
-            // if (_last_progress != s.Progress)
-            // {
-            if (s.Progress <= PROGRESS_REPORT_RANGE_METERS || s.Progress >= Status.TotalProgress - PROGRESS_REPORT_RANGE_METERS)
+            if (_last_progress != s.Progress)
             {
-                LogManager.Log($"Updating job progress {s.Progress}/{Status.TotalProgress}...");
-            }
-            else if (!loggedContinueMessage)
-            {
-                loggedContinueMessage = true;
-                LogManager.Log($"Progress logging will continue {PROGRESS_REPORT_RANGE_METERS} meters before completion...");
+                if (s.Progress <= PROGRESS_REPORT_RANGE_METERS || s.Progress >= Status.TotalProgress - PROGRESS_REPORT_RANGE_METERS)
+                {
+                    LogManager.Log($"Updating job progress {s.Progress}/{Status.TotalProgress}...");
+                }
+                else if (!loggedContinueMessage)
+                {
+                    loggedContinueMessage = true;
+                    LogManager.Log($"Progress logging will continue {PROGRESS_REPORT_RANGE_METERS} meters before completion...");
+                }
             }
-            //}
 
             if (s.Progress < 0)
             {
                 LogManager.Log($"Invalid job progress received '{s.Progress}'.", LogCategory.Error);
-                invalidProgress = true;
+                return;
             }
 
             if (s.Progress > Status.TotalProgress)
             {
                 LogManager.Log($"Invalid job progress received '{s.Progress}' while total progress is '{Status.TotalProgress}'.", LogCategory.Error);
-                invalidProgress = true;
+                return;
             }
 
-            //if (s.Progress < _last_progress)
-            //{
-            //    LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
-            //    invalidProgress = true;
-            //}
-
-            if (invalidProgress)
+            if (s.Progress < _last_progress)
             {
-                return;
+                LogManager.Log($"Invalid job progress received '{s.Progress}' while last progress was '{_last_progress}'.");
             }
 
             _last_progress = s.Progress;