Feature/sort datasets

src/containers/App/index.tsx

@@ -76,7 +76,7 @@ function mapStateToProps(state: State) {
         isLoading: metadataStateBranch.selectors.getIsLoading(state),
         loadingText: metadataStateBranch.selectors.getLoadingText(state),
         selectedDataset: selectionStateBranch.selectors.getSelectedDataset(state),
-        datasets: metadataStateBranch.selectors.getDatasets(state),
+        datasets: metadataStateBranch.selectors.getDatasetsByNewest(state),
     };
 }
 

src/state/metadata/selectors.ts

@@ -5,6 +5,7 @@ import {
     MITOTIC_STAGE_KEY,
     PROTEIN_NAME_KEY,
 } from "../../constants";
+import { DatasetMetaData } from "../../constants/datasets";
 import { State } from "../types";
 
 import {
@@ -28,6 +29,31 @@ export const getMeasuredFeaturesDefs = (state: State) => state.metadata.measured
 export const getFileInfo = (state: State) => state.metadata.cellFileInfo;
 export const getClusterData = (state: State) => state.metadata.clusterData;
 
+export const getDatasetsByNewest = createSelector([getDatasets], (datasets) => {
+    return datasets.sort((a: DatasetMetaData, b: DatasetMetaData) => {
+        // TODO: We need to sort and group datasets by "megasets"
+        // and then order those megasets by "newness"
+        // plus we have plans to have different versions of the same
+        // dataset contained within one card, so this is a temporary 
+        // sort function to get the newest datasets on top 
+        if (a.name === b.name) {
+            // if it's the same dataset, return the newest version first
+            if (a.version > b.version) {
+                return -1;
+            } else {
+                return 1;
+            }
+        // otherwise sort by name
+        } else if (a.name > b.name){
+            return -1;
+        } else if (a.name < b.name) {
+            return 1;
+        } else {
+            return 0
+        }
+    });
+})
+
 export const getMeasuredFeatureArrays = createSelector([getPerCellDataForPlot], (dataForPlot: DataForPlot) => {
     return dataForPlot.values;
 });

src/state/metadata/test/selectors.test.ts

@@ -2,20 +2,23 @@ import { expect } from "chai";
 
 import { mockState } from "../../test/mocks";
 import { State } from "../../types";
-import { getMeasuredFeaturesKeys, getProteinNames } from "../selectors";
+import { getDatasetsByNewest, getMeasuredFeaturesKeys, getProteinNames } from "../selectors";
 
 describe("Metadata branch selectors", () => {
-
     describe("getMeasuredFeaturesKeys", () => {
         it("returns the keys of measured features data", () => {
             const state: State = {
                 ...mockState,
             };
             const result: string[] = getMeasuredFeaturesKeys(state);
-            expect(result).to.deep.equal(["apical-proximity", "cell-segmentation", "cellular-surface-area", "missing-data"]);
+            expect(result).to.deep.equal([
+                "apical-proximity",
+                "cell-segmentation",
+                "cellular-surface-area",
+                "missing-data",
+            ]);
         });
     });
-
     describe("getProteinNames", () => {
         it("returns names of the proteins in the dataset", () => {
             const state: State = {
@@ -24,8 +27,74 @@ describe("Metadata branch selectors", () => {
             const result: string[] = getProteinNames(state).sort((a: string, b: string) => {
                 return b > a ? 1 : -1;
             });
-            expect(result).to.deep.equal(["Nucleophosmin", "Delta-actin", "Beta-catenin", "Beta-actin", "Alpha-actinin-1"]);
+            expect(result).to.deep.equal([
+                "Nucleophosmin",
+                "Delta-actin",
+                "Beta-catenin",
+                "Beta-actin",
+                "Alpha-actinin-1",
+            ]);
         });
     });
 
+    describe("getDatasetsByNewest", () => {
+        it("returns the dataset card data in the order of newest to oldest", () => {
+            const dataset1 = {
+                name: "name1",
+                version: "2020.1",
+            };
+            const dataset2 = {
+                name: "name1",
+                version: "2021.1",
+            };
+            const state: State = {
+                ...mockState,
+                metadata: {
+                    datasets: [dataset1, dataset2],
+                },
+            };
+            const result: string[] = getDatasetsByNewest(state);
+            expect(result).to.deep.equal([dataset2, dataset1]);
+        });
+        it("returns the dataset card data in the order of newest to oldest", () => {
+            const dataset1 = {
+                name: "name1",
+                version: "2021.1",
+            };
+            const dataset2 = {
+                name: "name1",
+                version: "2021.2",
+            };
+            const state: State = {
+                ...mockState,
+                metadata: {
+                    datasets: [dataset1, dataset2],
+                },
+            };
+            const result: string[] = getDatasetsByNewest(state);
+            expect(result).to.deep.equal([dataset2, dataset1]);
+        });
+        it("returns the dataset card data with datasets grouped by name", () => {
+            const newerName1 = {
+                name: "name1",
+                version: "2021.2",
+            };
+            const dataset2 = {
+                name: "name2",
+                version: "2021.2",
+            };
+            const olderName1 = {
+                name: "name1",
+                version: "2021.1",
+            };
+            const state: State = {
+                ...mockState,
+                metadata: {
+                    datasets: [newerName1, dataset2, olderName1],
+                },
+            };
+            const result: string[] = getDatasetsByNewest(state);
+            expect(result).to.deep.equal([dataset2, newerName1, olderName1]);
+        });
+    });
 });