Merge branch 'resolve-realtime-node-replacement-undo-redo' into 'develop'

Resolve automation node replacement undo/redo

See merge request baserow/baserow!3748

Author: picklepete

backend/src/baserow/contrib/automation/apps.py

@@ -48,6 +48,7 @@ def ready(self):
             UpdateAutomationNodeOperationType,
         )
         from baserow.contrib.automation.nodes.registries import (
+            ReplaceAutomationNodeTrashOperationType,
             automation_node_type_registry,
         )
         from baserow.contrib.automation.nodes.trash_types import (
@@ -169,6 +170,12 @@ def ready(self):
             )
             automation_node_type_registry.register(CorePeriodicTriggerNodeType())
 
+            from baserow.core.trash.registries import trash_operation_type_registry
+
+            trash_operation_type_registry.register(
+                ReplaceAutomationNodeTrashOperationType()
+            )
+
             from baserow.contrib.automation.data_providers.data_provider_types import (
                 PreviousNodeProviderType,
             )

backend/src/baserow/contrib/automation/nodes/actions.py

@@ -12,7 +12,11 @@
 from baserow.contrib.automation.nodes.handler import AutomationNodeHandler
 from baserow.contrib.automation.nodes.models import AutomationNode
 from baserow.contrib.automation.nodes.node_types import AutomationNodeType
+from baserow.contrib.automation.nodes.registries import (
+    ReplaceAutomationNodeTrashOperationType,
+)
 from baserow.contrib.automation.nodes.service import AutomationNodeService
+from baserow.contrib.automation.nodes.signals import automation_node_replaced
 from baserow.contrib.automation.nodes.trash_types import AutomationNodeTrashableItemType
 from baserow.contrib.automation.nodes.types import NextAutomationNodeValues
 from baserow.contrib.automation.workflows.models import AutomationWorkflow
@@ -432,12 +436,25 @@ def undo(
         action_to_undo: Action,
     ):
         # Restore the node to its original type.
-        TrashHandler.restore_item(
+        restored_node = TrashHandler.restore_item(
             user,
             AutomationNodeTrashableItemType.type,
             params.original_node_id,
         )
-        AutomationNodeService().delete_node(user, params.node_id)
+        # Trash the node of the new type, and pass its operation type so that its
+        # trash entry is flagged as managed to prevent users from restoring it.
+        deleted_node = AutomationNodeService().delete_node(
+            user,
+            params.node_id,
+            trash_operation_type=ReplaceAutomationNodeTrashOperationType.type,
+        )
+        automation_node_replaced.send(
+            cls,
+            workflow=restored_node.workflow,
+            deleted_node=deleted_node,
+            restored_node=restored_node.specific,
+            user=user,
+        )
 
     @classmethod
     def redo(
@@ -447,9 +464,22 @@ def redo(
         action_to_redo: Action,
     ):
         # Restore the node to its new type again.
-        TrashHandler.restore_item(
+        restored_node = TrashHandler.restore_item(
             user,
             AutomationNodeTrashableItemType.type,
             params.node_id,
         )
-        AutomationNodeService().delete_node(user, params.original_node_id)
+        # Trash the node of the original type, and pass its operation type so that its
+        # trash entry is flagged as managed to prevent users from restoring it.
+        deleted_node = AutomationNodeService().delete_node(
+            user,
+            params.original_node_id,
+            trash_operation_type=ReplaceAutomationNodeTrashOperationType.type,
+        )
+        automation_node_replaced.send(
+            cls,
+            workflow=restored_node.workflow,
+            restored_node=restored_node.specific,
+            deleted_node=deleted_node,
+            user=user,
+        )

backend/src/baserow/contrib/automation/nodes/handler.py

@@ -223,11 +223,15 @@ def create_node(
                     "previous_node_output"
                 ] = before.previous_node_output
 
-            # Find any nodes which have a previous node ID and output
-            # that match the before node's previous node ID and output.
+            # Find the nodes that are using `before` as their previous node.
+            # If `before` has a `previous_node_id`, then we get `before.previous_node`'s
+            # next nodes. If there's no `previous_node_id`, then `before` is a trigger,
+            # so we want the nodes that come after this trigger.
             node_previous_ids_to_update = list(
                 workflow.automation_workflow_nodes.filter(
-                    previous_node_id=before.previous_node_id,
+                    previous_node_id=before.id
+                    if before.previous_node_id is None
+                    else before.previous_node_id,
                     previous_node_output=before.previous_node_output,
                 )
             )

backend/src/baserow/contrib/automation/nodes/registries.py

@@ -25,6 +25,7 @@
 from baserow.core.services.exceptions import InvalidServiceTypeDispatchSource
 from baserow.core.services.handler import ServiceHandler
 from baserow.core.services.registries import ServiceTypeSubClass, service_type_registry
+from baserow.core.trash.registries import TrashOperationType
 
 
 class AutomationNodeType(
@@ -303,4 +304,28 @@ class AutomationNodeTypeRegistry(
     name = "automation_node_type"
 
 
+class ReplaceAutomationNodeTrashOperationType(TrashOperationType):
+    """
+    The replace-automation-node trash operation is used when an automation node is
+    replaced with another node type. This operation type exists to ensure that extra
+    steps are followed when the node is restored from its trashed state.
+    """
+
+    type = "replace_automation_node"
+
+    """
+    This trash operation type is 'managed'. We don't want users to interact with
+    it in the workspace trash, the system is responsible for it.
+    """
+    managed = True
+
+    """
+    In this trash operation type we don't want to send any created or deleted signals.
+    We need to be precise with our realtime signals, so at a strategic time we use
+    the `replace` signal instead.
+    """
+    send_post_restore_created_signal = False
+    send_post_trash_deleted_signal = False
+
+
 automation_node_type_registry = AutomationNodeTypeRegistry()

backend/src/baserow/contrib/automation/nodes/service.py

@@ -19,10 +19,14 @@
     ReadAutomationNodeOperationType,
     UpdateAutomationNodeOperationType,
 )
-from baserow.contrib.automation.nodes.registries import automation_node_type_registry
+from baserow.contrib.automation.nodes.registries import (
+    ReplaceAutomationNodeTrashOperationType,
+    automation_node_type_registry,
+)
 from baserow.contrib.automation.nodes.signals import (
     automation_node_created,
     automation_node_deleted,
+    automation_node_replaced,
     automation_node_updated,
     automation_nodes_reordered,
 )
@@ -186,12 +190,20 @@ def update_node(
 
         return updated_node
 
-    def delete_node(self, user: AbstractUser, node_id: int) -> AutomationNode:
+    def delete_node(
+        self,
+        user: AbstractUser,
+        node_id: int,
+        trash_operation_type: Optional[str] = None,
+    ) -> AutomationNode:
         """
         Deletes the specified automation node.
 
         :param user: The user trying to delete the node.
         :param node_id: The ID of the node to delete.
+        :param trash_operation_type: The trash operation type to use when trashing
+            the node.
+        :return: The deleted node.
         :raises AutomationTriggerModificationDisallowed: If the node is a trigger.
         """
 
@@ -205,15 +217,22 @@ def delete_node(self, user: AbstractUser, node_id: int) -> AutomationNode:
         )
 
         automation = node.workflow.automation
-        TrashHandler.trash(user, automation.workspace, automation, node)
-
-        automation_node_deleted.send(
-            self,
-            workflow=node.workflow,
-            node_id=node.id,
-            user=user,
+        trash_entry = TrashHandler.trash(
+            user,
+            automation.workspace,
+            automation,
+            node,
+            trash_operation_type=trash_operation_type,
         )
 
+        if trash_entry.get_operation_type().send_post_trash_deleted_signal:
+            automation_node_deleted.send(
+                self,
+                workflow=node.workflow,
+                node_id=node.id,
+                user=user,
+            )
+
         return node
 
     def order_nodes(
@@ -331,6 +350,7 @@ def replace_node(
             workflow=node.workflow,
             before=node,
             order=node.order,
+            previous_node_id=node.previous_node_id,
             previous_node_output=node.previous_node_output,
             **prepared_values,
         )
@@ -339,8 +359,24 @@ def replace_node(
         # After the node creation, the replaced node has changed
         node.refresh_from_db()
 
+        # Trash the old node, assigning it a specific trash operation
+        # type so that we know it was replaced when restoring it.
         automation = node.workflow.automation
-        TrashHandler.trash(user, automation.workspace, automation, node)
+        TrashHandler.trash(
+            user,
+            automation.workspace,
+            automation,
+            node,
+            trash_operation_type=ReplaceAutomationNodeTrashOperationType.type,
+        )
+
+        automation_node_replaced.send(
+            self,
+            workflow=new_node.workflow,
+            restored_node=new_node,
+            deleted_node=node,
+            user=user,
+        )
 
         return ReplacedAutomationNode(
             node=new_node,

backend/src/baserow/contrib/automation/nodes/signals.py

@@ -3,4 +3,5 @@
 automation_node_created = Signal()
 automation_node_updated = Signal()
 automation_node_deleted = Signal()
+automation_node_replaced = Signal()
 automation_nodes_reordered = Signal()

backend/src/baserow/contrib/automation/nodes/trash_types.py

@@ -5,10 +5,7 @@
 from baserow.contrib.automation.nodes.operations import (
     RestoreAutomationNodeOperationType,
 )
-from baserow.contrib.automation.nodes.signals import (
-    automation_node_created,
-    automation_node_deleted,
-)
+from baserow.contrib.automation.nodes.signals import automation_node_created
 from baserow.contrib.automation.workflows.models import AutomationWorkflow
 from baserow.core.models import TrashEntry
 from baserow.core.trash.exceptions import TrashItemRestorationDisallowed
@@ -51,14 +48,11 @@ def trash(
             item_to_trash.previous_node, next_nodes, item_to_trash.previous_node_output
         )
 
-        automation_node_deleted.send(
-            self,
-            workflow=item_to_trash.workflow,
-            node_id=item_to_trash.id,
-            user=requesting_user,
-        )
-
-    def restore(self, trashed_item: AutomationActionNode, trash_entry: TrashEntry):
+    def restore(
+        self,
+        trashed_item: AutomationActionNode,
+        trash_entry: TrashEntry,
+    ):
         workflow = trashed_item.workflow
         next_nodes = list(
             AutomationNodeHandler().get_next_nodes(workflow, trashed_item.previous_node)
@@ -106,7 +100,8 @@ def restore(self, trashed_item: AutomationActionNode, trash_entry: TrashEntry):
                 updates.append(next_node)
             AutomationNode.objects.bulk_update(updates, ["previous_node_output"])
 
-        automation_node_created.send(self, node=trashed_item, user=None)
+        if trash_entry.get_operation_type().send_post_restore_created_signal:
+            automation_node_created.send(self, node=trashed_item, user=None)
 
     def permanently_delete_item(
         self, trashed_item: AutomationNode, trash_item_lookup_cache=None

backend/src/baserow/contrib/automation/nodes/ws/signals.py

@@ -11,10 +11,12 @@
 from baserow.contrib.automation.nodes.operations import (
     ListAutomationNodeOperationType,
     ReadAutomationNodeOperationType,
+    UpdateAutomationNodeOperationType,
 )
 from baserow.contrib.automation.nodes.signals import (
     automation_node_created,
     automation_node_deleted,
+    automation_node_replaced,
     automation_node_updated,
     automation_nodes_reordered,
 )
@@ -98,3 +100,29 @@ def nodes_reordered(
             getattr(user, "web_socket_id", None),
         )
     )
+
+
+@receiver(automation_node_replaced)
+def node_replaced(
+    sender,
+    workflow: AutomationWorkflow,
+    deleted_node: AutomationNode,
+    restored_node: AutomationNode,
+    user: AbstractUser,
+    **kwargs,
+):
+    transaction.on_commit(
+        lambda: broadcast_to_permitted_users.delay(
+            workflow.automation.workspace_id,
+            UpdateAutomationNodeOperationType.type,
+            AutomationWorkflowObjectScopeType.type,
+            workflow.id,
+            {
+                "type": "automation_node_replaced",
+                "workflow_id": workflow.id,
+                "deleted_node": AutomationNodeSerializer(deleted_node).data,
+                "restored_node": AutomationNodeSerializer(restored_node).data,
+            },
+            getattr(user, "web_socket_id", None),
+        )
+    )

backend/src/baserow/contrib/automation/trash_types.py

@@ -30,7 +30,11 @@ def trash(
 
         super().trash(item_to_trash, requesting_user, trash_entry)
 
-    def restore(self, trashed_item: Automation, trash_entry: TrashEntry):
+    def restore(
+        self,
+        trashed_item: Automation,
+        trash_entry: TrashEntry,
+    ):
         super().restore(trashed_item, trash_entry)
         application_created.send(self, application=trashed_item, user=None)
 

backend/src/baserow/contrib/automation/workflows/trash_types.py

@@ -34,7 +34,11 @@ def trash(
             user=None,
         )
 
-    def restore(self, trashed_item: AutomationWorkflow, trash_entry: TrashEntry):
+    def restore(
+        self,
+        trashed_item: AutomationWorkflow,
+        trash_entry: TrashEntry,
+    ):
         super().restore(trashed_item, trash_entry)
         automation_workflow_created.send(self, workflow=trashed_item, user=None)