< Summary

Information
Class: ReportingServices.Shared.ViewModels.ProductionReport.DailyReport
Assembly: ReportingServices.Shared
File(s): C:\Users\wathen\source\repos\ReportingServices\ReportingServices.Shared\ViewModels\ProductionReport\DailyReport.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 107
Coverable lines: 107
Total lines: 145
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 12
Branch coverage: 0%
Method coverage

Method coverage is only available for sponsors.

Upgrade to PRO version

Metrics

File(s)

C:\Users\wathen\source\repos\ReportingServices\ReportingServices.Shared\ViewModels\ProductionReport\DailyReport.cs

#LineLine coverage
 1using ReportingServices.Shared.HelperClasses;
 2using ReportingServices.Shared.Models.ProductionReport;
 3using ReportingServices.Shared.ViewModels.ProductionReport;
 4
 5namespace ReportingServices.Shared.ViewModels.ProductionReport
 6{
 7    public class DailyReport
 8    {
 09        public DateTime StartDate { get; set; }
 010        public YieldStatistics CurrentWeek { get; set; }
 011        public YieldStatistics PreviousWeek { get; set; }
 012        public Dictionary<string, List<EquipmentStateByDay>> ToolAvailibilityByType { get; set; }
 013        public Dictionary<string, ToolStateByType> ToolStateByType { get; set; }
 014        public Dictionary<string, List<string>> ToolStatesByOwner { get; set; }
 015        public Dictionary<string, List<int>> DualLayerReactors { get; set; }
 016        public ManualReportEntries ManualReportEntries { get; set; }
 017        public List<UnloadTempsByDay> UnloadTempsByDay { get; set; }
 018        public List<SLLTool> SLLTools { get; set; }
 019        public int NumberOfToolsWaferSize6IN { get; set; }
 020        public int NumberOfToolsWaferSize8IN { get; set; }
 021        public int NumberOfToolsWaferSize6INScheduled { get; set; }
 022        public int NumberOfToolsWaferSize8INScheduled { get; set; }
 023        public QuarterlyTargets QuarterlyTargets { get; set; }
 24
 025        public DailyReport()
 026        {
 027            ToolAvailibilityByType = new();
 028            ToolStateByType = new();
 029            DualLayerReactors = new();
 030            UnloadTempsByDay = new();
 031            StartDate = DateTime.Parse(APIHelperFunctions.GetBeginningOfWeekAsAPIString());
 032            CurrentWeek = new(StartDate, true);
 033            PreviousWeek = new(StartDate.AddDays(-7), false);
 034        }
 35
 36        public void AddToolAvailibilityByType(string key, List<EquipmentStateByDay> states)
 037        {
 038            ToolAvailibilityByType.Add(key, states);
 039        }
 40
 41        public void AddToolStateByType(string key, List<ToolStateCurrent> states)
 042        {
 043            ToolStateByType state = new(states);
 44
 045            ToolStateByType.Add(key, state);
 046        }
 47
 48        public void SetReactorInfo(List<Reactor> reactors, List<int> unscheduledReactors)
 049        {
 050            SetToolsByPocketSize(reactors, unscheduledReactors);
 051            SetDisabledLoadlocks(reactors);
 052        }
 53
 54        public void SetRDSInfo(List<RDS> rdsList)
 055        {
 056            SetDualLayerReactors(rdsList);
 057            SetUnloadTempsLessThan700(rdsList);
 058        }
 59
 60        private void SetToolsByPocketSize(List<Reactor> reactors, List<int> unscheduledReactors)
 061        {
 062            NumberOfToolsWaferSize6IN = reactors.Where(react => react.PocketSize.Contains("150")).Count();
 063            NumberOfToolsWaferSize8IN = reactors.Where(react => react.PocketSize.Contains("200")).Count();
 64
 065            NumberOfToolsWaferSize6INScheduled =
 066                reactors.Where(react => !unscheduledReactors.Contains(react.ReactorNumber)
 067                && react.PocketSize.Contains("150")).Count();
 068            NumberOfToolsWaferSize8INScheduled =
 069                reactors.Where(react => !unscheduledReactors.Contains(react.ReactorNumber)
 070                && react.PocketSize.Contains("200")).Count();
 071        }
 72
 73        private void SetDisabledLoadlocks(List<Reactor> reactors)
 074        {
 075            List<Reactor> reactorsWithDisabledLoadlocks = reactors.Where(react => react.HasDisabledLoadlock).ToList();
 76
 077            int singleLoadlockASM = reactorsWithDisabledLoadlocks.Where(react => react.Type.Contains("ASM")).Count();
 078            int singleLoadlockHTR = reactorsWithDisabledLoadlocks.Where(react => react.Type.Contains("HTR")).Count();
 79
 080            foreach (SLLTool sll in SLLTools)
 081            {
 082                if (sll.Date.Date == DateTime.Now.Date)
 083                {
 084                    sll.ASM = singleLoadlockASM;
 085                    sll.HTR = singleLoadlockHTR;
 086                    return;
 87                }
 088            }
 89
 090            SLLTools.Add(new SLLTool
 091            {
 092                Date = DateTime.Now.Date,
 093                ASM = singleLoadlockASM,
 094                HTR = singleLoadlockHTR
 095            });
 096        }
 97
 98        private void SetDualLayerReactors(List<RDS> rdsList)
 099        {
 0100            DateTime compareDate = DateTime.Now.Date;
 0101            List<RDS> rdsWithDualLayerPSN = rdsList.Where(rds => rds.LayerType.Contains("2 Layer") && rds.DateOut == com
 102
 0103            DualLayerReactors.Add("ASM", rdsWithDualLayerPSN.
 0104                Where(rds => rds.ReactorType.Contains("ASM")).
 0105                OrderBy(rds => rds.Reactor).
 0106                Select(rds => rds.Reactor).
 0107                Distinct().ToList());
 0108            DualLayerReactors.Add("HTR", rdsWithDualLayerPSN.
 0109                Where(rds => rds.ReactorType.Contains("HTR")).
 0110                OrderBy(rds => rds.Reactor).
 0111                Select(rds => rds.Reactor).
 0112                Distinct().ToList());
 0113            DualLayerReactors.Add("EPP", rdsWithDualLayerPSN.
 0114                Where(rds => rds.ReactorType.Contains("EPP")).
 0115                OrderBy(rds => rds.Reactor).
 0116                Select(rds => rds.Reactor).
 0117                Distinct().ToList());
 0118        }
 119
 120        private void SetUnloadTempsLessThan700(List<RDS> rdsList)
 0121        {
 0122            var rdsWithTempsLessThan700 = rdsList.Where(rds => rds.UnloadTemp < 700).GroupBy(rds => rds.DateOut);
 123
 0124            foreach (var group in rdsWithTempsLessThan700)
 0125            {
 0126                UnloadTempsByDay.Add(new UnloadTempsByDay
 0127                {
 0128                    Date = group.Key,
 0129                    ASMUnloadsBelow700 = group.Where(rds => rds.ReactorType.Contains("ASM")).Select(rds => rds.Reactor).
 0130                    HTRUnloadsBelow700 = group.Where(rds => rds.ReactorType.Contains("HTR")).Select(rds => rds.Reactor).
 0131                });
 0132            }
 0133        }
 134
 135        public void ReverseLists()
 0136        {
 0137            CurrentWeek.ScrapByDay = APIHelperFunctions.ReverseList(CurrentWeek.ScrapByDay);
 0138            PreviousWeek.ScrapByDay = APIHelperFunctions.ReverseList(PreviousWeek.ScrapByDay);
 139
 0140            ToolAvailibilityByType["ASM"] = APIHelperFunctions.ReverseList(ToolAvailibilityByType["ASM"]);
 0141            ToolAvailibilityByType["EPP"] = APIHelperFunctions.ReverseList(ToolAvailibilityByType["EPP"]);
 0142            ToolAvailibilityByType["HTR"] = APIHelperFunctions.ReverseList(ToolAvailibilityByType["HTR"]);
 0143        }
 144    }
 145}