refinements regarding violations resolution

Signed-off-by: tdruez <tdruez@aboutcode.org>

Author: tdruez

policy/engine.py

@@ -78,10 +78,14 @@ def evaluate_rule(rule_type, product, threshold, parameters):
         return violation, created, 0
 
     now = timezone.now()
-    resolved_count = ProductPolicyViolation.objects.filter(**lookup, resolved=False).update(
-        resolved=True,
-        resolved_date=now,
-        last_checked=now,
+    resolved_count = (
+        ProductPolicyViolation.objects.filter(**lookup)
+        .unresolved()
+        .update(
+            resolved=True,
+            resolved_date=now,
+            last_checked=now,
+        )
     )
     return None, False, resolved_count
 
@@ -96,17 +100,21 @@ def evaluate_rules(product):
     """
     new_violations = []
     resolved_count = 0
+    now = timezone.now()
 
     for rule_type in RULE_REGISTRY:
         config = get_effective_config(rule_type, product.dataspace)
         if not config["is_active"]:
             # Explicitly resolve open violations so disabling a rule clears its history
             # rather than leaving stale unresolved records.
-            rows = ProductPolicyViolation.objects.filter(
-                rule_type=rule_type,
-                product=product,
-                resolved=False,
-            ).update(resolved=True, resolved_date=timezone.now())
+            rows = (
+                ProductPolicyViolation.objects.filter(
+                    rule_type=rule_type,
+                    product=product,
+                )
+                .unresolved()
+                .update(resolved=True, resolved_date=now, last_checked=now)
+            )
             resolved_count += rows
             continue
 

policy/tasks.py

@@ -24,7 +24,11 @@ def evaluate_product_rules_task(product_uuid):
     Product = apps.get_model("product_portfolio", "product")
 
     try:
-        product = get_unsecured_manager(Product).get(uuid=product_uuid)
+        product = (
+            get_unsecured_manager(Product)
+            .select_related("dataspace__configuration")
+            .get(uuid=product_uuid)
+        )
     except Product.DoesNotExist:
         logger.error(f"evaluate_product_rules_task: product {product_uuid} not found, skipping.")
         return
@@ -49,7 +53,7 @@ def evaluate_all_products_rules_task(include_locked=False, product_uuids=None):
     if product_uuids is not None:
         products = products.filter(uuid__in=product_uuids)
     if not include_locked:
-        products = products.exclude(configuration_status__is_locked=True)
+        products = products.exclude_locked()
 
     count = products.count()
     logger.info(f"Starting policy rule evaluation for {count} product(s).")

product_portfolio/admin.py

@@ -46,7 +46,7 @@
 from dje.permissions import assign_all_object_permissions
 from dje.permissions import get_limited_perms_for_model
 from dje.utils import is_purl_fragment
-from policy.tasks import evaluate_product_rules_task
+from policy.tasks import evaluate_all_products_rules_task
 from product_portfolio.filters import ComponentCompletenessListFilter
 from product_portfolio.forms import ProductAdminForm
 from product_portfolio.forms import ProductComponentAdminForm
@@ -397,10 +397,11 @@ class ProductAdmin(
     readonly_fields = DataspacedAdmin.readonly_fields + ("get_feature_datalist",)
 
     def evaluate_policy_rules(self, request, queryset):
-        count = queryset.count()
-        for product in queryset:
-            evaluate_product_rules_task.delay(product_uuid=product.uuid)
-        self.message_user(request, f"Policy rules evaluation enqueued for {count} product(s).")
+        product_uuids = list(queryset.values_list("uuid", flat=True))
+        evaluate_all_products_rules_task.delay(product_uuids=product_uuids)
+        self.message_user(
+            request, f"Policy rules evaluation enqueued for {len(product_uuids)} product(s)."
+        )
 
     evaluate_policy_rules.short_description = _("Evaluate policy rules")
 

product_portfolio/filters.py

@@ -200,9 +200,8 @@ def filter_policy_violations(self, queryset, name, value):
             return queryset
         has_violation = ProductPolicyViolation.objects.filter(
             product_id=OuterRef("pk"),
-            resolved=False,
-            rule_type__in=RULE_REGISTRY,
-        )
+            rule_type__in=RULE_REGISTRY.keys(),
+        ).unresolved()
         condition = Exists(has_violation)
         return queryset.filter(condition if value else ~condition)
 

product_portfolio/tests/test_admin.py

@@ -554,7 +554,7 @@ def setUp(self):
         self.product1 = Product.objects.create(name="Product1", dataspace=self.dataspace)
         self.product2 = Product.objects.create(name="Product2", dataspace=self.dataspace)
 
-    @patch("product_portfolio.admin.evaluate_product_rules_task.delay")
+    @patch("product_portfolio.admin.evaluate_all_products_rules_task.delay")
     def test_evaluate_policy_rules_action_queues_task_for_selected_products(self, mock_delay):
         self.client.login(username="nexb_user", password="secret")
         url = reverse("admin:product_portfolio_product_changelist")
@@ -564,7 +564,7 @@ def test_evaluate_policy_rules_action_queues_task_for_selected_products(self, mo
         }
         response = self.client.post(url, data, follow=True)
         self.assertEqual(200, response.status_code)
-        self.assertEqual(2, mock_delay.call_count)
-        called_uuids = {call[1]["product_uuid"] for call in mock_delay.call_args_list}
+        mock_delay.assert_called_once()
+        called_uuids = set(mock_delay.call_args[1]["product_uuids"])
         self.assertIn(self.product1.uuid, called_uuids)
         self.assertIn(self.product2.uuid, called_uuids)

product_portfolio/views.py

@@ -2869,9 +2869,9 @@ def get_license_compliance_context(licenses, distribution_limit=10):
     @staticmethod
     def get_policy_compliance_context(product):
         policy_violations = list(
-            product.policy_violations.filter(resolved=False, rule_type__in=RULE_REGISTRY).order_by(
-                "rule_type"
-            )
+            product.policy_violations.filter(rule_type__in=RULE_REGISTRY.keys())
+            .unresolved()
+            .order_by("rule_type")
         )
         violated_rule_types = {violation.rule_type for violation in policy_violations}