[16.0][ADD] base_tier_validation: compute validation flag dynamically

base_tier_validation/models/tier_definition.py

@@ -140,3 +140,32 @@ def _cron_send_review_reminder(self):
             review_to_remind = record._get_review_needing_reminder()
             if review_to_remind:
                 review_to_remind._send_review_reminder()
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        result = super().create(vals_list)
+        result._update_registry()
+        return result
+
+    def write(self, vals):
+        result = super().write(vals)
+        if "definition_domain" in vals:
+            self._update_registry()
+        return result
+
+    def unlink(self):
+        models = set(self.mapped("model"))
+        result = super().unlink()
+        self._update_registry(models)
+        return result
+
+    def _update_registry(self, models=None):
+        """Update dependencies of validation flag"""
+        for model in models or set(self.mapped("model")):
+            depends = self.env[model]._compute_need_validation._depends
+            if not callable(depends):  # pragma: no cover
+                continue
+            self.pool.field_depends[
+                self.env[model]._fields["need_validation"]
+            ] = depends(self.env[model])
+            self.pool.registry_invalidated = True

base_tier_validation/models/tier_validation.py

@@ -9,7 +9,7 @@
 
 from odoo import _, api, fields, models
 from odoo.exceptions import ValidationError
-from odoo.osv.expression import OR
+from odoo.osv.expression import OR, is_leaf
 from odoo.tools.misc import frozendict
 
 BASE_EXCEPTION_FIELDS = ["message_follower_ids", "access_token"]
@@ -218,11 +218,9 @@
         """Override for different rejection policy."""
         return any([s == "rejected" for s in reviews.mapped("status")])
 
+    @api.depends(lambda self: self._compute_need_validation_dependencies())
     def _compute_need_validation(self):
         for rec in self:
-            if isinstance(rec.id, models.NewId):
-                rec.need_validation = False
-                continue
             tiers = (
                 self.env["tier.definition"]
                 .with_context(active_test=True)
@@ -238,6 +236,40 @@
                 not rec.review_ids and valid_tiers and rec._check_state_from_condition()
             )
 
+    def _compute_need_validation_dependencies(self):
+        """Return the fields the validation flag depends on"""
+        if self._abstract:
+            return []
+        tiers = self.env["tier.definition"].search([("model", "=", self._name)])
+        tier_domains = sum(
+            # we can't browse because this is called during updates too
+            (
+                literal_eval(
+                    tier.read(["definition_domain"])[0]["definition_domain"] or "[]"
+                )
+                for tier in tiers
+            ),
+            [],
+        )
+        dependencies = []
+        for leaf in tier_domains:
+            if not is_leaf(leaf):
+                continue
+            field_name = leaf[0]
+            model = self
+            while "." in field_name:
+                field_name, tail = field_name.split(".", 1)
+                if field_name in model._fields:
+                    model = self.env[model._fields[field_name].comodel_name]
+                    field_name = tail
+                else:
+                    break
+            else:
+                if field_name in model._fields:
+                    dependencies.append(leaf[0])
+
+        return dependencies
+
     def evaluate_tier(self, tier):
         if tier.definition_domain:
             domain = literal_eval(tier.definition_domain)

base_tier_validation/tests/test_tier_validation.py

@@ -905,6 +905,22 @@ def test_25_change_field_exception_validation(self):
             )
         self.assertEqual(self.test_record.test_validation_field, 4)
 
+    def test_26_update_registry(self):
+        """Test that changes to the tier definition reloads the registry"""
+        tier = self.env["tier.definition"].search(
+            [
+                ("model_id", "=", self.tester_model.id),
+            ]
+        )
+        field = self.env[self.test_model._name]._fields["need_validation"]
+        self.assertIn("test_field", self.env.registry.field_depends[field])
+        tier.write({"definition_domain": "[('user_id.name', '=', 'test')]"})
+        self.assertNotIn("test_field", self.env.registry.field_depends[field])
+        tier.unlink()
+        self.assertNotIn("test_field", self.env.registry.field_depends[field])
+        self.assertTrue(self.env.registry.registry_invalidated)
+        self.env.registry.registry_invalidated = False
+
 
 @tagged("at_install")
 class TierTierValidationView(CommonTierValidation):