Merge pull request #245 from American-Institutes-for-Research/HEA-947/Add-LivelihoodStrategyType-to-LivelihoodZoneBaselineFacetedSearchView

Hea 947/add livelihood strategy type to livelihood zone baseline faceted search view

Author: rhunwicks

apps/baseline/tests/test_viewsets.py

@@ -21,7 +21,7 @@
 )
 from common.fields import translation_fields
 from common.tests.factories import ClassifiedProductFactory, CountryFactory
-from metadata.models import LivelihoodActivityScenario
+from metadata.models import LivelihoodActivityScenario, LivelihoodStrategyType
 from metadata.tests.factories import (
     CharacteristicGroupFactory,
     LivelihoodCategoryFactory,
@@ -762,6 +762,15 @@ def test_search_with_product(self):
         self.assertEqual(search_data["products"][0]["count"], 2)  # 2 zones have this product
         # confirm the product value is correct
         self.assertEqual(search_data["products"][0]["value"], self.product1.cpc)
+        # confirm livelihood_zone_baselines are present with correct data
+        baselines = search_data["products"][0]["livelihood_zone_baselines"]
+        self.assertEqual(len(baselines), 2)
+        baseline_ids = {b["id"] for b in baselines}
+        self.assertEqual(baseline_ids, {self.baseline1.id, self.baseline3.id})
+        for b in baselines:
+            self.assertIn("name", b)
+            self.assertIn("livelihood_zone__code", b)
+            self.assertIn("reference_year_end_date", b)
         # Apply the filters to the baseline
         baseline_url = reverse("livelihoodzonebaseline-list")
         response = self.client.get(
@@ -775,9 +784,11 @@ def test_search_with_product(self):
         self.assertTrue(any(d["name"] == self.baseline3.name for d in data))
         self.assertFalse(any(d["name"] == self.baseline2.name for d in data))
 
+        # Find the item matching characteristic1 (not relying on order)
+        characteristic1_item = next(item for item in search_data["items"] if item["value"] == self.characteristic1.pk)
         response = self.client.get(
             baseline_url,
-            {search_data["items"][0]["filter"]: search_data["items"][0]["value"]},
+            {characteristic1_item["filter"]: characteristic1_item["value"]},
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(json.loads(response.content)), 1)
@@ -804,6 +815,14 @@ def test_search_with_wealth_characterstics(self):
         self.assertEqual(len(data["items"]), 2)
         self.assertEqual(data["items"][0]["count"], 1)  # 1 zone for this characteristic
         self.assertEqual(data["items"][1]["count"], 1)  # 1 zone for this characteristic
+        # confirm livelihood_zone_baselines are present on each item
+        for item in data["items"]:
+            self.assertIn("livelihood_zone_baselines", item)
+            self.assertEqual(len(item["livelihood_zone_baselines"]), 1)
+            self.assertIn("id", item["livelihood_zone_baselines"][0])
+            self.assertIn("name", item["livelihood_zone_baselines"][0])
+            self.assertIn("livelihood_zone__code", item["livelihood_zone_baselines"][0])
+            self.assertIn("reference_year_end_date", item["livelihood_zone_baselines"][0])
         # Search by the second characteristic
         response = self.client.get(
             self.url,
@@ -826,6 +845,86 @@ def test_search_with_wealth_characterstics(self):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(len(data["items"]), 0)
 
+    def test_search_with_livelihood_strategy_type(self):
+        # Create products with "goat" in the name for partial match testing
+        goat_product = ClassifiedProductFactory(
+            cpc="L09901AA",
+            description_en="Goats",
+            common_name_en="Goat",
+        )
+        goat_meat_product = ClassifiedProductFactory(
+            cpc="L09902AA",
+            description_en="Goat Meat",
+            common_name_en="Goat Meat",
+        )
+        goat_milk_product = ClassifiedProductFactory(
+            cpc="L09903AA",
+            description_en="Goat's Milk",
+            common_name_en="Goat Milk",
+        )
+        # Create strategies linking products to baselines with specific strategy types
+        LivelihoodStrategyFactory(
+            product=goat_milk_product,
+            livelihood_zone_baseline=self.baseline1,
+            strategy_type=LivelihoodStrategyType.MILK_PRODUCTION,
+        )
+        LivelihoodStrategyFactory(
+            product=goat_meat_product,
+            livelihood_zone_baseline=self.baseline2,
+            strategy_type=LivelihoodStrategyType.MEAT_PRODUCTION,
+        )
+        LivelihoodStrategyFactory(
+            product=goat_product,
+            livelihood_zone_baseline=self.baseline3,
+            strategy_type=LivelihoodStrategyType.LIVESTOCK_SALE,
+        )
+        # Test that search "Milk" returns MilkProduction in livelihood_strategy_types facet
+        response = self.client.get(self.url, {"search": "Milk"})
+        self.assertEqual(response.status_code, 200)
+        data = response.data
+        self.assertIn("livelihood_strategy_types", data)
+        strategy_type_results = data["livelihood_strategy_types"]
+        milk_results = [r for r in strategy_type_results if r["value"] == "MilkProduction"]
+        self.assertEqual(len(milk_results), 1)
+        self.assertEqual(milk_results[0]["filter"], "strategy_type")
+        self.assertEqual(milk_results[0]["value_label"], "Milk Production")
+        self.assertEqual(milk_results[0]["count"], 1)
+        # confirm livelihood_zone_baselines on strategy type result
+        baselines = milk_results[0]["livelihood_zone_baselines"]
+        self.assertEqual(len(baselines), 1)
+        self.assertEqual(baselines[0]["id"], self.baseline1.id)
+        self.assertIn("name", baselines[0])
+        self.assertIn("livelihood_zone__code", baselines[0])
+        self.assertIn("reference_year_end_date", baselines[0])
+
+        # Test that search "lait" with language=fr returns MilkProduction via French translation
+        response = self.client.get(self.url, {"search": "lait", "language": "fr"})
+        self.assertEqual(response.status_code, 200)
+        data = response.data
+        strategy_type_results = data["livelihood_strategy_types"]
+        milk_results = [r for r in strategy_type_results if r["value"] == "MilkProduction"]
+        self.assertEqual(len(milk_results), 1)
+        self.assertEqual(milk_results[0]["value_label"], "Production du lait")
+
+        # Test that search "goat" returns multiple goat-related products
+        response = self.client.get(self.url, {"search": "goat", "language": "en"})
+        self.assertEqual(response.status_code, 200)
+        data = response.data
+        product_results = data["products"]
+        product_cpcs = {r["value"] for r in product_results}
+        self.assertIn(goat_product.cpc, product_cpcs)
+        self.assertIn(goat_meat_product.cpc, product_cpcs)
+        self.assertIn(goat_milk_product.cpc, product_cpcs)
+        self.assertEqual(len(product_results), 3)
+
+        # test taht strategy_type filter to baseline list endpoint
+        baseline_url = reverse("livelihoodzonebaseline-list")
+        response = self.client.get(baseline_url, {"strategy_type": "MilkProduction"})
+        self.assertEqual(response.status_code, 200)
+        baseline_data = json.loads(response.content)
+        self.assertEqual(len(baseline_data), 1)
+        self.assertEqual(baseline_data[0]["name"], self.baseline1.name)
+
 
 class LivelihoodProductCategoryViewSetTestCase(APITestCase):
     @classmethod

apps/baseline/viewsets.py

@@ -17,9 +17,10 @@
 
 from common.fields import translation_fields
 from common.filters import DefaultingDateFilter, MultiFieldFilter, UpperCaseFilter
+from common.models import ClassifiedProduct
 from common.utils import make_condition_funcs
 from common.viewsets import AggregatingViewSet, BaseModelViewSet
-from metadata.models import WealthGroupCategory
+from metadata.models import LivelihoodStrategyType, WealthGroupCategory
 
 from .models import (
     BaselineLivelihoodActivity,
@@ -212,6 +213,7 @@ class Meta:
     wealth_characteristic = CharFilter(
         method="filter_by_wealth_characteristic", label="Filter by Wealth Characteristic"
     )
+    strategy_type = CharFilter(method="filter_by_strategy_type", label="Filter by Strategy Type")
     as_of_date = DefaultingDateFilter(
         label="As of Date",
         help_text="Filter baselines valid as of this date (YYYY-MM-DD format or special values like 'today').",
@@ -257,6 +259,13 @@ def filter_by_wealth_characteristic(self, queryset, name, value):
 
         return queryset.filter(id__in=Subquery(matching_baselines))
 
+    def filter_by_strategy_type(self, queryset, name, value):
+        """
+        Filter the baseline by matching livelihood strategy type
+        """
+        matching_baselines = LivelihoodStrategy.objects.filter(strategy_type=value).values("livelihood_zone_baseline")
+        return queryset.filter(id__in=matching_baselines)
+
 
 class LivelihoodZoneBaselineViewSet(BaseModelViewSet):
     """
@@ -2088,6 +2097,28 @@ class LivelihoodZoneBaselineFacetedSearchView(APIView):
     renderer_classes = [JSONRenderer]
     permission_classes = [AllowAny]
 
+    def _get_baselines(self, baselines_qs):
+        # returs a list of baseline dicts with id, name, livelihood_zone__code, reference_year_end_date.
+        return [
+            {
+                "id": baseline.id,
+                "name": baseline.name,
+                "livelihood_zone__code": baseline.livelihood_zone.code,
+                "reference_year_end_date": baseline.reference_year_end_date,
+            }
+            for baseline in baselines_qs.select_related("livelihood_zone")
+        ]
+
+    def _search_products(self, search_term):
+        # Search products using icontains for broader matching than the default iexact search.
+        q_object = Q()
+        for field in [*translation_fields("description"), *translation_fields("common_name")]:
+            q_object |= Q(**{f"{field}__icontains": search_term})
+        q_object |= Q(cpc__startswith=search_term)
+        q_object |= Q(aliases__contains=[search_term.lower()])
+        q_object |= Q(scientific_name__icontains=search_term)
+        return ClassifiedProduct.objects.filter(q_object).distinct()
+
     def get(self, request, format=None):
         """
         Return a faceted set of matching filters
@@ -2100,56 +2131,89 @@ def get(self, request, format=None):
             for model_entry in MODELS_TO_SEARCH:
                 app_name = model_entry["app_name"]
                 model_name = model_entry["model_name"]
-                filter, filter_label, filter_category = (
-                    model_entry["filter"]["key"],
-                    model_entry["filter"]["label"],
-                    model_entry["filter"]["category"],
-                )
+                filter_key = model_entry["filter"]["key"]
+                filter_label = model_entry["filter"]["label"]
+                filter_category = model_entry["filter"]["category"]
                 ModelClass = apps.get_model(app_name, model_name)
-                search_per_model = ModelClass.objects.search(search_term)
+                if model_name == "ClassifiedProduct":
+                    search_per_model = self._search_products(search_term)
+                else:
+                    search_per_model = ModelClass.objects.search(search_term)
                 results[filter_category] = []
                 # for activating language
                 with override(language):
                     for search_result in search_per_model:
                         if model_name == "ClassifiedProduct":
-                            unique_zones = (
-                                LivelihoodStrategy.objects.filter(product=search_result)
-                                .values("livelihood_zone_baseline")
-                                .distinct()
-                                .count()
-                            )
+                            baselines_qs = LivelihoodZoneBaseline.objects.filter(
+                                id__in=LivelihoodStrategy.objects.filter(product=search_result).values(
+                                    "livelihood_zone_baseline"
+                                )
+                            ).distinct()
                             value_label, value = search_result.description, search_result.pk
                         elif model_name == "LivelihoodCategory":
-                            unique_zones = LivelihoodZoneBaseline.objects.filter(
+                            baselines_qs = LivelihoodZoneBaseline.objects.filter(
                                 main_livelihood_category=search_result
-                            ).count()
+                            )
                             value_label, value = search_result.description, search_result.pk
                         elif model_name == "LivelihoodZone":
-                            unique_zones = LivelihoodZoneBaseline.objects.filter(livelihood_zone=search_result).count()
+                            baselines_qs = LivelihoodZoneBaseline.objects.filter(livelihood_zone=search_result)
                             value_label, value = search_result.name, search_result.pk
                         elif model_name == "WealthCharacteristic":
-                            unique_zones = (
-                                WealthGroupCharacteristicValue.objects.filter(wealth_characteristic=search_result)
-                                .values("wealth_group__livelihood_zone_baseline")
-                                .distinct()
-                                .count()
-                            )
+                            baselines_qs = LivelihoodZoneBaseline.objects.filter(
+                                id__in=WealthGroupCharacteristicValue.objects.filter(
+                                    wealth_characteristic=search_result
+                                ).values("wealth_group__livelihood_zone_baseline")
+                            ).distinct()
                             value_label, value = search_result.description, search_result.pk
                         elif model_name == "Country":
-                            unique_zones = (
-                                LivelihoodZoneBaseline.objects.filter(livelihood_zone__country=search_result)
-                                .distinct()
-                                .count()
-                            )
+                            baselines_qs = LivelihoodZoneBaseline.objects.filter(
+                                livelihood_zone__country=search_result
+                            ).distinct()
                             value_label, value = search_result.iso_en_name, search_result.pk
-                        if unique_zones > 0:
+                        baselines = self._get_baselines(baselines_qs)
+                        if baselines:
                             results[filter_category].append(
                                 {
-                                    "filter": filter,
+                                    "filter": filter_key,
                                     "filter_label": filter_label,
                                     "value_label": value_label,
                                     "value": value,
-                                    "count": unique_zones,
+                                    "count": len(baselines),
+                                    "livelihood_zone_baselines": baselines,
+                                }
+                            )
+
+            # Search livelihood strategy types (not a model query)
+            results["livelihood_strategy_types"] = []
+            search_lower = search_term.lower()
+            # Get English labels outside language override for matching
+            english_labels = {}
+            with override("en"):
+                for strategy_type in LivelihoodStrategyType:
+                    english_labels[strategy_type.value] = str(strategy_type.label).lower()
+            with override(language):
+                for strategy_type in LivelihoodStrategyType:
+                    translated_label = str(strategy_type.label)
+                    if (
+                        search_lower in strategy_type.value.lower()
+                        or search_lower in english_labels[strategy_type.value]
+                        or search_lower in translated_label.lower()
+                    ):
+                        baselines_qs = LivelihoodZoneBaseline.objects.filter(
+                            id__in=LivelihoodStrategy.objects.filter(strategy_type=strategy_type.value).values(
+                                "livelihood_zone_baseline"
+                            )
+                        ).distinct()
+                        baselines = self._get_baselines(baselines_qs)
+                        if baselines:
+                            results["livelihood_strategy_types"].append(
+                                {
+                                    "filter": "strategy_type",
+                                    "filter_label": "Livelihood Strategy Type",
+                                    "value_label": translated_label,
+                                    "value": strategy_type.value,
+                                    "count": len(baselines),
+                                    "livelihood_zone_baselines": baselines,
                                 }
                             )