Updated daily report to show correct information when two work weeks split quarters.

Also current changes to project with Blazor implementation is implemented here as well.

ReportingServices.Shared.Blazor/Component1.razor

@@ -0,0 +1,3 @@
+<div class="my-component">
+    This component is defined in the <strong>ReportingServices.Shared.Blazor</strong> library.
+</div>

ReportingServices.Shared.Blazor/Component1.razor.css

@@ -0,0 +1,6 @@
+.my-component {
+    border: 2px dashed red;
+    padding: 1em;
+    margin: 1em 0;
+    background-image: url('background.png');
+}

ReportingServices.Shared.Blazor/ExampleJsInterop.cs

@@ -0,0 +1,35 @@
+using Microsoft.JSInterop;
+
+namespace ReportingServices.Shared.Blazor;
+// This class provides an example of how JavaScript functionality can be wrapped
+// in a .NET class for easy consumption. The associated JavaScript module is
+// loaded on demand when first needed.
+//
+// This class can be registered as scoped DI service and then injected into Blazor
+// components for use.
+
+public class ExampleJsInterop : IAsyncDisposable
+{
+    private readonly Lazy<Task<IJSObjectReference>> moduleTask;
+
+    public ExampleJsInterop(IJSRuntime jsRuntime)
+    {
+        moduleTask = new(() => jsRuntime.InvokeAsync<IJSObjectReference>(
+            "import", "./_content/ReportingServices.Shared.Blazor/exampleJsInterop.js").AsTask());
+    }
+
+    public async ValueTask<string> Prompt(string message)
+    {
+        var module = await moduleTask.Value;
+        return await module.InvokeAsync<string>("showPrompt", message);
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (moduleTask.IsValueCreated)
+        {
+            var module = await moduleTask.Value;
+            await module.DisposeAsync();
+        }
+    }
+}

ReportingServices.Shared.Blazor/HelperClasses/APIHelperFunctions.cs

@@ -0,0 +1,65 @@
+using System.Text.RegularExpressions;
+
+namespace ReportingServices.Shared.Blazor.HelperClasses;
+
+public static class APIHelperFunctions
+{
+    public static string GetBeginningOfWeekAsAPIString()
+    {
+        DateTime date = DateTime.Now;
+
+        int dayOfWeek = (int)date.DayOfWeek;
+
+        date = dayOfWeek switch
+        {
+            0 => date.AddDays(-6),
+            1 => date,
+            _ => date.AddDays(1 - dayOfWeek)
+        };
+
+        return GetDateTimeAsAPIString(date.ToString(), false);
+    }
+
+    public static string GetDateWithOffsetAsAPIString(string dateString, float offset)
+    {
+        DateTime date = DateTime.Parse(dateString);
+
+        date = date.AddHours(offset);
+
+        return GetDateTimeAsAPIString(date.ToString(), true);
+    }
+
+    public static string GetDateTimeAsAPIString(string dateString, bool fullDateTime)
+    {
+        DateTime date = DateTime.Parse(dateString);
+
+        if (fullDateTime)
+            dateString = date.ToString("yyyy-M-d HH:mm:ss");
+        else
+            dateString = date.Year + "-" + date.Month + "-" + date.Day + " 0:0:0";
+
+        return dateString;
+    }
+
+    public static List<T> ReverseList<T>(List<T> inputList)
+    {
+        List<T> temp = new();
+
+        for (int i = inputList.Count - 1; i >= 0; i--)
+        {
+            temp.Add(inputList[i]);
+        }
+
+        return temp;
+    }
+
+    public static string SplitOnCamelCase(string input)
+    {
+        Regex r = new(@"
+                (?<=[A-Z])(?=[A-Z][a-z]) |
+                 (?<=[^A-Z])(?=[A-Z]) |
+                 (?<=[A-Za-z])(?=[^A-Za-z])", RegexOptions.IgnorePatternWhitespace);
+
+        return r.Replace(input, " ");
+    }
+}

ReportingServices.Shared.Blazor/HelperClasses/ApiCaller.cs

@@ -0,0 +1,19 @@
+using System.Text.Json;
+
+namespace ReportingServices.Shared.Blazor.HelperClasses;
+
+public static class ApiCaller
+{
+    public static async Task<T> GetApi<T>(string url)
+    {
+        T deserializedJson = default;
+
+        using (HttpClient client = new())
+        {
+            string apiResponse = await client.GetStringAsync(url);
+            deserializedJson = JsonSerializer.Deserialize<T>(apiResponse);
+        }
+
+        return deserializedJson;
+    }
+}

ReportingServices.Shared.Blazor/HelperClasses/JsonFileHandler.cs

@@ -0,0 +1,18 @@
+using System.Text.Json;
+
+namespace ReportingServices.Shared.Blazor.HelperClasses;
+
+public static class JsonFileHandler
+{
+    public static T LoadJSONFile<T>(string file)
+    {
+        string json = File.ReadAllText(file);
+        return JsonSerializer.Deserialize<T>(json);
+    }
+
+    public static void SaveJSONFile<T>(T obj, string file)
+    {
+        string json = JsonSerializer.Serialize(obj);
+        File.WriteAllText(file, json);
+    }
+}

ReportingServices.Shared.Blazor/Models/PlanningReport/ReactorPSNWORuns.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.PlanningReport;
+
+public class ReactorPSNWORuns
+{
+    [JsonPropertyName("REACTOR")]
+    public string REACTOR { get; set; }
+    [JsonPropertyName("PSN")]
+    public string PSN { get; set; }
+    [JsonPropertyName("WO")]
+    public string WO { get; set; }
+    [JsonPropertyName("WO_COUNT")]
+    public int WO_COUNT { get; set; }
+}

ReportingServices.Shared.Blazor/Models/PlanningReport/WeeklyPartChanges.cs

@@ -0,0 +1,9 @@
+namespace ReportingServices.Shared.Blazor.Models.PlanningReport;
+
+public class WeeklyPartChanges
+{
+    public int TotalPartChanges { get; set; }
+    public string StartDate { get; set; }
+    public string EndDate { get; set; }
+    public List<ReactorPSNWORuns> ReactorPSNWORuns { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/HoldLot.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+public class HoldLot
+{
+    [JsonPropertyName("WO_NO")]
+    public string WO_NO { get; set; }
+    [JsonPropertyName("HOLD_DATE")]
+    public DateTime HOLD_DATE { get; set; }
+    [JsonPropertyName("HOLD_USER")]
+    public string HOLD_USER { get; set; }
+    [JsonPropertyName("HOLD_REASON")]
+    public string HOLD_REASON { get; set; }
+    [JsonPropertyName("RDS_NO")]
+    public string RDS_NO { get; set; }
+    [JsonPropertyName("REACTOR")]
+    public string REACTOR { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ManualReportEntries.cs

@@ -0,0 +1,18 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ManualReportEntries
+{
+    public int OperatorHeadcountDays { get; set; }
+    public int OperatorHeadcountNights { get; set; }
+    public int OperatorCallOutsDays { get; set; }
+    public int OperatorCallOutsNights { get; set; }
+    public int EngineeringHeadcountDays { get; set; }
+    public int EngineeringHeadcountNights { get; set; }
+    public int EngineeringCallOutsDays { get; set; }
+    public int EngineeringCallOutsNights { get; set; }
+    public int MaintenanceHeadcountDays { get; set; }
+    public int MaintenanceHeadcountNights { get; set; }
+    public int MaintenanceCallOutsDays { get; set; }
+    public int MaintenanceCallOutsNights { get; set; }
+    public string BottleChanges { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/NCR.cs

@@ -0,0 +1,18 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+public class NCR
+{
+    [JsonPropertyName("ENTRY_DATE")]
+    public DateTime ENTRY_DATE { get; set; }
+    [JsonPropertyName("SHIFT")]
+    public string SHIFT { get; set; }
+    [JsonPropertyName("REACTOR")]
+    public string REACTOR { get; set; }
+    [JsonPropertyName("RDS_NO")]
+    public string RDS_NO { get; set; }
+    [JsonPropertyName("TOT_REJ")]
+    public int TOT_REJ { get; set; }
+    [JsonPropertyName("LOSS_COMMENTS")]
+    public string LOSS_COMMENTS { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/OutsAndScrapTotal.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class OutsAndScrapTotal
+{
+    [JsonPropertyName("Outs")]
+    public int Outs { get; set; }
+    [JsonPropertyName("CustomerScrap")]
+    public int CustomerScrap { get; set; }
+    [JsonPropertyName("ManufacturingScrap")]
+    public int ManufacturingScrap { get; set; }
+    [JsonPropertyName("ProductionScrap")]
+    public int ProductionScrap { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/QuarterlyTargets.cs

@@ -0,0 +1,17 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class QuarterlyTargets
+{
+    [JsonPropertyName("Reactor_Outs")]
+    public int Reactor_Outs { get; set; }
+    [JsonPropertyName("Yield_Outs")]
+    public int Yield_Outs { get; set; }
+    [JsonPropertyName("IFX_Scrap")]
+    public int IFX_Scrap { get; set; }
+    [JsonPropertyName("Yield")]
+    public float Yield { get; set; }
+    [JsonPropertyName("PlanWorkingDays")]
+    public int PlanWorkingDays { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/RDS.cs

@@ -0,0 +1,17 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class RDS
+{
+    [JsonPropertyName("Reactor")]
+    public int Reactor { get; set; }
+    [JsonPropertyName("ReactorType")]
+    public string ReactorType { get; set; }
+    [JsonPropertyName("DateOut")]
+    public DateTime DateOut { get; set; }
+    [JsonPropertyName("UnloadTemp")]
+    public int UnloadTemp { get; set; }
+    [JsonPropertyName("LayerType")]
+    public string LayerType { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/Reactor.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class Reactor
+{
+    [JsonPropertyName("ReactorNumber")]
+    public int ReactorNumber { get; set; }
+    [JsonPropertyName("Type")]
+    public string Type { get; set; }
+    [JsonPropertyName("PocketSize")]
+    public string PocketSize { get; set; }
+    [JsonPropertyName("HasDisabledLoadLock")]
+    public bool HasDisabledLoadlock { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ReactorEvent.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ReactorEvent
+{
+    [JsonPropertyName("REACT_NO")]
+    public string REACT_NO { get; set; }
+    [JsonPropertyName("EVENT_DTM")]
+    public string EVENT_DTM { get; set; }
+    [JsonPropertyName("REASON")]
+    public string REASON { get; set; }
+    [JsonPropertyName("REACT_MODE")]
+    public string REACT_MODE { get; set; }
+    [JsonPropertyName("COMMENT")]
+    public string COMMENT { get; set; }
+    [JsonPropertyName("CAT_PROB_DESC")]
+    public string CAT_PROB_DESC { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ReactorOutsByDay.cs

@@ -0,0 +1,7 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ReactorOutsByDay
+{
+    public string StartDate { get; set; }
+    public int TotalWafers { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ReactorOutsByRDS.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ReactorOutsByRDS
+{
+    [JsonPropertyName("RDS_NO")]
+    public string RDS_NO { get; set; }
+    [JsonPropertyName("Units")]
+    public string Units { get; set; }
+    [JsonPropertyName("EndProcessTime")]
+    public string EndProcessTime { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/SLLTool.cs

@@ -0,0 +1,8 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class SLLTool
+{
+    public DateTime Date { get; set; }
+    public int ASM { get; set; }
+    public int HTR { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ScheduledEvent.cs

@@ -0,0 +1,20 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+public class ScheduledEvent
+{
+    [JsonPropertyName("REACT_NO")]
+    public string REACT_NO { get; set; }
+    [JsonPropertyName("WO_NO")]
+    public string WO_NO { get; set; }
+    [JsonPropertyName("PROD_SPEC_ID")]
+    public string PROD_SPEC_ID { get; set; }
+    [JsonPropertyName("START_DTM")]
+    public DateTime START_DTM { get; set; }
+    [JsonPropertyName("STOP_DTM")]
+    public DateTime STOP_DTM { get; set; }
+    [JsonPropertyName("BLOCKOUT")]
+    public string BLOCKOUT { get; set; }
+    [JsonPropertyName("BLOCKOUT_TYPE")]
+    public string BLOCKOUT_TYPE { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ScrapByDay.cs

@@ -0,0 +1,17 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ScrapByDay
+{
+    [JsonPropertyName("StartDate")]
+    public string StartDate { get; set; }
+    [JsonPropertyName("TW_PROD")]
+    public int TW_PROD { get; set; }
+    [JsonPropertyName("TOT_REJ_CUST")]
+    public int TOT_REJ_CUST { get; set; }
+    [JsonPropertyName("TOT_REJ_MANU")]
+    public int TOT_REJ_MANU { get; set; }
+    [JsonPropertyName("TOT_REJ_WFRS")]
+    public int TOT_REJ_WFRS { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ToolEvent.cs

@@ -0,0 +1,15 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ToolEvent
+{
+    [JsonPropertyName("TOOL_ID")]
+    public string TOOL_ID { get; set; }
+    [JsonPropertyName("START_DTM")]
+    public string START_DTM { get; set; }
+    [JsonPropertyName("TOOL_MODE")]
+    public string TOOL_MODE { get; set; }
+    [JsonPropertyName("TOOL_MODE_DESC")]
+    public string TOOL_MODE_DESC { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/ToolUptimeData.cs

@@ -0,0 +1,7 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class ToolUptimeData
+{
+    public string Date { get; set; }
+    public double UptimePercentage { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/UnloadTempsByDay.cs

@@ -0,0 +1,8 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class UnloadTempsByDay
+{
+    public DateTime Date { get; set; }
+    public int ASMUnloadsBelow700 { get; set; }
+    public int HTRUnloadsBelow700 { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/YieldInformation.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+public class YieldInformation
+{
+    [JsonPropertyName("Outs")]
+    public List<ReactorOutsByRDS> Outs { get; set; }
+    [JsonPropertyName("Scrap")]
+    public List<ScrapByDay> Scrap { get; set; }
+}

ReportingServices.Shared.Blazor/Models/ProductionReport/YieldStatistics.cs

@@ -0,0 +1,10 @@
+namespace ReportingServices.Shared.Blazor.Models.ProductionReport;
+public class YieldStatistics
+{
+    public int Outs { get; set; }
+    public int CustomerScrap { get; set; }
+    public int ManufacturingScrap { get; set; }
+    public int ProductionScrap { get; set; }
+    public int YieldedOuts { get; set; }
+    public double YieldPercent { get; set; }
+}

ReportingServices.Shared.Blazor/ReportingServices.Shared.Blazor.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk.Razor">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+
+  <ItemGroup>
+    <SupportedPlatform Include="browser" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="6.0.11" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="5.0.1" />
+  </ItemGroup>
+
+</Project>

ReportingServices.Shared.Blazor/Repositories/Implementations/ScrapeDatabaseRepository.cs

@@ -0,0 +1,807 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Logging;
+using ReportingServices.Shared.Blazor.Models.PlanningReport;
+using ReportingServices.Shared.Blazor.Models.ProductionReport;
+using System.Data;
+
+namespace ReportingServices.Shared.Blazor.Repositories;
+
+public class ScrapeDatabaseRepository : IScrapeDatabaseRepository
+{
+    private SqlConnection _connection;
+    private readonly string _connectionString;
+
+    public ScrapeDatabaseRepository(string connectionString) => _connectionString = connectionString;
+
+    public void OpenConnection()
+    {
+        _connection ??= new SqlConnection(_connectionString);
+
+        if (_connection.State != ConnectionState.Open)
+            _connection.Open();
+    }
+
+    public void CloseConnection()
+    {
+        if (_connection.State != ConnectionState.Closed)
+            _connection.Close();
+    }
+
+    public int GetNumberOfPartChanges(string startDate, string endDate)
+    {
+        int result = 0;
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT SUM(PCHANGE) " +
+                       "  FROM (SELECT REACTOR, " +
+                       "               COUNT(PROD_SPEC_ID) - 1 AS PCHANGE " +
+                       "          FROM (SELECT REACTOR, " +
+                       "                       PROD_SPEC_ID, " +
+                       "                       COUNT(WO) AS PSN_COUNT " +
+                       "                  FROM RDS " +
+                       "                 WHERE DATE_OUT BETWEEN @startDate AND @endDate " +
+                       "                GROUP BY REACTOR, PROD_SPEC_ID) AS t " +
+                       "        GROUP BY REACTOR) AS l";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            _ = reader.Read();
+
+            result = int.Parse(reader[0].ToString());
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return result;
+    }
+
+    public List<ScrapByDay> GetScrapByDay(List<ReactorOutsByRDS> outs)
+    {
+        List<ScrapByDay> scrap = new();
+        string rdsNumbers = "";
+
+        foreach (ReactorOutsByRDS rout in outs)
+            rdsNumbers = rdsNumbers + "'" + rout.RDS_NO + "', ";
+
+        rdsNumbers = rdsNumbers[..^2];
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT " +
+                        "  DATE_OUT," +
+                        "  SUM(CUST_TOT_REJ) AS TOT_REJ_CUST," +
+                        "  SUM(LSL_TOT_REJ) AS TOT_REJ_MANU," +
+                        "  SUM(CASE WHEN REACTOR_TYPE <> 'EPP' THEN TW_PROD ELSE 0 END) AS TW_PROD " +
+                        "FROM RDS " +
+                        "WHERE SEQ IN (" + rdsNumbers + ") " +
+                        "GROUP BY DATE_OUT " +
+                        "ORDER BY 1 DESC";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read() && reader[0].ToString() != "1/1/1900 12:00:00 AM")
+            {
+                int twProd = string.IsNullOrEmpty(reader[3].ToString()) ? 0 : int.Parse(reader[3].ToString());
+                int custScrap = string.IsNullOrEmpty(reader[1].ToString()) ? 0 : int.Parse(reader[1].ToString());
+                int manuScrap = string.IsNullOrEmpty(reader[2].ToString()) ? 0 : int.Parse(reader[2].ToString());
+                int totScrap = custScrap + manuScrap;
+
+                scrap.Add(new ScrapByDay
+                {
+                    StartDate = reader[0].ToString(),
+                    TW_PROD = twProd,
+                    TOT_REJ_CUST = custScrap,
+                    TOT_REJ_MANU = manuScrap,
+                    TOT_REJ_WFRS = totScrap
+                });
+            }
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return scrap;
+    }
+
+    public List<ReactorPSNWORuns> GetReactorPSNWORuns(string startDate, string endDate)
+    {
+        List<ReactorPSNWORuns> weeklyPartChanges = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT REACTOR, PROD_SPEC_ID, WO, COUNT(WO) FROM RDS " +
+                       " WHERE DATE_OUT BETWEEN @startDate AND @endDate " +
+                       "GROUP BY REACTOR, PROD_SPEC_ID, WO " +
+                       "ORDER BY 1";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                weeklyPartChanges.Add(new ReactorPSNWORuns
+                {
+                    REACTOR = reader[0].ToString(),
+                    PSN = reader[1].ToString(),
+                    WO = reader[2].ToString(),
+                    WO_COUNT = int.Parse(reader[3].ToString())
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return weeklyPartChanges;
+    }
+
+    public List<ReactorPSNWORuns> GetReactorPartChanges(string startDate, string endDate)
+    {
+        List<ReactorPSNWORuns> weeklyPartChanges = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT REACTOR, PROD_SPEC_ID, WO, COUNT(WO) AS WO_COUNT FROM RDS " +
+                       " WHERE DATE_OUT BETWEEN @startDate AND @endDate " +
+                       "  AND REACTOR IN (SELECT REACTOR " +
+                       "  FROM (SELECT REACTOR, " +
+                       "               COUNT(PROD_SPEC_ID) - 1 AS PCHANGE " +
+                       "          FROM (SELECT REACTOR, " +
+                       "                       PROD_SPEC_ID, " +
+                       "                       COUNT(WO) AS PSN_COUNT " +
+                       "                  FROM RDS " +
+                       "                 WHERE DATE_OUT BETWEEN @startDate AND @endDate " +
+                       "                GROUP BY REACTOR, PROD_SPEC_ID) AS t " +
+                       "        GROUP BY REACTOR) AS l " +
+                       " WHERE l.PCHANGE > 0) " +
+                       "GROUP BY REACTOR, PROD_SPEC_ID, WO " +
+                       "ORDER BY 1";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                weeklyPartChanges.Add(new ReactorPSNWORuns
+                {
+                    REACTOR = "R" + reader[0].ToString(),
+                    PSN = reader[1].ToString(),
+                    WO = reader[2].ToString(),
+                    WO_COUNT = int.Parse(reader[3].ToString())
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return weeklyPartChanges;
+    }
+
+    public QuarterlyTargets GetQuarterlyTargets()
+    {
+        Dictionary<string, float> targets = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT THRU_TARGET, THRU_QTY, THRU_PCNT FROM FISCAL_QTR_TARGETS " +
+                       " WHERE THRU_GROUP = 'TOT' " +
+                       "   AND FISCAL_YR = " +
+                       "    (SELECT FISCAL_YR FROM FISCAL_QTR " +
+                       "      WHERE START_DT < SYSDATETIME() " +
+                       "        AND END_DT > SYSDATETIME()) " +
+                       "   AND FISCAL_QTR = " +
+                       "    (SELECT FISCAL_QTR FROM FISCAL_QTR " +
+                       "      WHERE START_DT < SYSDATETIME() " +
+                       "        AND END_DT > SYSDATETIME()) " +
+                       "UNION " +
+                       "SELECT 'PlanWorkingDays' As THRU_TARGET," +
+                       "       PLAN_WORKING_DAYS AS THRU_QTY," +
+                       "       NULL AS THRU_PCNT" +
+                       "  FROM FISCAL_QTR " +
+                       " WHERE SYSDATETIME() BETWEEN START_DT AND END_DT";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+            {
+                if (reader[0].ToString().ToUpper() == "YIELD")
+                    targets.Add(reader[0].ToString(), float.Parse(reader[2].ToString()));
+                else if (!string.IsNullOrEmpty(reader[1].ToString()))
+                    targets.Add(reader[0].ToString(), int.Parse(reader[1].ToString()));
+            }
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        QuarterlyTargets quarterlyTargets = new()
+        {
+            Reactor_Outs = (int)targets["Reactor_Outs"],
+            Yield_Outs = (int)targets["Yield_Outs"],
+            IFX_Scrap = (int)targets["IFX_Scrap"],
+            Yield = targets["Yield"],
+            PlanWorkingDays = (int)targets["PlanWorkingDays"]
+        };
+
+        return quarterlyTargets;
+    }
+
+    public List<Reactor> GetReactors()
+    {
+        List<Reactor> reactors = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT " +
+                       "   REACT_NO, REACT_TYPE, SUSC_POCKET_SIZE, CASE WHEN ACTIVE_LL_DISABLED <> '' THEN 'TRUE' ELSE 'FALSE' END AS \"LL_DISABLED\" " +
+                       "  FROM REACTOR " +
+                       " WHERE REACT_ASSIGNMENT IS NOT NULL " +
+                       "   AND REACT_ASSIGNMENT <> 'Out of Service' " +
+                       "   AND REACT_ASSIGNMENT <> '' " +
+                       "   AND CURR_MODE_KEY = ''";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                reactors.Add(new Reactor
+                {
+                    ReactorNumber = int.Parse(reader[0].ToString()),
+                    Type = reader[1].ToString(),
+                    PocketSize = reader[2].ToString(),
+                    HasDisabledLoadlock = bool.Parse(reader[3].ToString())
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return reactors;
+    }
+
+    public List<RDS> GetRDSForLastDay(string date)
+    {
+        List<RDS> rdsList = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT rds.REACTOR, rds.REACTOR_TYPE, rds.DATE_OUT, " +
+                       "CASE WHEN lay.UL_TEMP IS NULL THEN '1000' ELSE lay.UL_TEMP END, psn.LAYER_TYPE FROM RDS " +
+                       "INNER JOIN RDS_LAYER lay ON lay.RDS_NO = SEQ " +
+                       "INNER JOIN PROD_SPEC psn ON rds.PROD_SPEC_ID = psn.SEQ " +
+                       "WHERE DATE_OUT >= @date";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@date", date);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                rdsList.Add(new RDS
+                {
+                    Reactor = int.Parse(reader[0].ToString()),
+                    ReactorType = reader[1].ToString(),
+                    DateOut = DateTime.Parse(reader[2].ToString()),
+                    UnloadTemp = int.Parse(reader[3].ToString()),
+                    LayerType = reader[4].ToString()
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return rdsList;
+    }
+
+    public List<ReactorOutsByRDS> GetRDSRunBetweenDates(string startDate, string endDate)
+    {
+        List<ReactorOutsByRDS> outs = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT SEQ, WFRS_OUT, DATE_OUT " +
+                       "  FROM RDS " +
+                       " WHERE DATE_OUT >= @startDate " +
+                       "   AND DATE_OUT < @endDate " +
+                       "ORDER BY DATE_OUT ASC";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                outs.Add(new ReactorOutsByRDS
+                {
+                    RDS_NO = reader[0].ToString(),
+                    Units = reader[1].ToString(),
+                    EndProcessTime = reader[2].ToString()
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return outs;
+    }
+
+    public List<ReactorEvent> GetReactorEvents(string startDate, string endDate, string reactorNumber)
+    {
+        List<ReactorEvent> events = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT " +
+                       "   REACT_NO, " +
+                       "   START_DTM, " +
+                       "   START_NOTE AS REASON, " +
+                       "   MODE, " +
+                       "   (SELECT TOP 1 NOTES " +
+                       "      FROM REACTOR_LOG_NOTES rnote " +
+                       "     WHERE rmode.START_RL_ID = rnote.SEQ " +
+                       "    ORDER BY MV_NO DESC) AS COMMENT, " +
+                       "   (SELECT TOP 1 CONCAT(PROB_CAT_ID, ' - ', PROB_CAT_DESC) " +
+                       "      FROM REACT_MODE_SERV_INFO srv " +
+                       "	 WHERE rmode.REACT_NO = srv.REACT_NO " +
+                       "	   AND rmode.START_DTM = srv.START_DTM " +
+                       "    ORDER BY MV_NO DESC) AS CATEGORY " +
+                       "  FROM REACT_MODE rmode " +
+                       " WHERE START_DTM > @startDate " +
+                       "   AND START_DTM < @endDate" +
+                       "   AND REACT_NO = @reactorNumber " +
+                       "UNION ALL " +
+                       "SELECT * " +
+                       "  FROM  " +
+                       "     (SELECT TOP 1 " +
+                       "             REACT_NO, " +
+                       "             START_DTM, START_NOTE AS REASON, " +
+                       "             MODE, " +
+                       "             (SELECT TOP 1 NOTES " +
+                       "                FROM REACTOR_LOG_NOTES rnote " +
+                       "               WHERE rmode.START_RL_ID = rnote.SEQ " +
+                       "              ORDER BY MV_NO DESC) AS COMMENT, " +
+                       "		     (SELECT TOP 1 CONCAT(PROB_CAT_ID, ' - ', PROB_CAT_DESC) " +
+                       "		      FROM REACT_MODE_SERV_INFO srv " +
+                       "		     WHERE rmode.REACT_NO = srv.REACT_NO " +
+                       "		       AND rmode.START_DTM = srv.START_DTM " +
+                       "		    ORDER BY MV_NO DESC) AS CATEGORY " +
+                       "        FROM REACT_MODE rmode " +
+                       "       WHERE START_DTM < @startDate" +
+                       "         AND REACT_NO = @reactorNumber " +
+                       "       ORDER BY START_DTM DESC) AS tbl1 " +
+                       "ORDER BY START_DTM ASC";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+        _ = cmd.Parameters.AddWithValue("@reactorNumber", reactorNumber);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                events.Add(new ReactorEvent
+                {
+                    REACT_NO = reader[0].ToString(),
+                    EVENT_DTM = reader[1].ToString(),
+                    REASON = reader[2].ToString(),
+                    REACT_MODE = reader[3].ToString(),
+                    COMMENT = reader[4].ToString(),
+                    CAT_PROB_DESC = reader[5].ToString()
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return events;
+    }
+
+    public ToolEvent GetLatestToolEvent(string toolID)
+    {
+        ToolEvent evnt = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT TOP 1 " +
+                       "    TOOL_ID, " +
+                       "    START_DTM, " +
+                       "    TOOL_MODE, " +
+                       "    TOOL_MODE_DESC " +
+                       "  FROM TOOL_LOG " +
+                       " WHERE TOOL_ID = @toolID " +
+                       "ORDER BY START_DTM DESC";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@toolID", toolID);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                evnt = new ToolEvent
+                {
+                    TOOL_ID = reader[0].ToString(),
+                    START_DTM = reader[1].ToString(),
+                    TOOL_MODE = reader[2].ToString(),
+                    TOOL_MODE_DESC = reader[3].ToString()
+                };
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return evnt;
+    }
+
+    public int GetLastUpTransaction(string reactorNumber)
+    {
+        int lastTransaction = 0;
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT TOP 1 DATEDIFF(MINUTE,STOP_DTM,SYSDATETIME()) " +
+                       "  FROM REACT_MODE " +
+                       " WHERE REACT_NO = @reactorNumber " +
+                       "   AND (MODE = 'UP' OR MODE = 'UP_WITH_INCREASED_SAMPLING') " +
+                       "ORDER BY START_DTM DESC";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@reactorNumber", reactorNumber);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                lastTransaction = int.Parse(reader[0].ToString());
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return lastTransaction;
+    }
+
+    public OutsAndScrapTotal GetOutsAndScrapTotals(string startDate, string endDate)
+    {
+        OutsAndScrapTotal totals = new()
+        {
+            Outs = 0,
+            CustomerScrap = 0,
+            ManufacturingScrap = 0,
+            ProductionScrap = 0
+        };
+
+        if (startDate == endDate)
+            return totals;
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT SUM(WFRS_OUT) AS OUTS, " +
+                       "       SUM(CUST_TOT_REJ) AS CUST, " +
+                       "       SUM(LSL_TOT_REJ) AS MANU, " +
+                       "       SUM(CASE WHEN REACTOR_TYPE <> 'EPP' THEN TW_PROD ELSE 0 END) AS PROD " +
+                       "  FROM RDS " +
+                       " WHERE DATE_OUT >= @startDate " +
+                       "   AND DATE_OUT < @endDate";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                totals = new()
+                {
+                    Outs = int.Parse(reader[0].ToString()),
+                    CustomerScrap = int.Parse(reader[1].ToString()),
+                    ManufacturingScrap = int.Parse(reader[2].ToString()),
+                    ProductionScrap = int.Parse(reader[3].ToString()),
+                };
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return totals;
+    }
+
+    public DateTime GetQuarterStartDate()
+    {
+        DateTime date = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT START_DT " +
+                       "  FROM FISCAL_QTR " +
+                       " WHERE START_DT < SYSDATETIME() " +
+                       "   AND END_DT > SYSDATETIME()";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                date = DateTime.Parse(reader[0].ToString());
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return date;
+    }
+
+    public List<HoldLot> GetCurrentHoldLots()
+    {
+        List<HoldLot> lots = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT WO_NO, " +
+                       "       HOLD_START_DTM, " +
+                       "       HOLD_START_USER, " +
+                       "       HOLD_START_REASON, " +
+                       "       SEQ, " +
+                       "       REACTOR " +
+                       "  FROM WO_MAT_HOLD_HISTORY, RDS " +
+                       " WHERE HOLD_STOP_DTM = '1/1/1900' " +
+                       "   AND HOLD_START_DTM > '1/1/2022' " +
+                       "   AND HOLD_ENTITY_ID = SEQ " +
+                       "   AND HOLD_ENTITY = 'RDS' " +
+                       "ORDER BY HOLD_START_DTM ASC";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                lots.Add(new HoldLot
+                {
+                    WO_NO = reader[0].ToString(),
+                    HOLD_DATE = DateTime.Parse(reader[1].ToString()),
+                    HOLD_USER = reader[2].ToString(),
+                    HOLD_REASON = reader[3].ToString(),
+                    RDS_NO = reader[4].ToString(),
+                    REACTOR = reader[5].ToString(),
+
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return lots;
+    }
+
+    public List<string> GetCurrentHotWORunning()
+    {
+        List<string> lots = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT DISTINCT(REACT_NO) " +
+                       "  FROM SCHED_DET_NG schd " +
+                       "INNER JOIN WO_LOG wlog ON WO = WO_NO " +
+                       " WHERE STOP_DTM > SYSDATETIME() " +
+                       "   AND START_DTM < SYSDATETIME() " +
+                       "   AND HOT_FLAG = 1 " +
+                       "ORDER BY REACT_NO";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                lots.Add("R" + reader[0].ToString());
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return lots;
+    }
+
+    public List<ScheduledEvent> GetScheduledEvents(string startDate, string endDate)
+    {
+        List<ScheduledEvent> events = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT REACT_NO, " +
+                       "       schd.WO_NO, " +
+                       "       PROC_SPEC_ID, " +
+                       "       START_DTM, " +
+                       "       STOP_DTM, " +
+                       "       BLOCKOUT, " +
+                       "       BLOCK_OUT_TYPE " +
+                       "  FROM SCHED_DET_NG schd " +
+                       "FULL OUTER JOIN WO_STEP step " +
+                       "  ON step.WO_NO = schd.WO_NO " +
+                       " WHERE ((STOP_DTM > @startDate AND STOP_DTM < @endDate) " +
+                       "    OR (START_DTM > @startDate AND START_DTM < @endDate)) " +
+                       "ORDER BY REACT_NO, START_DTM ASC";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                events.Add(new ScheduledEvent
+                {
+                    REACT_NO = reader[0].ToString(),
+                    WO_NO = reader[1].ToString(),
+                    PROD_SPEC_ID = reader[2].ToString(),
+                    START_DTM = DateTime.Parse(reader[3].ToString()),
+                    STOP_DTM = DateTime.Parse(reader[4].ToString()),
+                    BLOCKOUT = reader[5].ToString(),
+                    BLOCKOUT_TYPE = reader[6].ToString()
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return events;
+    }
+
+    public List<ReactorPSNWORuns> GetProjectedPartChanges(string startDate, string endDate)
+    {
+        List<ReactorPSNWORuns> events = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT REACT_NO, " +
+                       "       PROC_SPEC_ID, " +
+                       "	   schd.WO_NO " +
+                       "  FROM SCHED_DET_NG schd " +
+                       "FULL OUTER JOIN WO_STEP step " +
+                       "  ON step.WO_NO = schd.WO_NO " +
+                       " WHERE ((STOP_DTM > @startDate AND STOP_DTM < @endDate) " +
+                       "    OR (START_DTM > @startDate AND START_DTM < @endDate)) " +
+                       "   AND BLOCKOUT IS NULL " +
+                       "   AND REACT_NO IN (SELECT REACT_NO " +
+                       "                      FROM (SELECT REACT_NO, " +
+                       "					               COUNT(PROC_SPEC_ID) - 1 AS PCHANGE " +
+                       "						      FROM (SELECT REACT_NO, " +
+                       "							               PROC_SPEC_ID, " +
+                       "										   COUNT(schd.WO_NO) AS WO_COUNT " +
+                       "									  FROM SCHED_DET_NG schd " +
+                       "									FULL OUTER JOIN WO_STEP step " +
+                       "									  ON step.WO_NO = schd.WO_NO " +
+                       "									 WHERE ((STOP_DTM > @startDate AND STOP_DTM < @endDate) " +
+                       "									    OR (START_DTM > @startDate AND START_DTM < @endDate)) " +
+                       "									   AND BLOCKOUT IS NULL GROUP BY REACT_NO, PROC_SPEC_ID) AS l " +
+                       "							GROUP BY REACT_NO) AS p " +
+                       "					 WHERE PCHANGE > 0) " +
+                       "ORDER BY REACT_NO";
+
+        cmd.CommandText = query;
+        _ = cmd.Parameters.AddWithValue("@startDate", startDate);
+        _ = cmd.Parameters.AddWithValue("@endDate", endDate);
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                events.Add(new ReactorPSNWORuns
+                {
+                    REACTOR = "R" + reader[0].ToString(),
+                    PSN = reader[1].ToString(),
+                    WO = reader[2].ToString(),
+                    WO_COUNT = 0
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return events;
+    }
+
+    public List<NCR> GetCurrentNCRs()
+    {
+        List<NCR> ncrs = new();
+
+        OpenConnection();
+
+        SqlCommand cmd = _connection.CreateCommand();
+
+        string query = "SELECT l.ENTRY_DATE, " +
+                       "       l.SHIFT, " +
+                       "       l.REACTOR, " +
+                       "       r.RDS_ID AS RDS_NO, " +
+                       "       l.TOT_REJ, " +
+                       "       n.LOSS_COMMENTS " +
+                       "  FROM [NCR List] l, NCR n, NCR_RDS r " +
+                       " WHERE l.STATUS = 'Open' " +
+                       "   AND n.SEQ = l.SEQ " +
+                       "   AND n.SEQ = r.SEQ";
+
+        cmd.CommandText = query;
+
+        using (SqlDataReader reader = cmd.ExecuteReader())
+        {
+            while (reader.Read())
+                ncrs.Add(new NCR
+                {
+                    ENTRY_DATE = DateTime.Parse(reader[0].ToString()),
+                    SHIFT = reader[1].ToString(),
+                    REACTOR = reader[2].ToString(),
+                    RDS_NO = reader[3].ToString(),
+                    TOT_REJ = string.IsNullOrEmpty(reader[4].ToString()) ? 0 : int.Parse(reader[4].ToString()),
+                    LOSS_COMMENTS = reader[5].ToString()
+                });
+        }
+
+        cmd.Dispose();
+
+        CloseConnection();
+
+        return ncrs;
+    }
+}

ReportingServices.Shared.Blazor/Repositories/Interfaces/IScrapeDatabaseRepository.cs

@@ -0,0 +1,28 @@
+using ReportingServices.Shared.Blazor.Models.PlanningReport;
+using ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+namespace ReportingServices.Shared.Blazor.Repositories;
+
+public interface IScrapeDatabaseRepository
+{
+    public void OpenConnection();
+    public void CloseConnection();
+    public List<ScrapByDay> GetScrapByDay(List<ReactorOutsByRDS> outs);
+    public List<ReactorPSNWORuns> GetReactorPSNWORuns(string startDate, string endDate);
+    public int GetNumberOfPartChanges(string startDate, string endDate);
+    public QuarterlyTargets GetQuarterlyTargets();
+    public List<Reactor> GetReactors();
+    public List<RDS> GetRDSForLastDay(string date);
+    public List<ReactorOutsByRDS> GetRDSRunBetweenDates(string startDate, string endDate);
+    public List<ReactorEvent> GetReactorEvents(string startDate, string endDate, string reactorNumber);
+    public ToolEvent GetLatestToolEvent(string toolID);
+    public int GetLastUpTransaction(string reactorNumber);
+    public OutsAndScrapTotal GetOutsAndScrapTotals(string startDate, string endDate);
+    public DateTime GetQuarterStartDate();
+    public List<HoldLot> GetCurrentHoldLots();
+    public List<string> GetCurrentHotWORunning();
+    public List<ScheduledEvent> GetScheduledEvents(string startDate, string endDate);
+    public List<ReactorPSNWORuns> GetReactorPartChanges(string startDate, string endDate);
+    public List<ReactorPSNWORuns> GetProjectedPartChanges(string startDate, string endDate);
+    public List<NCR> GetCurrentNCRs();
+}

ReportingServices.Shared.Blazor/ViewModels/ProductionReport/ToolEventView.cs

@@ -0,0 +1,180 @@
+using ReportingServices.Shared.Blazor.Models.ProductionReport;
+
+namespace ReportingServices.Shared.Blazor.ViewModels.ProductionReport;
+
+public class ToolEventView
+{
+    public string Reactor { get; set; }
+    public string Type { get; set; }
+    public string StartDate { get; set; }
+    public string EndDate { get; set; }
+    public double Downtime { get; set; }
+    public bool IsInProduction { get; set; }
+    public List<ReactorEvent> Events { get; set; }
+    public ReactorEvent MostRecentEvent { get; set; }
+    public List<ToolUptimeData> Uptime { get; set; }
+
+    public ToolEventView(List<ReactorEvent> events, string startDate, string endDate, string reactor, string type)
+    {
+        Events = events;
+        StartDate = startDate;
+        EndDate = endDate;
+        Reactor = reactor;
+        Type = type;
+        MostRecentEvent = events[^1];
+        IsInProduction = EventIsProduction(MostRecentEvent.REACT_MODE);
+        Uptime = DetermineToolUptimeData();
+    }
+
+    public void SetDowntime(int timeSinceLastUpTransaction)
+    {
+        if (IsInProduction)
+            Downtime = 0;
+        else
+            Downtime = (double)timeSinceLastUpTransaction / 60;
+    }
+
+    public List<ToolUptimeData> DetermineToolUptimeData()
+    {
+        List<ToolUptimeData> data = new();
+
+        bool currentModeIsUp;
+        double uptime = 0;
+        DateTime compareDate = DateTime.Parse(StartDate).Date;
+        DateTime previousTransaction = DateTime.Parse(StartDate).Date;
+
+        currentModeIsUp = EventIsProduction(Events[0].REACT_MODE);
+
+        if (Events.Count == 1)
+            data = LoadUptimeData(currentModeIsUp);
+
+        for (int i = 1; i < Events.Count; i++)
+        {
+            DateTime currentTransaction = DateTime.Parse(Events[i].EVENT_DTM);
+
+            if (currentTransaction.Date == compareDate)
+            {
+                if (currentModeIsUp)
+                    uptime += (DateTime.Parse(Events[i].EVENT_DTM) - previousTransaction).TotalMinutes;
+
+                currentModeIsUp = EventIsProduction(Events[i].REACT_MODE);
+                previousTransaction = DateTime.Parse(Events[i].EVENT_DTM);
+            }
+
+            if ((currentTransaction.Date - compareDate).TotalHours == 24)
+            {
+                if (currentModeIsUp)
+                    uptime += (currentTransaction.Date - previousTransaction).TotalMinutes;
+
+                data.Add(new ToolUptimeData
+                {
+                    Date = compareDate.ToString(),
+                    UptimePercentage = uptime / 1440
+                });
+
+                if (currentModeIsUp)
+                    uptime = (currentTransaction - currentTransaction.Date).TotalMinutes;
+                else
+                    uptime = 0;
+
+                compareDate = compareDate.AddDays(1);
+                currentModeIsUp = EventIsProduction(Events[i].REACT_MODE);
+                previousTransaction = DateTime.Parse(Events[i].EVENT_DTM);
+            }
+
+            if ((currentTransaction.Date - compareDate).TotalHours > 24)
+            {
+                while (currentTransaction.Date != compareDate)
+                {
+                    if (currentModeIsUp)
+                        uptime += (compareDate.AddDays(1) - previousTransaction).TotalMinutes;
+
+                    data.Add(new ToolUptimeData
+                    {
+                        Date = compareDate.ToString(),
+                        UptimePercentage = uptime / 1440
+                    });
+
+                    uptime = 0;
+
+                    compareDate = compareDate.AddDays(1);
+                    previousTransaction = compareDate;
+                }
+            }
+
+            if (i == Events.Count - 1)
+            {
+                if (DateTime.Parse(EndDate).Date != compareDate)
+                {
+                    while (DateTime.Parse(EndDate).Date != compareDate)
+                    {
+                        if (currentModeIsUp)
+                            uptime += (compareDate.AddDays(1) - previousTransaction).TotalMinutes;
+
+                        data.Add(new ToolUptimeData
+                        {
+                            Date = compareDate.ToString(),
+                            UptimePercentage = uptime / 1440
+                        });
+
+                        uptime = 0;
+
+                        compareDate = compareDate.AddDays(1);
+                        previousTransaction = compareDate;
+                    }
+                }
+
+                if (currentModeIsUp)
+                    uptime += (DateTime.Parse(EndDate) - previousTransaction).TotalMinutes;
+
+                data.Add(new ToolUptimeData
+                {
+                    Date = DateTime.Now.Date.ToString(),
+                    UptimePercentage = uptime / (DateTime.Parse(EndDate) - DateTime.Parse(EndDate).Date).TotalMinutes
+                });
+
+            }
+        }
+
+        return data;
+    }
+
+    private List<ToolUptimeData> LoadUptimeData(bool currentModeIsUp)
+    {
+        List<ToolUptimeData> data = new();
+
+        double days = (DateTime.Parse(EndDate) - DateTime.Parse(StartDate)).TotalDays;
+
+        for (int i = 0; i < days; i++)
+        {
+            data.Add(new ToolUptimeData
+            {
+                Date = DateTime.Parse(StartDate).Date.AddDays(i).ToString(),
+                UptimePercentage = currentModeIsUp ? 1 : 0
+            });
+        }
+
+        return data;
+    }
+
+    private bool EventIsProduction(string evnt)
+    {
+        if (evnt.ToUpper() == "UP")
+            return true;
+
+        if (evnt.ToUpper() == "UP_WITH_INCREASED_SAMPLING")
+            return true;
+
+        if (evnt.ToUpper() == "IDLE")
+            return true;
+
+        if (evnt.ToUpper() == "ENGINEERING_DEVELOPMENT")
+            return true;
+
+        if (evnt.ToUpper() == "WAITING_FOR_ENGINEER_SCHEDULED")
+            return true;
+
+        return false;
+    }
+
+}

ReportingServices.Shared.Blazor/_Imports.razor

@@ -0,0 +1 @@
+@using Microsoft.AspNetCore.Components.Web

ReportingServices.Shared.Blazor/wwwroot/exampleJsInterop.js

@@ -0,0 +1,6 @@
+// This is a JavaScript module that is loaded on demand. It can export any number of
+// functions, and may import other JavaScript modules if required.
+
+export function showPrompt(message) {
+  return prompt(message, 'Type anything here');
+}