Make sure we don't show screenign on review tabs

Author: jmgasper

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

@@ -7,6 +7,7 @@ import { ActionLoading } from '~/apps/admin/src/lib'
 
 import { ChallengeDetailContext } from '../../contexts'
 import {
+    BackendPhase,
     BackendSubmission,
     ChallengeInfo,
     MappingReviewAppeal,
@@ -46,6 +47,33 @@ const normalizeType = (value?: string): string => (
         : ''
 )
 
+const resolvePhaseNameFromId = (
+    phaseId?: string,
+    phases?: BackendPhase[],
+): string | undefined => {
+    if (!phaseId || !Array.isArray(phases)) {
+        return undefined
+    }
+
+    const normalizedPhaseId = `${phaseId}`.trim()
+        .toLowerCase()
+    if (!normalizedPhaseId) {
+        return undefined
+    }
+
+    const matchingPhase = phases.find(phase => {
+        const candidates = [phase.id, phase.phaseId]
+
+        return candidates.some(candidate => (
+            typeof candidate === 'string'
+            && candidate.trim()
+                .toLowerCase() === normalizedPhaseId
+        ))
+    })
+
+    return matchingPhase?.name
+}
+
 const EXCLUDED_REVIEW_TYPES = [
     'approval',
     'checkpoint',
@@ -55,17 +83,84 @@ const EXCLUDED_REVIEW_TYPES = [
     'specification',
 ] as const
 
-const shouldIncludeInReviewPhase = (submission?: SubmissionInfo): boolean => {
+const shouldIncludeInReviewPhase = (
+    submission?: SubmissionInfo,
+    phases?: BackendPhase[],
+): boolean => {
     if (!submission) {
         return false
     }
 
-    const normalizedType = normalizeType(submission.reviewTypeId)
-    if (!normalizedType) {
+    const normalizedCandidates = new Set<string>()
+    const registerCandidate = (candidate?: string | null): void => {
+        if (typeof candidate !== 'string') {
+            return
+        }
+
+        const normalized = normalizeType(candidate)
+        if (normalized) {
+            normalizedCandidates.add(normalized)
+        }
+    }
+
+    registerCandidate(submission.reviewTypeId)
+    registerCandidate(submission.review?.phaseName)
+    registerCandidate(submission.review?.reviewType)
+    registerCandidate(resolvePhaseNameFromId(submission.review?.phaseId, phases))
+
+    const metadata = submission.review?.metadata
+    if (metadata && typeof metadata === 'object') {
+        const metadataHints: unknown[] = [
+            (metadata as { type?: unknown }).type,
+            (metadata as { reviewType?: unknown }).reviewType,
+            (metadata as { review_type?: unknown }).review_type,
+            (metadata as { phase?: unknown }).phase,
+            (metadata as { phaseName?: unknown }).phaseName,
+            (metadata as { reviewPhase?: unknown }).reviewPhase,
+        ]
+
+        metadataHints.forEach(hint => {
+            if (typeof hint === 'string') {
+                registerCandidate(hint)
+            }
+        })
+    }
+
+    if (!normalizedCandidates.size) {
+        if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.debug('[ReviewTab] shouldIncludeInReviewPhase', {
+                normalizedCandidates: [],
+                reviewPhaseName: submission.review?.phaseName,
+                reviewType: submission.review?.reviewType,
+                reviewTypeId: submission.reviewTypeId,
+                submissionId: submission.id ?? submission.review?.submissionId,
+                verdict: 'included (no candidates)',
+            })
+        }
+
         return true
     }
 
-    return !EXCLUDED_REVIEW_TYPES.some(fragment => normalizedType.includes(fragment))
+    const normalizedCandidateList = Array.from(normalizedCandidates)
+    const isExcluded = normalizedCandidateList
+        .some(normalizedType => (
+            EXCLUDED_REVIEW_TYPES.some(fragment => normalizedType.includes(fragment))
+        ))
+
+    if (process.env.NODE_ENV !== 'production') {
+        // eslint-disable-next-line no-console
+        console.debug('[ReviewTab] shouldIncludeInReviewPhase', {
+            normalizedCandidates: normalizedCandidateList,
+            reviewPhaseName: submission.review?.phaseName,
+            reviewType: submission.review?.reviewType,
+            reviewTypeId: submission.reviewTypeId,
+            submissionId: submission.id ?? submission.review?.submissionId,
+            verdict: isExcluded ? 'excluded' : 'included',
+        })
+    }
+
+    return !isExcluded
 }
 
 interface Props {
@@ -248,8 +343,11 @@ export const ChallengeDetailsContent: FC<Props> = (props: Props) => {
         [challengeInfo?.phases],
     )
     const passesReviewTabGuards: (submission: SubmissionInfo) => boolean = useMemo(
-        () => (submission: SubmissionInfo): boolean => shouldIncludeInReviewPhase(submission),
-        [],
+        () => (submission: SubmissionInfo): boolean => shouldIncludeInReviewPhase(
+            submission,
+            challengeInfo?.phases,
+        ),
+        [challengeInfo?.phases],
     )
     const {
         reviews: reviewTabReviews,

src/apps/review/src/lib/components/ChallengeDetailsContent/TabContentReview.tsx

@@ -15,6 +15,7 @@ import {
     ChallengeDetailContext,
 } from '../../contexts'
 import {
+    BackendPhase,
     BackendResource,
     BackendSubmission,
     ChallengeDetailContextModel,
@@ -315,7 +316,10 @@ export const TabContentReview: FC<Props> = (props: Props) => {
     const resolvedReviews = useMemo(
         () => {
             if (providedReviews.length) {
-                return providedReviews
+                return providedReviews.filter(submission => shouldDisplayOnReviewTab(
+                    submission,
+                    challengeInfo?.phases,
+                ))
             }
 
             const fallbackFromBackend: SubmissionInfo[] = []
@@ -334,9 +338,10 @@ export const TabContentReview: FC<Props> = (props: Props) => {
                                 [review.resourceId]: review,
                             },
                         }
-                        fallbackFromBackend.push(
-                            convertBackendSubmissionToSubmissionInfo(submissionForReviewer),
-                        )
+                        const converted = convertBackendSubmissionToSubmissionInfo(submissionForReviewer)
+                        if (shouldDisplayOnReviewTab(converted, challengeInfo?.phases)) {
+                            fallbackFromBackend.push(converted)
+                        }
                     })
                 })
             }
@@ -350,11 +355,21 @@ export const TabContentReview: FC<Props> = (props: Props) => {
             }
 
             const fallback = challengeSubmissions.filter(hasReviewerAssignment)
-            return fallback.length ? fallback : providedReviews
+            const filteredFallback = fallback.filter(submission => shouldDisplayOnReviewTab(
+                submission,
+                challengeInfo?.phases,
+            ))
+            return filteredFallback.length
+                ? filteredFallback
+                : providedReviews.filter(submission => shouldDisplayOnReviewTab(
+                    submission,
+                    challengeInfo?.phases,
+                ))
         },
         [
             backendChallengeSubmissions,
             challengeSubmissions,
+            challengeInfo?.phases,
             hasReviewerAssignment,
             myReviewerResourceIds,
             providedReviews,
@@ -389,6 +404,10 @@ export const TabContentReview: FC<Props> = (props: Props) => {
                     return false
                 }
 
+                if (!shouldDisplayOnReviewTab(submission, challengeInfo?.phases)) {
+                    return false
+                }
+
                 const submissionMemberId = submission.memberId
                     ? `${submission.memberId}`.trim()
                     : ''
@@ -410,11 +429,19 @@ export const TabContentReview: FC<Props> = (props: Props) => {
             })
                 .map(enhanceSubmissionForSubmitter)
 
-            return fallback.length ? fallback : providedSubmitterReviews
+            if (fallback.length) {
+                return fallback
+            }
+
+            return providedSubmitterReviews.filter(submission => shouldDisplayOnReviewTab(
+                submission,
+                challengeInfo?.phases,
+            ))
         },
         [
             challengeSubmissions,
             enhanceSubmissionForSubmitter,
+            challengeInfo?.phases,
             myOwnedMemberIds,
             myOwnedSubmissionIds,
             providedReviews,
@@ -522,3 +549,60 @@ export const TabContentReview: FC<Props> = (props: Props) => {
 }
 
 export default TabContentReview
+function normalizeReviewType(value?: string | null): string {
+    if (!value) {
+        return ''
+    }
+
+    return value
+        .toLowerCase()
+        .replace(/[^a-z]/g, '')
+}
+
+const EXCLUDED_REVIEW_TYPE_FRAGMENTS = [
+    'approval',
+    'checkpoint',
+    'iterative',
+    'postmortem',
+    'screening',
+    'specification',
+] as const
+
+function shouldDisplayOnReviewTab(
+    submission: SubmissionInfo,
+    phases?: BackendPhase[],
+): boolean {
+    const normalized = new Set<string>()
+    const register = (candidate?: string | null): void => {
+        const normalizedCandidate = normalizeReviewType(candidate)
+        if (normalizedCandidate) {
+            normalized.add(normalizedCandidate)
+        }
+    }
+
+    register(submission.reviewTypeId)
+    register(submission.review?.reviewType)
+    register(submission.review?.phaseName)
+
+    const phaseId = submission.review?.phaseId
+    if (phaseId && phases?.length) {
+        const normalizedPhaseId = `${phaseId}`.trim()
+            .toLowerCase()
+        const matchingPhase = phases.find(phase => (
+            (phase.id && phase.id.toLowerCase() === normalizedPhaseId)
+            || (phase.phaseId && phase.phaseId.toLowerCase() === normalizedPhaseId)
+        ))
+        if (matchingPhase?.name) {
+            register(matchingPhase.name)
+        }
+    }
+
+    if (!normalized.size) {
+        return true
+    }
+
+    return !Array.from(normalized)
+        .some(candidate => (
+            EXCLUDED_REVIEW_TYPE_FRAGMENTS.some(fragment => candidate.includes(fragment))
+        ))
+}