aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs
diff options
context:
space:
mode:
Diffstat (limited to 'Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs')
-rw-r--r--Software/Visual_Studio/PPC/Tango.PPC.UI/ViewModels/MachineStatusViewVM.cs855
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
+ }
+}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-19 21:14:56 +0000