Fix: deselect and trigger refresh for deleted documents from bulk operations with "delete originals" (#8996)

src/documents/bulk_edit.py

@@ -24,6 +24,7 @@ from documents.models import Document
 from documents.models import DocumentType
 from documents.models import StoragePath
 from documents.permissions import set_permissions_for_object
+from documents.plugins.helpers import DocumentsStatusManager
 from documents.tasks import bulk_update_documents
 from documents.tasks import consume_file
 from documents.tasks import update_document_content_maybe_archive_file
@@ -219,6 +220,9 @@ def delete(doc_ids: list[int]) -> Literal["OK"]:
         with index.open_index_writer() as writer:
             for id in doc_ids:
                 index.remove_document_by_id(writer, id)
+
+        status_mgr = DocumentsStatusManager()
+        status_mgr.send_documents_deleted(doc_ids)
     except Exception as e:
         if "Data too long for column" in str(e):
             logger.warning(

src/documents/plugins/helpers.py

@@ -15,16 +15,14 @@ class ProgressStatusOptions(str, enum.Enum):
     FAILED = "FAILED"
 
 
-class ProgressManager:
+class BaseStatusManager:
     """
     Handles sending of progress information via the channel layer, with proper management
     of the open/close of the layer to ensure messages go out and everything is cleaned up
     """
 
-    def __init__(self, filename: str, task_id: str | None = None) -> None:
-        self.filename = filename
+    def __init__(self) -> None:
         self._channel: RedisPubSubChannelLayer | None = None
-        self.task_id = task_id
 
     def __enter__(self):
         self.open()
@@ -49,6 +47,24 @@ class ProgressManager:
             async_to_sync(self._channel.flush)
             self._channel = None
 
+    def send(self, payload: dict[str, str | int | None]) -> None:
+        # Ensure the layer is open
+        self.open()
+
+        # Just for IDEs
+        if TYPE_CHECKING:
+            assert self._channel is not None
+
+        # Construct and send the update
+        async_to_sync(self._channel.group_send)("status_updates", payload)
+
+
+class ProgressManager(BaseStatusManager):
+    def __init__(self, filename: str | None = None, task_id: str | None = None) -> None:
+        super().__init__()
+        self.filename = filename
+        self.task_id = task_id
+
     def send_progress(
         self,
         status: ProgressStatusOptions,
@@ -57,13 +73,6 @@ class ProgressManager:
         max_progress: int,
         extra_args: dict[str, str | int | None] | None = None,
     ) -> None:
-        # Ensure the layer is open
-        self.open()
-
-        # Just for IDEs
-        if TYPE_CHECKING:
-            assert self._channel is not None
-
         payload = {
             "type": "status_update",
             "data": {
@@ -78,5 +87,16 @@ class ProgressManager:
         if extra_args is not None:
             payload["data"].update(extra_args)
 
-        # Construct and send the update
-        async_to_sync(self._channel.group_send)("status_updates", payload)
+        self.send(payload)
+
+
+class DocumentsStatusManager(BaseStatusManager):
+    def send_documents_deleted(self, documents: list[int]) -> None:
+        payload = {
+            "type": "documents_deleted",
+            "data": {
+                "documents": documents,
+            },
+        }
+
+        self.send(payload)

src/paperless/consumers.py

@@ -41,4 +41,10 @@ class StatusConsumer(WebsocketConsumer):
             self.close()
         else:
             if self._is_owner_or_unowned(event["data"]):
-                self.send(json.dumps(event["data"]))
+                self.send(json.dumps(event))
+
+    def documents_deleted(self, event):
+        if not self._authenticated():
+            self.close()
+        else:
+            self.send(json.dumps(event))

src/paperless/tests/test_websockets.py

@@ -5,6 +5,9 @@ from channels.testing import WebsocketCommunicator
 from django.test import TestCase
 from django.test import override_settings
 
+from documents.plugins.helpers import DocumentsStatusManager
+from documents.plugins.helpers import ProgressManager
+from documents.plugins.helpers import ProgressStatusOptions
 from paperless.asgi import application
 
 TEST_CHANNEL_LAYERS = {
@@ -22,6 +25,39 @@ class TestWebSockets(TestCase):
         self.assertFalse(connected)
         await communicator.disconnect()
 
+    @mock.patch("paperless.consumers.StatusConsumer.close")
+    @mock.patch("paperless.consumers.StatusConsumer._authenticated")
+    async def test_close_on_no_auth(self, _authenticated, mock_close):
+        _authenticated.return_value = True
+
+        communicator = WebsocketCommunicator(application, "/ws/status/")
+        connected, subprotocol = await communicator.connect()
+        self.assertTrue(connected)
+
+        message = {"type": "status_update", "data": {"task_id": "test"}}
+
+        _authenticated.return_value = False
+
+        channel_layer = get_channel_layer()
+        await channel_layer.group_send(
+            "status_updates",
+            message,
+        )
+        await communicator.receive_nothing()
+
+        mock_close.assert_called_once()
+        mock_close.reset_mock()
+
+        message = {"type": "documents_deleted", "data": {"documents": [1, 2, 3]}}
+
+        await channel_layer.group_send(
+            "status_updates",
+            message,
+        )
+        await communicator.receive_nothing()
+
+        mock_close.assert_called_once()
+
     @mock.patch("paperless.consumers.StatusConsumer._authenticated")
     async def test_auth(self, _authenticated):
         _authenticated.return_value = True
@@ -33,19 +69,19 @@ class TestWebSockets(TestCase):
         await communicator.disconnect()
 
     @mock.patch("paperless.consumers.StatusConsumer._authenticated")
-    async def test_receive(self, _authenticated):
+    async def test_receive_status_update(self, _authenticated):
         _authenticated.return_value = True
 
         communicator = WebsocketCommunicator(application, "/ws/status/")
         connected, subprotocol = await communicator.connect()
         self.assertTrue(connected)
 
-        message = {"task_id": "test"}
+        message = {"type": "status_update", "data": {"task_id": "test"}}
 
         channel_layer = get_channel_layer()
         await channel_layer.group_send(
             "status_updates",
-            {"type": "status_update", "data": message},
+            message,
         )
 
         response = await communicator.receive_json_from()
@@ -53,3 +89,73 @@ class TestWebSockets(TestCase):
         self.assertEqual(response, message)
 
         await communicator.disconnect()
+
+    @mock.patch("paperless.consumers.StatusConsumer._authenticated")
+    async def test_receive_documents_deleted(self, _authenticated):
+        _authenticated.return_value = True
+
+        communicator = WebsocketCommunicator(application, "/ws/status/")
+        connected, subprotocol = await communicator.connect()
+        self.assertTrue(connected)
+
+        message = {"type": "documents_deleted", "data": {"documents": [1, 2, 3]}}
+
+        channel_layer = get_channel_layer()
+        await channel_layer.group_send(
+            "status_updates",
+            message,
+        )
+
+        response = await communicator.receive_json_from()
+
+        self.assertEqual(response, message)
+
+        await communicator.disconnect()
+
+    @mock.patch("channels.layers.InMemoryChannelLayer.group_send")
+    def test_manager_send_progress(self, mock_group_send):
+        with ProgressManager(task_id="test") as manager:
+            manager.send_progress(
+                ProgressStatusOptions.STARTED,
+                "Test message",
+                1,
+                10,
+                extra_args={
+                    "foo": "bar",
+                },
+            )
+
+        message = mock_group_send.call_args[0][1]
+
+        self.assertEqual(
+            message,
+            {
+                "type": "status_update",
+                "data": {
+                    "filename": None,
+                    "task_id": "test",
+                    "current_progress": 1,
+                    "max_progress": 10,
+                    "status": ProgressStatusOptions.STARTED,
+                    "message": "Test message",
+                    "foo": "bar",
+                },
+            },
+        )
+
+    @mock.patch("channels.layers.InMemoryChannelLayer.group_send")
+    def test_manager_send_documents_deleted(self, mock_group_send):
+        with DocumentsStatusManager() as manager:
+            manager.send_documents_deleted([1, 2, 3])
+
+        message = mock_group_send.call_args[0][1]
+
+        self.assertEqual(
+            message,
+            {
+                "type": "documents_deleted",
+                "data": {
+                    "documents": [1, 2, 3],
+                },
+            },
+        )