Fix up reivew progress indicator on active-challenges list, and make sure submitters don't see their review scores until appeals or after iterative review

Author: jmgasper

src/apps/review/src/lib/components/TableReviewAppealsForSubmitter/TableReviewAppealsForSubmitter.tsx

@@ -1,7 +1,13 @@
 /**
  * Table Winners.
  */
-import { FC, MouseEvent, useContext, useMemo } from 'react'
+import {
+    FC,
+    MouseEvent,
+    useCallback,
+    useContext,
+    useMemo,
+} from 'react'
 import { Link } from 'react-router-dom'
 import { toast } from 'react-toastify'
 import { includes, noop } from 'lodash'
@@ -20,8 +26,15 @@ import {
     AggregatedReviewDetail,
     AggregatedSubmissionReviews,
     aggregateSubmissionReviews,
+    isAppealsPhase,
+    isAppealsResponsePhase,
 } from '../../utils'
-import { NO_RESOURCE_ID, WITHOUT_APPEAL } from '../../../config/index.config'
+import {
+    FIRST2FINISH,
+    NO_RESOURCE_ID,
+    TRACK_CHALLENGE,
+    WITHOUT_APPEAL,
+} from '../../../config/index.config'
 import { ChallengeDetailContext } from '../../contexts'
 import { useSubmissionDownloadAccess } from '../../hooks'
 import type { UseSubmissionDownloadAccessResult } from '../../hooks/useSubmissionDownloadAccess'
@@ -73,6 +86,29 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
         [challengeTrack, challengeType],
     )
 
+    const isFirst2FinishChallenge = useMemo(
+        () => [challengeType, challengeTrack]
+            .some(type => type === FIRST2FINISH),
+        [challengeTrack, challengeType],
+    )
+
+    const isStandardChallenge = useMemo(
+        () => [challengeType, challengeTrack]
+            .some(type => type === TRACK_CHALLENGE),
+        [challengeTrack, challengeType],
+    )
+
+    const isAppealsWindowOpen = useMemo(
+        () => isAppealsPhase(challengeInfo)
+            || isAppealsResponsePhase(challengeInfo),
+        [challengeInfo],
+    )
+
+    const shouldShowAppealsColumn = useMemo(
+        () => allowsAppeals && (isAppealsWindowOpen || isChallengeCompleted),
+        [allowsAppeals, isAppealsWindowOpen, isChallengeCompleted],
+    )
+
     const aggregatedRows = useMemo(() => aggregateSubmissionReviews({
         mappingReviewAppeal,
         reviewers,
@@ -95,6 +131,43 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
         [aggregatedRows],
     )
 
+    const canDisplayScores = useCallback(
+        (submission: SubmissionRow): boolean => {
+            if (isChallengeCompleted) {
+                return true
+            }
+
+            if (isFirst2FinishChallenge) {
+                const reviews = submission.aggregated?.reviews ?? []
+                if (!reviews.length) {
+                    return false
+                }
+
+                const allReviewsCompleted = reviews.every(review => {
+                    const status = (review.reviewInfo?.status ?? '').toUpperCase()
+                    const committed = review.reviewInfo?.committed ?? false
+
+                    return committed
+                        || includes(['COMPLETED', 'SUBMITTED'], status)
+                })
+
+                return allReviewsCompleted
+            }
+
+            if (isStandardChallenge) {
+                return isAppealsWindowOpen
+            }
+
+            return true
+        },
+        [
+            isAppealsWindowOpen,
+            isChallengeCompleted,
+            isFirst2FinishChallenge,
+            isStandardChallenge,
+        ],
+    )
+
     const columns = useMemo<TableColumn<SubmissionRow>[]>(() => {
         const submissionColumn: TableColumn<SubmissionRow> = {
             className: styles.submissionColumn,
@@ -222,6 +295,14 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
             columnId: 'review-score',
             label: 'Review Score',
             renderer: (data: SubmissionRow) => {
+                if (!canDisplayScores(data)) {
+                    return (
+                        <span className={styles.notReviewed}>
+                            --
+                        </span>
+                    )
+                }
+
                 const scoreDisplay = data.aggregated?.averageFinalScoreDisplay
                 if (!scoreDisplay) {
                     return (
@@ -294,6 +375,14 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
                 )
             }
 
+            if (!canDisplayScores(data)) {
+                return (
+                    <span className={styles.notReviewed}>
+                        --
+                    </span>
+                )
+            }
+
             const finalScore = reviewDetail?.finalScore
             const formattedScore = typeof finalScore === 'number' && Number.isFinite(finalScore)
                 ? finalScore.toFixed(2)
@@ -386,7 +475,7 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
                 type: 'element',
             })
 
-            if (allowsAppeals) {
+            if (shouldShowAppealsColumn) {
                 aggregatedColumns.push({
                     className: styles.tableCellNoWrap,
                     columnId: `appeals-${index}`,
@@ -400,11 +489,13 @@ export const TableReviewAppealsForSubmitter: FC<Props> = (props: Props) => {
         return aggregatedColumns
     }, [
         allowsAppeals,
+        canDisplayScores,
         downloadSubmission,
         isSubmissionDownloadRestricted,
         isDownloading,
         isChallengeCompleted,
         maxReviewCount,
+        shouldShowAppealsColumn,
         restrictionMessage,
     ])
 

src/apps/review/src/lib/hooks/useFetchActiveReviews.ts

@@ -41,6 +41,24 @@ export interface useFetchActiveReviewsProps {
     pagination: ActiveReviewsPagination
 }
 
+const normalizeReviewProgressValue = (value: number): number => {
+    if (!Number.isFinite(value)) {
+        return 0
+    }
+
+    const percentage = value <= 1 ? value * 100 : value
+
+    if (percentage < 0) {
+        return 0
+    }
+
+    if (percentage > 100) {
+        return 100
+    }
+
+    return percentage
+}
+
 export const transformAssignments = (
     assignments: BackendMyReviewAssignment[],
     startIndex = 1,
@@ -92,14 +110,15 @@ export const transformAssignments = (
             )
             : undefined
 
-        const reviewProgressValues = items
+        const normalizedReviewProgressValues = items
             .map(item => item.reviewProgress)
             .filter((value): value is number => typeof value === 'number')
+            .map(normalizeReviewProgressValue)
 
-        const aggregatedReviewProgress = reviewProgressValues.length
+        const aggregatedReviewProgress = normalizedReviewProgressValues.length
             ? Math.round(
-                reviewProgressValues.reduce((total, value) => total + value, 0)
-                / reviewProgressValues.length,
+                normalizedReviewProgressValues.reduce((total, value) => total + value, 0)
+                / normalizedReviewProgressValues.length,
             )
             : undefined