fixup! [REF] util.helpers: introduce new resolve_model_fields_path helper

Author: aj-fuentes

src/base/tests/test_util.py

@@ -694,19 +694,16 @@ def test_resolve_model_fields_path(self):
         # test with provided paths
         model, path = "res.currency", ["rate_ids", "company_id", "user_ids", "partner_id"]
         expected_result = [
-            FieldsPathPart(model, path, 1, "res.currency", "rate_ids", "res.currency.rate"),
-            FieldsPathPart(model, path, 2, "res.currency.rate", "company_id", "res.company"),
-            FieldsPathPart(model, path, 3, "res.company", "user_ids", "res.users"),
-            FieldsPathPart(model, path, 4, "res.users", "partner_id", "res.partner"),
+            FieldsPathPart("res.currency", "rate_ids", "res.currency.rate"),
+            FieldsPathPart("res.currency.rate", "company_id", "res.company"),
+            FieldsPathPart("res.company", "user_ids", "res.users"),
+            FieldsPathPart("res.users", "partner_id", "res.partner"),
         ]
         result = resolve_model_fields_path(cr, model, path)
         self.assertEqual(result, expected_result)
 
         model, path = "res.users", ("partner_id", "removed_field", "user_id")
-        expected_result = [
-            FieldsPathPart(model, list(path), 1, "res.users", "partner_id", "res.partner"),
-            FieldsPathPart(model, list(path), 2, "res.partner", "removed_field", None),
-        ]
+        expected_result = [FieldsPathPart("res.users", "partner_id", "res.partner")]
         result = resolve_model_fields_path(cr, model, path)
         self.assertEqual(result, expected_result)
 

src/util/domains.py

@@ -164,12 +164,9 @@ def _model_of_path(cr, model, path):
         return model
     path = tuple(path)
     resolved_parts = resolve_model_fields_path(cr, model, path)
-    if not resolved_parts:
-        return None
-    last_part = resolved_parts[-1]
-    if last_part.part_index != len(last_part.path):
-        return None
-    return last_part.relation_model  # could be None
+    if len(resolved_parts) == len(path):
+        return resolved_parts[-1].relation_model
+    return None
 
 
 def _valid_path_to(cr, path, from_, to):

src/util/helpers.py

@@ -217,16 +217,10 @@ def _get_theme_models():
     }
 
 
-FieldsPathPart = namedtuple(
-    "FieldsPathPart",
-    "model path part_index field_model field_name relation_model",
-)
+FieldsPathPart = namedtuple("FieldsPathPart", "field_model field_name relation_model")
 FieldsPathPart.__doc__ = """
 Encapsulate information about a field within a fields path.
 
-:param str model: model to resolve the fields ``path`` from
-:param typing.Sequence[str] path: fields path starting from ``model``
-:param int part_index: index of this field in ``path``
 :param str field_model: model of the field
 :param str field_name: name of the field
 :param str relation_model: target model of the field, if relational, otherwise ``None``
@@ -239,8 +233,12 @@ def resolve_model_fields_path(cr, model, path):
     """
     Resolve model fields paths.
 
-    This function returns a list of :class:`~odoo.upgrade.util.helpers.FieldsPathPart` where
-    each item describes the field in ``path`` (in the same order).
+    This function returns a list of :class:`~odoo.upgrade.util.helpers.FieldsPathPart`
+    where each item describes a field in ``path`` (in the same order). The returned list
+    could be shorter than the original ``path`` due to a missing field or model, or
+    because there is a non-relational field in the path. The only non-relational field
+    allowed in a fields path is the last one, in which case the returned list has the same
+    length as the input ``path``.
 
     .. example::
 
@@ -261,35 +259,35 @@ def resolve_model_fields_path(cr, model, path):
         """
         WITH RECURSIVE resolved_fields_path AS (
             -- non-recursive term
-               SELECT p.model                       AS model,
-                      p.path                        AS path,
-                      1                             AS part_index,
-                      p.model                       AS field_model,
-                      p.path[1]                     AS field_name,
-                      imf.relation                  AS relation_model
+               SELECT imf.model AS field_model,
+                      imf.name AS field_name,
+                      imf.relation AS relation_model,
+                      p.path AS path,
+                      1 AS part_index
                  FROM (VALUES (%(model)s, %(path)s)) p(model, path)
-            LEFT JOIN ir_model_fields imf
+                 JOIN ir_model_fields imf
                    ON imf.model = p.model
                   AND imf.name = p.path[1]
 
             UNION ALL
 
             -- recursive term
-               SELECT rfp.model,
-                      rfp.path,
-                      rfp.part_index + 1            AS part_index,
-                      rfp.relation_model            AS field_model,
-                      rfp.path[rfp.part_index + 1]  AS field_name,
-                      rimf.relation                 AS relation_model
+               SELECT rimf.model AS field_model,
+                      rimf.name AS field_name,
+                      rimf.relation AS relation_model,
+                      rfp.path AS path,
+                      rfp.part_index + 1 AS part_index
                  FROM resolved_fields_path rfp
-            LEFT JOIN ir_model_fields rimf
+                 JOIN ir_model_fields rimf
                    ON rimf.model = rfp.relation_model
                   AND rimf.name = rfp.path[rfp.part_index + 1]
                 WHERE cardinality(rfp.path) > rfp.part_index
-                  AND rfp.relation_model IS NOT NULL
         )
-        SELECT * FROM resolved_fields_path
-        ORDER BY model, path, part_index
+        SELECT field_model,
+               field_name,
+               relation_model
+          FROM resolved_fields_path
+         ORDER BY part_index
         """,
         {"model": model, "path": list(path)},
     )