feat(spp_statistics_dashboard): add per-program statistics refresh

The dashboard now computes statistics for each active program in
addition to system-wide and per-area dimensions. Program scope is
built by querying enrolled members via get_beneficiaries() and passing
their IDs as an explicit scope to the aggregation service.

Refactors _refresh_statistic into _refresh_scope for clearer
separation of the iteration logic from the per-scope computation.

Author: jeremi

spp_cel_domain/tests/test_cel_parser.py

@@ -431,24 +431,20 @@ def test_odoo_null_field_equals_null(self):
         result = P.evaluate(ast, {"m": partner})
         self.assertTrue(
             result,
-            "m.disabled == null should be True when disabled is unset "
-            f"(ORM returns {partner.disabled!r})",
+            f"m.disabled == null should be True when disabled is unset (ORM returns {partner.disabled!r})",
         )
 
         # CEL: m.disabled != null should be False (field is unset)
         ast = P.parse("m.disabled != null")
         result = P.evaluate(ast, {"m": partner})
         self.assertFalse(
             result,
-            "m.disabled != null should be False when disabled is unset "
-            f"(ORM returns {partner.disabled!r})",
+            f"m.disabled != null should be False when disabled is unset (ORM returns {partner.disabled!r})",
         )
 
     def test_odoo_boolean_false_not_treated_as_null(self):
         """Boolean fields that are legitimately False should NOT be normalized to None."""
-        partner = self.env["res.partner"].create(
-            {"name": "CEL Bool Test", "is_registrant": False}
-        )
+        partner = self.env["res.partner"].create({"name": "CEL Bool Test", "is_registrant": False})
 
         # is_registrant is a Boolean field, False is a real value
         ast = P.parse("m.is_registrant == false")

spp_statistics_dashboard/models/dashboard_data.py

@@ -205,9 +205,14 @@ def action_refresh_all(self):
         }
 
     def _refresh_statistic(self, stat_id, area_ids):
-        """Refresh one statistic across all area combinations.
+        """Refresh one statistic across all scope combinations.
 
-        Called as a queue_job. Handles errors per-area so one failure
+        Computes values for:
+        - System-wide (no area, no program)
+        - Per area (each configured area)
+        - Per program (each active program with enrolled members)
+
+        Called as a queue_job. Handles errors per-scope so one failure
         does not abort the entire statistic refresh.
         """
         stat = self.env["spp.statistic"].browse(stat_id)
@@ -216,26 +221,42 @@ def _refresh_statistic(self, stat_id, area_ids):
             return
 
         areas = self.env["spp.area"].browse(area_ids)
+        programs = self._get_dashboard_programs()
 
-        # False = system-wide
-        area_list = [False] + list(areas)
+        # Area dimension: system-wide + per-area
+        for area in [False] + list(areas):
+            self._refresh_scope(stat, area, False)
 
-        for area in area_list:
-            try:
-                scope = self._build_scope(area, False)
-                result = self.env["spp.aggregation.service"].compute_aggregation(
-                    scope=scope,
-                    statistics=[stat.name],
-                    context="dashboard",
-                )
-                self._upsert_data(stat, area, False, result)
-            except (ValueError, TypeError, KeyError, AttributeError) as e:
-                _logger.warning(
-                    "Dashboard refresh failed for stat=%s area=%s: %s",
-                    stat.name,
-                    area.code if area else "all",
-                    e,
-                )
+        # Program dimension: per-program (system-wide area)
+        for program in programs:
+            self._refresh_scope(stat, False, program)
+
+    def _refresh_scope(self, stat, area, program):
+        """Refresh a single (stat, area, program) combination.
+
+        Args:
+            stat: spp.statistic record
+            area: spp.area record or False
+            program: spp.program record or False
+        """
+        try:
+            scope = self._build_scope(area, program)
+            result = self.env["spp.aggregation.service"].compute_aggregation(
+                scope=scope,
+                statistics=[stat.name],
+                context="dashboard",
+            )
+            self._upsert_data(stat, area, program, result)
+        except (ValueError, TypeError, KeyError, AttributeError) as e:
+            area_label = area.code if area else "all"
+            prog_label = program.name if program else "all"
+            _logger.warning(
+                "Dashboard refresh failed for stat=%s area=%s program=%s: %s",
+                stat.name,
+                area_label,
+                prog_label,
+                e,
+            )
 
     @api.model
     def _get_dashboard_areas(self):
@@ -266,11 +287,20 @@ def _build_scope(self, area, program):
 
         Args:
             area: spp.area record or False (system-wide)
-            program: spp.program record or False (unused, kept for API compatibility)
+            program: spp.program record or False (all programs)
 
         Returns:
             dict: scope definition for spp.aggregation.service
         """
+        if program:
+            # Program scope: use enrolled members as explicit partner IDs
+            memberships = program.get_beneficiaries(state=["enrolled"])
+            partner_ids = memberships.mapped("partner_id").ids
+            return {
+                "scope_type": "explicit",
+                "explicit_partner_ids": partner_ids,
+            }
+
         if area:
             return {
                 "scope_type": "area",

spp_statistics_dashboard/tests/test_dashboard_refresh.py

@@ -338,6 +338,52 @@ def test_build_scope_with_area(self):
         self.assertEqual(scope["area_id"], self.area.id)
         self.assertTrue(scope["include_child_areas"])
 
+    def test_build_scope_with_program(self):
+        """Test _build_scope with a program returns explicit scope from enrolled members."""
+        # Create a program with enrolled members
+        program = self.env["spp.program"].create({"name": "Scope Test Program", "target_type": "group"})
+        registrant = self.env["res.partner"].create(
+            {"name": "Scope Program Person", "is_registrant": True, "is_group": False}
+        )
+        self.env["spp.program.membership"].create(
+            {"partner_id": registrant.id, "program_id": program.id, "state": "enrolled"}
+        )
+
+        DashData = self.env["spp.dashboard.data"]
+        scope = DashData._build_scope(False, program)
+        self.assertEqual(scope["scope_type"], "explicit")
+        self.assertIn(registrant.id, scope["explicit_partner_ids"])
+
+    def test_refresh_statistic_with_programs(self):
+        """Test that refresh creates rows for each active program."""
+        DashData = self.env["spp.dashboard.data"]
+
+        program = self.env["spp.program"].create({"name": "Refresh Program Test", "target_type": "group"})
+        registrant = self.env["res.partner"].create(
+            {"name": "Program Refresh Person", "is_registrant": True, "is_group": False}
+        )
+        self.env["spp.program.membership"].create(
+            {"partner_id": registrant.id, "program_id": program.id, "state": "enrolled"}
+        )
+
+        mock_result = self._mock_aggregation_result(value=10, total_count=10)
+        with patch.object(
+            type(self.env["spp.aggregation.service"]),
+            "compute_aggregation",
+            return_value=mock_result,
+        ):
+            DashData._refresh_statistic(self.statistic.id, [])
+
+        # Should create at least 2 rows: system-wide + one per active program
+        program_data = DashData.search(
+            [
+                ("statistic_id", "=", self.statistic.id),
+                ("program_id", "=", program.id),
+            ]
+        )
+        self.assertEqual(len(program_data), 1, "Expected one row for the program")
+        self.assertEqual(program_data.value, 10.0)
+
     def test_label_from_context_config(self):
         """Test that label is taken from statistic context config."""
         # Create a context config with a dashboard label override