[IMP] util/records: enforce cascade removal for actions

The implementation of the python inheritance mechanism between the base class
`ir.actions.actions` and its child classes (eg. `ir.actions.act_window`) does
not allow the creation of foreign keys when `ir.actions.actions` is a M2O field
of another model; what leads to the not execution of some constraints, one of
them being the `ondelete='cascade'` constraint, which is set in PSQL level.

That said, when a `ir.actions.actions` record is deleted, if it is being
referenced as a M2O field by another model (eg. `ir.filters`), records from this
second model won't be affected, what leads to undesired behaviour: a
MissingError in the UI, indicating that the action was deleted.

Such behaviour of not creating foreign keys and thus constraints is specific to
`ir.actions.actions`.
This commit remedies this specific case, removing records with a M2O field to
`ir.actions.actions` with `ondelete=cascade` when the action referenced in such
field is removed using `upgrade-util`.

Co-authored-by: Christophe Simonis <[email protected]>

Author: pauloamed

src/util/records.py

@@ -32,6 +32,7 @@
     _get_unique_indexes_with,
     _validate_table,
     column_exists,
+    column_nullable,
     column_type,
     column_updatable,
     explode_execute,
@@ -309,6 +310,82 @@ def remove_asset(cr, name):
         remove_view(cr, name, silent=True)
 # fmt:on
 
+def get_models_inheriting_actions_actions(cr):
+    cr.execute(
+        """
+        SELECT child_model.model
+            FROM ir_model AS child_model
+            JOIN ir_model_inherit
+            ON child_model.id = ir_model_inherit.model_id
+            JOIN ir_model AS base_model
+            ON ir_model_inherit.parent_id = base_model.id
+            WHERE base_model.model = 'ir.actions.actions'
+        """
+    )
+    return cr.fetchall()
+
+def remove_action(cr, xml_id=None, action_id=None):
+    assert bool(xml_id) ^ bool(action_id)
+    
+    if xml_id:
+        action_id = ref(cr, xml_id)
+
+    action_model = None
+    if action_id:
+        module, _, name = xml_id.partition(".")
+        cr.execute("SELECT model FROM ir_model_data WHERE module=%s AND name=%s", [module, name])
+        [action_model] = cr.fetchone()
+        if not action_model in get_models_inheriting_actions_actions(cr):
+            raise ValueError(
+                "%r should point to a model inheriting from 'ir.actions.actions', not a %r" % (xml_id, action_model)
+            )
+        
+    if version_gte("11.0"):    
+        cr.execute(
+            """
+            SELECT name,
+                   model,
+                   on_delete
+              FROM ir_model_fields
+             WHERE relation = 'ir.actions.actions'
+               AND on_delete IN ( 'cascade', 'set null' )
+               AND ttype = 'many2one'
+            """
+        )
+        
+        for column_name, model, on_delete in cr.fetchall():
+            model_table = table_of_model(cr, model)
+            if on_delete == 'cascade':
+                query = format_query(cr, "DELETE FROM {} WHERE {} = %s", model_table, column_name)
+            else:
+                query = format_query(cr, "UPDATE {} SET {} = NULL WHERE {} = %s", model_table, column_name, column_name)
+            cr.execute(query, (action_id,))
+    else:
+        # Before V11, we did not have `on_delete` on `ir_model_fields`.
+        # However, we can infer the intended behaviour by checking if the column containing the deleted action's id is
+        # nullable or not:
+        # if not nullable, the record containing the deleted action should also be deleted (cascade);
+        # else, we just set the column to NULL (set null)
+        cr.execute(
+            """
+            SELECT name,
+                   model
+              FROM ir_model_fields
+             WHERE relation = 'ir.actions.actions'
+               AND ttype = 'many2one'
+            """
+        )
+
+        for column_name, model in cr.fetchall():
+            model_table = table_of_model(cr, model)
+            if not column_nullable(cr, model_of_table, column_name):
+                query = format_query(cr, "DELETE FROM {} WHERE {} = %s", model_table, column_name)
+            else:
+                query = format_query(cr, "UPDATE {} SET {} = NULL WHERE {} = %s", model_table, column_name, column_name)
+            cr.execute(query, (action_id,))
+
+    remove_records(cr, action_model, [action_id])
+
 
 def remove_record(cr, name):
     """
@@ -351,10 +428,13 @@ def remove_record(cr, name):
     if model == "res.groups":
         _logger.log(NEARLYWARN, "Removing group %r", name)
         return remove_group(cr, group_id=res_id)
+    
+    if model in get_models_inheriting_actions_actions(cr):
+        _logger.log(NEARLYWARN, "Removing action %r", name)
+        return remove_action(cr, action_id=res_id)
 
     return remove_records(cr, model, [res_id])
 
-
 def remove_records(cr, model, ids):
     if not ids:
         return