path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/ViewModels/JobRunsViewVM.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core.Commands;
using Tango.MachineStudio.Common;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.Statistics.Models;
using Tango.SharedUI;
using Tango.SharedUI.Components;
using Tango.AutoComplete.Editors;
using System.Windows.Media;
using LiveCharts.Wpf;
using LiveCharts;
using Tango.BL.ValueObjects;
using System.Diagnostics;
using Microsoft.Win32;
using Tango.CSV;
using System.ComponentModel;

namespace Tango.MachineStudio.Statistics.ViewModels
{
    public enum HeadCleaningSelectionEnum
    {
        [Description("Exclude")]
        Exclude = 0,
        [Description("Include")]
        Include = 1,
        [Description("Only")]
        Only = 2
    };


    public class JobRunsViewVM : ViewModel
    {
        private INotificationProvider _notification;
        private List<OrganisationToSiteModel> _organizations;
        private List<Machine> _allMachines;
        private List<User> _allUsers;
        private List<RmlModel> _rmlsModels;



        #region Properties

        private ObservableCollection<JobRunModel> _jobRuns;
        /// <summary>
        /// Gets or sets the job runs. Contains filtered data of JobRunModel.
        /// </summary>
        public ObservableCollection<JobRunModel> JobRuns
        {
            get { return _jobRuns; }
            set
            {
                _jobRuns = value;
                RaisePropertyChangedAuto();
            }
        }

        private JobRunModel _selectedJobRun = null;
        /// <summary>
        /// Gets or sets the JobRunModel. Binding to selected item of grid items.
        /// </summary>
        public JobRunModel SelectedJobRun
        {
            get { return _selectedJobRun; }
            set
            {
                _selectedJobRun = value;
                RaisePropertyChangedAuto();
            }
        }

        private SelectedObjectCollection<OrganisationToSiteModel> _selectedOrganizations;
        /// <summary>
        /// Gets or sets the selected machines. Contains all available machines and selected machines. Binding to ComboBox Machines.
        /// </summary>
        public SelectedObjectCollection<OrganisationToSiteModel> SelectedOrganizations
        {
            get { return _selectedOrganizations; }
            set
            {
                _selectedOrganizations = value;
                RaisePropertyChangedAuto();
            }
        }

        private bool _IsEnabledSelectionSites;

        public bool IsEnabledSelectionSites
        {
            get { return _IsEnabledSelectionSites; }
            set
            {
                _IsEnabledSelectionSites = value;
                RaisePropertyChangedAuto();
            }
        }

        private bool _allSelectedSites;

        public bool AllSelectedSites
        {
            get { return _allSelectedSites; }
            set
            {
                _allSelectedSites = value;
                RaisePropertyChangedAuto();
            }
        }


        private SelectedObjectCollection<SiteModel> _selectedSites;
        /// <summary>
        /// Gets or sets the selected machines. Contains all available machines and selected machines. Binding to ComboBox Machines.
        /// </summary>
        public SelectedObjectCollection<SiteModel> SelectedSites
        {
            get { return _selectedSites; }
            set
            {
                _selectedSites = value;
                RaisePropertyChangedAuto();
            }
        }

        private bool _allSelectedMachines;

        public bool AllSelectedMachines
        {
            get { return _allSelectedMachines; }
            set
            {
                _allSelectedMachines = value;
                RaisePropertyChangedAuto();
            }
        }

        private SelectedObjectCollection<MachineModel> _selectedMachines;
        /// <summary>
        /// Gets or sets the selected machines. Contains all available machines and selected machines. Binding to ComboBox Machines.
        /// </summary>
        public SelectedObjectCollection<MachineModel> SelectedMachines
        {
            get { return _selectedMachines; }
            set
            {
                _selectedMachines = value;
                RaisePropertyChangedAuto();
            }
        }

        private DateTime _startSelectedDate;
        /// <summary>
        /// Gets or sets the start selected date.
        /// </summary>
        public DateTime StartSelectedDate
        {
            get { return _startSelectedDate; }
            set
            {
                _startSelectedDate = value;
                RaisePropertyChangedAuto();
            }
        }

        private DateTime _endSelectedDate;
        /// <summary>
        /// Gets or sets the end selected date.
        /// </summary>
        public DateTime EndSelectedDate
        {
            get { return _endSelectedDate; }
            set { _endSelectedDate = value; RaisePropertyChangedAuto(); }
        }

        protected Double _lengthLowerValue;
        /// <summary>
        /// Gets or sets the length lower value of Range Slider
        /// </summary>
        public Double LengthLowerValue
        {
            get { return _lengthLowerValue; }
            set
            {
                _lengthLowerValue = value;
                RaisePropertyChangedAuto();
            }
        }

        protected Double _lengthUpperValue;
        /// <summary>
        /// Gets or sets the length upper value of Range Slider.
        /// </summary>
        public Double LengthUpperValue
        {
            get { return _lengthUpperValue; }
            set
            {
                _lengthUpperValue = value;
                RaisePropertyChangedAuto();
            }
        }

        private SelectedObjectCollection<JobSource> _jobRunSelectedSources;
        /// <summary>
        /// Gets or sets the job run selected sources. Binding to ComboBox "Source".
        /// </summary>
        public SelectedObjectCollection<JobSource> JobRunSelectedSources
        {
            get { return _jobRunSelectedSources; }
            set { _jobRunSelectedSources = value; RaisePropertyChangedAuto(); }
        }

        private SelectedObjectCollection<JobRunStatus> _jobRunSelectedStatuses;
        /// <summary>
        /// Gets or sets the job run selected statuses. Binding to ComboBox "Status".
        /// </summary>
        public SelectedObjectCollection<JobRunStatus> JobRunSelectedStatuses
        {
            get { return _jobRunSelectedStatuses; }
            set { _jobRunSelectedStatuses = value; RaisePropertyChangedAuto(); }
        }

        public SelectedObjectCollection<bool> _isGradientSelection;
        /// <summary>
        /// Gets or sets the is gradient selection. Binding to ComboBox "IsGradient".
        /// </summary>
        public SelectedObjectCollection<bool> IsGradientSelection
        {
            get { return _isGradientSelection; }
            set
            {
                _isGradientSelection = value;
                RaisePropertyChangedAuto();
            }
        }

        private SelectedObjectCollection<RmlModel> _selectedThreads;
        /// <summary>
        /// Gets or sets the selected threads. Contains all available threads and selected threads. Binding to ComboBox "Thread".
        /// </summary>
        public SelectedObjectCollection<RmlModel> SelectedThreads
        {
            get { return _selectedThreads; }
            set
            {
                _selectedThreads = value;
                RaisePropertyChangedAuto();
            }
        }

        private HeadCleaningSelectionEnum _headCleaningSelected;

        public HeadCleaningSelectionEnum HeadCleaningSelected
        {
            get { return _headCleaningSelected; }
            set
            {
                _headCleaningSelected = value;
                RaisePropertyChangedAuto();
            }
        }


        /// <summary>
        /// Gets or sets the JobRuns providers.
        /// </summary>
        public ISuggestionProvider JobsProvider { get; set; }

        private Job _selectedJob;
        /// <summary>
        /// Gets or sets the job.
        /// </summary>
        public Job SelectedJob
        {
            get { return _selectedJob; }
            set
            {
                _selectedJob = value;
                RaisePropertyChangedAuto();
            }
        }

        /// <summary>
        /// Gets or sets the statistics value collection. Class - container included calculated statistic values.
        /// </summary>
        public StatisticsValueCollection StatisticsValueCollection { get; set; }

        #endregion

        public RelayCommand LoadJobRunsCommand { get; set; }

        public RelayCommand ExportToExcelCommand { get; set; }

        public JobRunsViewVM(INotificationProvider notificationProvider)
        {
            _notification = notificationProvider;
            JobRuns = new ObservableCollection<JobRunModel>();
            LoadJobRunsCommand = new RelayCommand(async () => await LoadJobRuns(), () => IsFree && SelectedMachines != null && SelectedMachines.Source.Count > 0);
            ExportToExcelCommand = new RelayCommand(ExportToExcel, () => IsFree);
            LengthUpperValue = 1000000.0;
            LengthLowerValue = 0.0;
            DateTime now = DateTime.Now;
            StartSelectedDate = now.AddMonths(-1);
            EndSelectedDate = now;

            JobRunSelectedSources = new SelectedObjectCollection<JobSource>(new ObservableCollection<JobSource>()
            {
                JobSource.Local,
                JobSource.Remote
            }, new ObservableCollection<JobSource>()
            {
                JobSource.Local,
                JobSource.Remote
            });
            JobRunSelectedSources.SelectionChanged -= (x, y) => RaisePropertyChanged(nameof(JobRunSelectedSources));
            JobRunSelectedSources.SelectionChanged += (x, y) => RaisePropertyChanged(nameof(JobRunSelectedSources));

            JobRunSelectedStatuses = new SelectedObjectCollection<JobRunStatus>(new ObservableCollection<JobRunStatus>()
            {
                JobRunStatus.Aborted,
                JobRunStatus.Completed,
                JobRunStatus.Failed,

            }, new ObservableCollection<JobRunStatus>()
            {
                JobRunStatus.Aborted,
                JobRunStatus.Completed,
                JobRunStatus.Failed,

            });
            JobRunSelectedStatuses.SelectionChanged -= (x, y) => RaisePropertyChanged(nameof(JobRunSelectedStatuses));
            JobRunSelectedStatuses.SelectionChanged += (x, y) => RaisePropertyChanged(nameof(JobRunSelectedStatuses));

            IsGradientSelection = new SelectedObjectCollection<bool>(new ObservableCollection<bool>
            {
                true,
                false
            }, new ObservableCollection<bool>
            {
                true,
                false
            });
            IsGradientSelection.SelectionChanged -= (x, y) => RaisePropertyChanged(nameof(IsGradientSelection));
            IsGradientSelection.SelectionChanged += (x, y) => RaisePropertyChanged(nameof(IsGradientSelection));

            HeadCleaningSelected = HeadCleaningSelectionEnum.Exclude;

            JobsProvider = new SuggestionProvider((filter) =>
            {
                try
                {
                    if (filter != null)
                    {
                        using (ObservablesContext db = ObservablesContext.CreateDefault())
                        {
                            return db.Jobs.Where(x => x.Name != null && x.Name.ToLower().Contains(filter.ToLower())).ToList();
                        }
                    }
                    else
                    {
                        return new List<Job>();
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error loading jobs.");
                    return null;
                }
            });

            StatisticsValueCollection = new StatisticsValueCollection();
        }

        /// <summary>
        /// Initializes this instance. Called form main view VM in OnApplicationReady
        /// </summary>
        public async void Init()
        {
            using (_notification.PushTaskItem("Loading job runs..."))
            {
                try
                {
                    IsFree = false;

                    using (var db = ObservablesContext.CreateDefault())
                    {

                        _organizations = await db.Organizations.Select(x => new OrganisationToSiteModel() { Name = x.Name, Guid = x.Guid }).ToListAsync();
                        foreach (var org in _organizations)
                        {
                            org.Sites = await db.Sites.Where(y => y.OrganizationGuid == org.Guid).Select(y => new SiteModel() { Guid = y.Guid, Name = y.Name, }).ToListAsync();
                            foreach (var site in org.Sites)
                            {
                                site.Machines = await db.Machines.Where(x => x.SiteGuid == site.Guid).Select(y => new MachineModel() { Guid = y.Guid, Name = y.Name, SerialNumber = y.SerialNumber }).ToListAsync();
                            }
                            org.Machines = await db.Machines.Where(y => y.OrganizationGuid == org.Guid).Select(y => new MachineModel() { Guid = y.Guid, Name = y.Name, SerialNumber = y.SerialNumber }).ToListAsync();
                        }
                        _allMachines = await db.Machines.ToListAsync();
                        _allUsers = await db.Users.Include(x => x.Contact).ToListAsync();
                        _rmlsModels = await db.Rmls.Select(x => new RmlModel() { Name = x.Name, Guid = x.Guid }).ToListAsync();
                    }
                    IsEnabledSelectionSites = false;
                    SelectedMachines = new SelectedObjectCollection<MachineModel>(new ObservableCollection<MachineModel>(), new ObservableCollection<MachineModel>());
                    SelectedThreads = new SelectedObjectCollection<RmlModel>(_rmlsModels.ToObservableCollection(), new ObservableCollection<RmlModel>());
                    SelectedSites = new SelectedObjectCollection<SiteModel>(new ObservableCollection<SiteModel>(), new ObservableCollection<SiteModel>());
                    SelectedOrganizations = new SelectedObjectCollection<OrganisationToSiteModel>(_organizations.ToObservableCollection(), _organizations.ToObservableCollection());
                    SelectedOrganizations.SelectionChanged -= OnSelectedOrganizationsChanged;
                    SelectedOrganizations.SelectionChanged += OnSelectedOrganizationsChanged;
                    SelectedSites.SelectionChanged -= OnSelectedSitesChanged;
                    SelectedSites.SelectionChanged += OnSelectedSitesChanged;
                    AllSelectedSites = true;
                    AllSelectedMachines = true;
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error loading job runs.");
                }
                finally
                {
                    IsFree = true;
                }
            }

        }

        private void OnSelectedSitesChanged(object sender, EventArgs e)
        {
            if (SelectedSites.SynchedSource.Count > 0)
            {
                SelectedMachines = new SelectedObjectCollection<MachineModel>(SelectedSites.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection(), SelectedSites.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection());
            }
            else
            {
                SelectedMachines = new SelectedObjectCollection<MachineModel>(SelectedOrganizations.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection(), SelectedOrganizations.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection());
            }
            AllSelectedMachines = false;
            AllSelectedMachines = true;
            InvalidateRelayCommands();
        }

        private void OnSelectedOrganizationsChanged(object sender, EventArgs e)
        {
            if (SelectedOrganizations.SynchedSource.Count != SelectedOrganizations.Source.Count)
            {
                IsEnabledSelectionSites = true;
                var selectedOrg = SelectedOrganizations.SynchedSource.ToList();
                SelectedSites = new SelectedObjectCollection<SiteModel>(selectedOrg.SelectMany(x => x.Sites).ToObservableCollection(), selectedOrg.SelectMany(x => x.Sites).ToObservableCollection());
                SelectedSites.SelectionChanged -= OnSelectedSitesChanged;
                SelectedSites.SelectionChanged += OnSelectedSitesChanged;
                SelectedMachines = new SelectedObjectCollection<MachineModel>(selectedOrg.SelectMany(x => x.Machines).ToObservableCollection(), selectedOrg.SelectMany(x => x.Machines).ToObservableCollection());
                AllSelectedSites = false;
                AllSelectedSites = true;
            }
            else
            {
                SelectedSites = new SelectedObjectCollection<SiteModel>(SelectedOrganizations.SynchedSource.SelectMany(x => x.Sites).ToObservableCollection(), SelectedOrganizations.SynchedSource.SelectMany(x => x.Sites).ToObservableCollection());
                AllSelectedSites = false;
                IsEnabledSelectionSites = false;
                SelectedMachines = new SelectedObjectCollection<MachineModel>(SelectedOrganizations.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection(), SelectedOrganizations.SynchedSource.SelectMany(x => x.Machines).ToObservableCollection());
            }
            AllSelectedMachines = false;
            AllSelectedMachines = true;
            InvalidateRelayCommands();
        }

        /// <summary>
        /// Loads the job runs by filters. 
        /// </summary>
        private async Task LoadJobRuns()
        {
            using (_notification.PushTaskItem("Loading job runs..."))
            {
                try
                {
                    IsFree = false;

                    using (var db = ObservablesContext.CreateDefault())
                    {
                        DateTime startUtc = new DateTime(StartSelectedDate.Year, StartSelectedDate.Month, StartSelectedDate.Day, 0, 0, 0).ToUniversalTime();
                        TimeSpan offsetTime = (EndSelectedDate.Date == DateTime.Now.Date) ? DateTime.Now.TimeOfDay : new TimeSpan(23, 59, 59);
                        DateTime endUtc = EndSelectedDate.ToUniversalTime() + offsetTime;

                        string jobName = SelectedJob == null ? "" : SelectedJob.Name;

                        var db_JobRuns = db.JobRuns.Where(x => (x.StartDate <= endUtc && x.StartDate >= startUtc))
                            .Select(x => new
                            {
                                x.ID,
                                x.MachineType,
                                x.ActualStartDate,
                                x.EndDate,
                                x.EndPosition,
                                x.GradientResolutionCm,
                                x.Guid,
                                x.HeatingStartDate,
                                x.IsGradient,
                                x.JobGuid,
                                x.JobLength,
                                x.JobName,
                                x.JobSource,
                                x.MachineGuid,
                                x.RmlGuid,
                                x.StartDate,
                                x.Status,
                                x.UploadingStartDate,
                                x.UserGuid,
                                x.CyanQuantity,
                                x.MagentaQuantity,
                                x.YellowQuantity,
                                x.BlackQuantity,
                                x.TransparentQuantity,
                                x.LubricantQuantity,
                                x.CleanerQuantity,
                                x.LightCyanQuantity,
                                x.LightMagentaQuantity,
                                x.LightYellowQuantity,
                                x.IsHeadCleaning,
                                x.ActualStartPosition,
                                x.ActualEndPosition,
                                x.JobLogicalLength,
                            });
                        var machineIDs = new HashSet<string>(SelectedMachines.SynchedSource.ToList().Select(p => p.Guid));
                        if (machineIDs.Count > 0)
                        {
                            db_JobRuns = db_JobRuns.Where(x => machineIDs.Contains(x.MachineGuid));
                        }
                        int[] jobRunSourceArr = JobRunSelectedSources.SynchedSource.Select(x => (int)x).ToArray();
                        if (jobRunSourceArr.Length > 0)
                        {
                            db_JobRuns = db_JobRuns.Where(x => jobRunSourceArr.Contains(x.JobSource));
                        }
                        int[] jobRunStatusArr = JobRunSelectedStatuses.SynchedSource.Select(x => (int)x).ToArray();
                        if (jobRunStatusArr.Length > 0)
                        {
                            db_JobRuns = db_JobRuns.Where(x => jobRunStatusArr.Contains(x.Status));
                        }
                        bool[] isGradientArr = IsGradientSelection.SynchedSource.Select(x => (bool)x).ToArray();
                        if (isGradientArr.Length > 0)
                        {
                            db_JobRuns = db_JobRuns.Where(x => isGradientArr.Contains(x.IsGradient));
                        }

                        if (HeadCleaningSelected != HeadCleaningSelectionEnum.Include)
                        {
                            bool isHeadCleaning = HeadCleaningSelected == HeadCleaningSelectionEnum.Only;
                            db_JobRuns = db_JobRuns.Where(x => isHeadCleaning == x.IsHeadCleaning);
                        }

                        List<String> rmlGuids = SelectedThreads.SynchedSource.Select(y => y.Guid).ToList();
                        if (rmlGuids != null && rmlGuids.Count > 0)
                        {
                            db_JobRuns = db_JobRuns.Where(x => rmlGuids.Contains(x.RmlGuid));
                        }
                        if (!String.IsNullOrEmpty(jobName))
                        {
                            db_JobRuns = db_JobRuns.Where(x => x.JobName.ToLower().StartsWith(jobName.ToLower()));
                        }

                        var runs_db = await db_JobRuns.ToListAsync(); //Execute actual query.


                        List<JobRun> runs = runs_db.Where(x => (x.JobLength < LengthUpperValue && x.JobLength >= LengthLowerValue))
                            .Select(x => new JobRun()
                            {
                                ID = x.ID,
                                MachineType = x.MachineType,
                                ActualStartDate = x.ActualStartDate,
                                EndDate = x.EndDate,
                                EndPosition = x.EndPosition,
                                GradientResolutionCm = x.GradientResolutionCm,
                                Guid = x.Guid,
                                HeatingStartDate = x.HeatingStartDate,
                                IsGradient = x.IsGradient,
                                JobGuid = x.JobGuid,
                                JobLength = x.JobLength,
                                JobName = x.JobName,
                                JobSource = x.JobSource,
                                MachineGuid = x.MachineGuid,
                                RmlGuid = x.RmlGuid,
                                StartDate = x.StartDate,
                                Status = x.Status,
                                UploadingStartDate = x.UploadingStartDate,
                                UserGuid = x.UserGuid,
                                CyanQuantity = x.CyanQuantity,
                                MagentaQuantity = x.MagentaQuantity,
                                YellowQuantity = x.YellowQuantity,
                                BlackQuantity = x.BlackQuantity,
                                TransparentQuantity = x.TransparentQuantity,
                                LubricantQuantity = x.LubricantQuantity,
                                CleanerQuantity = x.CleanerQuantity,
                                LightCyanQuantity = x.LightCyanQuantity,
                                LightMagentaQuantity = x.LightMagentaQuantity,
                                LightYellowQuantity = x.LightYellowQuantity,
                                IsHeadCleaning = x.IsHeadCleaning,
                                ActualStartPosition = x.ActualStartPosition,
                                ActualEndPosition = x.ActualEndPosition,
                                JobLogicalLength = x.JobLogicalLength,
                            }).ToList();

                        var modelList = runs.Select(x => new JobRunModel()
                        {
                            JobRun = x,
                            Machine = _allMachines.FirstOrDefault(y => y.Guid == x.MachineGuid),
                            User = _allUsers.SingleOrDefault(y => y.Guid == x.UserGuid),
                            Rml = _rmlsModels.SingleOrDefault(y => y.Guid == x.RmlGuid),
                        }).OrderByDescending(x => x.JobRun.StartDate).ToList();

                        modelList.ForEach(x => x.Init());
                        JobRuns = modelList.ToObservableCollection();
                        GenerateStatistics();
                    }

                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error loading job runs.");
                }
                finally
                {
                    IsFree = true;
                }
            }
        }

        private void ExportToExcel()
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Title = "Job Runs Statistic Report";
            dlg.Filter = "CSV Files|*.csv";
            dlg.FileName = $"Statistics_Job_runs";
            dlg.DefaultExt = ".csv";
            if (dlg.ShowDialog().Value)
            {
                try
                {
                    CsvFile<ExcelModel> csvFile = new CsvFile<ExcelModel>(new CsvDestination(dlg.FileName), new CsvDefinition()
                    {
                        Columns = new List<String>()
                         {
                             "ID",
                             "Machine",
                             "Source",
                             "Job Name",
                             "Job Kind",
                             "Thread",
                             "Length",
                             "Number Of Units",
                             "Start Time",
                             "Duration",
                             "Distance",
                             "Start Position",
                             "End Position",
                             "Status",
                             "Output Cyan",
                             "Output Magenta",
                             "Output Yellow",
                             "Output Black",
                             "Output Light Cyan",
                             "Output Light Magenta",
                             "Output Light Yellow",
                             "Output Blue",
                             "Output Light Blue",
                             "Output Orange",
                             "Output Light Orange",
                             "Output Rubine",
                             "Output Light Rubine",
                             "Output Navy",
                             "Output Violet",
                             "Output Transparent Ink",
                             "Output Lubricant",
                             "Failure Reason",
                         },
                    });
                    var selection = JobRuns;// item 5861 (all available jobs should be saved) .Where(z => z.JobRun.EndPosition > 0 && z.JobRun.EndDate != null && z.JobRun.ActualStartDate != null);
                    foreach (var jobRunModel in selection)
                    {
                        ExcelModel excel_model = new ExcelModel();
                        excel_model.ID = jobRunModel.JobRun.ID.ToString();
                        excel_model.Gen = ((MachineTypes)jobRunModel.JobRun.MachineType).ToDescription();
                        excel_model.Machine = jobRunModel.Machine != null ? jobRunModel.Machine.SerialNumber : "";
                        excel_model.Source = jobRunModel.JobRun.Source.ToString();
                        excel_model.JobName = jobRunModel.JobRun.JobName;
                        excel_model.JobKind = ((JobDesignations)jobRunModel.JobRun.JobDesignation).ToDescription();
                        excel_model.Thread = jobRunModel.Rml != null ? jobRunModel.Rml.Name : "";
                        excel_model.Length = jobRunModel.LogicalLengthMeters.ToString();
                        excel_model.NumberOfUnits = Math.Max(jobRunModel.JobRun.NumberOfUnits, 1).ToString();
                        excel_model.StartTime = jobRunModel.JobRun.StartDate.ToLocalTime().ToString();
                        //excel_model.UploadDuration = jobRunModel.UploadDuration != null ? ((TimeSpan)(jobRunModel.UploadDuration)).ToString(@"hh\:mm\:ss") : TimeSpan.FromSeconds(0).ToString(@"hh\:mm\:ss");
                        //excel_model.HeatingDuration = jobRunModel.HeatingDuration != null ? ((TimeSpan)(jobRunModel.HeatingDuration)).ToString(@"hh\:mm\:ss") : TimeSpan.FromSeconds(0).ToString(@"hh\:mm\:ss");
                        //excel_model.IsGradient = jobRunModel.JobRun.IsGradient ? "Yes" : "No";
                        //excel_model.GR = jobRunModel.JobRun.GradientResolutionCm.ToString();
                        excel_model.Duration = jobRunModel.Duration.ToStringUnlimitedHours();
                        excel_model.Distance = jobRunModel.Distance.ToString();
                        excel_model.StartPosition = jobRunModel.ActualStartPosition.ToString();
                        excel_model.EndPosition = jobRunModel.ActualEndPosition.ToString();
                        excel_model.Status = jobRunModel.JobRun.JobRunStatus.ToString();
                        //excel_model.EndTime = jobRunModel.JobRun.EndDate != null ? ((DateTime)jobRunModel.JobRun.EndDate).ToLocalTime().ToString("MM/dd/yy HH:mm"): "";
                        //excel_model.TotalDyeingTime = jobRunModel.JobRun.TotalDyeingTime != default(TimeSpan) ? ((TimeSpan)jobRunModel.JobRun.TotalDyeingTime).ToString(@"hh\:mm\:ss") : TimeSpan.FromSeconds(0).ToString(@"hh\:mm\:ss");

                        excel_model.OutputCyan = jobRunModel.JobRun.CyanQuantity < 0 ? "" : jobRunModel.JobRun.CyanQuantity.ToString();
                        excel_model.OutputMagenta = jobRunModel.JobRun.MagentaQuantity < 0 ? "" : jobRunModel.JobRun.MagentaQuantity.ToString();
                        excel_model.OutputYellow = jobRunModel.JobRun.YellowQuantity < 0 ? "" : jobRunModel.JobRun.YellowQuantity.ToString();
                        excel_model.OutputBlack = jobRunModel.JobRun.BlackQuantity < 0 ? "" : jobRunModel.JobRun.BlackQuantity.ToString();
                        excel_model.OutputLightCyan = jobRunModel.JobRun.LightCyanQuantity < 0 ? "" : jobRunModel.JobRun.LightCyanQuantity.ToString();
                        excel_model.OutputLightMagenta = jobRunModel.JobRun.LightMagentaQuantity < 0 ? "" : jobRunModel.JobRun.LightMagentaQuantity.ToString();
                        excel_model.OutputLightYellow = jobRunModel.JobRun.LightYellowQuantity < 0 ? "" : jobRunModel.JobRun.LightYellowQuantity.ToString();

                        excel_model.OutputBlue = jobRunModel.JobRun.BlueQuantity < 0 ? "" : jobRunModel.JobRun.BlueQuantity.ToString();
                        excel_model.OutputLightBlue = jobRunModel.JobRun.LightBlueQuantity < 0 ? "" : jobRunModel.JobRun.LightBlueQuantity.ToString();
                        excel_model.OutputOrange = jobRunModel.JobRun.OrangeQuantity < 0 ? "" : jobRunModel.JobRun.OrangeQuantity.ToString();
                        excel_model.OutputLightOrange = jobRunModel.JobRun.LightOrangeQuantity < 0 ? "" : jobRunModel.JobRun.LightOrangeQuantity.ToString();
                        excel_model.OutputRubine = jobRunModel.JobRun.RubineQuantity < 0 ? "" : jobRunModel.JobRun.RubineQuantity.ToString();
                        excel_model.OutputLightRubine = jobRunModel.JobRun.LightRubineQuantity < 0 ? "" : jobRunModel.JobRun.LightRubineQuantity.ToString();
                        excel_model.OutputNavy = jobRunModel.JobRun.NavyQuantity < 0 ? "" : jobRunModel.JobRun.NavyQuantity.ToString();
                        excel_model.OutputViolet = jobRunModel.JobRun.VioletQuantity < 0 ? "" : jobRunModel.JobRun.VioletQuantity.ToString();

                        excel_model.OutputTransparentInk = jobRunModel.JobRun.TransparentQuantity < 0 ? "" : jobRunModel.JobRun.TransparentQuantity.ToString();
                        excel_model.OutputLubricant = jobRunModel.JobRun.LubricantQuantity < 0 ? "" : jobRunModel.JobRun.LubricantQuantity.ToString();
                        //excel_model.Cleaner = jobRunModel.JobRun.CleanerQuantity < 0 ? "" : jobRunModel.JobRun.CleanerQuantity.ToString();
                        excel_model.FailureReason = jobRunModel.JobRun.FailedMessage;

                        csvFile.Append(excel_model);

                    }

                    csvFile.Dispose();
                    _notification.ShowInfo("Report generated successfully.");
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error generating Statistics Job Runs report.");
                    _notification.ShowError($"Error generating Statistics Job Runs report..\n{ex.Message}");
                }
            }
        }

        #region GenerateS_StatisticsValueCollection 

        /// <summary>
        /// Generates the statistics.
        /// </summary>
        protected void GenerateStatistics()
        {
            StatisticsValueCollection.Clean();
            if (JobRuns.Count() == 0)
                return;
            GenerateTotalRunsCount();
            GenerateTotalRunsLength();
            GenerateTotalThreadConsumption();
            GenerateRunsDuration();
            GenerateAverageUploadDuration();
            GenerateAverageHeatingDuration();

            GeneratePieCharts();
            CreateThreadConsumptionPerThread();
            GenerateAllLiquidQuantities();
        }

        protected void GenerateTotalRunsCount()
        {//Total Runs: 
            int val = JobRuns.Count();
            StatisticsValueCollection.AddStatisticsValue("Total Runs ", val, " ");
        }

        /// <summary>
        /// Generates the total length of the job runs.
        /// </summary>
        protected void GenerateTotalRunsLength()
        {
            double val = JobRuns.Where(z => z.JobRun.EndPosition > 0).Sum(x => x.Distance);
            StatisticsValueCollection.AddStatisticsValue("Total Runs Length", val, " m");
        }

        /// <summary>
        /// Generates the duration and average of the job runs.
        /// </summary>
        protected void GenerateRunsDuration()
        {
            var selection = JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.JobRun.EndDate != null && z.JobRun.ActualStartDate != null);
            double val = 0d;
            double average = 0d;
            if (selection != null && selection.Count<JobRunModel>() > 0)
            {
                val = selection.Sum(x => (x.JobRun.EndDate - x.JobRun.ActualStartDate).Value.TotalHours);
                average = selection.Average(x => (x.JobRun.EndDate - x.JobRun.ActualStartDate).Value.TotalMilliseconds);
            }
            StatisticsValueCollection.AddStatisticsValue("Total Dyeing Time", val, " hours");
            StatisticsValueCollection.AddStatisticsValue("Average Dyeing Time", Math.Max(TimeSpan.FromMilliseconds(average).TotalHours, 0), " hours");
        }

        /// <summary>
        /// Generates the average upload duration of the job runs.
        /// </summary>
        protected void GenerateAverageUploadDuration()
        {
            var average = (long)JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.UploadDuration != null).Average(x => x.UploadDuration.Value.TotalMilliseconds);
            StatisticsValueCollection.AddStatisticsValue("Average Upload Duration", Math.Max(TimeSpan.FromMilliseconds(average).TotalMinutes, 0), " minutes");
        }

        /// <summary>
        /// Generates the average duration heating of the job runs.
        /// </summary>
        protected void GenerateAverageHeatingDuration()
        {
            var average = JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.HeatingDuration != null && z.HeatingDuration.Value.Ticks > 0).Average(x => x.HeatingDuration.Value.TotalMilliseconds);
            StatisticsValueCollection.AddStatisticsValue("Average Heating Duration", Math.Max(TimeSpan.FromMilliseconds(average).TotalMinutes, 0), " minutes");
        }

        /// <summary>
        /// Generates the total thread consumption by EndPosition.
        /// </summary>
        protected void GenerateTotalThreadConsumption()
        {
            double val = JobRuns.Where(z => z.JobRun.EndPosition > 0).Sum(x => x.JobRun.EndPosition);
            StatisticsValueCollection.AddStatisticsValue("Total Dyeing Length", val, " m");
        }

        /// <summary>
        /// Generates the pie charts in percentage: JobSource, JobRunStatus, Gradient.
        /// </summary>
        protected void GeneratePieCharts()
        {
            int PPCCount = JobRuns.Count(x => x.JobRun.Source == JobSource.Local);
            int MSCount = JobRuns.Count(x => x.JobRun.Source == JobSource.Remote);
            StatisticsValueCollection.GeneratePieJobSource(PPCCount, MSCount);

            int failedCount = JobRuns.Count(x => x.JobRun.JobRunStatus == JobRunStatus.Failed);
            int abortedCount = JobRuns.Count(x => x.JobRun.JobRunStatus == JobRunStatus.Aborted);
            int completedCount = JobRuns.Count(x => x.JobRun.JobRunStatus == JobRunStatus.Completed);
            StatisticsValueCollection.GeneratePieJobRunStatus(failedCount, abortedCount, completedCount);

            int gradientCount = JobRuns.Count(x => x.JobRun.IsGradient == true);
            int solidCount = JobRuns.Count(x => x.JobRun.IsGradient == false);
            StatisticsValueCollection.GeneratePieGradientSolid(gradientCount, solidCount);

        }

        /// <summary>
        /// Creates the thread consumption per thread.
        /// </summary>
        protected void CreateThreadConsumptionPerThread()
        {
            var temp = JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.Rml != null).GroupBy(x => x.Rml.Name);
            List<StatisticsValue> result = JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.Rml != null && !String.IsNullOrEmpty(z.Rml.Name)).GroupBy(x => x.Rml.Name).Select(y => new StatisticsValue { Name = y.Key, Value = y.Sum(x => x.JobRun.EndPosition), Unit = "m" }).ToList();
            StatisticsValueCollection.CreateThreadConsumptionPerThread(result);
        }

        /// <summary>
        /// Generates all liquid quantities.
        /// </summary>
        protected void GenerateAllLiquidQuantities()
        {
            var runs = JobRuns.Where(z => z.JobRun.EndPosition > 0 && z.JobRun.LiquidQuantitiesFast.Count > 0).ToList();

            Dictionary<LiquidTypes, ulong> total_quantities = new Dictionary<LiquidTypes, ulong>();

            foreach (LiquidTypes ltype in (LiquidTypes[])Enum.GetValues(typeof(LiquidTypes)))
            {
                total_quantities[ltype] = 0;
            }

            foreach (var run in runs)
            {
                foreach (var lq in run.JobRun.LiquidQuantitiesFast)
                {
                    if (lq.Quantity < 0)
                    {
                        Debug.WriteLine($"Warning: JobRun '{run.JobRun.ID}' of machine '{run.Machine?.SerialNumber}' with user '{run.User?.Email}' started on '{run.JobRun.StartDate.ToLocalTime()}' ended on '{run.JobRun.EndDate.ToLocalTime()}' contains an invalid value '{lq.Quantity}' for {lq.LiquidType} quantity.");
                    }

                    total_quantities[lq.LiquidType] += Convert.ToUInt64(Math.Max(lq.Quantity, 0));
                }
            }

            List<TotalLiquidQuantityModel> allLiquidQuantities = total_quantities.Select(x => new TotalLiquidQuantityModel()
            {
                LiquidType = x.Key,
                Quantity = x.Value
            }).ToList();


            //foreach (LiquidTypes ltype in (LiquidTypes[])Enum.GetValues(typeof(LiquidTypes)))
            //{
            //    var liquidQuantityByTypeList = db_liquidQuantities.Select(x => x.FirstOrDefault(y => y.LiquidType == ltype)).Where(x => x != null);
            //    var count = liquidQuantityByTypeList != null ? liquidQuantityByTypeList.Sum(x => x.Quantity) : 0;
            //    JobRunLiquidQuantity lq = new JobRunLiquidQuantity() { LiquidType = ltype, Quantity = count };
            //    allLiquidQuantities.Add(lq);
            //}
            StatisticsValueCollection.GenerateStatisticsLiquidQuantity(allLiquidQuantities);
        }
        #endregion

    }
}