Show Answer Details in Assessment Statistics Page (Part 2: Last Graded Answer (Forum Post Response, Programming))

app/controllers/concerns/course/statistics/reference_times_concern.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+module Course::Statistics::ReferenceTimesConcern
+  private
+
+  def personal_end_at_hash
+    personal_end_at = Course::PersonalTime.find_by_sql(<<-SQL.squish
+      WITH course_user_personal_end_at AS (
+        SELECT course_user_id, end_at
+        FROM course_personal_times cpt
+        JOIN (
+          SELECT course_lesson_plan_items.id
+          FROM course_lesson_plan_items
+          WHERE course_lesson_plan_items.actable_type = 'Course::Assessment'
+            AND course_lesson_plan_items.actable_id = #{assessment_params[:id]}
+        ) clpi
+        ON cpt.lesson_plan_item_id = clpi.id
+      ),
+
+      personal_times AS (
+        SELECT cu.id AS course_user_id, pt.end_at
+        FROM (
+          SELECT course_users.id
+          FROM course_users
+          WHERE course_users.course_id = #{@assessment.course.id}
+        ) cu
+        LEFT JOIN (
+          SELECT course_user_id, end_at
+          FROM course_user_personal_end_at
+        ) pt
+        ON cu.id = pt.course_user_id
+      ),
+
+      personal_reference_times AS (
+        SELECT cu.id AS course_user_id, crt.end_at
+        FROM (
+          SELECT course_users.id, course_users.reference_timeline_id
+          FROM course_users
+          WHERE course_users.course_id = #{@assessment.course.id} AND course_users.role = #{CourseUser.roles[:student]}
+        ) cu
+        LEFT JOIN (
+          SELECT reference_timeline_id, lesson_plan_item_id, end_at
+          FROM course_reference_times
+        ) crt
+        ON crt.reference_timeline_id = cu.reference_timeline_id
+        LEFT JOIN (
+          SELECT id
+          FROM course_lesson_plan_items
+          WHERE course_lesson_plan_items.actable_type = 'Course::Assessment'
+            AND course_lesson_plan_items.actable_id = #{assessment_params[:id]}
+        ) clpi
+        ON crt.lesson_plan_item_id = clpi.id
+      )
+
+      SELECT
+        pt.course_user_id,
+        CASE WHEN pt.end_at IS NOT NULL THEN pt.end_at ELSE prt.end_at END AS end_at
+      FROM personal_times pt
+      LEFT JOIN personal_reference_times prt
+      ON pt.course_user_id = prt.course_user_id
+    SQL
+                                                      )
+    personal_end_at.map { |pea| [pea.course_user_id, pea.end_at] }.to_h
+  end
+
+  def reference_times_hash
+    reference_times = Course::ReferenceTime.find_by_sql(<<-SQL.squish
+      SELECT clpi.actable_id AS lesson_plan_item_id, crt.end_at
+      FROM course_reference_times crt
+      JOIN (
+        SELECT id
+        FROM course_reference_timelines
+        WHERE course_id = #{@assessment.course.id} AND "default" = TRUE
+      ) crtl
+      ON crt.reference_timeline_id = crtl.id
+      JOIN (
+        SELECT id, actable_id
+        FROM course_lesson_plan_items
+        WHERE course_lesson_plan_items.actable_type = 'Course::Assessment'
+          AND course_lesson_plan_items.actable_id = #{assessment_params[:id]}
+      ) clpi
+      ON crt.lesson_plan_item_id = clpi.id
+    SQL
+                                                       )
+    reference_times.map { |rt| [rt.lesson_plan_item_id, rt.end_at] }.to_h
+  end
+end

app/controllers/concerns/course/statistics/submissions_concern.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+module Course::Statistics::SubmissionsConcern
+  include Course::Statistics::ReferenceTimesConcern
+
+  private
+
+  def initialize_student_hash(students)
+    students.to_h { |student| [student, nil] }
+  end
+
+  def fetch_hash_for_main_assessment(submissions, students)
+    student_hash = initialize_student_hash(students)
+
+    populate_hash_including_answers(student_hash, submissions)
+    student_hash
+  end
+
+  def fetch_hash_for_ancestor_assessment(submissions, students)
+    student_hash = initialize_student_hash(students)
+
+    populate_hash_without_answers(student_hash, submissions)
+    student_hash
+  end
+
+  def answer_statistics_hash
+    submission_answer_statistics = Course::Assessment::Answer.find_by_sql(<<-SQL.squish
+      WITH
+        attempt_count AS (
+          SELECT
+            caa.question_id,
+            caa.submission_id,
+            COUNT(*) AS attempt_count
+          FROM course_assessment_answers caa
+          JOIN course_assessment_submissions cas ON caa.submission_id = cas.id
+          WHERE cas.assessment_id = #{assessment_params[:id]}
+          GROUP BY caa.question_id, caa.submission_id
+        ),
+
+        attempt_info AS (
+          SELECT
+            caa_ranked.question_id,
+            caa_ranked.submission_id,
+            jsonb_agg(jsonb_build_array(caa_ranked.id, caa_ranked.grade, caa_ranked.correct, caa_ranked.workflow_state)) AS submission_info
+          FROM (
+            SELECT
+              caa_inner.id,
+              caa_inner.question_id,
+              caa_inner.submission_id,
+              caa_inner.correct,
+              caa_inner.grade,
+              cas_inner.workflow_state,
+              ROW_NUMBER() OVER (PARTITION BY caa_inner.question_id, caa_inner.submission_id ORDER BY caa_inner.created_at DESC) AS row_num
+            FROM
+              course_assessment_answers caa_inner
+            JOIN
+              course_assessment_submissions cas_inner ON caa_inner.submission_id = cas_inner.id
+            WHERE
+              cas_inner.assessment_id = #{assessment_params[:id]}
+          ) AS caa_ranked
+          WHERE caa_ranked.row_num <= 2
+          GROUP BY caa_ranked.question_id, caa_ranked.submission_id
+        )
+
+      SELECT
+        CASE WHEN jsonb_array_length(attempt_info.submission_info) = 1 OR attempt_info.submission_info->0->>3 != 'attempting'
+            THEN attempt_info.submission_info->0->>0 ELSE attempt_info.submission_info->1->>0
+        END AS last_attempt_answer_id,
+        attempt_count.question_id,
+        attempt_count.submission_id,
+        attempt_count.attempt_count,
+        CASE WHEN jsonb_array_length(attempt_info.submission_info) = 1 OR attempt_info.submission_info->0->>3 != 'attempting'
+            THEN attempt_info.submission_info->0->>1 ELSE attempt_info.submission_info->1->>1
+        END AS grade,
+        CASE WHEN jsonb_array_length(attempt_info.submission_info) = 1 OR attempt_info.submission_info->0->>3 != 'attempting'
+            THEN attempt_info.submission_info->0->>2 ELSE attempt_info.submission_info->1->>2
+        END AS correct
+      FROM attempt_count
+      JOIN attempt_info
+      ON attempt_count.question_id = attempt_info.question_id AND attempt_count.submission_id = attempt_info.submission_id
+    SQL
+                                                                         )
+
+    submission_answer_statistics.group_by(&:submission_id).
+      transform_values do |grouped_answers|
+        grouped_answers.sort_by { |answer| @question_order_hash[answer.question_id] }
+      end
+  end
+
+  def populate_hash_including_answers(student_hash, submissions)
+    answers_hash = answer_statistics_hash
+    fetch_personal_and_reference_timeline_hash
+
+    submissions.map do |submission|
+      submitter_course_user = submission.creator.course_users.select { |u| u.course_id == @assessment.course_id }.first
+      next unless submitter_course_user&.student?
+
+      answers = answers_hash[submission.id]
+      end_at = @personal_end_at_hash[submitter_course_user.id] || @reference_times_hash[@assessment.id]
+
+      student_hash[submitter_course_user] = [submission, answers, end_at]
+    end
+  end
+
+  def populate_hash_without_answers(student_hash, submissions)
+    fetch_personal_and_reference_timeline_hash
+
+    submissions.map do |submission|
+      submitter_course_user = submission.creator.course_users.select { |u| u.course_id == @assessment.course_id }.first
+      next unless submitter_course_user&.student?
+
+      end_at = @personal_end_at_hash[submitter_course_user.id] || @reference_times_hash[@assessment.id]
+
+      student_hash[submitter_course_user] = [submission, end_at]
+    end
+  end
+
+  def fetch_personal_and_reference_timeline_hash
+    @personal_end_at_hash = personal_end_at_hash
+    @reference_times_hash = reference_times_hash
+  end
+end

app/controllers/concerns/course/statistics/users_concern.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Course::Statistics::UsersConcern
+  private
+
+  def group_names_hash
+    group_names = Course::Group.find_by_sql(<<-SQL.squish
+      WITH course_students AS (
+        SELECT cgu.group_id, cgu.course_user_id
+        FROM course_group_users cgu
+        JOIN (
+          SELECT course_users.id
+          FROM course_users
+          WHERE course_users.role = #{CourseUser.roles[:student]}
+          AND course_users.course_id = #{current_course.id}
+        ) cu
+        ON cgu.course_user_id = cu.id
+      ),
+
+      course_group_names AS (
+        SELECT course_groups.id, course_groups.name
+        FROM course_groups
+      )
+
+      SELECT id, ARRAY_AGG(group_name) AS group_names
+      FROM (
+        SELECT
+          cs.course_user_id as id,
+          cgn.name as group_name
+        FROM course_students cs
+        JOIN course_group_names cgn
+        ON cs.group_id = cgn.id
+      ) group_tables
+      GROUP BY group_tables.id
+    SQL
+                                           )
+    group_names.map { |course_user| [course_user.id, course_user.group_names] }.to_h
+  end
+end

app/controllers/course/statistics/answers_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+class Course::Statistics::AnswersController < Course::Statistics::Controller
+  helper Course::Assessment::Submission::SubmissionsHelper.name.sub(/Helper$/, '')
+
+  def question_answer_details
+    @answer = Course::Assessment::Answer.find(answer_params[:id])
+    @submission = @answer.submission
+    @assessment = @submission.assessment
+  end
+
+  private
+
+  def answer_params
+    params.permit(:id)
+  end
+end

app/controllers/course/statistics/assessments_controller.rb

@@ -1,6 +1,27 @@
 # frozen_string_literal: true
 class Course::Statistics::AssessmentsController < Course::Statistics::Controller
-  def assessment
+  include Course::UsersHelper
+  include Course::Statistics::SubmissionsConcern
+  include Course::Statistics::UsersConcern
+
+  def main_statistics
+    @assessment = Course::Assessment.where(id: assessment_params[:id]).
+                  calculated(:maximum_grade, :question_count).
+                  preload(course: :course_users).first
+    submissions = Course::Assessment::Submission.where(assessment_id: assessment_params[:id]).
+                  calculated(:grade, :grader_ids).
+                  preload(creator: :course_users)
+    @course_users_hash = preload_course_users_hash(@assessment.course)
+
+    load_course_user_students_info
+    fetch_all_ancestor_assessments
+    create_question_related_hash
+
+    @assessment_autograded = @question_hash.any? { |_, (_, _, auto_gradable)| auto_gradable }
+    @student_submissions_hash = fetch_hash_for_main_assessment(submissions, @all_students)
+  end
+
+  def ancestor_statistics
     @assessment = Course::Assessment.where(id: assessment_params[:id]).
                   calculated(:maximum_grade).
                   preload(lesson_plan_item: [:reference_times, personal_times: :course_user],
@@ -9,19 +30,9 @@ def assessment
     submissions = Course::Assessment::Submission.preload(creator: :course_users).
                   where(assessment_id: assessment_params[:id]).
                   calculated(:grade)
-    @submission_records = compute_submission_records(submissions)
-    @all_students = @assessment.course.course_users.students
-  end
-
-  def ancestors
-    @assessment = Course::Assessment.preload(:duplication_traceable).find(assessment_params[:id])
-    @assessments = [@assessment]
-    while @assessment.duplication_traceable.present? && @assessment.duplication_traceable.source_id.present?
-      @assessment = @assessment.duplication_traceable.source
-      break unless can?(:read_ancestor, @assessment)
 
-      @assessments << @assessment
-    end
+    @all_students = @assessment.course.course_users.students
+    @student_submissions_hash = fetch_hash_for_ancestor_assessment(submissions, @all_students).compact
   end
 
   private
@@ -30,14 +41,29 @@ def assessment_params
     params.permit(:id)
   end
 
-  def compute_submission_records(submissions)
-    submissions.map do |submission|
-      submitter_course_user = submission.creator.course_users.select { |u| u.course_id == @assessment.course_id }.first
-      next unless submitter_course_user&.student?
+  def load_course_user_students_info
+    @all_students = current_course.course_users.students
+    @group_names_hash = group_names_hash
+  end
 
-      end_at = @assessment.lesson_plan_item.time_for(submitter_course_user).end_at
-      grade = submission.grade
-      [submitter_course_user, submission.submitted_at, end_at, grade]
-    end.compact
+  def fetch_all_ancestor_assessments
+    current_assessment = Course::Assessment.preload(:duplication_traceable).find(assessment_params[:id])
+    @ancestors = [current_assessment]
+    while current_assessment.duplication_traceable.present? &&
+          current_assessment.duplication_traceable.source_id.present?
+      current_assessment = current_assessment.duplication_traceable.source
+      break unless can?(:read_ancestor, current_assessment)
+
+      @ancestors.unshift(current_assessment)
+    end
+  end
+
+  def create_question_related_hash
+    @question_order_hash = @assessment.question_assessments.to_h do |q|
+      [q.question_id, q.weight]
+    end
+    @question_hash = @assessment.questions.to_h do |q|
+      [q.id, [q.maximum_grade, q.question_type, q.auto_gradable?]]
+    end
   end
 end

app/models/course/assessment.rb

@@ -91,6 +91,16 @@ class Course::Assessment < ApplicationRecord
       )
   end)
 
+  # @!attribute [r] question_count
+  #   Gets the number of questions in this assessment.
+  #   @return [Integer]
+  calculated :question_count, (lambda do
+    Course::QuestionAssessment.unscope(:order).
+      select('coalesce(count(DISTINCT cqa.question_id), 0)').
+      joins('INNER JOIN course_question_assessments cqa ON cqa.assessment_id = course_assessments.id').
+      group('course_assessments.id')
+  end)
+
   # @!method self.ordered_by_date_and_title
   #   Orders the assessments by the starting date and title.
   scope :ordered_by_date_and_title, (lambda do

app/views/course/statistics/answers/question_answer_details.json.jbuilder

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+question = @answer.question
+
+json.question do
+  json.id question.id
+  json.title question.title
+  json.maximumGrade question.maximum_grade
+  json.description format_ckeditor_rich_text(question.description)
+  json.type question.question_type
+
+  json.partial! question, question: question.specific, can_grade: false, answer: @answer
+end
+
+specific_answer = @answer.specific
+json.answer do
+  json.id @answer.id
+  json.grade @answer.grade
+  json.questionType question.question_type
+  json.partial! specific_answer, answer: specific_answer, can_grade: false
+end