1026 lines
42 KiB
C#
1026 lines
42 KiB
C#
using MesaFabApproval.Client.Pages.Components;
|
|
using MesaFabApproval.Client.Services;
|
|
using MesaFabApproval.Shared.Models;
|
|
using MesaFabApproval.Shared.Utilities;
|
|
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Components.Forms;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
|
|
using MudBlazor;
|
|
|
|
using System.Text;
|
|
|
|
namespace MesaFabApproval.Client.Pages;
|
|
|
|
public partial class MRBSingle {
|
|
[Parameter]
|
|
public string? mrbNumber { get; set; }
|
|
[Inject] IMRBService mrbService { get; set; }
|
|
[Inject] ISnackbar snackbar { get; set; }
|
|
[Inject] IDialogService dialogService { get; set; }
|
|
[Inject] NavigationManager navigationManager { get; set; }
|
|
[Inject] MesaFabApprovalAuthStateProvider authStateProvider { get; set; }
|
|
[Inject] IUserService userService { get; set; }
|
|
[Inject] IConfiguration config { get; set; }
|
|
[Inject] IApprovalService approvalService { get; set; }
|
|
[Inject] IPCRBService pcrbService { get; set; }
|
|
[Inject] IECNService ecnService { get; set; }
|
|
[Inject] ICustomerService customerService { get; set; }
|
|
[Inject] IMemoryCache cache { get; set; }
|
|
private int mrbNumberInt = 0;
|
|
private MRB? mrb { get; set; }
|
|
private User? currentUser = null;
|
|
private int currentUserId = 0;
|
|
private IEnumerable<User> allActiveUsers = new List<User>();
|
|
private IEnumerable<MRBAction> mrbActions = new List<MRBAction>();
|
|
private IEnumerable<MRBActionAttachment> mrbActionAttachments = new List<MRBActionAttachment>();
|
|
private IEnumerable<MRBAttachment> mrbAttachments = new List<MRBAttachment>();
|
|
private IEnumerable<Approval> mrbApprovals = new List<Approval>();
|
|
private IEnumerable<Approval> nonTaskApprovals = new List<Approval>();
|
|
private IEnumerable<Approval> taskApprovals = new List<Approval>();
|
|
private IEnumerable<string> customerNames = new List<string>();
|
|
private IEnumerable<string> partNumbers = new List<string>();
|
|
private IEnumerable<string> lotNumbers = new List<string>();
|
|
private bool processing = false;
|
|
private bool saveInProcess = false;
|
|
private bool submitInProcess = false;
|
|
private bool deleteInProcess = false;
|
|
private bool recallInProcess = false;
|
|
private bool approvalInProcess = false;
|
|
private bool taskApprovalInProcess = false;
|
|
private bool denialInProcess = false;
|
|
private bool completeAllActionsInProcess = false;
|
|
private bool deleteActionInProcess = false;
|
|
private bool attachmentUploadInProcess = false;
|
|
private bool deleteAttachmentInProcess = false;
|
|
private string actionSearchString = "";
|
|
private string attachmentSearchString = "";
|
|
private string currentUrl = "";
|
|
private MudTextField<int>? processEcnField;
|
|
private bool processEcnIsValid = false;
|
|
private MudTextField<string>? pcrbNoField;
|
|
private bool pcrbNoIsValid = false;
|
|
|
|
protected override async Task OnParametersSetAsync() {
|
|
processing = true;
|
|
try {
|
|
allActiveUsers = await userService.GetAllActiveUsers();
|
|
currentUser = authStateProvider.CurrentUser;
|
|
currentUrl = navigationManager.Uri;
|
|
|
|
if (!string.IsNullOrWhiteSpace(mrbNumber) && Int32.TryParse(mrbNumber, out mrbNumberInt)) {
|
|
mrb = await mrbService.GetMRBById(mrbNumberInt);
|
|
if (mrb.ProcessECNNumber > 0) await ECNNoIsValid(mrb.ProcessECNNumber);
|
|
if (!string.IsNullOrWhiteSpace(mrb.PCRBNo)) await PCRBNoIsValid(mrb.PCRBNo);
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrbNumberInt, false);
|
|
partNumbers = GetPartNumbers();
|
|
lotNumbers = GetLotNumbers();
|
|
mrb.NumberOfLotsAffected = GetTotalActionQuantities();
|
|
mrbActionAttachments = await mrbService.GetAllActionAttachmentsForMRB(mrbNumberInt, false);
|
|
mrbAttachments = await mrbService.GetAllAttachmentsForMRB(mrbNumberInt, false);
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrbNumberInt, false);
|
|
|
|
nonTaskApprovals = mrbApprovals.Where(a => a.Step < 3).ToList();
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
} else {
|
|
mrbNumberInt = 0;
|
|
mrbNumber = "";
|
|
mrb = new() { Status = "Draft", StageNo = 0 };
|
|
mrbActions = new List<MRBAction>();
|
|
mrbAttachments = new List<MRBAttachment>();
|
|
mrbApprovals = new List<Approval>();
|
|
nonTaskApprovals = new List<Approval>();
|
|
taskApprovals = new List<Approval>();
|
|
if (authStateProvider is not null && authStateProvider.CurrentUser is not null) {
|
|
mrb.OriginatorID = authStateProvider.CurrentUser.UserID;
|
|
mrb.OriginatorName = $"{authStateProvider.CurrentUser.FirstName} {authStateProvider.CurrentUser.LastName}";
|
|
}
|
|
}
|
|
|
|
if (customerNames is null || customerNames.Count() <= 0)
|
|
customerNames = (await customerService.GetAllCustomerNames()).OrderBy(c => c);
|
|
|
|
StateHasChanged();
|
|
} catch (Exception ex) {
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
processing = false;
|
|
}
|
|
|
|
private void ReturnToAllMrbs() {
|
|
cache.Set("redirectUrl", $"mrb/all");
|
|
navigationManager.NavigateTo("mrb/all");
|
|
}
|
|
|
|
private async void SaveMRB() {
|
|
if (!saveInProcess) {
|
|
try {
|
|
saveInProcess = true;
|
|
MRB initialMrb = new MRB() {
|
|
MRBNumber = mrb.MRBNumber,
|
|
Status = mrb.Status,
|
|
StageNo = 0,
|
|
NumberOfLotsAffected = 0
|
|
};
|
|
if (mrb is not null) {
|
|
User? originator = allActiveUsers.Where(u => $"{u.FirstName} {u.LastName}".Equals(mrb.OriginatorName)).FirstOrDefault();
|
|
if (originator is not null) mrb.OriginatorID = originator.UserID;
|
|
|
|
if (mrb.MRBNumber <= 0) {
|
|
await mrbService.CreateNewMRB(mrb);
|
|
mrb = await mrbService.GetMRBByTitle(mrb.Title, true);
|
|
cache.Set("redirectUrl", $"mrb/{mrb.MRBNumber}");
|
|
}
|
|
|
|
mrb.NumberOfLotsAffected = 0;
|
|
foreach (MRBAction action in mrbActions) {
|
|
if (action is not null) {
|
|
action.MRBNumber = mrbNumberInt;
|
|
if (action.ActionID > 0) {
|
|
await mrbService.UpdateMRBAction(action);
|
|
} else {
|
|
await mrbService.CreateMRBAction(action);
|
|
}
|
|
|
|
mrb.NumberOfLotsAffected += action.Quantity;
|
|
}
|
|
}
|
|
|
|
if (mrb.MRBNumber > 0) await mrbService.UpdateMRB(mrb);
|
|
|
|
mrbNumber = mrb.MRBNumber.ToString();
|
|
mrbNumberInt = mrb.MRBNumber;
|
|
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrbNumberInt, true);
|
|
}
|
|
saveInProcess = false;
|
|
StateHasChanged();
|
|
snackbar.Add($"MRB {mrb.MRBNumber} successfully saved", Severity.Success);
|
|
|
|
if (initialMrb.MRBNumber <= 0)
|
|
navigationManager.NavigateTo($"mrb/{mrb.MRBNumber}");
|
|
} catch (Exception ex) {
|
|
saveInProcess = false;
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
saveInProcess = false;
|
|
}
|
|
}
|
|
|
|
private async void DeleteMRB() {
|
|
if (!deleteInProcess) {
|
|
try {
|
|
bool? result = await dialogService.ShowMessageBox(
|
|
"Warning",
|
|
$"Are you sure you want to delete MRB# {mrb.MRBNumber}?",
|
|
yesText: "Yes", noText: "No"
|
|
);
|
|
|
|
if (result == true) {
|
|
deleteInProcess = true;
|
|
|
|
await mrbService.DeleteMRB(mrb.MRBNumber);
|
|
|
|
deleteInProcess = false;
|
|
|
|
snackbar.Add("MRB successfully deleted", Severity.Success);
|
|
|
|
navigationManager.NavigateTo("mrb/all");
|
|
}
|
|
} catch (Exception ex) {
|
|
deleteInProcess = false;
|
|
|
|
snackbar.Add($"Unable to delete MRB, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void SubmitMRBForApproval() {
|
|
if (!submitInProcess && !processing) {
|
|
submitInProcess = true;
|
|
processing = true;
|
|
try {
|
|
if (mrb is null) throw new Exception("MRB cannot be null");
|
|
|
|
User? originator = allActiveUsers.Where(u => $"{u.FirstName} {u.LastName}".Equals(mrb.OriginatorName)).FirstOrDefault();
|
|
if (originator is not null) mrb.OriginatorID = originator.UserID;
|
|
|
|
if (mrb.StageNo == 0) {
|
|
mrb.StageNo++;
|
|
mrb.SubmittedDate = DateTime.Now;
|
|
}
|
|
|
|
mrb.NumberOfLotsAffected = 0;
|
|
foreach (MRBAction action in mrbActions) {
|
|
if (action is not null) {
|
|
action.MRBNumber = mrb.MRBNumber;
|
|
if (action.ActionID > 0) {
|
|
await mrbService.UpdateMRBAction(action);
|
|
} else {
|
|
await mrbService.CreateMRBAction(action);
|
|
}
|
|
|
|
mrb.NumberOfLotsAffected += action.Quantity;
|
|
}
|
|
}
|
|
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrbNumberInt, true);
|
|
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
await mrbService.SubmitForApproval(mrb);
|
|
|
|
await mrbService.NotifyNewApprovals(mrb);
|
|
|
|
if (mrb.StageNo == 1) {
|
|
StringBuilder messageBuilder = new();
|
|
messageBuilder.Append($"MRB# {mrb.MRBNumber} [{mrb.Title}] has been submitted for approval. ");
|
|
messageBuilder.Append("You will receive an email after it has been approved.");
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = messageBuilder.ToString()
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
}
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
|
|
nonTaskApprovals = mrbApprovals.Where(a => a.Step < 3).ToList();
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
|
|
submitInProcess = false;
|
|
processing = false;
|
|
|
|
snackbar.Add("MRB submitted for approval", Severity.Success);
|
|
} catch (Exception ex) {
|
|
submitInProcess = false;
|
|
processing = false;
|
|
snackbar.Add($"Unable to submit MRB for approval, because {ex.Message}", Severity.Error);
|
|
}
|
|
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private async void ApproveMRB() {
|
|
if (!approvalInProcess && !processing) {
|
|
approvalInProcess = true;
|
|
processing = true;
|
|
try {
|
|
if (mrb is null) throw new Exception("MRB is null");
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
|
|
if (mrbApprovals is null || mrbApprovals.Count() <= 0)
|
|
throw new Exception("there are no approvals to approve");
|
|
if (authStateProvider.CurrentUser is null) {
|
|
navigationManager.NavigateTo("login");
|
|
return;
|
|
}
|
|
|
|
string? comments = "";
|
|
|
|
DialogParameters<Comments> parameters = new DialogParameters<Comments> { { x => x.comments, comments } };
|
|
var dialog = dialogService.Show<Comments>($"Approval Comments", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (result.Canceled) throw new Exception("you must provide approval comments");
|
|
|
|
comments = result.Data.ToString();
|
|
|
|
IEnumerable<Approval> approvals = mrbApprovals.Where(a => a.UserID == authStateProvider.CurrentUser.UserID &&
|
|
a.ItemStatus == 0 &&
|
|
!(a.CompletedDate < DateTimeUtilities.MAX_DT) &&
|
|
a.Step == mrb.StageNo);
|
|
|
|
foreach (Approval approval in approvals) {
|
|
approval.CompletedDate = DateTime.Now;
|
|
approval.Comments = comments is null ? "" : comments;
|
|
approval.ItemStatus = 1;
|
|
await approvalService.Approve(approval);
|
|
|
|
IEnumerable<Approval> sameRoleApprovals = mrbApprovals.Where(a => a.Step == mrb.StageNo &&
|
|
!(a.UserID == authStateProvider.CurrentUser.UserID) &&
|
|
a.ItemStatus == 0 &&
|
|
a.SubRoleCategoryItem.ToLower().Equals(approval.SubRoleCategoryItem.ToLower()) &&
|
|
!(a.CompletedDate < DateTimeUtilities.MAX_DT));
|
|
foreach (Approval sameApp in sameRoleApprovals) {
|
|
sameApp.CompletedDate = DateTime.Now;
|
|
sameApp.Comments = comments is null ? "" : comments;
|
|
sameApp.ItemStatus = 1;
|
|
await approvalService.Approve(sameApp);
|
|
}
|
|
}
|
|
|
|
IEnumerable<Approval> remainingApprovalsInKind = mrbApprovals.Where(a => a.Step == mrb.StageNo &&
|
|
a.ItemStatus == 0 &&
|
|
!(a.CompletedDate < DateTimeUtilities.MAX_DT));
|
|
|
|
if (remainingApprovalsInKind is null || remainingApprovalsInKind.Count() <= 0) {
|
|
mrb.StageNo++;
|
|
if (mrb.StageNo == 3) mrb.ApprovalDate = DateTime.Now;
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
if (mrb.StageNo < 3) {
|
|
processing = false;
|
|
SubmitMRBForApproval();
|
|
processing = true;
|
|
}
|
|
|
|
|
|
processing = true;
|
|
|
|
if (mrb.StageNo == 3) {
|
|
processing = false;
|
|
GenerateActionTasks();
|
|
processing = true;
|
|
|
|
StringBuilder messageBuilder = new();
|
|
messageBuilder.Append($"MRB# {mrb.MRBNumber} [{mrb.Title}] has been approved. ");
|
|
messageBuilder.Append("You will receive an email when all actions are complete.");
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = messageBuilder.ToString()
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
|
|
string msg = $"MRB# {mrb.MRBNumber} [{mrb.Title}] has been approved.";
|
|
|
|
notification = new() {
|
|
MRB = mrb,
|
|
Message = msg
|
|
};
|
|
|
|
await mrbService.NotifyQAPreApprover(notification);
|
|
}
|
|
}
|
|
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrb.MRBNumber, true);
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
nonTaskApprovals = mrbApprovals.Where(a => a.Step < 3).ToList();
|
|
|
|
if (mrb.StageNo == 3 && taskApprovals.Count() <= 0) {
|
|
mrb.StageNo++;
|
|
mrb.CloseDate = DateTime.Now;
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
string body = $"MRB# {mrb.MRBNumber} [{mrb.Title}] is complete.";
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = body
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
await mrbService.NotifyQAPreApprover(notification);
|
|
|
|
snackbar.Add("MRB complete", Severity.Success);
|
|
}
|
|
|
|
approvalInProcess = false;
|
|
processing = false;
|
|
|
|
StateHasChanged();
|
|
|
|
snackbar.Add("Successfully approved", Severity.Success);
|
|
} catch (Exception ex) {
|
|
approvalInProcess = false;
|
|
processing = false;
|
|
|
|
snackbar.Add($"Unable to approve, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void RecallMRB() {
|
|
if (!recallInProcess) {
|
|
recallInProcess = true;
|
|
try {
|
|
if (mrb is null)
|
|
throw new Exception("MRB cannot be null");
|
|
|
|
User? currentUser = authStateProvider.CurrentUser;
|
|
if (currentUser is null) {
|
|
recallInProcess = false;
|
|
snackbar.Add("You must be logged in to recall this MRB", Severity.Error);
|
|
navigationManager.NavigateTo($"login/mrb/{mrb.MRBNumber}");
|
|
} else {
|
|
await mrbService.RecallMRB(mrb, currentUser);
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
nonTaskApprovals = mrbApprovals.Where(a => a.Step < 3).ToList();
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
}
|
|
|
|
recallInProcess = false;
|
|
|
|
StateHasChanged();
|
|
|
|
snackbar.Add("MRB successfully recalled", Severity.Success);
|
|
} catch (Exception ex) {
|
|
recallInProcess = false;
|
|
snackbar.Add($"Unable to recall MRB, because {ex.Message}", Severity.Error);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void DenyMRB() {
|
|
if (!denialInProcess) {
|
|
denialInProcess = true;
|
|
try {
|
|
if (mrbApprovals is null || mrbApprovals.Count() <= 0)
|
|
throw new Exception("there are no approvals to deny");
|
|
if (authStateProvider.CurrentUser is null) {
|
|
navigationManager.NavigateTo("login");
|
|
return;
|
|
}
|
|
if (mrb is null) throw new Exception("MRB is null");
|
|
|
|
string? comments = "";
|
|
|
|
DialogParameters<Comments> parameters = new DialogParameters<Comments> { { x => x.comments, comments } };
|
|
var dialog = dialogService.Show<Comments>($"Denial Comments", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (result.Canceled) throw new Exception("you must provide your denial comments");
|
|
|
|
comments = result.Data.ToString();
|
|
|
|
if (string.IsNullOrWhiteSpace(comments)) throw new Exception("you must provide your denial comments");
|
|
|
|
IEnumerable<Approval> approvals = mrbApprovals.Where(a => !(a.CompletedDate < DateTimeUtilities.MAX_DT) &&
|
|
a.Step == mrb.StageNo);
|
|
|
|
foreach (Approval approval in approvals) {
|
|
approval.CompletedDate = DateTime.Now;
|
|
approval.Comments = comments is null ? "" : comments;
|
|
approval.ItemStatus = -1;
|
|
await approvalService.Deny(approval);
|
|
}
|
|
|
|
mrb.StageNo = 0;
|
|
mrb.SubmittedDate = DateTimeUtilities.MIN_DT;
|
|
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
nonTaskApprovals = mrbApprovals.Where(a => a.Step < 3).ToList();
|
|
|
|
StringBuilder messageBuilder = new();
|
|
messageBuilder.AppendLine($"MRB# {mrb.MRBNumber} [{mrb.Title}] has been denied by {authStateProvider.CurrentUser.GetFullName()}. ");
|
|
messageBuilder.AppendLine("");
|
|
messageBuilder.Append($"Comments: {comments}");
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = messageBuilder.ToString()
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
|
|
denialInProcess = false;
|
|
|
|
StateHasChanged();
|
|
|
|
snackbar.Add("Successfully denied", Severity.Success);
|
|
} catch (Exception ex) {
|
|
denialInProcess = false;
|
|
|
|
snackbar.Add($"Unable to process denial, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void GenerateActionTasks() {
|
|
try {
|
|
if (mrb is null) throw new Exception("MRB cannot be null");
|
|
|
|
foreach (MRBAction action in mrbActions) {
|
|
if (action.CompletedDate == DateTimeUtilities.MAX_DT) {
|
|
action.AssignedDate = DateTime.Now;
|
|
await mrbService.UpdateMRBAction(action);
|
|
|
|
await mrbService.GenerateActionTasks(mrb, action);
|
|
}
|
|
}
|
|
|
|
await mrbService.NotifyNewApprovals(mrb);
|
|
} catch (Exception ex) {
|
|
snackbar.Add($"Unable to generate action tasks, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
|
|
private async void CompleteAction(MRBAction action) {
|
|
try {
|
|
if (action is null) throw new Exception("MRB action cannot be null");
|
|
if (authStateProvider.CurrentUser is null)
|
|
throw new Exception("you must be logged in to complete this action");
|
|
if (mrb is null) throw new Exception("MRB cannot be null");
|
|
|
|
string? comments = "";
|
|
|
|
DialogParameters<MRBActionCommentsAndFiles> parameters = new DialogParameters<MRBActionCommentsAndFiles> {
|
|
{ x => x.comments, comments },
|
|
{ x => x.actionId, action.ActionID} };
|
|
var dialog = dialogService.Show<MRBActionCommentsAndFiles>($"Completion Comments", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (result.Canceled)
|
|
throw new Exception("you must provide your completion comments");
|
|
|
|
comments = result.Data.ToString();
|
|
|
|
if (string.IsNullOrWhiteSpace(comments))
|
|
throw new Exception("you must provide your completion comments");
|
|
|
|
action.CompletedDate = DateTime.Now;
|
|
action.CompletedByUserID = authStateProvider.CurrentUser.UserID;
|
|
action.CompletedByUser = authStateProvider.CurrentUser;
|
|
|
|
await mrbService.UpdateMRBAction(action);
|
|
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(action.MRBNumber, true);
|
|
|
|
foreach (Approval approval in taskApprovals) {
|
|
if (approval.ItemStatus == 0 && approval.TaskID == action.ActionID) {
|
|
approval.Comments = comments;
|
|
await approvalService.Approve(approval);
|
|
}
|
|
}
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
|
|
int outStandingTaskCount = taskApprovals.Where(a => a.CompletedDate >= DateTimeUtilities.MAX_DT).Count();
|
|
|
|
if (outStandingTaskCount == 0) {
|
|
mrb.StageNo++;
|
|
mrb.CloseDate = DateTime.Now;
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
string body = $"MRB# {mrb.MRBNumber} [{mrb.Title}] is complete.";
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = body
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
await mrbService.NotifyQAPreApprover(notification);
|
|
|
|
snackbar.Add("All MRB actions complete", Severity.Success);
|
|
}
|
|
|
|
mrbActionAttachments = await mrbService.GetAllActionAttachmentsForMRB(action.MRBNumber, true);
|
|
|
|
StateHasChanged();
|
|
} catch (Exception ex) {
|
|
snackbar.Add($"Unable to mark action complete, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
|
|
private async void CompleteAllActions() {
|
|
if (!completeAllActionsInProcess) {
|
|
try {
|
|
completeAllActionsInProcess = true;
|
|
|
|
if (mrbActions is null) throw new Exception("MRB actions cannot be null");
|
|
if (authStateProvider.CurrentUser is null)
|
|
throw new Exception("you must be logged in to complete this action");
|
|
if (mrb is null) throw new Exception("MRB cannot be null");
|
|
|
|
string? comments = "";
|
|
|
|
MRBAction? firstAction = mrbActions.FirstOrDefault();
|
|
|
|
if (firstAction is null) throw new Exception("there are actions to complete");
|
|
|
|
DialogParameters<MRBActionCommentsAndFiles> parameters = new DialogParameters<MRBActionCommentsAndFiles> {
|
|
{ x => x.comments, comments },
|
|
{ x => x.actionId, firstAction.ActionID} };
|
|
var dialog = dialogService.Show<MRBActionCommentsAndFiles>($"Completion Comments", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (result.Canceled)
|
|
throw new Exception("you must provide your completion comments");
|
|
|
|
comments = result.Data.ToString();
|
|
|
|
if (string.IsNullOrWhiteSpace(comments))
|
|
throw new Exception("you must provide your completion comments");
|
|
|
|
foreach (MRBAction action in mrbActions) {
|
|
action.CompletedDate = DateTime.Now;
|
|
action.CompletedByUserID = authStateProvider.CurrentUser.UserID;
|
|
action.CompletedByUser = authStateProvider.CurrentUser;
|
|
|
|
await mrbService.UpdateMRBAction(action);
|
|
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(action.MRBNumber, true);
|
|
|
|
mrbActionAttachments = await mrbService.GetAllActionAttachmentsForMRB(action.MRBNumber, true);
|
|
}
|
|
|
|
foreach (Approval approval in taskApprovals) {
|
|
if (approval.ItemStatus == 0) {
|
|
approval.Comments = comments;
|
|
await approvalService.Approve(approval);
|
|
}
|
|
}
|
|
|
|
mrbApprovals = await approvalService.GetApprovalsForIssueId(mrb.MRBNumber, true);
|
|
taskApprovals = mrbApprovals.Where(a => a.Step >= 3).ToList();
|
|
|
|
int outStandingTaskCount = taskApprovals.Where(a => a.CompletedDate >= DateTimeUtilities.MAX_DT).Count();
|
|
|
|
if (outStandingTaskCount == 0) {
|
|
mrb.StageNo++;
|
|
mrb.CloseDate = DateTime.Now;
|
|
await mrbService.UpdateMRB(mrb);
|
|
|
|
string body = $"MRB# {mrb.MRBNumber} [{mrb.Title}] is complete.";
|
|
|
|
MRBNotification notification = new() {
|
|
MRB = mrb,
|
|
Message = body
|
|
};
|
|
|
|
await mrbService.NotifyOriginator(notification);
|
|
await mrbService.NotifyQAPreApprover(notification);
|
|
|
|
snackbar.Add("All MRB actions complete", Severity.Success);
|
|
}
|
|
|
|
completeAllActionsInProcess = false;
|
|
|
|
StateHasChanged();
|
|
} catch (Exception ex) {
|
|
completeAllActionsInProcess = false;
|
|
snackbar.Add($"Unable to mark action complete, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool mrbIsReadyToSubmit() {
|
|
bool isReadyToSubmit = mrb is not null &&
|
|
!(mrb.SubmittedDate > DateTimeUtilities.MIN_DT) &&
|
|
mrb.MRBNumber > 0 && mrb.OriginatorID > 0 &&
|
|
!string.IsNullOrWhiteSpace(mrb.OriginatorName) &&
|
|
!string.IsNullOrWhiteSpace(mrb.Title) &&
|
|
!string.IsNullOrWhiteSpace(mrb.Category) &&
|
|
mrb.Val > 0 &&
|
|
!string.IsNullOrWhiteSpace(mrb.IssueDescription) &&
|
|
!string.IsNullOrWhiteSpace(mrb.Department) &&
|
|
!string.IsNullOrWhiteSpace(mrb.Process) &&
|
|
(!mrb.CustomerImpacted || !string.IsNullOrWhiteSpace(mrb.CustomerImpactedName)) &&
|
|
(!mrb.SpecsImpacted || processEcnIsValid) &&
|
|
(string.IsNullOrWhiteSpace(mrb.PCRBNo) || pcrbNoIsValid);
|
|
|
|
if (mrb is not null && !mrb.Category.Equals("Material Transfer")) {
|
|
isReadyToSubmit = isReadyToSubmit && mrbActions is not null && mrbActions.Count() > 0;
|
|
isReadyToSubmit = isReadyToSubmit && mrb.NumberOfLotsAffected > 0;
|
|
}
|
|
|
|
isReadyToSubmit = isReadyToSubmit && mrbAttachments is not null && mrbAttachments.Count() > 0;
|
|
|
|
return isReadyToSubmit;
|
|
}
|
|
|
|
private IEnumerable<string> GetIncompleteFields() {
|
|
List<string> incompleteFields = new();
|
|
|
|
if (string.IsNullOrWhiteSpace(mrb.Title))
|
|
incompleteFields.Add("Title");
|
|
if (string.IsNullOrWhiteSpace(mrb.IssueDescription))
|
|
incompleteFields.Add("Description");
|
|
if (string.IsNullOrWhiteSpace(mrb.OriginatorName))
|
|
incompleteFields.Add("Originator");
|
|
if (string.IsNullOrWhiteSpace(mrb.Category))
|
|
incompleteFields.Add("Category");
|
|
if (string.IsNullOrWhiteSpace(mrb.Department))
|
|
incompleteFields.Add("Department");
|
|
if (string.IsNullOrWhiteSpace(mrb.Process))
|
|
incompleteFields.Add("Process");
|
|
if (mrb.Val <= 0) incompleteFields.Add("Value");
|
|
if (mrb.SpecsImpacted && (processEcnField is null || processEcnField.HasErrors))
|
|
incompleteFields.Add("Process ECN#");
|
|
if (mrb.CustomerImpacted && string.IsNullOrWhiteSpace(mrb.CustomerImpactedName))
|
|
incompleteFields.Add("Affected Customer");
|
|
|
|
return incompleteFields;
|
|
}
|
|
|
|
private bool currentUserIsApprover() {
|
|
if (mrbApprovals is null || authStateProvider is null) return false;
|
|
if (authStateProvider.CurrentUser is null) return false;
|
|
|
|
IEnumerable<Approval> approvalsForCurrentUser = mrbApprovals.Where(a => mrb is not null &&
|
|
mrb.StageNo < 3 &&
|
|
a.UserID == authStateProvider.CurrentUser.UserID &&
|
|
a.ItemStatus == 0);
|
|
|
|
if (approvalsForCurrentUser is not null && approvalsForCurrentUser.Count() > 0) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private async void CreateNewAction() {
|
|
try {
|
|
MRBAction mrbAction = new() {
|
|
Action = "",
|
|
Customer = "",
|
|
LotNumber = "",
|
|
PartNumber = "",
|
|
MRBNumber = mrbNumberInt,
|
|
Quantity = 0
|
|
};
|
|
|
|
DialogParameters<MRBActionForm> parameters = new DialogParameters<MRBActionForm> { { x => x.mrbAction, mrbAction } };
|
|
var dialog = dialogService.Show<MRBActionForm>($"New MRB Action", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (!result.Canceled) {
|
|
if (mrbNumberInt > 0) {
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrbNumberInt, true);
|
|
} else {
|
|
List<MRBAction> actionList = mrbActions.ToList();
|
|
actionList.Add(mrbAction);
|
|
mrbActions = actionList;
|
|
}
|
|
StateHasChanged();
|
|
}
|
|
} catch (Exception ex) {
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
}
|
|
|
|
private async void EditAction(MRBAction mrbAction) {
|
|
try {
|
|
if (mrbAction is null)
|
|
throw new ArgumentNullException("Action cannot be null");
|
|
|
|
var parameters = new DialogParameters<MRBActionForm> { { x => x.mrbAction, mrbAction } };
|
|
var dialog = dialogService.Show<MRBActionForm>($"MRB Action {mrbAction.ActionID}", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (!result.Canceled) {
|
|
if (mrbNumberInt > 0) {
|
|
mrbActions = await mrbService.GetMRBActionsForMRB(mrbNumberInt, true);
|
|
} else {
|
|
List<MRBAction> actionList = mrbActions.ToList();
|
|
actionList.Add(mrbAction);
|
|
mrbActions = actionList;
|
|
}
|
|
StateHasChanged();
|
|
}
|
|
} catch (Exception ex) {
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
}
|
|
|
|
private async void DeleteAction(MRBAction mrbAction) {
|
|
if (!deleteActionInProcess) {
|
|
deleteActionInProcess = true;
|
|
try {
|
|
if (mrbAction is null)
|
|
throw new ArgumentNullException("Action cannot be null");
|
|
|
|
await mrbService.DeleteMRBAction(mrbAction);
|
|
|
|
List<MRBAction> mrbActionList = mrbActions.ToList();
|
|
mrbActionList.RemoveAll(x => x.ActionID == mrbAction.ActionID);
|
|
mrbActions = mrbActionList;
|
|
|
|
snackbar.Add("Action successfully deleted", Severity.Success);
|
|
} catch (Exception ex) {
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
deleteActionInProcess = false;
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private bool FilterFuncForMRBActionTable(MRBAction action) => MRBActionFilterFunc(action, actionSearchString);
|
|
|
|
private bool MRBActionFilterFunc(MRBAction action, string searchString) {
|
|
if (string.IsNullOrWhiteSpace(searchString))
|
|
return true;
|
|
|
|
string search = searchString.ToLower();
|
|
if (action.Customer.ToLower().Contains(search))
|
|
return true;
|
|
if (action.Action.ToLower().Contains(search))
|
|
return true;
|
|
if (action.PartNumber.ToLower().Contains(search))
|
|
return true;
|
|
if (action.LotNumber.ToLower().Contains(search))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private async Task AddAttachments(InputFileChangeEventArgs args) {
|
|
if (!attachmentUploadInProcess) {
|
|
attachmentUploadInProcess = true;
|
|
try {
|
|
IReadOnlyList<IBrowserFile> attachments = args.GetMultipleFiles();
|
|
|
|
if (authStateProvider.CurrentUser is not null) {
|
|
await mrbService.UploadAttachments(attachments, mrbNumberInt);
|
|
|
|
mrbAttachments = await mrbService.GetAllAttachmentsForMRB(mrbNumberInt, true);
|
|
|
|
attachmentUploadInProcess = false;
|
|
|
|
StateHasChanged();
|
|
}
|
|
} catch (Exception ex) {
|
|
attachmentUploadInProcess = false;
|
|
snackbar.Add($"Unable to upload attachments, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void DeleteAttachment(MRBAttachment mrbAttachment) {
|
|
if (!deleteAttachmentInProcess) {
|
|
deleteAttachmentInProcess = true;
|
|
try {
|
|
if (mrbAttachment is null)
|
|
throw new ArgumentNullException("Attachment cannot be null");
|
|
|
|
await mrbService.DeleteAttachment(mrbAttachment);
|
|
|
|
List<MRBAttachment> mrbAttachmentList = mrbAttachments.ToList();
|
|
mrbAttachmentList.RemoveAll(x => x.AttachmentID == mrbAttachment.AttachmentID);
|
|
mrbAttachments = mrbAttachmentList;
|
|
|
|
snackbar.Add("Attachment successfully deleted", Severity.Success);
|
|
} catch (Exception ex) {
|
|
snackbar.Add(ex.Message, Severity.Error);
|
|
}
|
|
deleteAttachmentInProcess = false;
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private async Task SpecsImpactedChanged(bool newValue) {
|
|
if (mrb is not null) {
|
|
mrb.SpecsImpacted = newValue;
|
|
if (!newValue) mrb.ProcessECNNumber = 0;
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private async Task CustomerImpactedChanged(bool newValue) {
|
|
if (mrb is not null) {
|
|
mrb.CustomerImpacted = newValue;
|
|
if (!newValue) mrb.CustomerImpactedName = "";
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private bool FilterFuncForMRBAttachmentTable(MRBAttachment attachment) => MRBAttachmentFilterFunc(attachment, attachmentSearchString);
|
|
|
|
private bool MRBAttachmentFilterFunc(MRBAttachment attachment, string searchString) {
|
|
if (string.IsNullOrWhiteSpace(searchString))
|
|
return true;
|
|
|
|
string search = searchString.ToLower();
|
|
if (attachment.FileName.ToLower().Contains(search))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private async Task<string> PCRBNoIsValid(string id) {
|
|
string? result = await pcrbService.IdIsValid(id);
|
|
if (result is null) pcrbNoIsValid = true;
|
|
else pcrbNoIsValid = false;
|
|
StateHasChanged();
|
|
return result;
|
|
}
|
|
|
|
private async Task<string> ECNNoIsValid(int ecnNumber) {
|
|
string? result = await ecnService.ECNNumberIsValidStr(ecnNumber);
|
|
if (result is null) processEcnIsValid = true;
|
|
else processEcnIsValid = false;
|
|
StateHasChanged();
|
|
return result;
|
|
}
|
|
|
|
private async Task ReassignApproval(Approval approval) {
|
|
try {
|
|
if (approval is null) throw new ArgumentNullException("approval cannot be null");
|
|
|
|
if (approval.CompletedDate < DateTimeUtilities.MAX_DT || approval.ItemStatus != 0)
|
|
throw new ArgumentException("cannot reassign a complete approval");
|
|
|
|
User? selectedUser = null;
|
|
DialogParameters<MRBApproverSelector> parameters = new DialogParameters<MRBApproverSelector> { { x => x.selectedUser, selectedUser } };
|
|
var dialog = dialogService.Show<MRBApproverSelector>($"Select a new approver", parameters);
|
|
|
|
var result = await dialog.Result;
|
|
|
|
if (!result.Canceled) {
|
|
selectedUser = (User)result.Data;
|
|
}
|
|
|
|
if (selectedUser is null) throw new Exception("you must select a new approver");
|
|
|
|
if (selectedUser.UserID == approval.UserID)
|
|
throw new Exception("new approver must be different from current approver");
|
|
|
|
await SetUserForApproval(approval, selectedUser);
|
|
|
|
snackbar.Add($"Successfully reassigned approval", Severity.Success);
|
|
} catch (Exception ex) {
|
|
snackbar.Add($"Unable to reassign approval, because {ex.Message}", Severity.Error);
|
|
}
|
|
}
|
|
|
|
private async Task SetUserForApproval(Approval approval, User user) {
|
|
if (approval is null) throw new ArgumentNullException("approval cannot be null");
|
|
if (user is null) throw new ArgumentNullException("user cannot be null");
|
|
|
|
if (approval.CompletedDate < DateTimeUtilities.MAX_DT || approval.ItemStatus != 0)
|
|
throw new ArgumentException("cannot reassign a complete approval");
|
|
|
|
approval.UserID = user.UserID;
|
|
approval.User = user;
|
|
approval.NotifyDate = DateTimeUtilities.MIN_DT;
|
|
|
|
await approvalService.UpdateApproval(approval);
|
|
await approvalService.GetApprovalsForIssueId(approval.IssueID, true);
|
|
|
|
MRB mrb = await mrbService.GetMRBById(approval.IssueID, true);
|
|
await mrbService.NotifyNewApprovals(mrb);
|
|
}
|
|
|
|
private int GetTotalActionQuantities() {
|
|
int total = 0;
|
|
foreach (MRBAction action in mrbActions) {
|
|
total += action.Quantity;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
private IEnumerable<string> GetPartNumbers() {
|
|
HashSet<string> partNumbers = new();
|
|
foreach (MRBAction action in mrbActions) {
|
|
partNumbers.Add(action.PartNumber);
|
|
}
|
|
return partNumbers;
|
|
}
|
|
|
|
private IEnumerable<string> GetLotNumbers() {
|
|
HashSet<string> lotNumbers = new();
|
|
foreach (MRBAction action in mrbActions) {
|
|
lotNumbers.Add(action.LotNumber);
|
|
}
|
|
return lotNumbers;
|
|
}
|
|
|
|
private async Task<IEnumerable<string>> ToolSearch(string value) {
|
|
IEnumerable<Tool> matchingTools =
|
|
Tool.FqaTools.Where(t => t.Name.Contains(value, StringComparison.InvariantCultureIgnoreCase));
|
|
HashSet<string> toolNames = new();
|
|
foreach (Tool tool in matchingTools)
|
|
toolNames.Add(tool.Name);
|
|
return toolNames;
|
|
}
|
|
|
|
private void ProcessChanged(string selectedProcess) {
|
|
if (!selectedProcess.Equals(mrb.Process))
|
|
mrb.Tool = "";
|
|
|
|
mrb.Process = selectedProcess;
|
|
|
|
StateHasChanged();
|
|
}
|
|
|
|
private void DepartmentChanged(string selectedDepartment) {
|
|
if (!selectedDepartment.Equals(mrb.Department))
|
|
mrb.Process = "";
|
|
|
|
mrb.Department = selectedDepartment;
|
|
|
|
StateHasChanged();
|
|
}
|
|
}
|