E2601. Reimplement student quizzes

.rubocop.yml

@@ -13,19 +13,19 @@ Style/FrozenStringLiteralComment:
 Metrics/BlockLength:
   Max: 120
   Exclude:
-    - 'db/**/*.rb'
+    - "db/**/*.rb"
 
 Metrics/MethodLength:
-    Max: 20
-    Exclude:
-      - 'db/**/*.rb'
+  Max: 20
+  Exclude:
+    - "db/**/*.rb"
 
 Metrics/AbcSize:
   Max: 20
   Exclude:
-    - 'db/**/*.rb'
+    - "db/**/*.rb"
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: single_quotes
   Exclude:
-      - 'db/**/*.rb'
+    - "db/**/*.rb"

README.md

@@ -5,17 +5,18 @@ application up and running.
 
 Things you may want to cover:
 
-* Ruby version - 3.4.5
+- Ruby version - 3.4.5
 
 ## Development Environment
 
 ### Prerequisites
+
 - Verify that [Docker Desktop](https://www.docker.com/products/docker-desktop/) is installed and running.
 - [Download](https://www.jetbrains.com/ruby/download/) RubyMine
 - Make sure that the Docker plugin [is enabled](https://www.jetbrains.com/help/ruby/docker.html#enable_docker).
 
-
 ### Instructions
+
 Tutorial: [Docker Compose as a remote interpreter](https://www.jetbrains.com/help/ruby/using-docker-compose-as-a-remote-interpreter.html)
 
 ### Video Tutorial
@@ -25,5 +26,6 @@ Tutorial: [Docker Compose as a remote interpreter](https://www.jetbrains.com/hel
 alt="IMAGE ALT TEXT HERE" width="560" height="315" border="10" /></a>
 
 ### Database Credentials
+
 - username: root
 - password: expertiza

app/controllers/responses_controller.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+class ResponsesController < ApplicationController
+  prepend_before_action :set_response, only: %i[show update]
+  before_action :find_and_authorize_map_for_create, only: %i[create]
+
+  # Checks whether the current user can use the requested response action.
+  def action_allowed?
+    case action_name
+    when "create"
+      true  # auth already handled by before_action above
+    when "show", "update"
+      @response && @response.map.reviewer.user_id == current_user.id
+    else
+      true
+    end
+  end
+
+  # Shows the response details for one task response.
+  def show
+    render json: {
+      response_id: @response.id,
+      map_id: @response.map_id,
+      task_type: @response.map.type,
+      submitted: @response.is_submitted,
+      additional_comment: @response.additional_comment
+    }
+  end
+
+  # Creates or reuses a response for the requested response map.
+  def create
+    return unless enforce_task_order!(@map)
+
+    round = (params[:round].presence || 1).to_i
+    response = Response.where(map_id: @map.id, round: round)
+                       .order(:created_at)
+                       .last || Response.new(map_id: @map.id, round: round)
+
+    if params[:content].present? || params[:additional_comment].present?
+      response.additional_comment = params[:content].presence || params[:additional_comment]
+    end
+
+    if response.save
+      render json: { response_id: response.id, map_id: @map.id, round: response.round }, status: :created
+    else
+      render json: { errors: response.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+  # Updates the saved response with submission details or comments.
+  def update
+    return unless enforce_task_order!(@response.map)
+
+    if @response.update(response_update_params)
+      render json: {
+        response_id: @response.id,
+        map_id: @response.map_id,
+        submitted: @response.is_submitted,
+        additional_comment: @response.additional_comment
+      }, status: :ok
+    else
+      render json: { errors: @response.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  # Finds the response used by show and update.
+  def set_response
+    @response = Response.find(params[:id])
+  end
+
+  # Finds the response map and checks that the current user owns it.
+  def find_and_authorize_map_for_create
+    @map = ResponseMap.find_by(id: params[:response_map_id])
+    unless @map
+      render json: { error: "ResponseMap not found" }, status: :not_found
+      return
+    end
+
+    unless @map.reviewer.user_id == current_user.id
+      render json: { error: "You are not authorized to create this response" }, status: :forbidden
+    end
+  end
+
+
+  # Allows only the response fields that can be changed by this controller.
+  def response_update_params
+    p = params.permit(:is_submitted, :additional_comment, :content, :round)
+    p[:additional_comment] = p[:content] if p[:content].present?
+    p.delete(:content)
+    p
+  end
+
+  # Makes sure earlier tasks are finished before this task can be changed.
+  def enforce_task_order!(map)
+    participant = map.reviewer
+    unless participant.user_id == current_user.id
+      render json: { error: "Unauthorized" }, status: :forbidden
+      return false
+    end
+
+    context = StudentTask.resolve_context_for_participant(participant)
+    unless context
+      render json: { error: "TeamsParticipant not found for reviewer" }, status: :forbidden
+      return false
+    end
+
+    tasks = StudentTask.build_tasks(context)
+    current_task = StudentTask.find_task_for_map(tasks, map.id)
+    unless current_task
+      render json: { error: "Response map is not a respondable task for this participant" }, status: :forbidden
+      return false
+    end
+
+    unless StudentTask.prior_tasks_complete?(tasks, current_task)
+      render json: { error: "Complete previous task first" }, status: :precondition_failed
+      return false
+    end
+
+    true
+  end
+end

app/controllers/student_tasks_controller.rb

@@ -1,28 +1,79 @@
 class StudentTasksController < ApplicationController
-
+  
   # List retrieves all student tasks associated with the current logged-in user.
   def action_allowed?
     current_user_has_student_privileges?
   end
+
+  # ---------------------------------------------------------------------------
+  # Actions
+  # ---------------------------------------------------------------------------
+
   def list
-    # Retrieves all tasks that belong to the current user.
     @student_tasks = StudentTask.from_user(current_user)
-    # Render the list of student tasks as JSON.
     render json: @student_tasks, status: :ok
   end
 
   def show
     render json: @student_task, status: :ok
   end
 
-  # The view function retrieves a student task based on a participant's ID.
-  # It is meant to provide an endpoint where tasks can be queried based on participant ID.
   def view
-    # Retrieves the student task where the participant's ID matches the provided parameter.
-    # This function will be used for clicking on a specific student task to "view" its details.
     @student_task = StudentTask.from_participant_id(params[:id])
-    # Render the found student task as JSON.
     render json: @student_task, status: :ok
   end
 
+  # Returns the full ordered task queue for an assignment.
+  def queue
+    context = StudentTask.resolve_context_for_assignment(current_user, params[:assignment_id])
+    return render json: { error: "Not authorized or not found" }, status: :not_found unless context
+
+    tasks = StudentTask.build_tasks(context)
+    StudentTask.ensure_response_objects!(tasks)
+
+    render json: tasks.map(&:to_h), status: :ok
+  end
+
+  # Returns the next unfinished task in the assignment queue.
+  def next_task
+    context = StudentTask.resolve_context_for_assignment(current_user, params[:assignment_id])
+    return render json: { error: "Not authorized or not found" }, status: :not_found unless context
+
+    tasks = StudentTask.build_tasks(context)
+    StudentTask.ensure_response_objects!(tasks)
+    next_task = tasks.find { |task| !task.completed? }
+
+    if next_task
+      render json: next_task.to_h, status: :ok
+    else
+      render json: { message: "All tasks completed" }, status: :ok
+    end
+  end
+
+  # Starts a task after checking that earlier tasks are complete.
+  def start_task
+    map = ResponseMap.find_by(id: params[:response_map_id])
+    return render json: { error: "ResponseMap not found" }, status: :not_found unless map
+
+    participant = map.reviewer
+    return render json: { error: "Unauthorized" }, status: :forbidden if participant.user_id != current_user.id
+
+    context = StudentTask.resolve_context_for_participant(participant)
+    return render json: { error: "Task not in respondable queue" }, status: :not_found unless context
+
+    tasks = StudentTask.build_tasks(context)
+    current_task = StudentTask.find_task_for_map(tasks, map.id)
+    return render json: { error: "Task not in respondable queue" }, status: :not_found unless current_task
+
+    unless StudentTask.prior_tasks_complete?(tasks, current_task)
+      return render json: { error: "Complete previous task first" }, status: :forbidden
+    end
+
+    current_task.ensure_response!
+
+    render json: {
+      message: "Task started",
+      task: current_task.to_h
+    }, status: :ok
+  end
 end

app/models/assignment.rb

@@ -20,10 +20,22 @@ class Assignment < ApplicationRecord
   #This method return the value of the has_badge field for the given assignment object.
   attr_accessor :title, :description, :has_badge, :enable_pair_programming, :is_calibrated, :staggered_deadline
 
+  # Returns the assignment-linked review questionnaire record.
+  # The assignment can be linked to many questionnaires via AssignmentQuestionnaire.
+  def review_questionnaire_for_review_flow
+    questionnaires.find_by(questionnaire_type: 'ReviewQuestionnaire')
+  end
+
   def review_questionnaire_id
     Questionnaire.find_by_assignment_id id
   end
 
+  # Returns the quiz questionnaire used by the reviewer pre-check flow.
+  # If no quiz questionnaire is attached, the caller can skip quiz task creation.
+  def quiz_questionnaire_for_review_flow
+    questionnaires.find_by(questionnaire_type: 'QuizQuestionnaire')
+  end
+
   def teams?
     @has_teams ||= teams.any?
   end

app/models/quiz_task_item.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class QuizTaskItem < StudentTask::BaseTaskItem
+  # Labels this task item as a quiz task.
+  def task_type
+    :quiz
+  end
+
+  # Finds the quiz questionnaire attached to this assignment.
+  def questionnaire
+    assignment.quiz_questionnaire_for_review_flow
+  end
+
+  # Finds or creates the quiz response map used to answer this task.
+  def response_map
+    return @response_map if @response_map
+
+    existing_map = QuizResponseMap.find_by(
+      reviewer_id: team_participant.participant_id,
+      reviewee_id: review_map&.reviewee_id || 0
+    )
+    return @response_map = existing_map if existing_map
+
+    return nil if questionnaire.nil?
+
+    attributes = {
+      reviewer_id: team_participant.participant_id,
+      reviewee_id: review_map&.reviewee_id || 0,
+      reviewed_object_id: questionnaire.id,
+      type: "QuizResponseMap"
+    }
+
+    @response_map = QuizResponseMap.new(attributes).tap { |map| map.save!(validate: false) }
+  end
+end

app/models/review_task_item.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class ReviewTaskItem < StudentTask::BaseTaskItem
+  # Labels this task item as a review task.
+  def task_type
+    :review
+  end
+
+  # Uses the existing review response map for this task.
+  def response_map
+    review_map
+  end
+end