Merge pull request #183 from CodeForPhilly/feat/zbl-hyperlinkgenus

Implement genus and family filters in plant search; add corresponding…

Author: ZacharyLeahan

lib/server.js

@@ -176,51 +176,45 @@ module.exports = async function ({ plants, nurseries }) {
       const queryRegex = new RegExp(queryLower, 'i');
       const sections = [];
 
-      // Search Plants by Common Name and Scientific Name
-      const plantsByCommonName = await plants.find({
-        "Common Name": queryRegex
-      })
-      .sort({ "Recommendation Score": -1 })
-      .limit(10)
-      .toArray();
-
-      const plantsByScientificName = await plants.find({
-        "Scientific Name": queryRegex
-      })
-      .sort({ "Recommendation Score": -1 })
-      .limit(10)
-      .toArray();
+      // Search Genus
+      const genusValues = await plants.distinct("Genus");
+      const matchingGenus = genusValues
+        .filter(value => value && queryRegex.test(value))
+        .slice(0, 10);
 
-      // Combine and deduplicate plant results
-      const plantMap = new Map();
-      plantsByCommonName.forEach(plant => {
-        plantMap.set(plant._id, {
-          plantId: plant._id,
-          commonName: plant["Common Name"],
-          scientificName: plant["Scientific Name"],
-          displayText: plant["Common Name"],
-          subtitle: plant["Scientific Name"],
-          action: "navigateToPlant"
+      if (matchingGenus.length > 0) {
+        sections.push({
+          type: "filter",
+          filterName: "Genus",
+          label: "Genus",
+          items: matchingGenus.map(value => ({
+            value: value,
+            displayText: value,
+            action: "applyFilter",
+            filterName: "Genus",
+            filterValue: value
+          }))
         });
-      });
-      plantsByScientificName.forEach(plant => {
-        if (!plantMap.has(plant._id)) {
-          plantMap.set(plant._id, {
-            plantId: plant._id,
-            commonName: plant["Common Name"],
-            scientificName: plant["Scientific Name"],
-            displayText: plant["Common Name"],
-            subtitle: plant["Scientific Name"],
-            action: "navigateToPlant"
-          });
-        }
-      });
+      }
 
-      if (plantMap.size > 0) {
+      // Search Family
+      const familyValues = await plants.distinct("Family");
+      const matchingFamily = familyValues
+        .filter(value => value && queryRegex.test(value))
+        .slice(0, 10);
+
+      if (matchingFamily.length > 0) {
         sections.push({
-          type: "plant",
-          label: "Plant",
-          items: Array.from(plantMap.values())
+          type: "filter",
+          filterName: "Family",
+          label: "Family",
+          items: matchingFamily.map(value => ({
+            value: value,
+            displayText: value,
+            action: "applyFilter",
+            filterName: "Family",
+            filterValue: value
+          }))
         });
       }
 
@@ -268,6 +262,54 @@ module.exports = async function ({ plants, nurseries }) {
         });
       }
 
+      // Search Plants by Common Name and Scientific Name (kept last so filters are shown first)
+      const plantsByCommonName = await plants.find({
+        "Common Name": queryRegex
+      })
+      .sort({ "Recommendation Score": -1 })
+      .limit(10)
+      .toArray();
+
+      const plantsByScientificName = await plants.find({
+        "Scientific Name": queryRegex
+      })
+      .sort({ "Recommendation Score": -1 })
+      .limit(10)
+      .toArray();
+
+      // Combine and deduplicate plant results
+      const plantMap = new Map();
+      plantsByCommonName.forEach(plant => {
+        plantMap.set(plant._id, {
+          plantId: plant._id,
+          commonName: plant["Common Name"],
+          scientificName: plant["Scientific Name"],
+          displayText: plant["Common Name"],
+          subtitle: plant["Scientific Name"],
+          action: "navigateToPlant"
+        });
+      });
+      plantsByScientificName.forEach(plant => {
+        if (!plantMap.has(plant._id)) {
+          plantMap.set(plant._id, {
+            plantId: plant._id,
+            commonName: plant["Common Name"],
+            scientificName: plant["Scientific Name"],
+            displayText: plant["Common Name"],
+            subtitle: plant["Scientific Name"],
+            action: "navigateToPlant"
+          });
+        }
+      });
+
+      if (plantMap.size > 0) {
+        sections.push({
+          type: "plant",
+          label: "Plant",
+          items: Array.from(plantMap.values())
+        });
+      }
+
       res.json({ query, sections });
     } catch (error) {
       console.error("Autocomplete error:", error);
@@ -446,6 +488,18 @@ module.exports = async function ({ plants, nurseries }) {
           value: [],
           array: true,
         },
+        {
+          name: "Genus",
+          value: [],
+          array: true,
+          unwind: false,
+        },
+        {
+          name: "Family",
+          value: [],
+          array: true,
+          unwind: false,
+        },
         {
           name: "Sun Exposure Flags",
           value: [],
@@ -843,16 +897,20 @@ module.exports = async function ({ plants, nurseries }) {
                 {
                   $match: matchQuery,
                 },
-                {
+              ];
+              // Some "array" filters are represented as scalar strings in MongoDB (e.g. Genus/Family).
+              // Only unwind when the field is actually an array.
+              if (filter.unwind !== false) {
+                aQuery.push({
                   $unwind: `$${filter.name}`,
+                });
+              }
+              aQuery.push({
+                $group: {
+                  _id: `$${filter.name}`,
+                  count: { $sum: 1 },
                 },
-                {
-                  $group: {
-                    _id: `$${filter.name}`,
-                    count: { $sum: 1 },
-                  },
-                },
-              ];
+              });
               filter.counts = await plants.aggregate(aQuery).toArray();
             } else if (filter.boolean) {
               const matchQuery = { ...query };