Fix Interface names, controller error handling, and RESTful API endpoints

Backend/prepAIred.API/Controllers/AuthController.cs

@@ -1,5 +1,6 @@
 using prepAIred.Data;
 using prepAIred.Services;
+using prepAIred.Exceptions;
 using Microsoft.AspNetCore.Mvc;
 
 namespace prepAIred.API
@@ -9,43 +10,107 @@ namespace prepAIred.API
     /// </summary>
     /// <remarks>
     /// This controller is responsible for handling HTTP requests related to authentication flows. It interacts 
-    /// with the <see cref="IAuthRepository"/> for authentication operations and <see cref="IRefreshTokenRepository"/> for token management.
+    /// with the <see cref="IAuthService"/> for authentication operations and <see cref="IRefreshTokenService"/> for token management.
     /// </remarks>
-    /// <param name="authRepository">Repository for handling authentication operations</param>
-    /// <param name="refreshTokenRepository">Repository for managing refresh tokens</param>
+    /// <param name="authService">Repository for handling authentication operations</param>
+    /// <param name="refreshTokenService">Repository for managing refresh tokens</param>
     [ApiController]
-    [Route("api/[controller]")]
-    public class AuthController(IAuthRepository authRepository, IRefreshTokenRepository refreshTokenRepository) : Controller
+    [Route("api/auth")]
+    public class AuthController(IAuthService authService, IRefreshTokenService refreshTokenService) : Controller
     {
-        private readonly IAuthRepository _authRepository = authRepository;
-        private readonly IRefreshTokenRepository _refreshTokenService = refreshTokenRepository;
+        private readonly IAuthService _authService = authService;
+        private readonly IRefreshTokenService _refreshTokenService = refreshTokenService;
 
         [HttpPost("register")]
         public async Task<ActionResult> Register([FromBody] UserCredentialsDTO userCredentialsDto)
         {
-            await _authRepository.RegisterAsync(userCredentialsDto);
-            return Ok("Register successful");
+            try
+            {
+                await _authService.RegisterAsync(userCredentialsDto);
+                return Ok("Register successful");
+            }
+            catch (InvalidCredentialsException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (UserAlreadyExistsException ex)
+            {
+                return Conflict(ex.Message);
+            }
+            catch (EmptyFieldsException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
         [HttpPost("login")]
         public async Task<ActionResult> Login([FromBody] LoginDTO loginDto)
         {
-            await _authRepository.LoginAsync(loginDto);
-            return Ok("Login successful");
+            try
+            {
+                await _authService.LoginAsync(loginDto);
+                return Ok("Login successful");
+            }
+            catch (InvalidCredentialsException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (EmptyFieldsException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
         [HttpPost("refresh-token")]
         public async Task<IActionResult> GenerateNewRefreshToken()
         {
-            RefreshTokenResponseDTO newRefreshToken = await _refreshTokenService.GenerateNewRefreshTokenAsync();
-            return Ok(newRefreshToken);
+            try
+            {
+                RefreshTokenResponseDTO newRefreshToken = await _refreshTokenService.GenerateNewRefreshTokenAsync();
+                return Ok(newRefreshToken);
+            }
+            catch (InvalidRefreshTokenException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (InvalidAccessTokenException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (NoUserLoggedInException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
         [HttpPost("logout")]
         public async Task<IActionResult> Logout()
         {
-            await _authRepository.LogoutAsync();
-            return Ok("Logged out successfully");
+            try
+            {
+                await _authService.LogoutAsync();
+                return Ok("Logged out successfully");
+            }
+            catch (NoUserLoggedInException ex)
+            {
+                return Unauthorized(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
     }
 }

Backend/prepAIred.API/Controllers/InterviewController.cs

@@ -1,5 +1,6 @@
 using prepAIred.Data;
 using prepAIred.Services;
+using prepAIred.Exceptions;
 using Microsoft.AspNetCore.Mvc;
 
 namespace prepAIred.API
@@ -9,54 +10,144 @@ namespace prepAIred.API
     /// </summary>
     /// <remarks>This controller serves as the API layer for interacting with interview data. It exposes
     /// endpoints for creating new AI interviews and retrieving existing ones. The controller depends on an 
-    /// <see cref="IInterviewRepository"/> implementation to handle interview data operations.</remarks>
-    /// <param name="interviewRepository">Repository for handling interview operations</param>
+    /// <see cref="IInterviewService"/> implementation to handle interview data operations.</remarks>
+    /// <param name="interviewService">Repository for handling interview operations</param>
     [ApiController]
-    [Route("api/[controller]")]
-    public class InterviewController(IInterviewRepository interviewRepository) : Controller
+    [Route("api/interviews")]
+    public class InterviewController(IInterviewService interviewService) : Controller
     {
-        private readonly IInterviewRepository _interviewRepository = interviewRepository;
+        private readonly IInterviewService _interviewService = interviewService;
 
-        [HttpPost("generate-hr-interviews")]
+        [HttpPost("hr")]
         public async Task<IActionResult> GenerateHrInterview([FromBody] HrRequestDTO hrRequest)
         {
-            await _interviewRepository.GenerateInterviewsAsync<HRInterview>(hrRequest);
-            return Ok("HR interviews created successfully.");
+            try
+            {
+                await _interviewService.GenerateInterviewsAsync<HRInterview>(hrRequest);
+                return Ok("HR interviews created successfully.");
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
-        [HttpGet("get-latest-hr-interviews")]
+        [HttpGet("hr/latest")]
         public async Task<IActionResult> GetLatestHrInterview()
         {
-            List<HRInterviewDTO> hrInterviews = await _interviewRepository.GetLatestInterviewsAsync<HRInterview, HRInterviewDTO>();
-            return Ok(hrInterviews);
+            try
+            {
+                List<HRInterviewDTO> hrInterviews = await _interviewService.GetLatestInterviewsAsync<HRInterview, HRInterviewDTO>();
+                return Ok(hrInterviews);
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
-        [HttpPost("evaluate-hr-interviews")]
+        [HttpPost("hr/evaluations")]
         public async Task<IActionResult> EvaluateHrInterviews([FromBody] List<EvaluateRequestDTO> evaluateRequests)
         {
-            await _interviewRepository.EvaluateInterviewsAsync<HRInterview>(evaluateRequests);
-            return Ok("HR interviews evaluated successfully.");
+            try
+            {
+                await _interviewService.EvaluateInterviewsAsync<HRInterview>(evaluateRequests);
+                return Ok("HR interviews evaluated successfully.");
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
-        [HttpPost("generate-technical-interviews")]
+        [HttpPost("technical")]
         public async Task<IActionResult> GenerateTechnicalInterviews([FromBody] TechnicalRequestDTO technicalRequest)
         {
-            await _interviewRepository.GenerateInterviewsAsync<TechnicalInterview>(technicalRequest);
-            return Ok("Technical interviews created successfully.");
+            try
+            {
+                await _interviewService.GenerateInterviewsAsync<TechnicalInterview>(technicalRequest);
+                return Ok("Technical interviews created successfully.");
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
-        [HttpGet("get-latest-technical-interviews")]
+        [HttpGet("technical/latest")]
         public async Task<IActionResult> GetLatestTechnicalInterview()
         {
-            List<TechnicalInterviewDTO> technicalInterviews = await _interviewRepository.GetLatestInterviewsAsync<TechnicalInterview, TechnicalInterviewDTO>();
-            return Ok(technicalInterviews);
+            try
+            {
+                List<TechnicalInterviewDTO> technicalInterviews = await _interviewService.GetLatestInterviewsAsync<TechnicalInterview, TechnicalInterviewDTO>();
+                return Ok(technicalInterviews);
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
 
-        [HttpPost("evaluate-technical-interviews")]
+        [HttpPost("technical/evaluations")]
         public async Task<IActionResult> EvaluateTechnicalInterviews([FromBody] List<EvaluateRequestDTO> evaluateRequests)
         {
-            await _interviewRepository.EvaluateInterviewsAsync<TechnicalInterview>(evaluateRequests);
-            return Ok("Technical interviews evaluated successfully.");
+            try
+            {
+                await _interviewService.EvaluateInterviewsAsync<TechnicalInterview>(evaluateRequests);
+                return Ok("Technical interviews evaluated successfully.");
+            }
+            catch (InterviewSessionNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (ResourceNotFoundException ex)
+            {
+                return NotFound(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
         }
     }
 }