fix(teacher): exam submissions review was fully broken (#282) (#305)

The teacher exam-grading pages passed data shaped for an older component
contract, so both pages were unusable:

Submissions list (`.../submissions/page.tsx`):
- mapped student_name / score / review_status, but ExamSubmissionsReview reads
  profiles.full_name / ai_score / final_score / status → every row showed
  "Unknown Student" with "undefined%" scores and all stat cards read 0.

Submission detail (`.../submissions/[submissionId]/page.tsx`):
- same field drift → "undefined%" scores and "Invalid Date".
- filtered exam_questions / exam_answers / exam_question_scores / exam_scores by
  `tenant_id`, but none of those tables have a tenant_id column → every query
  errored → empty Questions list and no scores. (RLS isolates via the parent
  exam/submission, so the explicit filter was both wrong and unnecessary.)
- never passed the `questions` / `answers` props the component reads, so even a
  successful query would have rendered nothing.
- onSave expected `{ score, question_overrides[] }` but the component calls
  onSave(overrides) keyed by question id → the override never persisted.

Fixes: align both pages to the component contract, drop the invalid tenant_id
filters, pass questions/answers, and rewrite handleSave to consume the real
overrides shape, recompute the overall score from per-question points, and
persist to exam_question_scores / exam_scores / exam_submissions.

Verified on Code Academy Pro (creator admin, alice's Python final): list shows
Alice Student / AI Reviewed / 70%; detail renders all 10 questions with options
and AI scores; overriding Q1 10→5 recomputes 70%→65%, marks the submission
teacher_reviewed, and the list updates to Graded / 65%.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: guillermoscript

app/[locale]/dashboard/teacher/courses/[courseId]/exams/[examId]/submissions/[submissionId]/page.tsx

@@ -51,23 +51,21 @@ export default async function SubmissionDetailPage({ params }: { params: Promise
         )
       `)
       .eq('exam_id', parseInt(examId))
-      .eq('tenant_id', tenantId)
+      // exam_questions has no tenant_id column; isolation is enforced by RLS
+      // via the parent exam (already validated above).
       .order('question_id', { ascending: true }),
     supabase
       .from('exam_answers')
       .select('*')
-      .eq('submission_id', parseInt(submissionId))
-      .eq('tenant_id', tenantId),
+      .eq('submission_id', parseInt(submissionId)),
     supabase
       .from('exam_question_scores')
       .select('*')
-      .eq('submission_id', parseInt(submissionId))
-      .eq('tenant_id', tenantId),
+      .eq('submission_id', parseInt(submissionId)),
     supabase
       .from('exam_scores')
       .select('*')
-      .eq('submission_id', parseInt(submissionId))
-      .eq('tenant_id', tenantId),
+      .eq('submission_id', parseInt(submissionId)),
   ])
 
   // Build per-question data combining questions, answers, and AI scores
@@ -98,65 +96,106 @@ export default async function SubmissionDetailPage({ params }: { params: Promise
     }
   })
 
+  // Field names here must match what SubmissionReview reads on `submission`
+  // (status, submitted_at, ai_score, final_score, teacher_feedback). They had
+  // drifted (review_status / submission_date / score), so the header showed
+  // "undefined%" scores and "Invalid Date".
+  const aiScore = rawSubmission.score ?? null
+  const finalScore = examScores?.[0]?.score ?? rawSubmission.score ?? null
   const submission = {
     submission_id: rawSubmission.submission_id,
     exam_id: rawSubmission.exam_id,
     student_id: rawSubmission.student_id,
     student_name: student?.full_name || t('manageCourse.studentList.unknownStudent'),
-    submission_date: rawSubmission.submission_date,
-    score: rawSubmission.score,
-    review_status: rawSubmission.review_status || 'pending',
+    status: rawSubmission.review_status || 'pending',
+    submitted_at: rawSubmission.submission_date,
+    ai_score: aiScore,
+    final_score: finalScore,
+    teacher_feedback: examScores?.[0]?.feedback || rawSubmission.feedback || (rawSubmission.ai_data as any)?.overall_feedback || '',
     ai_data: rawSubmission.ai_data,
     ai_model_used: rawSubmission.ai_model_used,
-    overall_feedback: examScores?.[0]?.feedback || (rawSubmission.ai_data as any)?.overall_feedback || '',
-    teacher_notes: examScores?.[0]?.teacher_notes || '',
-    questions: questionData,
   }
 
-  const handleSave = async (overrides: {
-    score: number
-    feedback: string
-    teacher_notes: string
-    question_overrides: {
-      question_id: number
-      points_earned: number
-      is_correct: boolean
-      teacher_notes: string
-    }[]
-  }) => {
+  // SubmissionReview reads `questions` and `answers` as their own props (not
+  // nested under submission). It keys overrides by question id, so `id` must
+  // equal the answer's question_id. exam_questions has no `sequence` column,
+  // so fall back to question_id for ordering.
+  const questionsForReview = questionData.map(q => ({
+    id: q.question_id,
+    sequence: q.question_id,
+    question_type: q.question_type,
+    question_text: q.question_text,
+    points_possible: q.points_possible,
+    answer_text: q.answer_text,
+    options: (q.options || []).map((o: any) => ({
+      id: o.option_id,
+      option_text: o.option_text,
+      is_correct: o.is_correct,
+    })),
+  }))
+
+  const answersForReview = questionData.map(q => ({
+    question_id: q.question_id,
+    points_earned: q.points_earned,
+    is_correct: q.is_correct,
+    teacher_notes: q.teacher_notes,
+    teacher_score_override: q.is_overridden ? q.points_earned : null,
+  }))
+
+  // SubmissionReview calls onSave(overrides) where `overrides` is keyed by
+  // question id — NOT the { score, question_overrides[] } shape this previously
+  // expected, so the override never persisted. Consume the real shape, recompute
+  // the overall score from the per-question points, and persist.
+  const handleSave = async (overrides: Record<number, {
+    points_earned?: number
+    is_correct?: boolean
+    teacher_notes?: string
+    is_overridden?: boolean
+  }>) => {
     'use server'
     const supabase = createAdminClient()
     const userId = await getCurrentUserId()
     if (!userId) return
 
-    // Update individual question scores
-    for (const qo of overrides.question_overrides) {
+    let totalEarned = 0
+    let totalPossible = 0
+
+    // Upsert individual question scores
+    for (const [questionIdStr, data] of Object.entries(overrides)) {
+      const questionId = parseInt(questionIdStr)
+      const pointsPossible = questionData.find(q => q.question_id === questionId)?.points_possible || 10
+      const pointsEarned = data.points_earned ?? 0
+      totalEarned += pointsEarned
+      totalPossible += pointsPossible
+
       await supabase
         .from('exam_question_scores')
         .upsert({
           submission_id: parseInt(submissionId),
-          question_id: qo.question_id,
-          points_earned: qo.points_earned,
-          points_possible: questionData.find(q => q.question_id === qo.question_id)?.points_possible || 10,
-          is_correct: qo.is_correct,
+          question_id: questionId,
+          points_earned: pointsEarned,
+          points_possible: pointsPossible,
+          is_correct: data.is_correct ?? null,
           teacher_id: userId,
-          teacher_notes: qo.teacher_notes,
-          is_overridden: true,
+          teacher_notes: data.teacher_notes || null,
+          is_overridden: data.is_overridden || false,
           reviewed_at: new Date().toISOString(),
         }, { onConflict: 'submission_id,question_id' })
     }
 
+    const newScore = totalPossible > 0
+      ? Math.round((totalEarned / totalPossible) * 100)
+      : (rawSubmission.score ?? 0)
+
     // Update overall exam_scores
     await supabase
       .from('exam_scores')
       .upsert({
         submission_id: parseInt(submissionId),
         student_id: rawSubmission.student_id,
         exam_id: rawSubmission.exam_id,
-        score: overrides.score,
-        feedback: overrides.feedback,
+        score: newScore,
         teacher_id: userId,
-        teacher_notes: overrides.teacher_notes,
         is_overridden: true,
         reviewed_at: new Date().toISOString(),
       }, { onConflict: 'submission_id,student_id,exam_id' })
@@ -165,7 +204,7 @@ export default async function SubmissionDetailPage({ params }: { params: Promise
     await supabase
       .from('exam_submissions')
       .update({
-        score: overrides.score,
+        score: newScore,
         review_status: 'teacher_reviewed',
         requires_attention: false,
       })
@@ -190,7 +229,12 @@ export default async function SubmissionDetailPage({ params }: { params: Promise
         </div>
       </div>
 
-      <SubmissionReview submission={submission} onSave={handleSave} />
+      <SubmissionReview
+        submission={submission}
+        questions={questionsForReview}
+        answers={answersForReview}
+        onSave={handleSave}
+      />
     </div>
   )
 }

app/[locale]/dashboard/teacher/courses/[courseId]/exams/[examId]/submissions/page.tsx

@@ -50,13 +50,22 @@ export default async function SubmissionsPage({ params }: { params: Promise<{ co
       || reviewStatus === 'pending_teacher_review'
       || (submission.ai_confidence_score != null && submission.ai_confidence_score < 0.7)
 
+    // NOTE: field names below must match what ExamSubmissionsReview reads
+    // (profiles.full_name, status, ai_score, final_score). They had drifted
+    // (student_name / review_status / score), which rendered every row as
+    // "Unknown Student" with "undefined%" scores and zeroed every stat card.
     return {
       id: submission.submission_id,
       student_id: submission.student_id,
-      student_name: student?.full_name || t('manageCourse.studentList.unknownStudent'),
+      profiles: {
+        full_name: student?.full_name || null,
+      },
+      status: reviewStatus,
       submitted_at: submission.submission_date,
-      score: submission.score || 0,
-      review_status: reviewStatus as 'pending' | 'pending_teacher_review' | 'ai_reviewed' | 'teacher_reviewed',
+      // DB has a single `score` column; AI grade and final score are the same
+      // until a teacher override updates `score`.
+      ai_score: submission.score ?? null,
+      final_score: submission.score ?? null,
       requires_attention: requiresAttention,
       ai_model_used: submission.ai_model_used || undefined,
       ai_processing_time_ms: submission.ai_processing_time_ms || undefined,