[92] Evaluation: Submission Scoring Completion

app/controllers/evaluations_controller.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
 # TODO: Reenable rubocop after refactor/shortening controller code or moving some functionality into service
-# rubocop:disable Metrics/ClassLength
-
 # Controller for evaluations CRUD actions.
-class EvaluationsController < ApplicationController
+class EvaluationsController < ApplicationController # rubocop:disable Metrics/ClassLength
   before_action -> { authorize_user('evaluator') }
   before_action :set_evaluation_and_submission_assignment, only: %i[create update]
-  before_action :set_phase, only: [:submissions]
 
   def index
     @phases = Phase.joins(:evaluator_submission_assignments).
@@ -20,6 +17,12 @@ def index
   end
 
   def submissions
+    @phase = Phase.joins(:challenge_phases_evaluators).
+      where(challenge_phases_evaluators: { user_id: current_user.id }).
+      find(params[:id])
+
+    @challenge = @phase.challenge
+
     @assigned_submissions = @phase.evaluator_submission_assignments.
       where(evaluator: current_user).
       where(status: %i[assigned recused]).
@@ -29,6 +32,11 @@ def submissions
     @submissions_count = helpers.calculate_submissions_count(@assigned_submissions)
   end
 
+  def confirmation
+    @evaluation = Evaluation.find(params[:id])
+    @subaction = params[:subaction]
+  end
+
   def new
     fetch_evaluator_submission_assignment
 
@@ -64,7 +72,7 @@ def create
           I18n.t("evaluations.notices.saved_draft")
         end
 
-      redirect_to submissions_evaluation_path(@evaluation.submission.phase_id)
+      redirect_to confirmation_evaluation_path(@evaluation, subaction: params[:subaction])
     else
       render :show, status: :unprocessable_entity
     end
@@ -79,18 +87,22 @@ def update
           I18n.t("evaluations.notices.saved_draft")
         end
 
-      redirect_to submissions_evaluation_path(@evaluation.submission.phase_id)
+      redirect_to confirmation_evaluation_path(@evaluation, subaction: params[:subaction])
     else
       render :show, status: :unprocessable_entity
     end
   end
 
   def recuse
-    @evaluation = Evaluation.find_by(id: params[:id], user_id: current_user.id)
-    fetch_evaluator_submission_assignment
-    return unauthorized_redirect unless can_access_evaluation?
+    @evaluator_submission_assignment =
+      current_user.evaluator_submission_assignments.where(submission_id: params[:submission_id]).first
 
-    process_recusal
+    if EvaluatorRecusalService.new(@evaluator_submission_assignment).call
+      flash[:notice] = I18n.t("evaluations.recusal.success")
+      redirect_to submissions_evaluation_path(@evaluator_submission_assignment.phase), status: :see_other
+    else
+      unauthorized_redirect
+    end
   end
 
   private
@@ -119,13 +131,6 @@ def set_evaluation_and_submission_assignment
     unauthorized_redirect unless can_access_evaluation?
   end
 
-  def set_phase
-    @phase = Phase.joins(:challenge_phases_evaluators).
-      where(challenge_phases_evaluators: { user_id: current_user.id }).
-      find(params[:id])
-    @challenge = @phase.challenge
-  end
-
   def find_or_initialize_evaluation
     if params[:id]
       Evaluation.includes([evaluation_scores: :evaluation_criterion]).find(params[:id])
@@ -159,51 +164,32 @@ def build_evaluation
     end
   end
 
-  def recuse_evaluator
-    @evaluator_submission_assignment&.update(status: :recused)
-  end
-
-  def destroy_recused_evaluation
-    @evaluator_submission_assignment.evaluation&.destroy!
-  end
-
   # Redirect Helpers
   def unauthorized_redirect
     redirect_to evaluations_path, alert: I18n.t("evaluations.alerts.unauthorized")
   end
 
   def evaluation_params
-    params.require(:evaluation).permit(
-      :user_id,
-      :evaluator_submission_assignment_id,
-      :submission_id,
-      :evaluation_form_id,
-      :additional_comments,
-      :revision_comments,
-      evaluation_scores_attributes: %i[
-        id evaluation_criterion_id
-        score score_override
-        comment comment_override
-      ]
-    )
-  end
+    normalize_evaluation_scores_keys!
 
-  def process_recusal
-    if recuse_evaluator
-      destroy_recused_evaluation
-      flash[:notice] = I18n.t("evaluations.recusal.success")
-      redirect_to submissions_evaluation_path(@evaluator_submission_assignment.phase), status: :see_other
-    else
-      handle_recusal_failure
-    end
-  rescue ActiveRecord::RecordInvalid
-    handle_recusal_failure
+    permitted_attributes = if @evaluation&.completed_at.present?
+                             %i[revision_comments] + [{ evaluation_scores_attributes: %i[id score_override
+                                                                                         comment_override] }]
+                           else
+                             %i[user_id evaluator_submission_assignment_id submission_id evaluation_form_id
+                                additional_comments revision_comments] +
+                               [{ evaluation_scores_attributes: %i[id evaluation_criterion_id score score_override
+                                                                   comment comment_override] }]
+                           end
+
+    params.require(:evaluation).permit(*permitted_attributes)
   end
 
-  def handle_recusal_failure
-    flash[:alert] = I18n.t("evaluations.recusal.failure")
-    redirect_to submissions_evaluation_path(@evaluator_submission_assignment.phase), status: :see_other
+  # Normalize random hex keys to integer indexes rails understands for nested_attributes
+  def normalize_evaluation_scores_keys!
+    return if params.dig(:evaluation, :evaluation_scores_attributes).blank?
+
+    params[:evaluation][:evaluation_scores_attributes] =
+      params[:evaluation][:evaluation_scores_attributes].transform_keys.with_index { |_key, index| index.to_s }
   end
 end
-# TODO: Remove this after above refactor
-# rubocop:enable Metrics/ClassLength

app/helpers/evaluation_scores_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# View helpers for evaluation score form inputs
+module EvaluationScoresHelper
+  def evaluation_score_id(_form, attribute, identifier)
+    prefix = "evaluation_evaluation_scores_attributes"
+
+    "#{prefix}_#{identifier}_#{attribute}"
+  end
+
+  def evaluation_score_name(_form, attribute, identifier)
+    prefix = "evaluation[evaluation_scores_attributes]"
+
+    "#{prefix}[#{identifier}][#{attribute}]"
+  end
+
+  def evaluation_score_input(score_fields, criterion, identifier, disabled)
+    field_id = evaluation_score_id(score_fields, :score, identifier)
+    field_name = evaluation_score_name(score_fields, :score, identifier)
+
+    case criterion.scoring_type
+    when 'numeric'
+      score_numeric_input(score_fields, field_id, field_name, disabled)
+    else # rating or binary
+      content_tag(:div, class: "usa-fieldset") do
+        score_options(criterion).each do |value, label|
+          concat(score_radio_input(score_fields, value, label, id: field_id, name: field_name, disabled:))
+        end
+      end
+    end
+  end
+
+  def score_numeric_input(score_fields, id, name, disabled)
+    criterion = score_fields.object.evaluation_criterion
+    min = 0
+    max = criterion.points_or_weight
+
+    content_tag(:div, class: "display-flex flex-column") do
+      # TODO: Should the lowest be 1?
+      concat(score_fields.label(:score, "Enter a number between #{min} and #{max}", for: id))
+      concat(score_fields.number_field(
+               :score, id:, name:, min:, max:, class: "usa-input width-10",
+                       data: {
+                         'evaluation-score-target': "scoreInput",
+                         action: "input->evaluation-score#calculateScore"
+                       }, disabled:
+             ))
+    end
+  end
+
+  def score_options(criterion)
+    (criterion.option_range_start..criterion.option_range_end).map do |value|
+      [value, criterion.option_labels[value.to_s] || value]
+    end
+  end
+
+  def score_radio_input(score_fields, value, label, opts = {})
+    id = opts[:id]
+    name = opts[:name]
+    disabled = opts[:disabled]
+
+    content_tag(:div, class: "usa-radio") do
+      concat(score_fields.radio_button(
+               :score, value, id: "#{id}_#{value}", name:, class: "usa-radio__input usa-radio__input--tile",
+                              data: {
+                                'evaluation-score-target': "scoreInput",
+                                action: "change->evaluation-score#calculateScore"
+                              },
+                              disabled:
+             ))
+      concat(score_fields.label("score_#{value}", label, for: "#{id}_#{value}", class: "usa-radio__label"))
+    end
+  end
+end

app/helpers/evaluations_helper.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength
 # View helpers for calculating evaluation & submission details.
 module EvaluationsHelper
   STATUS_COLORS = {
@@ -123,29 +122,7 @@ def evaluation_link(assignment)
     link_to("Evaluate", link_path, class: "usa-button font-body-2xs width-full text-no-wrap")
   end
 
-  def evaluation_score_input(score_fields, criterion)
-    content_tag(:div) do
-      case criterion.scoring_type
-      when 'numeric'
-        score_fields.number_field(:score, min: 0, max: criterion.points_or_weight)
-      # When rating or binary. Maybe change later if input styles are different
-      else
-        score_options(criterion).each { |value, label| concat(score_radio_input(score_fields, value, label)) }
-      end
-    end
-  end
-
-  def score_options(criterion)
-    (criterion.option_range_start..criterion.option_range_end).map do |value|
-      [value, criterion.option_labels[value.to_s] || value]
-    end
-  end
-
-  def score_radio_input(score_fields, value, label)
-    content_tag(:div) do
-      concat(score_fields.radio_button(:score, value))
-      concat(score_fields.label("score_#{value}", label))
-    end
+  def form_disabled?(evaluation)
+    evaluation.completed_at
   end
 end
-# rubocop:enable Metrics/ModuleLength

app/helpers/form_helper.rb

@@ -12,11 +12,28 @@ def input_error_class(form, fields)
     Array(fields).any? { |field| object.errors[field].present? } ? "border-secondary" : ""
   end
 
-  def inline_error(form, field)
-    object = form.object
-    field_id = (form.object_name + "_#{field}_error").gsub(/[\[\]]/, "_").squeeze('_')
-    error = object.errors[field].present? ? object.errors[field].join(", ") : ""
+  def inline_error(form, field, identifier = nil)
+    object_name = formatted_object_name(form, identifier)
+    field_id = "#{normalize_field_name(object_name, field)}_error"
+    error = form.object.errors[field].presence&.join(", ") || ""
 
     tag.span(error, class: "text-secondary font-body-2xs", id: field_id)
   end
+
+  private
+
+  def formatted_object_name(form, identifier)
+    object_name = form.object_name
+    return object_name if identifier.blank?
+
+    if form.options[:child_index].present?
+      object_name.sub(/\[\d+\]$/, "[#{identifier}]")
+    else
+      "#{object_name}[#{identifier}]"
+    end
+  end
+
+  def normalize_field_name(object_name, field)
+    "#{object_name}_#{field}".gsub(/[\[\]]/, "_").squeeze("_")
+  end
 end

app/javascript/controllers/evaluation_controller.js

@@ -0,0 +1,21 @@
+import { Controller } from "@hotwired/stimulus";
+
+export default class extends Controller {
+  static targets = ["calculatedScore", "totalScore"];
+
+  connect() {
+    this.updateTotalScore();
+  }
+
+  updateTotalScore() {
+    let totalScore = 0;
+
+    this.calculatedScoreTargets.forEach((span) => {
+      totalScore += parseFloat(span.textContent) || 0;
+    });
+
+    if (this.hasTotalScoreTarget) {
+      this.totalScoreTarget.textContent = totalScore.toFixed(2);
+    }
+  }
+}