mesa-fab-approval/MesaFabApproval.API/Controllers/PCRBController.cs

using MesaFabApproval.API.Services;
using MesaFabApproval.Shared.Models;
using MesaFabApproval.Shared.Services;

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace MesaFabApproval.API.Controllers;

[ApiController]
[Authorize]
public class PCRBController : ControllerBase {
    private readonly ILogger<MRBController> _logger;
    private readonly IPCRBService _pcrbService;
    private readonly IMonInWorkerClient _monInClient;

    public PCRBController(ILogger<MRBController> logger, IPCRBService pcrbService, IMonInWorkerClient monInClient) {
        _logger = logger ?? throw new ArgumentNullException("ILogger not injected");
        _pcrbService = pcrbService ?? throw new ArgumentNullException("IPCRBService not injected");
        _monInClient = monInClient ?? throw new ArgumentNullException("IMonInWorkerClient not injected");
    }

    [HttpPost]
    [Route("pcrb")]
    public async Task<IActionResult> CreateNewPCRB(PCRB pcrb) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to generate a new PCRB");

            if (pcrb is null) throw new ArgumentNullException("PCRB cannot be null");

            await _pcrbService.CreateNewPCRB(pcrb);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot create new PCRB, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "CreateNewPCRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("pcrb/all")]
    public async Task<IActionResult> GetAllPCRBs(bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get all PCRBs");

            IEnumerable<PCRB> allPCRBs = await _pcrbService.GetAllPCRBs(bypassCache);

            return Ok(allPCRBs);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get all PCRBs, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetAllPCRBs";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("pcrb/getByTitle")]
    public async Task<IActionResult> GetPCRBByTitle(string title, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get an PCRB by Title");

            if (string.IsNullOrWhiteSpace(title)) throw new ArgumentException("Title cannot be null or empty");

            PCRB pcrb = await _pcrbService.GetPCRBByTitle(title, bypassCache);

            return Ok(pcrb);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get PCRB by title, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetPCRBbyTitle";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpGet]
    [Route("pcrb/getByPlanNumber")]
    public async Task<IActionResult> GetPCRBByPlanNumber(int planNumber, bool bypassCache) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to get an PCRB by Title");

            if (planNumber <= 0) throw new ArgumentException($"{planNumber} is not a valid PCRB plan #");

            PCRB pcrb = await _pcrbService.GetPCRBByPlanNumber(planNumber, bypassCache);

            return Ok(pcrb);
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot get PCRB by plan number, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "GetPCRBbyPlanNumber";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpPut]
    [Route("pcrb")]
    public async Task<IActionResult> UpdatePCRB(PCRB pcrb) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation("Attempting to update a PCRB");

            if (pcrb is null) throw new ArgumentNullException("PCRB cannot be null");

            await _pcrbService.UpdatePCRB(pcrb);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot update PCRB, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "UpdatePCRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }

    [HttpDelete]
    [Route("pcrb")]
    public async Task<IActionResult> DeletePCRB(int planNumber) {
        DateTime start = DateTime.Now;
        bool isArgumentError = false;
        bool isInternalError = false;
        string errorMessage = "";

        try {
            _logger.LogInformation($"Attempting to delete PCRB# {planNumber}");

            if (planNumber <= 0) throw new ArgumentException($"{planNumber} is not a valid PCRB plan #");

            await _pcrbService.DeletePCRB(planNumber);

            return Ok();
        } catch (ArgumentException ex) {
            isArgumentError = true;
            errorMessage = ex.Message;
            return BadRequest(errorMessage);
        } catch (Exception ex) {
            isInternalError = true;
            errorMessage = $"Cannot delete PCRB# {planNumber}, because {ex.Message}";
            return Problem(errorMessage);
        } finally {
            string metricName = "DeletePCRB";
            DateTime end = DateTime.Now;
            double millisecondsDiff = (end - start).TotalMilliseconds;
            _monInClient.PostAverage(metricName + "Latency", millisecondsDiff);

            if (isArgumentError) {
                _logger.LogWarning(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            } else if (isInternalError) {
                _logger.LogError(errorMessage);
                _monInClient.PostStatus(metricName, StatusValue.Critical);
            } else {
                _monInClient.PostStatus(metricName, StatusValue.Ok);
            }
        }
    }
}