Moonlight/Moonlight.Frontend/UI/Admin/Views/Users/Roles.razor

@using LucideBlazor
@using Moonlight.Frontend.UI.Admin.Modals
@using Moonlight.Shared.Http.Requests
@using Moonlight.Shared.Http.Requests.Roles
@using Moonlight.Shared.Http.Responses
@using Moonlight.Shared.Http.Responses.Admin
@using ShadcnBlazor.DataGrids
@using ShadcnBlazor.Buttons
@using ShadcnBlazor.Dropdowns
@using ShadcnBlazor.Extras.AlertDialogs
@using ShadcnBlazor.Extras.Dialogs
@using ShadcnBlazor.Extras.Toasts
@using ShadcnBlazor.Tabels

@inject HttpClient HttpClient
@inject DialogService DialogService
@inject ToastService ToastService
@inject AlertDialogService AlertDialogService

<div class="flex flex-row justify-between mt-5">
    <div class="flex flex-col">
        <h1 class="text-xl font-semibold">Roles</h1>
        <div class="text-muted-foreground">
            Manage roles, their members and permissions
        </div>
    </div>
    <div class="flex flex-row gap-x-1.5">
        <Button @onclick="CreateAsync">
            <PlusIcon/>
            Create
        </Button>
    </div>
</div>

<div class="mt-3">
    <DataGrid @ref="Grid" TGridItem="RoleDto" Loader="LoadAsync" PageSize="10" ClassName="bg-card">
        <PropertyColumn Field="u => u.Id"/>
        <TemplateColumn Title="Name" IsFilterable="true" Identifier="@nameof(RoleDto.Name)">
            <HeadTemplate>
                <TableHead>Name</TableHead>
            </HeadTemplate>
            <CellTemplate>
                <TableCell>
                    <a class="text-primary" href="#" @onclick="_ => MembersAsync(context)" @onclick:preventDefault>
                        @context.Name
                    </a>
                </TableCell>
            </CellTemplate>
        </TemplateColumn>
        <PropertyColumn Title="Description" Field="r => r.Description"/>
        <PropertyColumn Title="Members" Field="r => r.MemberCount"/>
        <TemplateColumn>
            <CellTemplate>
                <TableCell>
                    <div class="flex flex-row items-center justify-end me-3">
                        <DropdownMenu>
                            <DropdownMenuTrigger>
                                <Slot Context="dropdownSlot">
                                    <Button Size="ButtonSize.IconSm" Variant="ButtonVariant.Ghost"
                                            @attributes="dropdownSlot">
                                        <EllipsisIcon/>
                                    </Button>
                                </Slot>
                            </DropdownMenuTrigger>
                            <DropdownMenuContent SideOffset="2">
                                <DropdownMenuItem OnClick="() => MembersAsync(context)">
                                    Members
                                    <DropdownMenuShortcut>
                                        <UsersRoundIcon/>
                                    </DropdownMenuShortcut>
                                </DropdownMenuItem>
                                <DropdownMenuItem OnClick="() => EditAsync(context)">
                                    Edit
                                    <DropdownMenuShortcut>
                                        <PenIcon/>
                                    </DropdownMenuShortcut>
                                </DropdownMenuItem>
                                <DropdownMenuItem OnClick="() => DeleteAsync(context)"
                                                  Variant="DropdownMenuItemVariant.Destructive">
                                    Delete
                                    <DropdownMenuShortcut>
                                        <TrashIcon/>
                                    </DropdownMenuShortcut>
                                </DropdownMenuItem>
                            </DropdownMenuContent>
                        </DropdownMenu>
                    </div>
                </TableCell>
            </CellTemplate>
        </TemplateColumn>
    </DataGrid>
</div>

@code
{
    private DataGrid<RoleDto> Grid;

    private async Task<DataGridResponse<RoleDto>> LoadAsync(DataGridRequest<RoleDto> request)
    {
        var query = $"?startIndex={request.StartIndex}&length={request.Length}";
        var filterOptions = request.Filters.Count > 0 ? new FilterOptions(request.Filters) : null;

        var response = await HttpClient.GetFromJsonAsync<PagedData<RoleDto>>(
            $"api/admin/roles{query}&filterOptions={filterOptions}",
            Constants.SerializerOptions
        );

        return new DataGridResponse<RoleDto>(response!.Data, response.TotalLength);
    }

    private async Task CreateAsync()
    {
        await DialogService.LaunchAsync<CreateRoleDialog>(parameters =>
        {
            parameters[nameof(CreateRoleDialog.OnSubmit)] = async Task (CreateRoleDto request) =>
            {
                await HttpClient.PostAsJsonAsync(
                    "api/admin/roles",
                    request,
                    Constants.SerializerOptions
                );

                await ToastService.SuccessAsync("Role creation", $"Role {request.Name} has been successfully created");
                await Grid.RefreshAsync();
            };
        });
    }

    private async Task EditAsync(RoleDto role)
    {
        await DialogService.LaunchAsync<UpdateRoleDialog>(parameters =>
        {
            parameters[nameof(UpdateRoleDialog.Role)] = role;
            parameters[nameof(UpdateRoleDialog.OnSubmit)] = async Task (UpdateRoleDto request) =>
            {
                await HttpClient.PatchAsJsonAsync(
                    $"api/admin/roles/{role.Id}",
                    request,
                    Constants.SerializerOptions
                );

                await ToastService.SuccessAsync("Role update", $"Role {request.Name} has been successfully updated");
                await Grid.RefreshAsync();
            };
        });
    }

    private async Task MembersAsync(RoleDto role)
    {
        await DialogService.LaunchAsync<ManageRoleMembersDialog>(parameters => { parameters[nameof(ManageRoleMembersDialog.Role)] = role; }, model => { model.ClassName = "sm:max-w-xl"; });
    }

    private async Task DeleteAsync(RoleDto role)
    {
        await AlertDialogService.ConfirmDangerAsync(
            $"Deletion of role {role.Name}",
            $"Do you really want to delete the role {role.Name} with {role.MemberCount} members? This action cannot be undone",
            async () =>
            {
                await HttpClient.DeleteAsync($"api/admin/roles/{role.Id}");
                await ToastService.SuccessAsync("User deletion", $"Successfully deleted role {role.Name}");

                await Grid.RefreshAsync();
            }
        );
    }
}