fix

Author: Rafael Marinho

stream_chat/async_chat/channel.py

@@ -139,9 +139,6 @@ async def mark_unread(self, user_id: str, **data: Any) -> StreamResponse:
         payload = add_user_id(data, user_id)
         return await self.client.post(f"{self.url}/unread", data=payload)
 
-    async def mark_delivered(self, data: Dict[str, Any]) -> Optional[StreamResponse]:
-        return await self.client.post("channels/delivered", data=data)
-
     async def get_replies(self, parent_id: str, **options: Any) -> StreamResponse:
         return await self.client.get(f"messages/{parent_id}/replies", params=options)
 

stream_chat/async_chat/client.py

@@ -986,6 +986,51 @@ async def update_user_location(
         params = {"user_id": user_id, **options}
         return await self.put("users/live_locations", data=data, params=params)
 
+    async def mark_delivered(self, data: Dict[str, Any]) -> Optional[StreamResponse]:
+        """
+        Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
+        
+        :param data: MarkDeliveredOptions containing latest_delivered_messages and other optional fields
+        :return: The server response or None if delivery receipts are disabled
+        """
+        # Validate required fields
+        if not data.get("latest_delivered_messages"):
+            raise ValueError("latest_delivered_messages must not be empty")
+        
+        # Ensure either user or user_id is provided
+        if not data.get("user") and not data.get("user_id"):
+            raise ValueError("either user or user_id must be provided")
+        
+        return await self.post("channels/delivered", data=data)
+
+    async def mark_delivered_simple(self, user_id: str, message_id: str, channel_cid: str) -> Optional[StreamResponse]:
+        """
+        Convenience method to mark a message as delivered for a specific user.
+        
+        :param user_id: The user ID
+        :param message_id: The message ID
+        :param channel_cid: The channel CID (channel_type:channel_id)
+        :return: The server response or None if delivery receipts are disabled
+        """
+        if not user_id:
+            raise ValueError("user ID must not be empty")
+        if not message_id:
+            raise ValueError("message ID must not be empty")
+        if not channel_cid:
+            raise ValueError("channel CID must not be empty")
+        
+        data = {
+            "latest_delivered_messages": [
+                {
+                    "cid": channel_cid,
+                    "id": message_id
+                }
+            ],
+            "user_id": user_id
+        }
+        
+        return await self.mark_delivered(data)
+    
     async def close(self) -> None:
         await self.session.close()
 

stream_chat/base/channel.py

@@ -293,18 +293,6 @@ def mark_unread(
         """
         pass
 
-    @abc.abstractmethod
-    def mark_delivered(
-        self, data: Dict[str, Any]
-    ) -> Union[StreamResponse, Awaitable[StreamResponse], None]:
-        """
-        Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
-
-        :param data: MarkDeliveredOptions containing channel_delivered_message and other optional fields
-        :return: The server response or None if delivery receipts are disabled
-        """
-        pass
-
     @abc.abstractmethod
     def get_replies(
         self, parent_id: str, **options: Any

stream_chat/base/client.py

@@ -1537,6 +1537,32 @@ def update_user_location(
         """
         pass
 
+    @abc.abstractmethod
+    def mark_delivered(
+        self, data: Dict[str, Any]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse], None]:
+        """
+        Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
+
+        :param data: MarkDeliveredOptions containing latest_delivered_messages and other optional fields
+        :return: The server response or None if delivery receipts are disabled
+        """
+        pass
+
+    @abc.abstractmethod
+    def mark_delivered_simple(
+        self, user_id: str, message_id: str, channel_cid: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse], None]:
+        """
+        Convenience method to mark a message as delivered for a specific user.
+
+        :param user_id: The user ID
+        :param message_id: The message ID
+        :param channel_cid: The channel CID (channel_type:channel_id)
+        :return: The server response or None if delivery receipts are disabled
+        """
+        pass
+
     #####################
     #  Private methods  #
     #####################

stream_chat/channel.py

@@ -140,9 +140,6 @@ def mark_unread(self, user_id: str, **data: Any) -> StreamResponse:
         payload = add_user_id(data, user_id)
         return self.client.post(f"{self.url}/unread", data=payload)
 
-    def mark_delivered(self, data: Dict[str, Any]) -> Optional[StreamResponse]:
-       return self.client.post("channels/delivered", data=data)
-
     def get_replies(self, parent_id: str, **options: Any) -> StreamResponse:
         return self.client.get(f"messages/{parent_id}/replies", params=options)
 

stream_chat/client.py

@@ -939,3 +939,48 @@ def update_user_location(
             data.update(cast(dict, options))
         params = {"user_id": user_id, **options}
         return self.put("users/live_locations", data=data, params=params)
+
+    def mark_delivered(self, data: Dict[str, Any]) -> Optional[StreamResponse]:
+        """
+        Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
+        
+        :param data: MarkDeliveredOptions containing latest_delivered_messages and other optional fields
+        :return: The server response or None if delivery receipts are disabled
+        """
+        # Validate required fields
+        if not data.get("latest_delivered_messages"):
+            raise ValueError("latest_delivered_messages must not be empty")
+        
+        # Ensure either user or user_id is provided
+        if not data.get("user") and not data.get("user_id"):
+            raise ValueError("either user or user_id must be provided")
+        
+        return self.post("channels/delivered", data=data)
+
+    def mark_delivered_simple(self, user_id: str, message_id: str, channel_cid: str) -> Optional[StreamResponse]:
+        """
+        Convenience method to mark a message as delivered for a specific user.
+        
+        :param user_id: The user ID
+        :param message_id: The message ID
+        :param channel_cid: The channel CID (channel_type:channel_id)
+        :return: The server response or None if delivery receipts are disabled
+        """
+        if not user_id:
+            raise ValueError("user ID must not be empty")
+        if not message_id:
+            raise ValueError("message ID must not be empty")
+        if not channel_cid:
+            raise ValueError("channel CID must not be empty")
+        
+        data = {
+            "latest_delivered_messages": [
+                {
+                    "cid": channel_cid,
+                    "id": message_id
+                }
+            ],
+            "user_id": user_id
+        }
+        
+        return self.mark_delivered(data)

stream_chat/tests/test_channel.py

@@ -203,25 +203,6 @@ def test_mark_unread(self, channel: Channel, random_user: Dict):
         response = channel.mark_unread(random_user["id"], message_id=msg_id)
         assert "duration" in response
 
-    def test_mark_delivered(self, channel: Channel, random_user: Dict):
-        delivery_data = {
-            "channel_delivered_message": {channel.id: "test-message-id"},
-            "user_id": random_user["id"]
-        }
-        
-        response = channel.mark_delivered(delivery_data)
-        assert response is not None
-        
-        delivery_data_with_options = {
-            "channel_delivered_message": {channel.id: "test-message-id-2"},
-            "user_id": random_user["id"],
-            "client_id": "test-client",
-            "connection_id": "test-connection"
-        }
-        
-        response = channel.mark_delivered(delivery_data_with_options)
-        assert response is not None
-
     def test_get_messages(self, channel: Channel, random_user: Dict):
         msg_id = str(uuid.uuid4())
         channel.send_message({"id": msg_id, "text": "helloworld"}, random_user["id"])

stream_chat/tests/test_client.py

@@ -1016,3 +1016,58 @@ def test_query_message_history(
 
         assert len(response_next["message_history"]) == 1
         assert response_next["message_history"][0]["text"] == "helloworld-2"
+
+        def test_mark_delivered(self, client: StreamChat, channel: Channel, random_user: Dict):
+        """Test marking messages as delivered"""
+        # Test with basic delivery data using new format
+        delivery_data = {
+            "latest_delivered_messages": [
+                {
+                    "cid": channel.cid,
+                    "id": "test-message-id"
+                }
+            ],
+            "user_id": random_user["id"]
+        }
+        
+        response = client.mark_delivered(delivery_data)
+        assert response is not None
+        
+        # Test with multiple messages
+        delivery_data_multiple = {
+            "latest_delivered_messages": [
+                {
+                    "cid": channel.cid,
+                    "id": "test-message-id-1"
+                },
+                {
+                    "cid": channel.cid,
+                    "id": "test-message-id-2"
+                }
+            ],
+            "user_id": random_user["id"]
+        }
+        
+        response = client.mark_delivered(delivery_data_multiple)
+        assert response is not None
+
+    def test_mark_delivered_simple(self, client: StreamChat, channel: Channel, random_user: Dict):
+        """Test the convenience method for marking messages as delivered"""
+        response = client.mark_delivered_simple(
+            user_id=random_user["id"],
+            message_id="test-message-id",
+            channel_cid=channel.cid
+        )
+        assert response is not None
+
+    def test_mark_delivered_validation(self, client: StreamChat, random_user: Dict):
+        """Test validation of mark_delivered method"""
+        # Test empty latest_delivered_messages
+        with pytest.raises(ValueError, match="latest_delivered_messages must not be empty"):
+            client.mark_delivered({"user_id": random_user["id"]})
+        
+        # Test missing user and user_id
+        with pytest.raises(ValueError, match="either user or user_id must be provided"):
+            client.mark_delivered({
+                "latest_delivered_messages": [{"cid": "test:channel", "id": "test"}]
+            })