Filter and sort functionality for Data Management table

client/components/DataManagement/DataManagementRow/index.jsx

@@ -21,6 +21,7 @@ import ReportStatusDot from '../../common/ReportStatusDot';
 import UpdateTargetDateModal from '@components/common/UpdateTargetDateModal';
 import VersionString from '../../common/VersionString';
 import PhasePill from '../../common/PhasePill';
+import { getVersionData } from '../utils';
 
 const StatusCell = styled.div`
     display: flex;
@@ -147,7 +148,8 @@ const DataManagementRow = ({
     ats,
     testPlan,
     testPlanVersions,
-    setTestPlanVersions
+    setTestPlanVersions,
+    tableRowIndex
 }) => {
     const { triggerLoad, loadingMessage } = useTriggerLoad();
     const {
@@ -206,27 +208,6 @@ const DataManagementRow = ({
         );
     }, [testPlanVersions]);
 
-    // Get the version information based on the latest or earliest date info from a group of
-    // TestPlanVersions
-    const getVersionData = (testPlanVersions, dateKey = 'updatedAt') => {
-        const earliestVersion = testPlanVersions.reduce((a, b) =>
-            new Date(a[dateKey]) < new Date(b[dateKey]) ? a : b
-        );
-        const earliestVersionDate = new Date(earliestVersion[dateKey]);
-
-        const latestVersion = testPlanVersions.reduce((a, b) =>
-            new Date(a[dateKey]) > new Date(b[dateKey]) ? a : b
-        );
-        const latestVersionDate = new Date(latestVersion[dateKey]);
-
-        return {
-            earliestVersion,
-            earliestVersionDate,
-            latestVersion,
-            latestVersionDate
-        };
-    };
-
     const getUniqueAtObjects = testPlanReports => {
         const uniqueAtObjects = {};
         testPlanReports.forEach(testPlanReport => {
@@ -1009,7 +990,7 @@ const DataManagementRow = ({
 
     return (
         <LoadingStatus message={loadingMessage}>
-            <tr>
+            <tr aria-rowindex={tableRowIndex}>
                 <th>
                     <a href={`/data-management/${testPlan.directory}`}>
                         <b>{testPlan.title}</b>
@@ -1123,6 +1104,7 @@ DataManagementRow.propTypes = {
             recommendedPhaseReachedAt: PropTypes.string
         })
     ).isRequired,
+    tableRowIndex: PropTypes.number.isRequired,
     setTestPlanVersions: PropTypes.func
 };
 

client/components/DataManagement/hooks.js

@@ -0,0 +1,232 @@
+import { useMemo, useState } from 'react';
+import {
+    DATA_MANAGEMENT_TABLE_FILTER_OPTIONS,
+    DATA_MANAGEMENT_TABLE_SORT_OPTIONS,
+    TABLE_SORT_ORDERS,
+    TEST_PLAN_VERSION_PHASES
+} from '../../utils/constants';
+import { getVersionData } from './utils';
+
+export const useTestPlanVersionsByPhase = testPlanVersions => {
+    const testPlanVersionsByPhase = useMemo(() => {
+        const initialPhases = Object.keys(TEST_PLAN_VERSION_PHASES).reduce(
+            (acc, key) => {
+                acc[TEST_PLAN_VERSION_PHASES[key]] = [];
+                return acc;
+            },
+            {}
+        );
+
+        return testPlanVersions.reduce((acc, testPlanVersion) => {
+            acc[testPlanVersion.phase].push(testPlanVersion);
+            return acc;
+        }, initialPhases);
+    }, [testPlanVersions]);
+
+    return { testPlanVersionsByPhase };
+};
+
+export const useDerivedOverallPhaseByTestPlanId = (
+    testPlans,
+    testPlanVersions
+) => {
+    const { testPlanVersionsByPhase } =
+        useTestPlanVersionsByPhase(testPlanVersions);
+
+    const getVersionDataByDirectory = (directory, phaseKey, phaseTimeKey) => {
+        if (
+            testPlanVersionsByPhase[phaseKey].some(
+                testPlanVersion =>
+                    testPlanVersion.testPlan.directory === directory
+            )
+        ) {
+            const { earliestVersion, latestVersion } = getVersionData(
+                testPlanVersionsByPhase[phaseKey],
+                phaseTimeKey
+            );
+            return phaseTimeKey ? earliestVersion?.phase : latestVersion?.phase;
+        }
+        return undefined;
+    };
+
+    const derivedOverallPhaseByTestPlanId = useMemo(() => {
+        const derivedOverallPhaseByTestPlanId = {};
+        const phases = [
+            {
+                phase: TEST_PLAN_VERSION_PHASES.RECOMMENDED,
+                timeKey: 'recommendedPhaseReachedAt'
+            },
+            {
+                phase: TEST_PLAN_VERSION_PHASES.CANDIDATE,
+                timeKey: 'candidatePhaseReachedAt'
+            },
+            {
+                phase: TEST_PLAN_VERSION_PHASES.DRAFT,
+                timeKey: 'draftPhaseReachedAt'
+            },
+            { phase: TEST_PLAN_VERSION_PHASES.RD }
+        ];
+        for (const testPlan of testPlans) {
+            for (const { phase, timeKey } of phases) {
+                const derivedPhase = getVersionDataByDirectory(
+                    testPlan.directory,
+                    phase,
+                    timeKey
+                );
+                if (derivedPhase) {
+                    derivedOverallPhaseByTestPlanId[testPlan.id] = derivedPhase;
+                    break;
+                }
+            }
+        }
+        return derivedOverallPhaseByTestPlanId;
+    }, [testPlans, testPlanVersions]);
+
+    return { derivedOverallPhaseByTestPlanId };
+};
+
+export const useTestPlansByPhase = (testPlans, testPlanVersions) => {
+    const { derivedOverallPhaseByTestPlanId } =
+        useDerivedOverallPhaseByTestPlanId(testPlans, testPlanVersions);
+
+    const testPlansByPhase = useMemo(() => {
+        const testPlansByPhase = {};
+        for (const key of Object.keys(TEST_PLAN_VERSION_PHASES)) {
+            testPlansByPhase[TEST_PLAN_VERSION_PHASES[key]] = [];
+        }
+        for (const testPlan of testPlans) {
+            testPlansByPhase[
+                derivedOverallPhaseByTestPlanId[testPlan.id]
+            ]?.push(testPlan);
+        }
+        return testPlansByPhase;
+    }, [derivedOverallPhaseByTestPlanId]);
+
+    return { testPlansByPhase };
+};
+
+export const useDataManagementTableFiltering = (
+    testPlans,
+    testPlanVersions,
+    filter
+) => {
+    const { testPlansByPhase } = useTestPlansByPhase(
+        testPlans,
+        testPlanVersions
+    );
+
+    const filteredTestPlans = useMemo(() => {
+        if (!filter || filter === DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.ALL) {
+            return testPlans;
+        } else {
+            return testPlansByPhase[filter];
+        }
+    }, [filter, testPlansByPhase, testPlans]);
+
+    const filterLabels = {
+        [DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.ALL]: `All Plans (${testPlans.length})`
+    };
+
+    if (testPlansByPhase[TEST_PLAN_VERSION_PHASES.RD].length > 0) {
+        filterLabels[
+            DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.RD
+        ] = `R&D Complete (${
+            testPlansByPhase[TEST_PLAN_VERSION_PHASES.RD].length
+        })`;
+    }
+
+    if (testPlansByPhase[TEST_PLAN_VERSION_PHASES.DRAFT].length > 0) {
+        filterLabels[
+            DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.DRAFT
+        ] = `In Draft Review (${
+            testPlansByPhase[TEST_PLAN_VERSION_PHASES.DRAFT].length
+        })`;
+    }
+
+    if (testPlansByPhase[TEST_PLAN_VERSION_PHASES.CANDIDATE].length > 0) {
+        filterLabels[
+            DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.CANDIDATE
+        ] = `In Candidate Review (${
+            testPlansByPhase[TEST_PLAN_VERSION_PHASES.CANDIDATE].length
+        })`;
+    }
+
+    if (testPlansByPhase[TEST_PLAN_VERSION_PHASES.RECOMMENDED].length > 0) {
+        filterLabels[
+            DATA_MANAGEMENT_TABLE_FILTER_OPTIONS.RECOMMENDED
+        ] = `Recommended Plans (${
+            testPlansByPhase[TEST_PLAN_VERSION_PHASES.RECOMMENDED].length
+        })`;
+    }
+
+    return { filteredTestPlans, filterLabels };
+};
+
+export const useDataManagementTableSorting = (
+    testPlans,
+    testPlanVersions,
+    ats
+) => {
+    const [activeSort, setActiveSort] = useState({
+        key: DATA_MANAGEMENT_TABLE_SORT_OPTIONS.PHASE,
+        direction: TABLE_SORT_ORDERS.ASC
+    });
+
+    const { derivedOverallPhaseByTestPlanId } =
+        useDerivedOverallPhaseByTestPlanId(testPlans, testPlanVersions);
+
+    const sortedTestPlans = useMemo(() => {
+        const phaseOrder = {
+            NOT_STARTED: -1,
+            RD: 0,
+            DRAFT: 1,
+            CANDIDATE: 2,
+            RECOMMENDED: 3
+        };
+        const directionMod =
+            activeSort.direction === TABLE_SORT_ORDERS.ASC ? -1 : 1;
+
+        const sortByName = (a, b, dir = directionMod) =>
+            dir * (a.title < b.title ? -1 : 1);
+
+        const sortByAts = (a, b) => {
+            const countA = ats.length; // Stubs based on current rendering in DataManagementRow
+            const countB = ats.length;
+            if (countA === countB) return sortByName(a, b);
+            return directionMod * (countA - countB);
+        };
+
+        const sortByPhase = (a, b) => {
+            const testPlanVersionOverallA =
+                derivedOverallPhaseByTestPlanId[a.id] ?? 'NOT_STARTED';
+            const testPlanVersionOverallB =
+                derivedOverallPhaseByTestPlanId[b.id] ?? 'NOT_STARTED';
+            if (testPlanVersionOverallA === testPlanVersionOverallB) {
+                return sortByName(a, b, directionMod * -1);
+            }
+            return (
+                directionMod *
+                (phaseOrder[testPlanVersionOverallA] -
+                    phaseOrder[testPlanVersionOverallB])
+            );
+        };
+
+        const sortFunctions = {
+            NAME: sortByName,
+            ATS: sortByAts,
+            PHASE: sortByPhase
+        };
+
+        return testPlans.slice().sort(sortFunctions[activeSort.key]);
+    }, [activeSort, testPlans]);
+
+    const updateSort = ({ key, direction }) => {
+        setActiveSort({ key, direction });
+    };
+
+    return {
+        sortedTestPlans,
+        updateSort,
+        activeSort
+    };
+};