feat: implement soft delete for users and roles (#17)

Author: osm-Jatin

src/Api/Api.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="AspNetCore.HealthChecks.UI" Version="9.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.2" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.13">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -21,6 +22,8 @@
     <PackageReference Include="Swashbuckle.AspNetCore" Version="7.1.0" />
     <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="9.0.0" />
     <PackageReference Include="AspNetCore.HealthChecks.UI.InMemory.Storage" Version="9.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="7.2.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.1.2" />
   </ItemGroup>
 
   <ItemGroup>

src/Api/Controllers/RoleController.cs

@@ -1,3 +1,5 @@
+using Api.Models.Common;
+using Api.Models.Enums;
 using Core.Entities.DTOs;
 using Core.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
@@ -16,67 +18,76 @@ public RoleController(IRoleService roleService)
     }
 
     [HttpGet("{id}")]
-    public async Task<IActionResult> GetRoleById(int id)
+    public async Task<ActionResult<BaseResponse<RoleResponseDto>>> GetRoleById(int id)
     {
+        BaseResponse<RoleResponseDto> response = new(ResponseStatus.Success);
         RoleResponseDto? role = await _roleService.GetRoleByIdAsync(id).ConfigureAwait(false);
-        if (role == null)
-        {
-            return NotFound(new { message = "Role not found" });
-        }
-
-        return Ok(role);
+        response.Data = role;
+        response.Message = "Role retrieved successfully";
+        return Ok(response);
     }
 
     [HttpGet]
-    public async Task<IActionResult> GetAllRoles()
+    public async Task<ActionResult<BaseResponse<IEnumerable<RoleResponseDto>>>> GetAllRoles([FromQuery] int pageNumber = 1, [FromQuery] int pageSize = 10)
     {
-        IEnumerable<RoleResponseDto> roles = await _roleService.GetAllRolesAsync().ConfigureAwait(false);
-        return Ok(roles);
+        BaseResponse<IEnumerable<RoleResponseDto>> response = new(ResponseStatus.Success);
+        IEnumerable<RoleResponseDto> roles = await _roleService.GetAllRolesAsync(pageNumber, pageSize).ConfigureAwait(false);
+        int totalCount = await _roleService.GetTotalRolesCountAsync().ConfigureAwait(false);
+        int totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);
+
+        response.Data = roles;
+        response.Message = "Roles retrieved successfully";
+        response.Pagination = new PaginationMetadata
+        {
+            PageNumber = pageNumber,
+            PageSize = pageSize,
+            TotalCount = totalCount,
+            TotalPages = totalPages,
+            HasPreviousPage = pageNumber > 1,
+            HasNextPage = pageNumber < totalPages
+        };
+        return Ok(response);
     }
 
     [HttpPost]
-    public async Task<IActionResult> CreateRole([FromBody] RoleCreateDto roleDto)
+    public async Task<ActionResult<BaseResponse<RoleResponseDto?>>> CreateRole([FromBody] RoleCreateDto roleDto)
     {
+        BaseResponse<RoleResponseDto> response = new(ResponseStatus.Success);
         if (!ModelState.IsValid)
         {
-            return BadRequest(ModelState);
+            return ModelValidationBadRequest.GenerateErrorResponse(ModelState);
         }
 
         RoleResponseDto? createdRole = await _roleService.CreateRoleAsync(roleDto).ConfigureAwait(false);
-        if (createdRole == null)
-        {
-            return BadRequest(new { message = "Failed to create role" });
-        }
-
-        return CreatedAtAction(nameof(GetRoleById), new { id = createdRole.Id }, createdRole);
+        response.Data = createdRole;
+        response.Message = "Role created successfully";
+        return Ok(response);
     }
 
     [HttpPut("{id}")]
-    public async Task<IActionResult> UpdateRole(int id, [FromBody] RoleUpdateDto roleDto)
+    public async Task<ActionResult<BaseResponse<RoleResponseDto>>> UpdateRole(int id, [FromBody] RoleUpdateDto roleDto)
     {
+        BaseResponse<RoleResponseDto> response = new(ResponseStatus.Success);
         if (!ModelState.IsValid)
         {
-            return BadRequest(ModelState);
+            return ModelValidationBadRequest.GenerateErrorResponse(ModelState);
         }
 
-        bool success = await _roleService.UpdateRoleAsync(id, roleDto).ConfigureAwait(false);
-        if (!success)
-        {
-            return NotFound(new { message = "Role not found or update failed" });
-        }
+        RoleResponseDto? updatedRole = await _roleService.UpdateRoleAsync(id, roleDto).ConfigureAwait(false);
 
-        return NoContent();
+        response.Data = updatedRole;
+        response.Message = "Role updated successfully";
+        return Ok(response);
     }
 
     [HttpDelete("{id}")]
-    public async Task<IActionResult> DeleteRole(int id)
+    public async Task<ActionResult<BaseResponse<bool>>> DeleteRole(int id)
     {
-        bool success = await _roleService.DeleteRoleAsync(id).ConfigureAwait(false);
-        if (!success)
-        {
-            return NotFound(new { message = "Role not found or deletion failed" });
-        }
+        BaseResponse<bool> response = new(ResponseStatus.Success);
+        bool isDeleted = await _roleService.DeleteRoleAsync(id).ConfigureAwait(false);
 
-        return NoContent();
+        response.Data = isDeleted;
+        response.Message = "Role deactivated successfully";
+        return Ok(response);
     }
 }

src/Api/Controllers/UserController.cs

@@ -1,5 +1,8 @@
+using Api.Models.Common;
+using Api.Models.Enums;
 using Core.Entities.DTOs;
 using Core.Services.Interfaces;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
 namespace Api.Controllers;
@@ -15,55 +18,105 @@ public UserController(IUserService userService)
         _userService = userService;
     }
 
+    [Authorize]
     [HttpGet("{id}")]
-    public async Task<IActionResult> GetUserById(int id)
+    public async Task<ActionResult<BaseResponse<UserResponseDto>>> GetUserById(int id)
     {
+        BaseResponse<UserResponseDto> response = new(ResponseStatus.Success);
         UserResponseDto? user = await _userService.GetUserByIdAsync(id).ConfigureAwait(false);
-        return user == null ? NotFound(new { message = "User not found" }) : Ok(user);
+
+        response.Data = user;
+        response.Message = "User retrieved successfully";
+        return Ok(response);
     }
 
+    [Authorize]
     [HttpGet("email/{email}")]
-    public async Task<IActionResult> GetUserByEmail(string email)
+    public async Task<ActionResult<BaseResponse<UserResponseDto>>> GetUserByEmail(string email)
     {
+        BaseResponse<UserResponseDto> response = new(ResponseStatus.Success);
         UserResponseDto? user = await _userService.GetUserByEmailAsync(email).ConfigureAwait(false);
-        return user == null ? NotFound(new { message = "User not found" }) : Ok(user);
+
+        response.Data = user;
+        response.Message = "User retrieved successfully";
+        return Ok(response);
     }
 
+    [Authorize(Roles = "Admin")]
     [HttpGet]
-    public async Task<IActionResult> GetAllUsers()
+    public async Task<ActionResult<BaseResponse<IEnumerable<UserResponseDto>>>> GetAllUsers([FromQuery] int pageNumber = 1, [FromQuery] int pageSize = 10)
+    {
+        BaseResponse<IEnumerable<UserResponseDto>> response = new(ResponseStatus.Success);
+        IEnumerable<UserResponseDto> users = await _userService.GetAllUsersAsync(pageNumber, pageSize).ConfigureAwait(false);
+        int totalCount = await _userService.GetTotalUsersCountAsync().ConfigureAwait(false);
+        int totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);
+
+        response.Data = users;
+        response.Message = "Users retrieved successfully";
+        response.Pagination = new PaginationMetadata
+        {
+            PageNumber = pageNumber,
+            PageSize = pageSize,
+            TotalCount = totalCount,
+            TotalPages = totalPages,
+            HasPreviousPage = pageNumber > 1,
+            HasNextPage = pageNumber < totalPages
+        };
+        return Ok(response);
+    }
+
+    [HttpPost("login")]
+    public async Task<ActionResult<BaseResponse<string>>> Login([FromBody] LoginRequestDto loginDto)
     {
-        IEnumerable<UserResponseDto> users = await _userService.GetAllUsersAsync().ConfigureAwait(false);
-        return Ok(users);
+        BaseResponse<string> response = new(ResponseStatus.Success);
+        string? token = await _userService.Login(loginDto.Email, loginDto.Password).ConfigureAwait(false);
+        response.Data = token;
+        response.Message = "Login Successful";
+        return Ok(response);
     }
 
+
     [HttpPost("register")]
-    public async Task<IActionResult> RegisterUser([FromBody] UserCreateDto userDto)
+    public async Task<ActionResult<BaseResponse<UserResponseDto>>> RegisterUser([FromBody] UserCreateDto userDto)
     {
+        BaseResponse<UserResponseDto> response = new(ResponseStatus.Success);
         if (!ModelState.IsValid)
         {
-            return BadRequest(ModelState);
+            return ModelValidationBadRequest.GenerateErrorResponse(ModelState);
         }
+        UserResponseDto? createdUser = await _userService.AddUserAsync(userDto).ConfigureAwait(false);
 
-        bool success = await _userService.AddUserAsync(userDto).ConfigureAwait(false);
-        return success ? StatusCode(201, new { message = "User registered successfully" }) : BadRequest(new { message = "Failed to register user" });
+        response.Data = createdUser;
+        response.Message = "User registered successfully";
+        return Ok(response);
     }
 
+    [Authorize]
     [HttpPut("{id}")]
-    public async Task<IActionResult> UpdateUser(int id, [FromBody] UserUpdateDto userDto)
+    public async Task<ActionResult<BaseResponse<UserResponseDto>>> UpdateUser(int id, [FromBody] UserUpdateDto userDto)
     {
+        BaseResponse<UserResponseDto> response = new(ResponseStatus.Success);
         if (!ModelState.IsValid)
         {
-            return BadRequest(ModelState);
+            return ModelValidationBadRequest.GenerateErrorResponse(ModelState);
         }
 
-        bool success = await _userService.UpdateUserAsync(id, userDto).ConfigureAwait(false);
-        return success ? NoContent() : NotFound(new { message = "User not found or update failed" });
+        UserResponseDto? updatedUser = await _userService.UpdateUserAsync(id, userDto).ConfigureAwait(false);
+
+        response.Data = updatedUser;
+        response.Message = "User updated successfully";
+        return Ok(response);
     }
 
+    [Authorize(Roles = "Admin")]
     [HttpDelete("{id}")]
-    public async Task<IActionResult> DeleteUser(int id)
+    public async Task<ActionResult<BaseResponse<bool>>> DeleteUser(int id)
     {
-        bool success = await _userService.DeleteUserAsync(id).ConfigureAwait(false);
-        return success ? NoContent() : NotFound(new { message = "User not found or deletion failed" });
+        BaseResponse<bool> response = new(ResponseStatus.Success);
+        bool isDeleted = await _userService.DeleteUserAsync(id).ConfigureAwait(false);
+
+        response.Data = isDeleted;
+        response.Message = "User deactivated successfully";
+        return Ok(response);
     }
 }

src/Api/Filters/CustomExceptionFilter.cs

@@ -5,12 +5,6 @@
 using Core.Exceptions;
 using Microsoft.AspNetCore.Http;
 
-// /*
-// Added to suppress the following warning :
-// Warning : Add a public read-only property accessor for positional argument logger of Attribute CustomExceptionFilter
-// */
-// #pragma warning disable CA1019
-
 namespace Api.Filters;
 
 public class CustomExceptionFilter : ExceptionFilterAttribute
@@ -24,26 +18,28 @@ public CustomExceptionFilter(ILogger<CustomExceptionFilter> logger)
 
     public override void OnException(ExceptionContext context)
     {
-        BaseResponse<int> response = new BaseResponse<int>(ResponseStatus.Error);
+        BaseResponse<int> response = new BaseResponse<int>(ResponseStatus.Fail);
 
-        (int statusCode, string message) = context.Exception switch
+        (int statusCode, string message, ResponseStatus status) = context.Exception switch
         {
-            UnauthorizedAccessException ex => (StatusCodes.Status401Unauthorized, ex.Message),
-            NotFoundException ex => (StatusCodes.Status404NotFound, ex.Message),
-            BadRequestException ex => (StatusCodes.Status400BadRequest, ex.Message),
-            AlreadyExistsException ex => (StatusCodes.Status409Conflict, ex.Message),
+            UnauthorizedAccessException ex => (StatusCodes.Status401Unauthorized, ex.Message, ResponseStatus.Fail),
+            NotFoundException ex => (StatusCodes.Status404NotFound, ex.Message, ResponseStatus.Fail),
+            BadRequestException ex => (StatusCodes.Status400BadRequest, ex.Message, ResponseStatus.Fail),
+            AlreadyExistsException ex => (StatusCodes.Status409Conflict, ex.Message, ResponseStatus.Fail),
+            DatabaseOperationException ex => (StatusCodes.Status500InternalServerError, ex.Message, ResponseStatus.Error),
             _ => HandleUnexpectedException(context.Exception)
         };
+        response.Status = status;
         response.Message = message;
         context.Result = new JsonResult(response)
         {
             StatusCode = statusCode
         };
     }
 
-    private (int StatusCode, string Message) HandleUnexpectedException(Exception ex)
+    private (int StatusCode, string Message, ResponseStatus status) HandleUnexpectedException(Exception ex)
     {
         _logger.LogError(ex, "An unexpected error occurred");
-        return (StatusCodes.Status500InternalServerError, "An unexpected error occurred. Please try again later.");
+        return (StatusCodes.Status500InternalServerError, "An unexpected error occurred. Please try again later.", ResponseStatus.Error);
     }
 }

src/Api/Models/Common/BaseResponse.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
 using Api.Models.Enums;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 
 namespace Api.Models.Common;
 
@@ -52,48 +53,56 @@ public class BaseResponse<T>
 public class ModelValidationBadRequest
 {
     /// <summary>
-    /// Generates a BadRequestObjectResult based on the model state errors.
+    /// Generates a standardized BadRequest response with model validation errors.
     /// </summary>
-    /// <param name="actionContext">The action context containing the model state.</param>
+    /// <param name="modelState">The model state containing validation errors.</param>
     /// <returns>A BadRequestObjectResult encapsulating the validation errors.</returns>
-    public static BadRequestObjectResult ModelValidationErrorResponse(ActionContext actionContext)
+    public static BadRequestObjectResult GenerateErrorResponse(ModelStateDictionary modelState)
     {
         return new BadRequestObjectResult(new BaseResponse<int>(ResponseStatus.Error)
         {
-            Errors = actionContext.ModelState
-                .Where(modelError => modelError.Value != null && modelError.Value.Errors.Any())
+            Errors = modelState
+                .Where(entry => entry.Value != null && entry.Value.Errors.Any())
                 .ToDictionary(
-                    modelError => modelError.Key,
-                    modelError => modelError.Value != null
-                            ? modelError.Value.Errors.Select(e => e.ErrorMessage).ToList()
-                            : new List<string>()
+                    entry => entry.Key,
+                    entry => entry.Value!.Errors.Select(error => error.ErrorMessage).ToList()
                 )
         });
     }
 }
 
 /// <summary>
-/// Provides utilities for generating bad request responses based on model validation errors.
+/// Represents metadata for paginated responses, including page details and navigation indicators.
 /// </summary>
 public class PaginationMetadata
 {
+    /// <summary>
+    /// Gets or sets the current page number.
+    /// </summary>
+    public int PageNumber { get; set; }
+
     /// <summary>
     /// Gets or sets the number of items per page.
     /// </summary>
     public int PageSize { get; set; }
 
     /// <summary>
-    /// Gets or sets the total count of items (if available).
+    /// Gets or sets the total number of items.
     /// </summary>
-    public int? TotalCount { get; set; }
+    public int TotalCount { get; set; }
 
     /// <summary>
-    /// Gets or sets the cursor for the previous page.
+    /// Gets or sets the total number of pages.
     /// </summary>
-    public DateTime? PrevCursor { get; set; }
+    public int TotalPages { get; set; }
 
     /// <summary>
-    /// Gets or sets the cursor for the next page.
+    /// Gets or sets a value indicating whether there is a previous page.
     /// </summary>
-    public DateTime? NextCursor { get; set; }
-}
+    public bool HasPreviousPage { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether there is a next page.
+    /// </summary>
+    public bool HasNextPage { get; set; }
+}