Merge pull request #290 from American-Institutes-for-Research/HEA-1086/improve_livelihood_activity_admin

Hea 1086/improve livelihood activity admin

Author: rhunwicks

apps/baseline/admin.py

@@ -1,3 +1,4 @@
+import re
 from copy import deepcopy
 
 from binary_database_files.models import File
@@ -330,6 +331,7 @@ class LivelihoodStrategyAdmin(admin.ModelAdmin):
         *translation_fields("livelihood_zone_baseline__livelihood_zone__name__icontains"),
         *translation_fields("product__common_name__icontains"),
         *translation_fields("season__name__icontains"),
+        "livelihood_zone_baseline__livelihood_zone__country__iso_en_ro_name",
     )
 
     list_filter = (
@@ -338,6 +340,22 @@ class LivelihoodStrategyAdmin(admin.ModelAdmin):
         ("livelihood_zone_baseline__livelihood_zone__country", admin.RelatedOnlyFieldListFilter),
     )
 
+    def get_search_results(self, request, queryset, search_term):
+        # Allow natural key format "BF01: 2011-10-31" by stripping the colon separator.
+        normalized = search_term.replace(":", "")
+        date_match = re.search(r"\b(\d{4}-\d{2}-\d{2})\b", normalized)
+        year_match = re.search(r"\b(\d{4})\b", normalized)
+        # Remove date/year from the term so text fields are searched without them.
+        text_term = re.sub(r"\b\d{4}(?:-\d{2}-\d{2})?\b", "", normalized).strip()
+        queryset, use_distinct = super().get_search_results(request, queryset, text_term)
+        if date_match:
+            queryset = queryset.filter(livelihood_zone_baseline__reference_year_end_date=date_match.group(1))
+        elif year_match:
+            queryset = queryset.filter(
+                livelihood_zone_baseline__reference_year_end_date__year=int(year_match.group(1))
+            )
+        return queryset, use_distinct
+
     def get_queryset(self, request):
         return (
             super()
@@ -504,6 +522,8 @@ class LivelihoodActivityAdmin(admin.ModelAdmin):
     list_filter = (
         "strategy_type",
         "scenario",
+        ("livelihood_zone_baseline", admin.RelatedOnlyFieldListFilter),
+        ("wealth_group__wealth_group_category", admin.RelatedOnlyFieldListFilter),
         ("livelihood_strategy__product", admin.RelatedOnlyFieldListFilter),
         ("livelihood_strategy__season", admin.RelatedOnlyFieldListFilter),
         ("livelihood_zone_baseline__livelihood_zone__country", admin.RelatedOnlyFieldListFilter),
@@ -517,15 +537,32 @@ class LivelihoodActivityAdmin(admin.ModelAdmin):
         "livelihood_strategy__additional_identifier__icontains",
         "livelihood_zone_baseline__livelihood_zone__code",
         "livelihood_zone_baseline__livelihood_zone__alternate_code",
+        *translation_fields("livelihood_zone_baseline__livelihood_zone__name"),
         "livelihood_strategy__product__cpc__iexact",
         "livelihood_strategy__product__aliases__icontains",
         "livelihood_strategy__season__aliases__icontains",
         "livelihood_strategy__additional_identifier",
         *translation_fields("livelihood_strategy__product__common_name__icontains"),
         *translation_fields("livelihood_strategy__product__description__icontains"),
         *translation_fields("livelihood_strategy__season__name__icontains"),
+        "livelihood_zone_baseline__livelihood_zone__country__iso_en_ro_name",
     )
 
+    def get_search_results(self, request, queryset, search_term):
+        # Allow natural key format "BF01: 2011-10-31" by stripping the colon separator.
+        normalized = search_term.replace(":", "")
+        date_match = re.search(r"\b(\d{4}-\d{2}-\d{2})\b", normalized)
+        year_match = re.search(r"\b(\d{4})\b", normalized)
+        text_term = re.sub(r"\b\d{4}(?:-\d{2}-\d{2})?\b", "", normalized).strip()
+        queryset, use_distinct = super().get_search_results(request, queryset, text_term)
+        if date_match:
+            queryset = queryset.filter(livelihood_zone_baseline__reference_year_end_date=date_match.group(1))
+        elif year_match:
+            queryset = queryset.filter(
+                livelihood_zone_baseline__reference_year_end_date__year=int(year_match.group(1))
+            )
+        return queryset, use_distinct
+
     def get_object(self, request, object_id, from_field=None):
         obj = super().get_object(request, object_id, from_field)
         if obj is None:
@@ -600,6 +637,7 @@ def get_country_name(self, obj):
             None,
             {
                 "fields": [
+                    "wealth_group",
                     "livelihood_strategy",
                     "scenario",
                     "extra",
@@ -1065,19 +1103,39 @@ class SeasonalActivityAdmin(admin.ModelAdmin):
         "is_key",
     )
     search_fields = (
-        "seasonal_activity_type",
-        "season",
-        "product",
-        "additional_identifier",
+        "livelihood_zone_baseline__livelihood_zone__code",
+        "livelihood_zone_baseline__livelihood_zone__alternate_code",
+        "seasonal_activity_type__code__icontains",
+        *translation_fields("seasonal_activity_type__name__icontains"),
+        *translation_fields("season__name__icontains"),
+        "season__aliases__icontains",
+        *translation_fields("product__common_name__icontains"),
+        "product__cpc__iexact",
+        "additional_identifier__icontains",
     )
     list_filter = (
         "livelihood_zone_baseline__livelihood_zone",
         "seasonal_activity_type",
-        "season",
-        "product",
+        ("season", admin.RelatedOnlyFieldListFilter),
+        ("product", admin.RelatedOnlyFieldListFilter),
         "is_key",
     )
 
+    def get_search_results(self, request, queryset, search_term):
+        # Allow natural key format "BF01: 2011-10-31" by stripping the colon separator.
+        normalized = search_term.replace(":", "")
+        date_match = re.search(r"\b(\d{4}-\d{2}-\d{2})\b", normalized)
+        year_match = re.search(r"\b(\d{4})\b", normalized)
+        text_term = re.sub(r"\b\d{4}(?:-\d{2}-\d{2})?\b", "", normalized).strip()
+        queryset, use_distinct = super().get_search_results(request, queryset, text_term)
+        if date_match:
+            queryset = queryset.filter(livelihood_zone_baseline__reference_year_end_date=date_match.group(1))
+        elif year_match:
+            queryset = queryset.filter(
+                livelihood_zone_baseline__reference_year_end_date__year=int(year_match.group(1))
+            )
+        return queryset, use_distinct
+
 
 class SeasonalActivityOccurrenceAdmin(admin.ModelAdmin):
     list_display = (
@@ -1088,10 +1146,15 @@ class SeasonalActivityOccurrenceAdmin(admin.ModelAdmin):
         "end_month",
     )
     search_fields = (
-        "seasonal_activity__seasonal_activity_type",
-        "seasonal_activity__season",
-        "seasonal_activity__product",
-        "seasonal_activity__additional_identifier",
+        "seasonal_activity__livelihood_zone_baseline__livelihood_zone__code",
+        "seasonal_activity__livelihood_zone_baseline__livelihood_zone__alternate_code",
+        "seasonal_activity__seasonal_activity_type__code__icontains",
+        *translation_fields("seasonal_activity__seasonal_activity_type__name__icontains"),
+        *translation_fields("seasonal_activity__season__name__icontains"),
+        "seasonal_activity__season__aliases__icontains",
+        *translation_fields("seasonal_activity__product__common_name__icontains"),
+        "seasonal_activity__product__cpc__iexact",
+        "seasonal_activity__additional_identifier__icontains",
     )
     list_filter = (
         "seasonal_activity__seasonal_activity_type",
@@ -1100,6 +1163,23 @@ class SeasonalActivityOccurrenceAdmin(admin.ModelAdmin):
     )
     ordering = ["start"]
 
+    def get_search_results(self, request, queryset, search_term):
+        # Allow natural key format "BF01: 2011-10-31" by stripping the colon separator.
+        normalized = search_term.replace(":", "")
+        date_match = re.search(r"\b(\d{4}-\d{2}-\d{2})\b", normalized)
+        year_match = re.search(r"\b(\d{4})\b", normalized)
+        text_term = re.sub(r"\b\d{4}(?:-\d{2}-\d{2})?\b", "", normalized).strip()
+        queryset, use_distinct = super().get_search_results(request, queryset, text_term)
+        if date_match:
+            queryset = queryset.filter(
+                seasonal_activity__livelihood_zone_baseline__reference_year_end_date=date_match.group(1)
+            )
+        elif year_match:
+            queryset = queryset.filter(
+                seasonal_activity__livelihood_zone_baseline__reference_year_end_date__year=int(year_match.group(1))
+            )
+        return queryset, use_distinct
+
     @admin.display(boolean=True, description="Key seasonal activity")
     def seasonal_activity_is_key(self, obj):
         return obj.seasonal_activity.is_key

apps/baseline/tests/test_admin.py

@@ -262,6 +262,22 @@ def test_livelihoodstrategy_search_fields(self):
         self.assertContains(response, self.strategy1.product.cpc)
         self.assertNotContains(response, self.strategy2.product.cpc)
 
+    def test_livelihoodstrategy_search_by_natural_key(self):
+        zone_code = self.strategy1.livelihood_zone_baseline.livelihood_zone.code
+        ref_end_date = self.strategy1.livelihood_zone_baseline.reference_year_end_date.isoformat()
+        response = self.client.get(self.url, {"q": f"{zone_code}: {ref_end_date}"})
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.strategy1.product.cpc)
+        self.assertNotContains(response, self.strategy2.product.cpc)
+
+    def test_livelihoodstrategy_search_by_code_and_year(self):
+        zone_code = self.strategy1.livelihood_zone_baseline.livelihood_zone.code
+        ref_end_date = self.strategy1.livelihood_zone_baseline.reference_year_end_date
+        response = self.client.get(self.url, {"q": f"{zone_code} {ref_end_date.year}"})
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.strategy1.product.cpc)
+        self.assertNotContains(response, self.strategy2.product.cpc)
+
     def test_livelihoodstrategy_list_filter(self):
         response = self.client.get(
             self.url,
@@ -707,6 +723,32 @@ def test_search(self):
         self.assertIn(self.livelihood_strategy1.strategy_type, result_list_str)
         self.assertNotIn(self.livelihood_strategy2.strategy_type, result_list_str)
 
+    def test_search_by_baseline_natural_key(self):
+        zone_code = self.livelihood_zone_baseline1.livelihood_zone.code
+        ref_end_date = self.livelihood_zone_baseline1.reference_year_end_date.isoformat()
+        natural_key = f"{zone_code}: {ref_end_date}"
+        url = reverse("admin:baseline_livelihoodactivity_changelist") + f"?q={natural_key}"
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        soup = BeautifulSoup(response.content, "html.parser")
+        result_list = soup.find(id="result_list")
+        result_list_str = str(result_list)
+        self.assertIn(f'value="{self.activity1.pk}"', result_list_str)
+        self.assertNotIn(f'value="{self.activity2.pk}"', result_list_str)
+
+    def test_search_by_baseline_code_and_year(self):
+        zone_code = self.livelihood_zone_baseline1.livelihood_zone.code
+        ref_end_date = self.livelihood_zone_baseline1.reference_year_end_date
+        search_term = f"{zone_code} {ref_end_date.year}"
+        url = reverse("admin:baseline_livelihoodactivity_changelist") + f"?q={search_term}"
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        soup = BeautifulSoup(response.content, "html.parser")
+        result_list = soup.find(id="result_list")
+        result_list_str = str(result_list)
+        self.assertIn(f'value="{self.activity1.pk}"', result_list_str)
+        self.assertNotIn(f'value="{self.activity2.pk}"', result_list_str)
+
     def test_get_product_common_name(self):
         modeladmin = LivelihoodActivityAdmin(LivelihoodActivity, self.site)
         self.assertEqual(
@@ -738,6 +780,8 @@ def test_filters(self):
         filters = {
             "strategy_type": self.livelihood_strategy1.strategy_type,
             "scenario": self.activity3.scenario,
+            "livelihood_zone_baseline__id__exact": self.livelihood_zone_baseline1.pk,
+            "wealth_group__wealth_group_category": self.activity1.wealth_group.wealth_group_category.pk,
             "livelihood_strategy__product__cpc": self.livelihood_strategy1.product.cpc,
             "livelihood_strategy__season__id__exact": self.livelihood_strategy2.season.pk,
             "livelihood_zone_baseline__livelihood_zone__country": country.iso3166a2,

apps/baseline/tests/test_viewsets.py

@@ -2111,6 +2111,16 @@ def test_html(self):
         df = pd.read_html(content)[0].fillna("")
         self.assertEqual(len(df), self.num_records + 1)
 
+    def test_search_by_zone_code_and_year(self):
+        baseline = LivelihoodZoneBaselineFactory()
+        strategy = LivelihoodStrategyFactory(livelihood_zone_baseline=baseline)
+        zone_code = baseline.livelihood_zone.code
+        ref_year = baseline.reference_year_end_date.year
+        response = self.client.get(self.url, {"search": f"{zone_code} {ref_year}"})
+        self.assertEqual(response.status_code, 200)
+        ids = [r["id"] for r in response.json()]
+        self.assertIn(strategy.pk, ids)
+
     def test_filter_by_country(self):
         country = CountryFactory(
             iso3166a2="AA",
@@ -2361,6 +2371,16 @@ def test_html(self):
         df = pd.read_html(content)[0].fillna("")
         self.assertEqual(len(df), self.num_records + 1)
 
+    def test_search_by_zone_code_and_year(self):
+        baseline = LivelihoodZoneBaselineFactory()
+        activity = LivelihoodActivityFactory(livelihood_zone_baseline=baseline)
+        zone_code = baseline.livelihood_zone.code
+        ref_year = baseline.reference_year_end_date.year
+        response = self.client.get(self.url, {"search": f"{zone_code} {ref_year}"})
+        self.assertEqual(response.status_code, 200)
+        ids = [r["id"] for r in response.json()]
+        self.assertIn(activity.pk, ids)
+
     def test_filter_by_country(self):
         country = CountryFactory(
             iso3166a2="AA",

apps/baseline/viewsets.py

@@ -5,8 +5,8 @@
 from django.apps import apps
 from django.conf import settings
 from django.db import models
-from django.db.models import Expression, F, Q, Subquery, TextField, Value
-from django.db.models.functions import Coalesce, NullIf
+from django.db.models import CharField, Expression, F, Q, Subquery, TextField, Value
+from django.db.models.functions import Cast, Coalesce, ExtractYear, NullIf
 from django.utils import translation
 from django.utils.decorators import method_decorator
 from django.utils.translation import override
@@ -980,8 +980,23 @@ class LivelihoodStrategyViewSet(BaseModelViewSet):
     search_fields = [
         "additional_identifier",
         "strategy_type",
+        "livelihood_zone_baseline__livelihood_zone__code",
+        "livelihood_zone_baseline__livelihood_zone__alternate_code",
+        "reference_year",
     ]
 
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                reference_year=Cast(
+                    ExtractYear("livelihood_zone_baseline__reference_year_end_date"),
+                    output_field=CharField(),
+                )
+            )
+        )
+
 
 LIVELIHOOD_ACTIVITY_ORDER_BY = ["sort_key"]
 
@@ -1087,8 +1102,23 @@ class LivelihoodActivityViewSet(BaseModelViewSet):
     search_fields = [
         "scenario",
         "strategy_type",
+        "livelihood_zone_baseline__livelihood_zone__code",
+        "livelihood_zone_baseline__livelihood_zone__alternate_code",
+        "reference_year",
     ]
 
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                reference_year=Cast(
+                    ExtractYear("livelihood_zone_baseline__reference_year_end_date"),
+                    output_field=CharField(),
+                )
+            )
+        )
+
 
 class BaselineLivelihoodActivityFilterSet(LivelihoodActivityFilterSet):
     class Meta(LivelihoodActivityFilterSet.Meta):