Implemented member management of roles. Moved users controller

Moonlight.Api/Http/Controllers/Admin/RoleMembersController.cs

@@ -0,0 +1,166 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moonlight.Api.Database;
+using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Mappers;
+using Moonlight.Shared.Http.Responses;
+using Moonlight.Shared.Http.Responses.Users;
+
+namespace Moonlight.Api.Http.Controllers.Admin;
+
+[ApiController]
+[Route("api/admin/roles/{roleId:int}/members")]
+public class RoleMembersController : Controller
+{
+    private readonly DatabaseRepository<User> UsersRepository;
+    private readonly DatabaseRepository<Role> RolesRepository;
+    private readonly DatabaseRepository<RoleMember> RoleMembersRepository;
+
+    public RoleMembersController(
+        DatabaseRepository<User> usersRepository,
+        DatabaseRepository<Role> rolesRepository,
+        DatabaseRepository<RoleMember> roleMembersRepository
+    )
+    {
+        UsersRepository = usersRepository;
+        RolesRepository = rolesRepository;
+        RoleMembersRepository = roleMembersRepository;
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<PagedData<UserDto>>> GetAsync(
+        [FromRoute] int roleId,
+        [FromQuery] int startIndex, [FromQuery] int length,
+        [FromQuery] string? searchTerm
+    )
+    {
+        // Validation
+        if (startIndex < 0)
+            return Problem("Invalid start index specified", statusCode: 400);
+
+        if (length is < 1 or > 100)
+            return Problem("Invalid length specified");
+
+        // Query building
+
+        var query = RoleMembersRepository
+            .Query()
+            .Where(x => x.Role.Id == roleId)
+            .Select(x => x.User);
+
+        // Filtering
+        if (!string.IsNullOrWhiteSpace(searchTerm))
+        {
+            query = query.Where(x =>
+                EF.Functions.ILike(x.Username, $"%{searchTerm}%") ||
+                EF.Functions.ILike(x.Email, $"%{searchTerm}%")
+            );
+        }
+
+        // Pagination
+        var items = query
+            .Skip(startIndex)
+            .Take(length)
+            .ProjectToDto()
+            .ToArray();
+
+        var totalCount = await query.CountAsync();
+
+        return new PagedData<UserDto>(items, totalCount);
+    }
+
+    [HttpGet("available")]
+    public async Task<ActionResult<PagedData<UserDto>>> GetAvailableAsync(
+        [FromRoute] int roleId,
+        [FromQuery] int startIndex, [FromQuery] int length,
+        [FromQuery] string? searchTerm
+    )
+    {
+        // Validation
+        if (startIndex < 0)
+            return Problem("Invalid start index specified", statusCode: 400);
+
+        if (length is < 1 or > 100)
+            return Problem("Invalid length specified");
+
+        // Query building
+
+        var query = UsersRepository
+            .Query()
+            .Where(x => x.RoleMemberships.All(y => y.Role.Id != roleId));
+
+        // Filtering
+        if (!string.IsNullOrWhiteSpace(searchTerm))
+        {
+            query = query.Where(x =>
+                EF.Functions.ILike(x.Username, $"%{searchTerm}%") ||
+                EF.Functions.ILike(x.Email, $"%{searchTerm}%")
+            );
+        }
+
+        // Pagination
+        var items = query
+            .Skip(startIndex)
+            .Take(length)
+            .ProjectToDto()
+            .ToArray();
+
+        var totalCount = await query.CountAsync();
+
+        return new PagedData<UserDto>(items, totalCount);
+    }
+
+    [HttpPut("{userId:int}")]
+    public async Task<ActionResult> AddMemberAsync([FromRoute] int roleId, [FromRoute] int userId)
+    {
+        // Check and load role
+        var role = await RolesRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Id == roleId);
+
+        if (role == null)
+            return Problem("Role not found", statusCode: 404);
+
+        // Check and load user
+        var user = await UsersRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.Id == userId);
+
+        if (user == null)
+            return Problem("User not found", statusCode: 404);
+
+        // Check if a role member already exists with these details
+        var isUserInRole = await RoleMembersRepository
+            .Query()
+            .AnyAsync(x => x.Role.Id == roleId && x.User.Id == userId);
+
+        if (isUserInRole)
+            return Problem("User is already a member of this role", statusCode: 400);
+
+        var roleMember = new RoleMember
+        {
+            Role = role,
+            User = user
+        };
+
+        await RoleMembersRepository.AddAsync(roleMember);
+
+        return NoContent();
+    }
+
+    [HttpDelete("{userId:int}")]
+    public async Task<ActionResult> RemoveMemberAsync([FromRoute] int roleId, [FromRoute] int userId)
+    {
+        var roleMember = await RoleMembersRepository
+            .Query()
+            .FirstOrDefaultAsync(x => x.User.Id == userId && x.Role.Id == roleId);
+
+        if (roleMember == null)
+            return Problem("User is not a member of this role, the role does not exist or the user does not exist",
+                statusCode: 404);
+
+        await RoleMembersRepository.RemoveAsync(roleMember);
+
+        return NoContent();
+    }
+}

Moonlight.Api/Http/Controllers/Admin/UsersController.cs

@@ -1,19 +1,19 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Moonlight.Api.Database;
+using Moonlight.Api.Database.Entities;
+using Moonlight.Api.Mappers;
 using Moonlight.Shared.Http.Requests;
 using Moonlight.Shared.Http.Requests.Users;
 using Moonlight.Shared.Http.Responses;
 using Moonlight.Shared.Http.Responses.Users;
-using Moonlight.Api.Database;
-using Moonlight.Api.Database.Entities;
-using Moonlight.Api.Mappers;
 
-namespace Moonlight.Api.Http.Controllers;
+namespace Moonlight.Api.Http.Controllers.Admin;
 
 [Authorize]
 [ApiController]
-[Route("api/users")]
+[Route("api/admin/users")]
 public class UsersController : Controller
 {
     private readonly DatabaseRepository<User> UserRepository;