mesa-fab-approval/MesaFabApproval.Client/Pages/Components/PCRBApproverForm.razor

@inject MesaFabApprovalAuthStateProvider authStateProvider
@inject NavigationManager navigationManager
@inject IPCRBService pcrbService
@inject IUserService userService
@inject IApprovalService approvalService
@inject ISnackbar snackbar

<MudDialog>
    <DialogContent>
        <MudPaper Class="m-2 p-2">
            <MudForm @bind-Errors="@errors">
                <MudSelect T="string"
                              Label="Job Title"
                              Required
                              RequiredError="You must provide a job title"
                              ValueChanged="@SelectedJobTitleChanged"
                              @bind-Text="@selectedJobTitle"
                              Immediate
                              Disabled="@(approval is not null && !string.IsNullOrWhiteSpace(selectedJobTitle))"
                              Clearable
                              AutoFocus >
                    @foreach (string jt in availableJobTitles) {
                        <MudSelectItem Value="@jt">@jt</MudSelectItem>
                    }
                </MudSelect>
                <MudSelect T="User"
                           Label="Select a User"
                           Required
                           Clearable
                           Disabled="@(string.IsNullOrWhiteSpace(selectedJobTitle))"
                           Variant="Variant.Outlined"
                           AnchorOrigin="Origin.BottomCenter"
                           @bind-Value=selectedUser
                           ToStringFunc="@UserToNameConverter">
                    @foreach (User user in availableUsers) {
                        <MudSelectItem Value="@user">@user.GetFullName()</MudSelectItem>
                    }
                </MudSelect>
            </MudForm>
        </MudPaper>
    </DialogContent>
    <DialogActions>
        <MudButton Variant="Variant.Filled"
                   Color="Color.Tertiary"
                   Class="m1-auto"
                   OnClick=Save>
            @if (saveAttendeeInProcess) {
                <MudProgressCircular Class="m-1" Size="Size.Small" Indeterminate="true" />
                <MudText>Processing</MudText>
            } else {
                <MudText>Submit</MudText>
            }
        </MudButton>
        <MudButton Variant="Variant.Filled"
                   Class="grey text-black m1-auto"
                   OnClick=Cancel>
            Cancel
        </MudButton>
    </DialogActions>
</MudDialog>

@code {
    [CascadingParameter] 
    MudDialogInstance MudDialog { get; set; }

    [Parameter]
    public int planNumber { get; set; } = 0;

    [Parameter]
    public int step { get; set; } = 0;

    [Parameter]
    public Approval? approval { get; set; } = null;

    private HashSet<string> availableJobTitles = new();

    private Dictionary<string, SubRole> jobTitleToSubRoleMap = new();

    private Dictionary<string, IEnumerable<User>> jobTitleToAvailableUsersMap = new();

    private HashSet<User> availableUsers = new();

    private string[] errors = { };

    private string selectedJobTitle = "";
    private User? selectedUser = null;

    private bool saveAttendeeInProcess = false;

    protected override async Task OnParametersSetAsync() {
        if (authStateProvider.CurrentUser is null) {
            await authStateProvider.Logout();
            navigationManager.NavigateTo("login");
        }

        if (planNumber <= 0) {
            snackbar.Add($"{planNumber} is not a valid PCRB plan#", Severity.Error);
            MudDialog.Close(DialogResult.Cancel());
        }

        await GetAttendees();

        if (approval is not null) {
            selectedJobTitle = approval.RoleName;
            if (approval.UserID > 0) {
                if (approval.User is not null) {
                    selectedUser = approval.User;
                } else {
                    selectedUser = await userService.GetUserByUserId(approval.UserID);
                    approval.User = selectedUser;
                }
            }

            SelectedJobTitleChanged(selectedJobTitle);
        } else {
            selectedJobTitle = "";
            selectedUser = null;
        }
    }

    private async Task Save() {
        saveAttendeeInProcess = true;
        try {
            if (authStateProvider.CurrentUser is null) {
                await authStateProvider.Logout();
                navigationManager.NavigateTo("login");
            }

            if (string.IsNullOrWhiteSpace(selectedJobTitle)) throw new Exception("job title missing");
            if (selectedUser is null) throw new Exception("attendee not selected");

            PCRB pcrb = await pcrbService.GetPCRBByPlanNumber(planNumber, false);

            if (approval is null) {
                jobTitleToSubRoleMap.TryGetValue($"{selectedJobTitle}{selectedUser.UserID}", out SubRole? subRole);

                if (subRole is null) throw new Exception($"no approval role found for job title {selectedJobTitle}");

                approval = new() {
                    RoleName = subRole.SubRoleCategoryItem,
                    SubRole = subRole.SubRoleName,
                    SubRoleID = subRole.SubRoleID,
                    IssueID = planNumber,
                    Step = step,
                    User = selectedUser,
                    UserID = selectedUser.UserID,
                    AssignedDate = DateTimeUtilities.MIN_DT
                };

                await approvalService.CreateApproval(approval);
            } else {
                int originalUserId = approval.UserID;

                approval.UserID = selectedUser.UserID;
                approval.User = selectedUser;

                if (originalUserId != approval.UserID) {
                    if (approval.AssignedDate > DateTimeUtilities.MIN_DT)
                        approval.AssignedDate = DateTime.Now;
                    approval.NotifyDate = DateTimeUtilities.MIN_DT;
                }

                await approvalService.UpdateApproval(approval);

                if (originalUserId != approval.UserID)
                    await pcrbService.NotifyNewApprovals(pcrb);
            }

            saveAttendeeInProcess = false;

            MudDialog.Close(DialogResult.Ok(approval));
        } catch (Exception ex) {
            saveAttendeeInProcess = false;
            snackbar.Add($"Unable to save attendee, because {ex.Message}", Severity.Error);
        }
    }

    private void Cancel() {
        MudDialog.Close(DialogResult.Cancel());
    }

    private Func<User, string> UserToNameConverter = u => u is null ? string.Empty : u.GetFullName();

    private async Task GetAttendees() {
        int roleId = await approvalService.GetRoleIdForRoleName("Module Manager");

        if (roleId <= 0) throw new Exception($"could not find Director role ID");

        availableJobTitles.Clear();
        jobTitleToAvailableUsersMap.Clear();
        jobTitleToSubRoleMap.Clear();

        IEnumerable<SubRole> subRoles = await approvalService.GetSubRolesForSubRoleName("MMSubRole", roleId);

        HashSet<string> defaultSubRoleCategoryItems = new() { "Si Production", "Si Engineering", "Quality" };
        HashSet<string> unusedSubRoleCategoryItems = new() { "GaN Engineering", "GaN Operations", "Integration" };
        foreach (SubRole subRole in subRoles) {
            if (approval is null) {
                if (!defaultSubRoleCategoryItems.Contains(subRole.SubRoleCategoryItem) && 
                    !unusedSubRoleCategoryItems.Contains(subRole.SubRoleCategoryItem)) {
                    availableJobTitles.Add(subRole.SubRoleCategoryItem);

                    IEnumerable<User> subRoleMembers = await approvalService.GetApprovalGroupMembers(subRole.SubRoleID);

                    jobTitleToAvailableUsersMap.Add(subRole.SubRoleCategoryItem, subRoleMembers);

                    foreach (User member in subRoleMembers) {
                        jobTitleToSubRoleMap.Add($"{subRole.SubRoleCategoryItem}{member.UserID}", subRole);
                    }
                }
            } else {
                if (!unusedSubRoleCategoryItems.Contains(subRole.SubRoleCategoryItem)) {
                    IEnumerable<User> subRoleMembers = await approvalService.GetApprovalGroupMembers(subRole.SubRoleID);

                    jobTitleToAvailableUsersMap.Add(subRole.SubRoleCategoryItem, subRoleMembers);

                    foreach (User member in subRoleMembers)
                        availableUsers.Add(member);
                }
            }
        }
    }

    private void SelectedJobTitleChanged(string jobTitle) {
        selectedJobTitle = jobTitle;

        selectedUser = null;

        availableUsers.Clear();

        if (approval is null) {
            if (jobTitleToAvailableUsersMap.TryGetValue(jobTitle, out IEnumerable<User>? jobTitleMembers)) {
                if (jobTitleMembers is not null) {
                    foreach (User member in jobTitleMembers)
                        availableUsers.Add(member);
                }
            }
        } else {
            foreach (IEnumerable<User> memberList in jobTitleToAvailableUsersMap.Values) {
                if (memberList is not null) {
                    foreach(User member in memberList) {
                        availableUsers.Add(member);
                    }
                }
            }
        }

        StateHasChanged();
    }
}