mesa-fab-approval/MesaFabApproval.Client/Pages/Dashboard.razor.cs

using MesaFabApproval.Client.Services;
using MesaFabApproval.Shared.Models;

using Microsoft.AspNetCore.Components;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.JSInterop;

using MudBlazor;

namespace MesaFabApproval.Client.Pages;

public partial class Dashboard {
    [Inject] IConfiguration Configuration { get; set; }
    [Inject] MesaFabApprovalAuthStateProvider stateProvider { get; set; }
    [Inject] IApprovalService approvalService { get; set; }
    [Inject] IMemoryCache cache { get; set; }
    [Inject] NavigationManager navigationManager { get; set; }
    [Inject] ISnackbar snackbar { get; set; }
    [Inject] IMRBService mrbService { get; set; }
    [Inject] IPCRBService pcrbService { get; set; }
    [Inject] IECNService ecnService { get; set; }
    [Inject] ICAService caService { get; set; }
    [Inject] IJSRuntime jsRuntime { get; set; }

    private IEnumerable<Approval> approvalList = new List<Approval>();
    private IEnumerable<MRB> myMRBs = new List<MRB>();
    private IEnumerable<PCRB> myPCRBs = new List<PCRB>();

    private IEnumerable<int> ecnNumbers = new HashSet<int>();
    private IEnumerable<int> caNumbers = new HashSet<int>();
    private IEnumerable<int> mrbNumbers = new HashSet<int>();
    private IEnumerable<int> pcrbNumbers = new HashSet<int>();

    private bool myApprovalsProcessing = false;
    private bool myMrbsProcessing = false;
    private bool myPcrbsProcessing = false;

    private string mrbSearchString = "";
    private string pcrbSearchString = "";

    protected async override Task OnParametersSetAsync() {
        try {
            if (stateProvider.CurrentUser is not null) {
                myApprovalsProcessing = true;
                approvalList = (await approvalService.GetApprovalsForUserId(stateProvider.CurrentUser.UserID, true))
                    .Where(a => a.CompletedDate > DateTime.Now && a.ItemStatus == 0)
                    .ToList()
                    .OrderByDescending(x => x.AssignedDate);
                myApprovalsProcessing = false;

                myMrbsProcessing = true;
                myMRBs = (await mrbService.GetAllMRBs(false)).Where(m => m.OriginatorID == stateProvider.CurrentUser.UserID)
                    .ToList()
                    .OrderByDescending(x => x.SubmittedDate);
                myMrbsProcessing = false;

                myPcrbsProcessing = true;
                myPCRBs = (await pcrbService.GetAllPCRBs(false)).Where(p => p.OwnerID == stateProvider.CurrentUser.UserID)
                    .ToList()
                    .OrderByDescending(p => p.InsertTimeStamp);
                myPcrbsProcessing = false;
            }
        } catch (Exception ex) {
            myApprovalsProcessing = false;
            myMrbsProcessing = false;
            myPcrbsProcessing = false;
            snackbar.Add(ex.Message, Severity.Error);
        }
    }

    private async Task FollowLink(int issueId) {
        HashSet<Task> tasks = new();

        bool isEcn = false;
        bool isCa = false;
        bool isMrb = false;
        bool isPcrb = false;
        if (ecnNumbers.Contains(issueId))
            isEcn = true;
        if (caNumbers.Contains(issueId))
            isCa = true;
        if (mrbNumbers.Contains(issueId))
            isMrb = true;
        if (pcrbNumbers.Contains(issueId))
            isPcrb = true;

        if (!isEcn && !isCa && !isMrb) {
            Task<bool> isEcnTask = ecnService.ECNNumberIsValid(issueId);
            tasks.Add(isEcnTask);

            Task<bool> isCaTask = caService.CANumberIsValid(issueId);
            tasks.Add(isCaTask);

            Task<bool> isMrbTask = mrbService.NumberIsValid(issueId);
            tasks.Add(isMrbTask);

            Task<bool> isPcrbTask = pcrbService.IdIsValid(issueId);
            tasks.Add(isPcrbTask);

            await Task.WhenAll(tasks);

            if (isEcnTask.Result) {
                isEcn = true;
            } else if (isCaTask.Result) {
                isCa = true;
            } else if (isMrbTask.Result) {
                isMrb = true;
            } else if (isPcrbTask.Result) {
                isPcrb = true;
            }
        }

        if (isEcn) await GoToExternal($"{Configuration["OldFabApprovalUrl"]}/ECN/Edit?IssueID={issueId}", "");
        if (isCa) await GoToExternal($"{Configuration["OldFabApprovalUrl"]}/CorrectiveAction/Edit?IssueID={issueId}", "");
        if (isMrb) GoTo($"mrb/{issueId}");
        if (isPcrb) GoTo($"pcrb/{issueId}");
    }

    private void GoTo(string page) {
        cache.Set("redirectUrl", page);
        navigationManager.NavigateTo("/" + page);
    }

    private async Task GoToExternal(string url, string content) {
        IJSObjectReference windowModule = await jsRuntime.InvokeAsync<IJSObjectReference>("import", "./js/OpenInNewWindow.js");
        await windowModule.InvokeAsync<object>("OpenInNewWindow", url, content);
    }

    private bool FilterFuncForMRBTable(MRB mrb) => MRBFilterFunc(mrb, mrbSearchString);

    private bool MRBFilterFunc(MRB mrb, string searchString) {
        if (string.IsNullOrWhiteSpace(searchString))
            return true;
        if (mrb.Title.ToLower().Contains(searchString.Trim().ToLower()))
            return true;
        if (mrb.MRBNumber.ToString().Contains(searchString.Trim()))
            return true;
        return false;
    }

    private bool FilterFuncForPCRBTable(PCRB pcrb) => PCRBFilterFunc(pcrb, pcrbSearchString);

    private bool PCRBFilterFunc(PCRB pcrb, string searchString) {
        if (string.IsNullOrWhiteSpace(searchString))
            return true;
        if (pcrb.Title.ToLower().Contains(searchString.Trim().ToLower()))
            return true;
        if (pcrb.PlanNumber.ToString().Contains(searchString.Trim()))
            return true;
        return false;
    }

    private string GetCurrentPCRBStep(int step) {
        if (step < 0 || step > (PCRB.Stages.Length - 1)) return string.Empty;
        else return PCRB.Stages[step];
    }
}