Added Viewer and

change to App Setting File from Constants

Viewer/Controllers/ErrorHandlerController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace OI.Metrology.Viewer.Controllers;
+
+[Route("/error")]
+public class ErrorHandlerController : Controller
+{
+    private readonly ILogger _Logger;
+
+    public ErrorHandlerController(ILogger<ErrorHandlerController> logger) => _Logger = logger;
+
+    public IActionResult Index()
+    {
+        IExceptionHandlerFeature error = HttpContext.Features.Get<IExceptionHandlerFeature>();
+        if (error == null)
+        {
+            return Redirect("~/");
+        }
+        else
+        {
+            _Logger.LogError("Unhandled exception: " + error.Error.ToString());
+            dynamic r = new
+            {
+                Message = error.Error == null ? "Error" : error.Error.Message
+            };
+            return StatusCode(StatusCodes.Status500InternalServerError, r);
+        }
+    }
+}

Viewer/Controllers/ExportController.cs

@@ -0,0 +1,159 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+using OI.Metrology.Shared.DataModels;
+using OI.Metrology.Shared.Repositories;
+using OI.Metrology.Shared.ViewModels;
+using OI.Metrology.Viewer.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OI.Metrology.Viewer.Controllers;
+
+public class ExportController : Controller
+{
+    private readonly ILogger _Logger;
+    private readonly bool _IsTestDatabase;
+    private readonly IMetrologyRepo _Repo;
+
+    public ExportController(AppSettings appSettings, ILogger<ExportController> logger, IMetrologyRepo repo)
+    {
+        _Repo = repo;
+        _Logger = logger;
+        _IsTestDatabase = appSettings.ConnectionString.Contains("test", StringComparison.InvariantCultureIgnoreCase);
+    }
+
+    public override void OnActionExecuted(ActionExecutedContext context)
+    {
+        base.OnActionExecuted(context);
+        ViewBag.IsTestDatabase = _IsTestDatabase;
+    }
+    [HttpGet]
+    [Route("/Export")]
+    public ActionResult Index()
+    {
+        Export model = new()
+        {
+            ToolType = "",
+            StartTime = DateTime.Now.AddMonths(-1),
+            EndTime = DateTime.Now
+        };
+        return View(model);
+    }
+
+    [HttpPost]
+    [Route("/ExportData")]
+    public ActionResult ExportData(Export model)
+    {
+        ToolType toolType = null;
+        if (string.IsNullOrEmpty(model.ToolType))
+            ModelState.AddModelError("Exception", "Invalid selection");
+        else
+        {
+            if (model.StartTime > model.EndTime)
+                ModelState.AddModelError("EndTime", "End time must be after start time");
+            IEnumerable<ToolType> toolTypes = _Repo.GetToolTypes();
+            toolType = toolTypes.Where(tt => tt.ID.ToString() == model.ToolType).SingleOrDefault();
+            if (toolType is null)
+                ModelState.AddModelError("ToolType", "Invalid selection");
+            else if (string.IsNullOrWhiteSpace(toolType.ExportSPName))
+                ModelState.AddModelError("ToolType", "Tool type is not exportable");
+        }
+        if (ModelState.IsValid)
+        {
+            try
+            {
+                DateTime startDT = model.StartDate.Date.Add(model.StartTime.TimeOfDay);
+                DateTime endDT = model.EndDate.Date.Add(model.EndTime.TimeOfDay);
+
+                return DoCSVExport(toolType.ToolTypeName, toolType.ExportSPName, startDT, endDT);
+            }
+            catch (Exception ex)
+            {
+                ModelState.AddModelError("Exception", "Error exporting data");
+                ModelState.AddModelError("Exception", ex.Message);
+                string errorMessage = $"Error exporting: {ex}";
+                _Logger.LogError(message: errorMessage);
+            }
+        }
+        return View("Index", model);
+    }
+
+    protected ActionResult DoCSVExport(string toolTypeName, string spName, DateTime startTime, DateTime endTime)
+    {
+        string fileName = string.Format("Export_{0}_{1:yyyyMMddHHmm}_to_{2:yyyyMMddHHmm}.csv", toolTypeName, startTime, endTime);
+        StringBuilder sb = new();
+
+        System.Data.DataTable dt = _Repo.ExportData(spName, startTime, endTime);
+
+        _ = sb.AppendLine(GetColumnHeaders(dt));
+
+        foreach (System.Data.DataRow dr in dt.Rows)
+        {
+            _ = sb.AppendLine(GetRowData(dr));
+        }
+
+        byte[] contents = Encoding.UTF8.GetBytes(sb.ToString());
+
+        return File(contents, "application/octet-stream", fileName);
+    }
+
+    protected static string GetRowData(System.Data.DataRow dr)
+    {
+        StringBuilder r = new();
+        for (int i = 0; i < dr.Table.Columns.Count; i++)
+        {
+            if (i > 0)
+                _ = r.Append(',');
+
+            object v = dr[i];
+            if (!Convert.IsDBNull(v))
+                _ = r.Append(FormatForCSV(Convert.ToString(v)));
+        }
+        return r.ToString();
+    }
+
+    protected static string GetColumnHeaders(System.Data.DataTable dt)
+    {
+        StringBuilder r = new();
+        for (int i = 0; i < dt.Columns.Count; i++)
+        {
+            if (i > 0)
+                _ = r.Append(',');
+
+            _ = r.Append(FormatForCSV(dt.Columns[i].ColumnName.TrimEnd('_')));
+        }
+        return r.ToString();
+    }
+
+    protected static string FormatForCSV(string v)
+    {
+        StringBuilder r = new(v.Length + 2);
+
+        bool doubleQuoted = false;
+
+        if (v.StartsWith(' ') || v.EndsWith(' ') || v.Contains(',') || v.Contains('"'))
+        {
+            _ = r.Append('"');
+            doubleQuoted = true;
+        }
+
+        foreach (char c in v)
+        {
+            _ = c switch
+            {
+                '\r' or '\n' => r.Append(' '),
+                '"' => r.Append("\"\""),
+                _ => r.Append(c),
+            };
+        }
+
+        if (doubleQuoted)
+            _ = r.Append('"');
+
+        return r.ToString();
+    }
+
+}

Viewer/Controllers/PagesController.cs

@@ -0,0 +1,60 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using OI.Metrology.Shared.Repositories;
+using OI.Metrology.Shared.ViewModels;
+using OI.Metrology.Viewer.Models;
+using System;
+
+namespace OI.Metrology.Viewer.Controllers;
+
+public class PagesController : Controller
+{
+    private readonly IMetrologyRepo _Repo;
+    private readonly bool _IsTestDatabase;
+
+    public PagesController(AppSettings appSettings, IMetrologyRepo repo)
+    {
+        _Repo = repo;
+        _IsTestDatabase = appSettings.ConnectionString.Contains("test", StringComparison.InvariantCultureIgnoreCase);
+    }
+
+    public override void OnActionExecuted(ActionExecutedContext context)
+    {
+        base.OnActionExecuted(context);
+        ViewBag.IsTestDatabase = _IsTestDatabase;
+    }
+
+    [HttpGet]
+    [Route("/")]
+    public IActionResult Index() =>
+        View("AwaitingDispo");
+
+    [HttpGet]
+    [Route("/AwaitingDispo")]
+    public IActionResult AwaitingDispo() => View();
+
+    [HttpGet]
+    [Route("/RunInfo")]
+    public IActionResult RunInfo([FromQuery] int tooltypeid = 1, [FromQuery] int headerid = 0)
+    {
+        RunInfo m = new()
+        {
+            ToolTypeID = tooltypeid,
+            HeaderID = headerid,
+            HeaderAttachmentID = Guid.Empty,
+        };
+        if (headerid > 0)
+        {
+            m.HeaderAttachmentID = _Repo.GetHeaderAttachmentID(tooltypeid, headerid);
+        }
+        return View(m);
+    }
+
+    [HttpGet]
+    [Route("/RunHeaders")]
+    public IActionResult RunHeaders() => View();
+
+    [HttpGet]
+    [Route("/Crash")]
+    public IActionResult Crash() => throw new Exception("Test unhandled exception");
+}