Add instructor rating feature with enrollment-gated reviews

api/CourseRegistration.API/Controllers/InstructorRatingsController.cs

@@ -0,0 +1,207 @@
+using Microsoft.AspNetCore.Mvc;
+using CourseRegistration.Application.DTOs;
+using CourseRegistration.Application.Interfaces;
+
+namespace CourseRegistration.API.Controllers;
+
+/// <summary>
+/// Controller for instructor rating operations
+/// </summary>
+[ApiController]
+[Route("api/[controller]")]
+[Produces("application/json")]
+public class InstructorRatingsController : ControllerBase
+{
+    private readonly IInstructorRatingService _ratingService;
+    private readonly ILogger<InstructorRatingsController> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the InstructorRatingsController
+    /// </summary>
+    public InstructorRatingsController(IInstructorRatingService ratingService, ILogger<InstructorRatingsController> logger)
+    {
+        _ratingService = ratingService ?? throw new ArgumentNullException(nameof(ratingService));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Creates a new instructor rating
+    /// </summary>
+    /// <param name="createRatingDto">Rating creation details</param>
+    /// <returns>Created rating</returns>
+    [HttpPost]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> CreateRating([FromBody] CreateInstructorRatingDto createRatingDto)
+    {
+        _logger.LogInformation("Creating new rating for course {CourseId} by student {StudentId}", 
+            createRatingDto.CourseId, createRatingDto.StudentId);
+
+        try
+        {
+            var rating = await _ratingService.CreateRatingAsync(createRatingDto);
+
+            return CreatedAtAction(
+                nameof(GetRating),
+                new { id = rating.RatingId },
+                ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating created successfully"));
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning("Failed to create rating: {Message}", ex.Message);
+            return BadRequest(ApiResponseDto<InstructorRatingDto>.ErrorResponse(ex.Message));
+        }
+    }
+
+    /// <summary>
+    /// Gets a rating by ID
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <returns>Rating details</returns>
+    [HttpGet("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> GetRating(Guid id)
+    {
+        _logger.LogInformation("Getting rating with ID: {RatingId}", id);
+
+        var rating = await _ratingService.GetRatingByIdAsync(id);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific course
+    /// </summary>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("course/{courseId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByCourse(Guid courseId)
+    {
+        _logger.LogInformation("Getting ratings for course: {CourseId}", courseId);
+
+        var ratings = await _ratingService.GetRatingsByCourseIdAsync(courseId);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings submitted by a specific student
+    /// </summary>
+    /// <param name="studentId">Student ID</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("student/{studentId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByStudent(Guid studentId)
+    {
+        _logger.LogInformation("Getting ratings by student: {StudentId}", studentId);
+
+        var ratings = await _ratingService.GetRatingsByStudentIdAsync(studentId);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets all ratings for a specific instructor
+    /// </summary>
+    /// <param name="instructorName">Instructor name</param>
+    /// <returns>List of ratings</returns>
+    [HttpGet("instructor/{instructorName}")]
+    [ProducesResponseType(typeof(ApiResponseDto<IEnumerable<InstructorRatingDto>>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ApiResponseDto<IEnumerable<InstructorRatingDto>>>> GetRatingsByInstructor(string instructorName)
+    {
+        _logger.LogInformation("Getting ratings for instructor: {InstructorName}", instructorName);
+
+        var ratings = await _ratingService.GetRatingsByInstructorNameAsync(instructorName);
+        return Ok(ApiResponseDto<IEnumerable<InstructorRatingDto>>.SuccessResponse(ratings, "Ratings retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets rating statistics for an instructor
+    /// </summary>
+    /// <param name="instructorName">Instructor name</param>
+    /// <returns>Rating statistics</returns>
+    [HttpGet("instructor/{instructorName}/stats")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingStatsDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingStatsDto>>> GetInstructorStats(string instructorName)
+    {
+        _logger.LogInformation("Getting stats for instructor: {InstructorName}", instructorName);
+
+        var stats = await _ratingService.GetInstructorStatsAsync(instructorName);
+        if (stats == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingStatsDto>.ErrorResponse("No ratings found for this instructor"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingStatsDto>.SuccessResponse(stats, "Statistics retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Gets a rating by student and course
+    /// </summary>
+    /// <param name="studentId">Student ID</param>
+    /// <param name="courseId">Course ID</param>
+    /// <returns>Rating details</returns>
+    [HttpGet("student/{studentId:guid}/course/{courseId:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> GetRatingByStudentAndCourse(Guid studentId, Guid courseId)
+    {
+        _logger.LogInformation("Getting rating for student {StudentId} and course {CourseId}", studentId, courseId);
+
+        var rating = await _ratingService.GetRatingByStudentAndCourseAsync(studentId, courseId);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating retrieved successfully"));
+    }
+
+    /// <summary>
+    /// Updates an existing rating
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <param name="updateRatingDto">Rating update details</param>
+    /// <returns>Updated rating</returns>
+    [HttpPut("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<InstructorRatingDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<InstructorRatingDto>>> UpdateRating(Guid id, [FromBody] UpdateInstructorRatingDto updateRatingDto)
+    {
+        _logger.LogInformation("Updating rating with ID: {RatingId}", id);
+
+        var rating = await _ratingService.UpdateRatingAsync(id, updateRatingDto);
+        if (rating == null)
+        {
+            return NotFound(ApiResponseDto<InstructorRatingDto>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<InstructorRatingDto>.SuccessResponse(rating, "Rating updated successfully"));
+    }
+
+    /// <summary>
+    /// Deletes a rating
+    /// </summary>
+    /// <param name="id">Rating ID</param>
+    /// <returns>Success status</returns>
+    [HttpDelete("{id:guid}")]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ApiResponseDto<object>), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<ApiResponseDto<object>>> DeleteRating(Guid id)
+    {
+        _logger.LogInformation("Deleting rating with ID: {RatingId}", id);
+
+        var success = await _ratingService.DeleteRatingAsync(id);
+        if (!success)
+        {
+            return NotFound(ApiResponseDto<object>.ErrorResponse("Rating not found"));
+        }
+
+        return Ok(ApiResponseDto<object>.SuccessResponse(null, "Rating deleted successfully"));
+    }
+}

api/CourseRegistration.API/CourseRegistration.API.csproj

@@ -8,6 +8,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="8.0.11" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.11">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="8.0.11" />
     <PackageReference Include="Serilog.AspNetCore" Version="8.0.2" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.9.0" />

api/CourseRegistration.API/Program.cs

@@ -60,12 +60,14 @@
 builder.Services.AddScoped<IStudentRepository, StudentRepository>();
 builder.Services.AddScoped<ICourseRepository, CourseRepository>();
 builder.Services.AddScoped<IRegistrationRepository, RegistrationRepository>();
+builder.Services.AddScoped<IInstructorRatingRepository, InstructorRatingRepository>();
 builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 
 // Register services
 builder.Services.AddScoped<IStudentService, StudentService>();
 builder.Services.AddScoped<ICourseService, CourseService>();
 builder.Services.AddScoped<IRegistrationService, RegistrationService>();
+builder.Services.AddScoped<IInstructorRatingService, InstructorRatingService>();
 
 // Register authorization services
 builder.Services.AddScoped<AuthorizationService>();

api/CourseRegistration.Application/DTOs/InstructorRatingDtos.cs

@@ -0,0 +1,160 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace CourseRegistration.Application.DTOs;
+
+/// <summary>
+/// DTO for creating a new instructor rating
+/// </summary>
+public class CreateInstructorRatingDto
+{
+    /// <summary>
+    /// Course ID for which the instructor is being rated
+    /// </summary>
+    [Required]
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Student ID who is submitting the rating
+    /// </summary>
+    [Required]
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    [Required]
+    [Range(1, 5, ErrorMessage = "Rating must be between 1 and 5")]
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    [MaxLength(1000, ErrorMessage = "Comment cannot exceed 1000 characters")]
+    public string? Comment { get; set; }
+}
+
+/// <summary>
+/// DTO for updating an existing instructor rating
+/// </summary>
+public class UpdateInstructorRatingDto
+{
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    [Required]
+    [Range(1, 5, ErrorMessage = "Rating must be between 1 and 5")]
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    [MaxLength(1000, ErrorMessage = "Comment cannot exceed 1000 characters")]
+    public string? Comment { get; set; }
+}
+
+/// <summary>
+/// DTO for returning instructor rating details
+/// </summary>
+public class InstructorRatingDto
+{
+    /// <summary>
+    /// Unique identifier for the rating
+    /// </summary>
+    public Guid RatingId { get; set; }
+
+    /// <summary>
+    /// Course ID
+    /// </summary>
+    public Guid CourseId { get; set; }
+
+    /// <summary>
+    /// Course name
+    /// </summary>
+    public string CourseName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Instructor name
+    /// </summary>
+    public string InstructorName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Student ID who submitted the rating
+    /// </summary>
+    public Guid StudentId { get; set; }
+
+    /// <summary>
+    /// Student name
+    /// </summary>
+    public string StudentName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Rating value (1-5 scale)
+    /// </summary>
+    public int Rating { get; set; }
+
+    /// <summary>
+    /// Optional comment/review text
+    /// </summary>
+    public string? Comment { get; set; }
+
+    /// <summary>
+    /// Date when the rating was created
+    /// </summary>
+    public DateTime CreatedAt { get; set; }
+
+    /// <summary>
+    /// Date when the rating was last updated
+    /// </summary>
+    public DateTime UpdatedAt { get; set; }
+}
+
+/// <summary>
+/// DTO for instructor rating statistics
+/// </summary>
+public class InstructorRatingStatsDto
+{
+    /// <summary>
+    /// Instructor name
+    /// </summary>
+    public string InstructorName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Average rating
+    /// </summary>
+    public double AverageRating { get; set; }
+
+    /// <summary>
+    /// Total number of ratings
+    /// </summary>
+    public int TotalRatings { get; set; }
+
+    /// <summary>
+    /// Number of 5-star ratings
+    /// </summary>
+    public int FiveStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 4-star ratings
+    /// </summary>
+    public int FourStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 3-star ratings
+    /// </summary>
+    public int ThreeStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 2-star ratings
+    /// </summary>
+    public int TwoStarCount { get; set; }
+
+    /// <summary>
+    /// Number of 1-star ratings
+    /// </summary>
+    public int OneStarCount { get; set; }
+
+    /// <summary>
+    /// List of courses taught by this instructor
+    /// </summary>
+    public List<Guid> CourseIds { get; set; } = new();
+}