Merged Eureka Branch !!!

1 files changed, 855 insertions, 0 deletions

diff --git a/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs b/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs
new file mode 100644
index 000000000..131476c9e
--- /dev/null
+++ b/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs
@@ -0,0 +1,855 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.BL.Entities;
+using Tango.BL.Enumerations;
+using Tango.Core.Commands;
+using Tango.Core.DI;
+using Tango.Integration.Operation;
+using Tango.PMR.Diagnostics;
+using Tango.PMR.MachineStatus;
+using Tango.PPC.Common;
+using Tango.PPC.Common.Diagnostics;
+using Tango.PPC.Jobs;
+using Tango.PPC.Jobs.NavigationObjects;
+using Tango.PPC.Jobs.Views;
+using Tango.PPC.UI.Models;
+using System.Timers;
+using System.Windows.Threading;
+using System.Diagnostics;
+using Tango.PMR.Printing;
+using System.ComponentModel;
+using RealTimeGraphX.WPF;
+using RealTimeGraphX.DataPoints;
+using Tango.PPC.UI.Graphs;
+using Tango.BL;
+using System.Data.Entity;
+using System.Windows.Media;
+
+namespace Tango.PPC.UI.ViewModels
+{
+    public class MachineStatusViewVM : PPCViewModel
+    {
+        public enum StatisticTab
+        {
+            [Description("Production Data")]
+            Productiondata = 0,
+            [Description("Temperature")]
+            Temperature = 1,
+            [Description("Pressure")]
+            Pressure = 2,
+            [Description("Motor")]
+            Motor = 3
+        }
+
+        public class TimeToDyeValueItem
+        {
+            public DateTime startTime;
+            public DateTime endTime;
+            public double totalValue;
+        };
+
+        public class TimeToDyeValueCollection
+        {
+            public DateTime StartTime {  get; set;}
+            public List<TimeToDyeValueItem> items;
+            public TimeToDyeValueCollection()
+            {
+                items = new List<TimeToDyeValueItem>();
+            }
+        };
+
+        private DispatcherTimer _productiondata_timer;
+
+        #region Properties
+
+        [TangoInject]
+        public IDiagnosticsFrameProvider DefaultDiagnosticsFrameProvider { get; set; }
+
+        private JobHandler _handler;
+
+        private Job _job;
+        /// <summary>
+        /// Gets or sets the job.
+        /// </summary>
+        public Job Job
+        {
+            get { return _job; }
+            set
+            {
+                _job = value;
+                if (_job == null)
+                    IsDyeingProcess = false;
+                RaisePropertyChangedAuto();
+                InvalidateRelayCommands();
+            }
+        }
+
+        private RunningJobStatus _runningJobStatus;
+        /// <summary>
+        /// Gets or sets the running job status.
+        /// </summary>
+        public RunningJobStatus RunningJobStatus
+        {
+            get { return _runningJobStatus; }
+            set
+            {
+                _runningJobStatus = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        private bool _isJobStatusViewEnable;
+
+        public bool IsJobStatusViewEnable
+        {
+            get { return _isJobStatusViewEnable; }
+            set { _isJobStatusViewEnable = value; RaisePropertyChangedAuto(); }
+        }
+
+        private bool _isEnabledStopButton;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is enabled stop button.
+        /// </summary>
+        public bool IsEnabledStopButton
+        {
+            get { return _isEnabledStopButton; }
+            set { _isEnabledStopButton = value; RaisePropertyChangedAuto(); }
+        }
+
+        private bool _isSpoolView;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is spool view.
+        /// </summary>
+        public bool IsSpoolView
+        {
+            get { return _isSpoolView; }
+            set { _isSpoolView = value; RaisePropertyChangedAuto(); }
+        }
+
+        private bool _isWeightView;
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is length. Show indicator values in length or weight.
+        /// </summary>
+        public bool IsWeghtView
+        {
+            get { return _isWeightView; }
+            set { _isWeightView = value; RaisePropertyChangedAuto(); }
+        }
+
+
+        private bool _isDyeingProcess;
+
+        public bool IsDyeingProcess
+        {
+            get { return _isDyeingProcess; }
+            set
+            {
+                if (_isDyeingProcess != value)
+                {
+                    _isDyeingProcess = value;
+                    RaisePropertyChangedAuto();
+                }
+            }
+        }
+
+        private BrushStop _currentBrushStop;
+        public BrushStop CurrentBrushStop
+        {
+            get { return _currentBrushStop; }
+            set
+            {
+                // if (_currentBrushStop != value)
+                {
+                    _currentBrushStop = value;
+                    OnUpdateCurrentBrush();
+                    RaisePropertyChangedAuto();
+                }
+            }
+        }
+
+        public JobBrushStop JobBrushStop { get; set; }
+
+        public double CyanOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.Cyan); }
+        }
+
+        public double MagentaOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.Magenta); }
+        }
+
+        public double YellowOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.Yellow); }
+        }
+
+        public double BlackOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.Black); }
+        }
+
+        public double LightCyanOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.LightCyan); }
+        }
+
+        public double LightMagentaOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.LightMagenta); }
+        }
+
+        public double LightYellowOutput
+        {
+            get { return GetVolumeLiquidType(LiquidTypes.LightYellow); }
+        }
+        
+        //public double TransparentInkOutput
+        //{
+        //    get { return GetVolumeLiquidType(LiquidTypes.TransparentInk); }
+        //}
+
+        //public double LubricantOutput
+        //{
+        //    get { return GetVolumeLiquidType(LiquidTypes.Lubricant); }
+        //}
+
+        private List<JerricanLevelModel> _midTankLevels;
+        public List<JerricanLevelModel> MidTankLevels
+        {
+            get { return _midTankLevels; }
+            set { _midTankLevels = value; RaisePropertyChangedAuto(); }
+        }
+
+        private JerricanLevelModel _midTankLubLevel;
+        public JerricanLevelModel MidTankLubLevel
+        {
+            get { return _midTankLubLevel; }
+            set { _midTankLubLevel = value; RaisePropertyChangedAuto(); }
+        }
+
+        public MachineOverviewModel OverviewModel { get; set; }
+
+        private bool _isDisplayJobOutline;
+        /// <summary>
+        /// Gets or sets a value indicating whether to display the job outline.
+        /// </summary>
+        public bool IsDisplayJobOutline
+        {
+            get { return _isDisplayJobOutline; }
+            set { _isDisplayJobOutline = value; RaisePropertyChangedAuto(); }
+        }
+
+        private JobTicket _jobOutlineTicket;
+        /// <summary>
+        /// Gets or sets the job outline ticket.
+        /// </summary>
+        public JobTicket JobOutlineTicket
+        {
+            get { return _jobOutlineTicket; }
+            set { _jobOutlineTicket = value; RaisePropertyChangedAuto(); }
+        }
+
+        public MachineOverviewErrorStates MachineErrorStates {  get; set; }
+
+        private bool _isExpandedNotificatios;
+
+        public bool IsExpandedNotifications
+        {
+            get { return _isExpandedNotificatios; }
+            set {
+                _isExpandedNotificatios = value;
+            RaisePropertyChangedAuto();}
+        }
+
+        private int _selectedStatisticTabIndex;
+        /// <summary>
+        /// Gets or sets the index of the selected category.
+        /// </summary>
+        public int SelectedStatisticTabIndex
+        {
+            get { return _selectedStatisticTabIndex; }
+            set
+            {
+                if (_selectedStatisticTabIndex != value)
+                {
+                    _selectedStatisticTabIndex = value;
+                    RaisePropertyChangedAuto();
+                    switch (_selectedStatisticTabIndex)
+                    {
+                        case 0:
+                            {
+                                SelectedStatisticTab = StatisticTab.Productiondata;
+                                break;
+                            }
+                        case 1:
+                            {
+                                SelectedStatisticTab = StatisticTab.Temperature;
+                                break;
+                            }
+                        case 2:
+                            {
+                                SelectedStatisticTab = StatisticTab.Pressure;
+                                break;
+                            }
+                        case 3:
+                            {
+                                SelectedStatisticTab = StatisticTab.Motor;
+                                break;
+                            }
+                    }
+                }
+            }
+        }
+
+        private StatisticTab _selectedStatisticTab;
+        /// <summary>
+        /// Gets or sets the selected category.
+        /// </summary>
+        ///
+        public StatisticTab SelectedStatisticTab
+        {
+            get
+            {
+                return _selectedStatisticTab;
+            }
+            set
+            {
+                if (_selectedStatisticTab != value)
+                {
+                    _selectedStatisticTab = value;
+                    RaisePropertyChangedAuto();
+                }
+                _selectedStatisticTabIndex = _selectedStatisticTab.ToInt32();
+                RaisePropertyChanged(nameof(SelectedStatisticTabIndex));
+            }
+        }
+
+        public WpfGraphController<DateTimeDataPoint, DoubleDataPoint> JobController { get; set; }
+
+        #endregion
+
+        #region Commands
+
+        public RelayCommand StopCommand { get; set; }
+
+        public RelayCommand AbortCommand { get; set; }
+
+        public RelayCommand ResumeCommand { get; set; }
+        public RelayCommand CaancelJobCommand{ get; set; }
+        public RelayCommand RestartJobCommand { get; set; }
+        public RelayCommand ClearJobCommand { get; set; }
+        
+
+        public RelayCommand GoToJobCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the job status view command.
+        /// </summary>
+        public RelayCommand JobStatusViewCommand { get; set; }
+
+        /// <summary>
+        /// Gets or sets the overview view command.
+        /// </summary>
+        public RelayCommand OverviewViewCommand { get; set; }
+
+        public RelayCommand ClearAllNotificationsCommand { get; set; }
+
+        public RelayCommand DisplayJobOutlineCommand { get; set; }
+
+        public RelayCommand HideJobOutlineCommand { get; set; }
+
+        #endregion
+
+        public MachineStatusViewVM()
+        {
+            _productiondata_timer = new DispatcherTimer();
+            _productiondata_timer.Interval = TimeSpan.FromMinutes(10);
+            _productiondata_timer.Tick += _productiondata_timer_Tick;
+            
+
+            StopCommand = new RelayCommand(StopJob, () => CanStopped());
+            AbortCommand = new RelayCommand(AbortJob, () => CanStopped());
+
+            ResumeCommand = new RelayCommand(ResumeJob, () => CanStopped());
+            CaancelJobCommand = new RelayCommand(CaancelJob, () => CanStopped());
+            RestartJobCommand = new RelayCommand(RestartJob, () => CanStopped());
+            ClearJobCommand = new RelayCommand(ClearJob, () => CanStopped());
+           
+
+            GoToJobCommand = new RelayCommand(GoToJob, () => IsEnableGoToJob());
+            JobStatusViewCommand = new RelayCommand(JobStatusView);
+            OverviewViewCommand = new RelayCommand(OverviewView);
+            ClearAllNotificationsCommand = new RelayCommand(ClearAllNotifications);
+            DisplayJobOutlineCommand = new RelayCommand(DisplayJobOutline);
+            HideJobOutlineCommand = new RelayCommand(HideJobOutline);
+
+            IsJobStatusViewEnable = true;
+            IsEnabledStopButton = false;
+            IsSpoolView = false;
+            IsWeghtView = false;
+
+            OverviewModel = new MachineOverviewModel();
+            MachineErrorStates = new MachineOverviewErrorStates();
+
+            IsExpandedNotifications = false;
+            SelectedStatisticTabIndex = 0;
+
+            JobController = CreateController(CreateSeries("Total", GraphHelper.GraphColor.Green));
+        }
+
+        public override void OnApplicationReady()
+        {
+            base.OnApplicationReady();
+            EventLogger.EventReceived += EventLogger_EventReceived;
+
+            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.HasLevelMeasure ).OrderBy(x => x.PackIndex).Select(x => new JerricanLevelModel()
+            {
+                Max = x.MidTankType.LiterCapacity,
+                IDSPack = x,
+            }).OrderBy(y => y.IDSPack.LiquidType.Type).ToList();
+            var LubLevel = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.Where(x => x.MidTankType.Type == MidTankTypes.LubricantMidTank).FirstOrDefault();
+           
+            MidTankLubLevel = new JerricanLevelModel();
+            if(LubLevel != null)
+            {
+                MidTankLubLevel.Max = LubLevel.MidTankType.LiterCapacity;
+                MidTankLubLevel.IDSPack = LubLevel;
+            };
+
+            MachineProvider.MachineOperator.MachineStatusChanged += MachineOperator_MachineStatusChanged;
+
+            DateTime dateTime = DateTime.Now;
+            DateTime onedayEarlier = dateTime.AddDays(-1);
+
+            GetCollectionDyePropByStartTime(onedayEarlier);
+
+            _productiondata_timer.Start();
+        }
+
+        #region Events
+
+        private void EventLogger_EventReceived(object sender, MachinesEvent ev)
+        {
+            InvokeUI(() =>
+            {
+                if (ev.Category == EventTypeCategories.Error || ev.Category == EventTypeCategories.Critical)
+                   {
+                        IsExpandedNotifications = true;
+                   }
+            });
+        }
+
+            private void MachineOperator_MachineStatusChanged(object sender, MachineStatus status)
+        {
+            UpdateMidTankLevels(status);
+            UpdateMachineStatusErrors(status);
+        }
+        private void UpdateMidTankLevels(MachineStatus status)
+        {
+            if (!IsJobStatusViewEnable)
+            {
+                foreach (var item in status.IDSPacksLevels)
+                {
+                    JerricanLevelModel model = null;
+                    if (item.Index == 8)//lub
+                    {
+                        model = MidTankLubLevel;
+
+                    }
+                    else { 
+                        model = MidTankLevels.SingleOrDefault(x => x.IDSPack.PackIndex == item.Index);
+                    }
+
+                    if (model != null)
+                    {
+                        model.Level = item.MidTankLevel;
+                        model.JerricanPresent = item.JerricanPresent;
+                        model.FillingTimeoutError = item.FillingTimeoutError;
+                        model.MidTankEmpty = item.MidTankEmpty;
+                        model.MidTankRefillPumpActive = item.MidTankRefillPumpActive;
+                        model.RemainingTimeoutError = TimeSpan.FromSeconds(item.TimerRemainingSeconds);
+                    }
+                    //TEST
+                    //if (model != null)
+                    //{
+                    //    var Li = model.IDSPack.LiquidType.Type;
+                    //    var Mid = model.IDSPack.MidTankType.Type;
+                    //    model.Level = 0.0;
+                    //model.JerricanPresent = false;
+                    //model.FillingTimeoutError = false;
+                    //model.MidTankEmpty = true;
+                    //model.MidTankRefillPumpActive = false;
+                    //model.RemainingTimeoutError = TimeSpan.FromSeconds(300);
+
+                    //if (item.Index == 1)
+                    //{
+                    //    model.Level = 1.0;
+                    //}
+                    //if (item.Index == 2)
+                    //{
+                    //    model.Level = 2.0;
+                    //}
+                    //if (item.Index == 3)
+                    //{
+                    //    model.Level = 3.0;
+                    //}
+                    //if (item.Index == 4)//TI
+                    //{
+                    //    model.Level = 7.0;
+                    //}
+                    //if (item.Index == 5)//LC
+                    //{
+                    //    model.Level = 7.0;
+                    //}
+                    //if (item.Index == 6)//LM
+                    //{
+                    //    model.Level = 3.5;
+                    //}
+                    //if (item.Index == 7)//LY
+                    //{
+                    //    model.Level = 2.5;
+                    //}
+                    //    if (item.Index == 8)//Lub
+                    //    {
+                    //        model.Level = 1.5;
+                    //    }
+                    //    if (item.Index ==9)
+                    //    {
+                    //        model.Level = 4.99;
+                    //    }
+                        
+                    //}
+                    //////////////////////////////
+                }
+            }
+        }
+
+        private void UpdateMachineStatusErrors(MachineStatus status)
+        {
+            var windersInError = status.WindersInError.ToList();// to test
+            MachineErrorStates.UpdateWinders(windersInError);
+            var dansersInError = status.DancersInError.ToList();
+            MachineErrorStates.UpdateDancers(dansersInError);
+            var btsrsInErrors = status.BtsrsInError.ToList();
+            MachineErrorStates.UpdateBTSRs(btsrsInErrors);
+        }
+
+        private void MachineOperator_InkFillingStatusChanged(object sender, InkFillingStatusChangedEventArgs e)
+        {
+            //foreach (var cartridge in e.Status.CartridgesStatuses.Where(x => x.Cartridge.Slot != CartridgeSlot.Ink))
+            //{
+            //    var wasteState = WasteStates.SingleOrDefault(x => x.Slot == cartridge.Cartridge.Slot);
+
+            //    if (wasteState != null)
+            //    {
+            //        wasteState.State = cartridge.State;
+            //    }
+            //}
+        }
+
+        private void _productiondata_timer_Tick(object sender, EventArgs e)
+        {
+           var  CurrentDateTime = DateTime.Now;
+        }
+        #endregion
+
+        #region printing
+
+        public override void OnApplicationStarted()
+        {
+            MachineProvider.MachineOperator.PrintingStarted += MachineOperator_PrintingStarted;
+            MachineProvider.MachineOperator.PrintingEnded += MachineOperator_PrintingEnded;
+
+            DefaultDiagnosticsFrameProvider.FrameReceived += DefaultDiagnosticsFrameProvider_FrameReceived;
+        }
+
+        private void DefaultDiagnosticsFrameProvider_FrameReceived(object sender, PMR.Diagnostics.StartDiagnosticsResponse e)
+        {
+            OverviewModel.Update(e, this.Job != null ? Job.Rml : null, null);
+        }
+
+        private void MachineOperator_PrintingStarted(object sender, PrintingEventArgs e)
+        {
+            _handler = e.JobHandler;
+            Job = e.Job;
+            e.JobHandler.StatusChanged += JobHandler_StatusChanged;
+            //e.JobHandler.SpoolChangeRequired += JobHandler_SpoolChangeRequired;
+            e.JobHandler.Stopped += JobHandler_Stopped;
+            e.JobHandler.CanCancelChanged += JobHandler_CanCancelChanged;
+            InvokeUI(() =>
+            {
+                IsEnabledStopButton = true;
+                StopCommand.RaiseCanExecuteChanged();
+                AbortCommand.RaiseCanExecuteChanged();
+            });
+
+
+        }
+
+        private void JobHandler_Stopped(object sender, EventArgs e)
+        {
+            if (_handler != null)
+            {
+                _handler.StatusChanged -= JobHandler_StatusChanged;
+                //_handler.SpoolChangeRequired -= JobHandler_SpoolChangeRequired;
+                _handler.Stopped -= JobHandler_Stopped;
+                _handler.StatusChanged -= JobHandler_StatusChanged;
+                _handler.CanCancelChanged -= JobHandler_CanCancelChanged;
+            }
+        }
+
+        private void MachineOperator_PrintingEnded(object sender, PrintingEventArgs e)
+        {
+            LogManager.Log("Printing ended");
+            InvokeUI(() =>
+            {
+                IsEnabledStopButton = false;
+                StopCommand.RaiseCanExecuteChanged();
+                AbortCommand.RaiseCanExecuteChanged();
+            });
+        }
+
+        private void JobHandler_StatusChanged(object sender, RunningJobStatus e)
+        {
+            RunningJobStatus = e;
+            IsDyeingProcess = (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null);
+            if (RunningJobStatus != null && RunningJobStatus.CurrentSegment != null)
+            {
+                if(_runningJobStatus.CurrentSegment.IsInterSegment)
+                {
+                    CurrentBrushStop = _runningJobStatus.CurrentSegment.BrushStops.FirstOrDefault();
+                    JobBrushStop = null;
+                }
+                else
+                {
+                    var realsegmIndex = 1;
+                    if (Job.EnableInterSegment && Job.InterSegmentLength > 0)
+                    {
+                        int segmentIndex = _runningJobStatus.CurrentSegment.SegmentIndex - (Job.EffectiveSegments.Count * RunningJobStatus.CurrentUnit);
+                        if(RunningJobStatus.CurrentUnit > 0)
+                        {
+                            segmentIndex -= RunningJobStatus.CurrentUnit;// inter segment between units
+                        }
+                        realsegmIndex = (int)(segmentIndex/2) + 1;
+                    }
+                    else
+                    {
+                        realsegmIndex = Math.Max(_runningJobStatus.CurrentSegment.SegmentIndex - (Job.Segments.Count * RunningJobStatus.CurrentUnit), 0);
+                    }
+                    
+                    var segment = Job.Segments.FirstOrDefault(x => x.SegmentIndex == realsegmIndex);
+                    if (segment != null)
+                    {
+                        if (_handler.JobTicket.Segments.Count > 0)
+                        {
+                            JobBrushStop = _handler.JobTicket.Segments[Job.OrderedSegments.IndexOf(segment)].BrushStops.First();
+                        }
+                    }
+                    CurrentBrushStop = RunningJobStatus.CurrentSegment.FirstBrushStop;
+                }
+            }
+        }
+
+        private void JobHandler_CanCancelChanged(object sender, EventArgs e)
+        {
+            InvokeUI(() =>
+           {
+               IsEnabledStopButton = _handler.CanCancel;
+               StopCommand.RaiseCanExecuteChanged();
+               AbortCommand.RaiseCanExecuteChanged();
+           });
+        }
+
+        #endregion
+
+        #region Methods
+
+        private bool IsEnableGoToJob()
+        {
+            return Job != null && _handler != null;
+        }
+
+        private void GoToJob()
+        {
+
+            NavigationManager.NavigateWithObject<JobsV2Module, JobEurekaView, JobNavigationObject>(new JobNavigationObject() { Job = _handler.Job });
+            NavigationManager.ClearHistoryExcept<JobsView>();
+
+        }
+        /// <summary>
+        /// Toggles the application technician mode.
+        /// </summary>
+        public void ToggleTechnicianMode()
+        {
+            if (!ApplicationManager.IsInTechnicianMode)
+            {
+                ApplicationManager.EnterTechnicianMode();
+            }
+            else
+            {
+                ApplicationManager.ExitTechnicianMode();
+            }
+        }
+
+        protected void JobStatusView()
+        {
+            IsJobStatusViewEnable = true;
+        }
+
+        protected void OverviewView()
+        {
+            IsJobStatusViewEnable = false;
+        }
+
+        private double GetVolumeLiquidType(LiquidTypes liquidType)
+        {
+            if (JobBrushStop != null && JobBrushStop.Dispensers != null && JobBrushStop.Dispensers.Count > 0)
+            {
+                var lt = JobBrushStop.Dispensers.FirstOrDefault(x => x.DispenserLiquidType == (DispenserLiquidType)liquidType);
+
+                if (lt != null)
+                {
+                    return Math.Round(lt.Volume, 2);
+                }
+            }
+            return 0;
+        }
+
+        private bool CanStopped()
+        {
+            return IsEnabledStopButton;
+        }
+
+        private void StopJob()
+        {
+            _handler?.Cancel();
+        }
+
+        private void AbortJob()
+        {
+            _handler?.Cancel();
+            //Job = null;
+        }
+
+        private void ResumeJob()
+        {
+            
+        }
+
+        private void CaancelJob()
+        {
+            Job = null;
+        }
+
+        private void RestartJob()
+        {
+           
+        }
+
+        private void ClearJob()
+        {
+            Job = null;
+        }
+
+        protected void ClearAllNotifications()
+        {
+            NotificationProvider.NotificationItems.Where(x => x.CanClose).ToList().ForEach(y => NotificationProvider.PopNotification(y));
+        }
+
+        protected void OnUpdateCurrentBrush()
+        {
+            RaisePropertyChanged(nameof(CyanOutput));
+            RaisePropertyChanged(nameof(LightCyanOutput));
+            RaisePropertyChanged(nameof(MagentaOutput));
+            RaisePropertyChanged(nameof(LightMagentaOutput));
+            RaisePropertyChanged(nameof(YellowOutput));
+            RaisePropertyChanged(nameof(LightYellowOutput));
+            RaisePropertyChanged(nameof(BlackOutput));
+        }
+
+        private void HideJobOutline()
+        {
+            IsDisplayJobOutline = false;
+        }
+
+        private void DisplayJobOutline()
+        {
+            if(_handler != null && _handler.JobTicket != null)
+            {
+                JobOutlineTicket = _handler.JobTicket;
+                IsDisplayJobOutline = true;
+            }
+        }
+        
+        #endregion
+
+        #region graph
+
+        public TimeToDyeValueCollection graphDyeingValuesCollection = new TimeToDyeValueCollection();
+
+        private WpfGraphController<DateTimeDataPoint, DoubleDataPoint> CreateController(params WpfGraphDataSeries[] seriesCollection)
+        {
+            var controller = new WpfGraphController<DateTimeDataPoint, DoubleDataPoint>();
+
+            foreach (var series in seriesCollection)
+            {
+                controller.DataSeriesCollection.Add(series);
+            }
+
+            controller.Range.AutoY = true;
+            controller.Range.MaximumY = 100;
+            controller.Range.MinimumY = 0;
+            controller.Range.MaximumX = new DateTime(0).AddMinutes(30);
+
+            controller.RefreshRate = TimeSpan.FromMilliseconds(300000);//5 min
+
+            return controller;
+        }
+
+        private WpfGraphDataSeries CreateSeries(String name, GraphHelper.GraphColor fill)
+        {
+            WpfGraphDataSeries series = new WpfGraphDataSeries()
+            {
+                Stroke = Colors.DodgerBlue,
+            };
+            series.Name = name;
+            series.Fill = GraphHelper.GetGraphBrush(fill);
+            series.StrokeThickness = 1;
+            series.Stroke = GraphHelper.GetGraphStrokeColor();
+            return series;
+        }
+
+        public async void GetCollectionDyePropByStartTime(DateTime starttime)
+        {
+            try
+            {
+                using (ObservablesContext db = ObservablesContext.CreateDefault())
+                {
+                    var jobRuns = await db.JobRuns.Where(x => x.StartDate >= starttime).Select(x => new { x.StartDate, x.EndDate, x.EndPosition }).OrderBy(y => y.StartDate).ToListAsync();
+                    double allvalues = 0;
+                    graphDyeingValuesCollection.StartTime = starttime;
+                    for ( int i = 0; i < jobRuns.Count; i++)
+                    {
+                        JobController.PushData(jobRuns[i].StartDate, allvalues);
+                        if (i > 0)
+                        {
+                            allvalues += jobRuns[i-1].EndPosition;
+                        }
+                        graphDyeingValuesCollection.items.Add( new TimeToDyeValueItem(){ startTime = jobRuns[i].StartDate, endTime = jobRuns[i].EndDate, totalValue = allvalues });
+                        JobController.PushData(jobRuns[i].EndDate, allvalues);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error loading machine counters.");
+
+            }
+        }
+        #endregion
+    }
+}