merge conflicts -take remote

1 files changed, 268 insertions, 15 deletions

diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/ViewModels/JobRunsViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/ViewModels/JobRunsViewVM.cs
index a51d18909..800346ff9 100644
--- a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/ViewModels/JobRunsViewVM.cs
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Statistics/ViewModels/JobRunsViewVM.cs
@@ -16,6 +16,11 @@ 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;
 
 namespace Tango.MachineStudio.Statistics.ViewModels
 {
@@ -77,7 +82,8 @@ namespace Tango.MachineStudio.Statistics.ViewModels
         public DateTime StartSelectedDate
         {
             get { return _startSelectedDate; }
-            set { _startSelectedDate = value; RaisePropertyChangedAuto(); }
+            set { _startSelectedDate = value;
+                RaisePropertyChangedAuto(); }
         }
 
         private DateTime _endSelectedDate;
@@ -173,7 +179,7 @@ namespace Tango.MachineStudio.Statistics.ViewModels
 
         private Job _selectedJob;
         /// <summary>
-        /// Gets or sets the job. Used as Sele
+        /// Gets or sets the job.
         /// </summary>
         public Job SelectedJob
         {
@@ -185,6 +191,11 @@ namespace Tango.MachineStudio.Statistics.ViewModels
             }
         }
 
+        /// <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; }
@@ -247,7 +258,7 @@ namespace Tango.MachineStudio.Statistics.ViewModels
                     {
                         using (ObservablesContext db = ObservablesContext.CreateDefault())
                         {
-                            return db.Jobs.Where(x => x.Name!= null && x.Name.ToLower().Contains(filter.ToLower())).ToList();
+                            return db.Jobs.Where(x => x.Name != null && x.Name.ToLower().Contains(filter.ToLower())).ToList();
                         }
                     }
                     else
@@ -262,6 +273,7 @@ namespace Tango.MachineStudio.Statistics.ViewModels
                 }
             });
 
+            StatisticsValueCollection = new StatisticsValueCollection();
         }
 
         /// <summary>
@@ -308,33 +320,118 @@ namespace Tango.MachineStudio.Statistics.ViewModels
 
                     using (var db = ObservablesContext.CreateDefault())
                     {
-                        DateTime startUtc = StartSelectedDate.ToUniversalTime();
+                        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 runs = await new JobRunsCollectionBuilder(db).Set(x => x.StartDate <= DbFunctions.TruncateTime(endUtc) && x.StartDate >= DbFunctions.TruncateTime(startUtc.Date))
-                        .WithMachines(SelectedMachines.SynchedSource.ToList())
-                        .WithJobSource(JobRunSelectedSources.SynchedSource)
-                        .WithJobStatus(JobRunSelectedStatuses.SynchedSource)
-                        .WithGradient(IsGradientSelection.SynchedSource)
-                        .WithRmls(SelectedThreads.SynchedSource.Select(x => x.Guid).ToList())
-                        .Query(y => y.Where(x => ( String.IsNullOrEmpty(jobName) || x.JobName.ToLower().StartsWith(jobName.ToLower()))
-                                                && (x.JobLength < LengthUpperValue && x.JobLength >= LengthLowerValue)))
-                        .BuildListAsync();
+                        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.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
+                            });
+                        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));
+                        }
+                        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,
+                                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
+                            }).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)
+                            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)
                 {
@@ -347,5 +444,161 @@ namespace Tango.MachineStudio.Statistics.ViewModels
             }
         }
 
+        #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.JobRun.JobLength);
+            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("Total 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}' 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
+
     }
 }