MindsDB 25.3.4.1__py3-none-any.whl → 25.4.1.0__py3-none-any.whl

mindsdb/integrations/handlers/ms_teams_handler/ms_graph_api_teams_client.py

@@ -1,18 +1,18 @@
-from typing import Text, List, Dict, Optional
+from abc import ABC, abstractmethod
+from typing import Text, List, Dict
 
 from requests.exceptions import RequestException
 
 from mindsdb.integrations.utilities.handlers.api_utilities.microsoft.ms_graph_api_utilities import MSGraphAPIBaseClient
 from mindsdb.utilities import log
 
+
 logger = log.getLogger(__name__)
 
 
-class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient): 
+class MSGraphAPITeamsClient(MSGraphAPIBaseClient, ABC):
     """
-    The Microsoft Graph API client for the Microsoft Teams handler with delegated permissions.
-    This client is used for accessing the Microsoft Teams specific endpoints of the Microsoft Graph API.
-    Several common methods for submitting requests, fetching data, etc. are inherited from the base class.
+    The base class for the Microsoft Graph API client for the Microsoft Teams handler.
     """
 
     def check_connection(self) -> bool:
@@ -23,21 +23,89 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
             bool: True if the connection is established, False otherwise.
         """
         try:
-            self.fetch_data_json("me/joinedTeams")
+            self._get_all_groups()
             return True
         except RequestException as request_error:
             logger.error(f"Failed to check connection to Microsoft Teams: {request_error}")
             return False
         
-    def get_all_groups(self) -> List[Dict]:
+    def get_teams(self) -> List[Dict]:
         """
-        Get all groups that the signed in user is a member of.
+        Get teams from Microsoft Teams.
 
         Returns:
-            List[Dict]: The groups data.
+            List[Dict]: The teams data.
         """
-        return self.fetch_data_json("me/joinedTeams")
+        return self._get_all_groups()
         
+    def get_channels(self, group_id: Text = None, channel_ids: List[Text] = None) -> List[Dict]:
+        """
+        Get channels from Microsoft Teams.
+
+        Args:
+            group_id (Text): The ID of the group that the channels belong to.
+            channel_ids (List[Text]): The IDs of the channels.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        if group_id and channel_ids:
+            return self._get_channels_in_group_by_ids(group_id, channel_ids)
+        elif group_id:
+            return self._get_all_channels_in_group(group_id)
+        elif channel_ids:
+            return self._get_channels_across_all_groups_by_ids(channel_ids)
+        else:
+            return self._get_all_channels_across_all_groups()
+        
+    def get_channel_messages(self, group_id: Text, channel_id: Text, message_ids: List[Text] = None) -> List[Dict]:
+        """
+        Get channel messages from Microsoft Teams.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel that the messages belong to.
+            message_ids (List[Text]): The IDs of the messages.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        if message_ids:
+            return self._get_messages_in_channel_by_ids(group_id, channel_id, message_ids)
+        else:
+            return self._get_all_messages_in_channel(group_id, channel_id)
+        
+    def get_chats(self, chat_ids: List[Text] = None) -> List[Dict]:
+        """
+        Get chats from Microsoft Teams.
+
+        Args:
+            chat_ids (List[Text]): The IDs of the chats.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        if chat_ids:
+            return self._get_chats_by_ids(chat_ids)
+        else:
+            return self._get_all_chats()
+        
+    def get_chat_messages(self, chat_id: Text, message_ids: List[Text] = None) -> List[Dict]:
+        """
+        Get chat messages from Microsoft Teams.
+
+        Args:
+            chat_id (Text): The ID of the chat that the messages belong to.
+            message_ids (List[Text]): The IDs of the messages.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        if message_ids:
+            return self._get_messages_in_chat_by_ids(chat_id, message_ids)
+        else:
+            return self._get_all_messages_in_chat(chat_id)
+
     def _get_all_group_ids(self) -> List[Text]:
         """
         Get all group IDs related to Microsoft Teams.
@@ -46,12 +114,75 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
             List[Text]: The group IDs.
         """
         if not self._group_ids:
-            groups = self.get_all_groups()
+            groups = self._get_all_groups()
             self._group_ids = [group["id"] for group in groups]
 
         return self._group_ids
     
-    def get_channel_in_group_by_id(self, group_id: Text, channel_id: Text) -> Dict:
+    @abstractmethod
+    def _get_all_groups(self) -> List[Dict]:
+        """
+        Get all groups related to Microsoft Teams.
+
+        Returns:
+            List[Dict]: The groups data.
+        """
+        pass
+
+    @abstractmethod
+    def _get_chat_by_id(self, chat_id: Text) -> Dict:
+        """
+        Get a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            Dict: The chat data.
+        """
+        pass
+
+    @abstractmethod
+    def _get_all_chats(self, limit: int = None) -> List[Dict]:
+        """
+        Get all chats related to Microsoft Teams.
+
+        Args:
+            limit (int): The maximum number of chats to return.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        pass
+
+    @abstractmethod
+    def _get_message_in_chat_by_id(self, chat_id: Text, message_id: Text) -> Dict:
+        """
+        Get a message by its ID and the ID of the chat that it belongs to.
+
+        Args:
+            chat_id (Text): The ID of the chat that the message belongs to.
+            message_id (Text): The ID of the message.
+
+        Returns:
+            Dict: The message data.
+        """
+        pass
+
+    @abstractmethod
+    def _get_all_messages_in_chat(self, chat_id: Text, limit: int = None) -> List[Dict]:
+        """
+        Get messages of a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        pass
+
+    def _get_channel_in_group_by_id(self, group_id: Text, channel_id: Text) -> Dict:
         """
         Get a channel by its ID and the ID of the group that it belongs to.
 
@@ -68,7 +199,7 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
 
         return channel
     
-    def get_channels_in_group_by_ids(self, group_id: Text, channel_ids: List[Text]) -> List[Dict]:
+    def _get_channels_in_group_by_ids(self, group_id: Text, channel_ids: List[Text]) -> List[Dict]:
         """
         Get channels by their IDs and the ID of the group that they belong to.
 
@@ -81,11 +212,11 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         """
         channels = []
         for channel_id in channel_ids:
-            channels.append(self.get_channel_in_group_by_id(group_id, channel_id))
+            channels.append(self._get_channel_in_group_by_id(group_id, channel_id))
 
         return channels
-    
-    def get_all_channels_in_group(self, group_id: Text) -> List[Dict]:
+        
+    def _get_all_channels_in_group(self, group_id: Text) -> List[Dict]:
         """
         Get all channels of a group by its ID.
 
@@ -101,20 +232,20 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
 
         return channels
     
-    def get_all_channels_across_all_groups(self) -> List[Dict]:
+    def _get_all_channels_across_all_groups(self) -> List[Dict]:
         """
-        Get all channels across all groups that the signed in user is a member of.
+        Get all channels across all groups related to Microsoft Teams.
 
         Returns:
             List[Dict]: The channels data.
         """
         channels = []
         for group_id in self._get_all_group_ids():
-            channels += self.get_all_channels_in_group(group_id)
+            channels += self._get_all_channels_in_group(group_id)
 
         return channels
     
-    def get_channels_across_all_groups_by_ids(self, channel_ids: List[Text]) -> List[Dict]:
+    def _get_channels_across_all_groups_by_ids(self, channel_ids: List[Text]) -> List[Dict]:
         """
         Get channels by their IDs.
 
@@ -124,11 +255,11 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         Returns:
             List[Dict]: The channels data.
         """
-        channels = self.get_all_channels_across_all_groups()
+        channels = self._get_all_channels_across_all_groups()
 
         return [channel for channel in channels if channel["id"] in channel_ids]
     
-    def get_message_in_channel_by_id(self, group_id: Text, channel_id: Text, message_id: Text) -> Dict:
+    def _get_message_in_channel_by_id(self, group_id: Text, channel_id: Text, message_id: Text) -> Dict:
         """
         Get a message by its ID, the ID of the group that it belongs to, and the ID of the channel that it belongs to.
 
@@ -142,7 +273,7 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         """
         return self.fetch_data_json(f"teams/{group_id}/channels/{channel_id}/messages/{message_id}")
     
-    def get_messages_in_channel_by_ids(self, group_id: Text, channel_id: Text, message_ids: List[Text]) -> List[Dict]:
+    def _get_messages_in_channel_by_ids(self, group_id: Text, channel_id: Text, message_ids: List[Text]) -> List[Dict]:
         """
         Get messages by their IDs, the ID of the group that they belong to, and the ID of the channel that they belong to.
 
@@ -156,11 +287,11 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         """
         messages = []
         for message_id in message_ids:
-            messages.append(self.get_message_in_channel_by_id(group_id, channel_id, message_id))
+            messages.append(self._get_message_in_channel_by_id(group_id, channel_id, message_id))
 
         return messages
 
-    def get_all_messages_in_channel(self, group_id: Text, channel_id: Text, limit: int = None) -> List[Dict]:
+    def _get_all_messages_in_channel(self, group_id: Text, channel_id: Text, limit: int = None) -> List[Dict]:
         """
         Get messages of a channel by its ID and the ID of the group that it belongs to.
 
@@ -180,7 +311,60 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
 
         return messages[:limit]
     
-    def get_chat_by_id(self, chat_id: Text) -> Dict:
+    def _get_chats_by_ids(self, chat_ids: List[Text]) -> List[Dict]:
+        """
+        Get chats by their IDs.
+
+        Args:
+            chat_ids (List[Text]): The IDs of the chats.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        chats = []
+        for chat_id in chat_ids:
+            chats.append(self._get_chat_by_id(chat_id))
+
+        return chats
+    
+    def _get_messages_in_chat_by_ids(self, chat_id: Text, message_ids: List[Text]) -> List[Dict]:
+        """
+        Get messages by their IDs and the ID of the chat that they belong to.
+
+        Args:
+            chat_id (Text): The ID of the chat that the messages belong to.
+            message_ids (List[Text]): The IDs of the messages.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for message_id in message_ids:
+            messages.append(self._get_message_in_chat_by_id(chat_id, message_id))
+
+        return messages
+
+
+class MSGraphAPITeamsApplicationPermissionsClient(MSGraphAPITeamsClient):
+    """
+    The Microsoft Graph API client for the Microsoft Teams handler with application permissions.
+    This client is used for accessing the Microsoft Teams specific endpoints of the Microsoft Graph API.
+    Several common methods for submitting requests, fetching data, etc. are inherited from the base class.
+    """
+        
+    def _get_all_groups(self) -> List[Dict]:
+        """
+        Get all groups related to Microsoft Teams.
+
+        Returns:
+            List[Dict]: The groups data.
+        """
+        return self.fetch_data_json(
+            "/groups",
+            params={"$filter": "resourceProvisioningOptions/Any(x:x eq 'Team')"}
+        )
+    
+    def _get_chat_by_id(self, chat_id: Text) -> Dict:
         """
         Get a chat by its ID.
 
@@ -190,25 +374,82 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         Returns:
             Dict: The chat data.
         """
-        return self.fetch_data_json(f"/me/chats/{chat_id}")
+        return self.fetch_data_json(f"chats/{chat_id}")
     
-    def get_chats_by_ids(self, chat_ids: List[Text]) -> List[Dict]:
+    def _get_all_chats(self, limit: int = None) -> List[Dict]:
         """
-        Get chats by their IDs.
+        Get all chats related to Microsoft Teams.
 
         Args:
-            chat_ids (List[Text]): The IDs of the chats.
+            limit (int): The maximum number of chats to return.
 
         Returns:
             List[Dict]: The chats data.
         """
-        chats = []
-        for chat_id in chat_ids:
-            chats.append(self.get_chat_by_id(chat_id))
+        raise RuntimeError("Retrieving all chats is not supported with application permissions. Either use delegated permissions or provide a chat ID.")
 
-        return chats
+    def _get_message_in_chat_by_id(self, chat_id: Text, message_id: Text) -> Dict:
+        """
+        Get a message by its ID and the ID of the chat that it belongs to.
+
+        Args:
+            chat_id (Text): The ID of the chat that the message belongs to.
+            message_id (Text): The ID of the message.
+
+        Returns:
+            Dict: The message data.
+        """
+        return self.fetch_data_json(f"chats/{chat_id}/messages/{message_id}")
+    
+    def _get_all_messages_in_chat(self, chat_id: Text, limit: int = None) -> List[Dict]:
+        """
+        Get messages of a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
 
-    def get_all_chats(self, limit: int = None) -> List[Dict]:
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for messages_batch in self.fetch_paginated_data(f"chats/{chat_id}/messages"):
+            messages += messages_batch
+
+            if limit and len(messages) >= limit:
+                break
+
+        return messages[:limit]
+
+
+class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPITeamsClient): 
+    """
+    The Microsoft Graph API client for the Microsoft Teams handler with delegated permissions.
+    This client is used for accessing the Microsoft Teams specific endpoints of the Microsoft Graph API.
+    Several common methods for submitting requests, fetching data, etc. are inherited from the base class.
+    """
+        
+    def _get_all_groups(self) -> List[Dict]:
+        """
+        Get all groups that the signed in user is a member of.
+
+        Returns:
+            List[Dict]: The groups data.
+        """
+        return self.fetch_data_json("me/joinedTeams")
+    
+    def _get_chat_by_id(self, chat_id: Text) -> Dict:
+        """
+        Get a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            Dict: The chat data.
+        """
+        return self.fetch_data_json(f"/me/chats/{chat_id}")
+
+    def _get_all_chats(self, limit: int = None) -> List[Dict]:
         """
         Get all chats of the signed in user.
 
@@ -227,7 +468,7 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
 
         return chats[:limit]
     
-    def get_message_in_chat_by_id(self, chat_id: Text, message_id: Text) -> Dict:
+    def _get_message_in_chat_by_id(self, chat_id: Text, message_id: Text) -> Dict:
         """
         Get a message by its ID and the ID of the chat that it belongs to.
 
@@ -240,24 +481,7 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
         """
         return self.fetch_data_json(f"me/chats/{chat_id}/messages/{message_id}")
     
-    def get_messages_in_chat_by_ids(self, chat_id: Text, message_ids: List[Text]) -> List[Dict]:
-        """
-        Get messages by their IDs and the ID of the chat that they belong to.
-
-        Args:
-            chat_id (Text): The ID of the chat that the messages belong to.
-            message_ids (List[Text]): The IDs of the messages.
-
-        Returns:
-            List[Dict]: The messages data.
-        """
-        messages = []
-        for message_id in message_ids:
-            messages.append(self.get_message_in_chat_by_id(chat_id, message_id))
-
-        return messages
-    
-    def get_all_messages_in_chat(self, chat_id: Text, limit: int = None) -> List[Dict]:
+    def _get_all_messages_in_chat(self, chat_id: Text, limit: int = None) -> List[Dict]:
         """
         Get messages of a chat by its ID.
 
@@ -275,4 +499,3 @@ class MSGraphAPITeamsDelegatedPermissionsClient(MSGraphAPIBaseClient):
                 break
 
         return messages[:limit]
-

mindsdb/integrations/handlers/ms_teams_handler/ms_teams_handler.py

@@ -7,7 +7,11 @@ from botframework.connector.auth import MicrosoftAppCredentials
 import msal
 from requests.exceptions import RequestException
 
-from mindsdb.integrations.handlers.ms_teams_handler.ms_graph_api_teams_client import MSGraphAPITeamsDelegatedPermissionsClient
+from mindsdb.integrations.handlers.ms_teams_handler.ms_graph_api_teams_client import (
+    MSGraphAPIBaseClient,
+    MSGraphAPITeamsApplicationPermissionsClient,
+    MSGraphAPITeamsDelegatedPermissionsClient
+)
 from mindsdb.integrations.handlers.ms_teams_handler.ms_teams_tables import (
     ChannelsTable, ChannelMessagesTable, ChatsTable, ChatMessagesTable, TeamsTable
 )
@@ -15,17 +19,21 @@ from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
 )
 from mindsdb.integrations.libs.api_handler import APIChatHandler
-from mindsdb.integrations.utilities.handlers.auth_utilities import MSGraphAPIDelegatedPermissionsManager
+from mindsdb.integrations.utilities.handlers.auth_utilities import (
+    MSGraphAPIApplicationPermissionsManager,
+    MSGraphAPIDelegatedPermissionsManager
+)
 from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 from mindsdb.interfaces.chatbot.types import ChatBotMessage
 from mindsdb.utilities import log
 
+
 logger = log.getLogger(__name__)
 
 
 def chatbot_only(func):
     def wrapper(self, *args, **kwargs):
-        if self.connection_data.get('mode', 'chat') != 'chat':
+        if self.connection_data.get('opertion_mode', 'datasource') != 'chatbot':
             raise ValueError("This connection can only be used as a data source. Please use a chatbot connection by setting the 'mode' parameter to 'chat'.")
         return func(self, *args, **kwargs)
     return wrapper
@@ -62,7 +70,7 @@ class MSTeamsHandler(APIChatHandler):
         self.bot_id = None
         self.conversation_id = None
 
-    def connect(self) -> Union[MicrosoftAppCredentials, MSGraphAPITeamsDelegatedPermissionsClient]:
+    def connect(self) -> Union[MicrosoftAppCredentials, MSGraphAPIBaseClient]:
         """
         Establishes a connection to the Microsoft Teams registered app or the Microsoft Graph API.
 
@@ -72,13 +80,9 @@ class MSTeamsHandler(APIChatHandler):
         if self.is_connected:
             return self.connection
 
-        # The default mode is 'data'. This is used for data source connections.
-        if self.connection_data.get('mode', 'data') == 'chat':
-            self.connection = MicrosoftAppCredentials(
-                app_id=self.connection_data["client_id"],
-                password=self.connection_data["client_secret"]
-            )
-        else:
+        # The default operation mode is 'datasource'. This is used for data source connections.
+        operation_mode = self.connection_data.get('operation_mode', 'datasource')
+        if operation_mode == 'datasource':
             # Initialize the token cache.
             cache = msal.SerializableTokenCache()
 
@@ -92,13 +96,27 @@ class MSTeamsHandler(APIChatHandler):
             if cache_content:
                 cache.deserialize(cache_content)
 
-            permissions_manager = MSGraphAPIDelegatedPermissionsManager(
-                client_id=self.connection_data['client_id'],
-                client_secret=self.connection_data['client_secret'],
-                tenant_id=self.connection_data['tenant_id'],
-                cache=cache,
-                code=self.connection_data.get('code')
-            )
+            # The default permissions mode is 'delegated'. This requires the user to sign in.
+            permission_mode = self.connection_data.get('permission_mode', 'delegated')
+            if permission_mode == 'delegated':
+                permissions_manager = MSGraphAPIDelegatedPermissionsManager(
+                    client_id=self.connection_data['client_id'],
+                    client_secret=self.connection_data['client_secret'],
+                    tenant_id=self.connection_data['tenant_id'],
+                    cache=cache,
+                    code=self.connection_data.get('code')
+                )
+
+            elif permission_mode == 'application':
+                permissions_manager = MSGraphAPIApplicationPermissionsManager(
+                    client_id=self.connection_data['client_id'],
+                    client_secret=self.connection_data['client_secret'],
+                    tenant_id=self.connection_data['tenant_id'],
+                    cache=cache
+                )
+
+            else:
+                raise ValueError("The supported permission modes are 'delegated' and 'application'.")
 
             access_token = permissions_manager.get_access_token()
 
@@ -106,7 +124,11 @@ class MSTeamsHandler(APIChatHandler):
             if cache.has_state_changed:
                 self.handler_storage.file_set(cache_file, cache.serialize().encode('utf-8'))
 
-            self.connection = MSGraphAPITeamsDelegatedPermissionsClient(access_token)
+            if permission_mode == 'delegated':
+                self.connection = MSGraphAPITeamsDelegatedPermissionsClient(access_token)
+
+            else:
+                self.connection = MSGraphAPITeamsApplicationPermissionsClient(access_token)
 
             self._register_table('channels', ChannelsTable(self))
             self._register_table('channel_messages', ChannelMessagesTable(self))
@@ -114,6 +136,15 @@ class MSTeamsHandler(APIChatHandler):
             self._register_table('chat_messages', ChatMessagesTable(self))
             self._register_table('teams', TeamsTable(self))
 
+        elif operation_mode == 'chatbot':
+            self.connection = MicrosoftAppCredentials(
+                self.connection_data['app_id'],
+                self.connection_data['app_password']
+            )
+
+        else:
+            raise ValueError("The supported operation modes are 'datasource' and 'chatbot'.")
+
         self.is_connected = True
 
         return self.connection
@@ -129,8 +160,8 @@ class MSTeamsHandler(APIChatHandler):
 
         try:
             connection = self.connect()
-            # A connection check against the Microsoft Graph API is run if the connection is in 'data' mode.
-            if self.connection_data.get('mode', 'data') == 'data' and connection.check_connection():
+            # A connection check against the Microsoft Graph API is run if the connection is in 'datasource' mode.
+            if self.connection_data.get('operation_mode', 'datasource') == 'datasource' and connection.check_connection():
                 response.success = True
                 response.copy_storage = True
             else:

mindsdb/integrations/handlers/ms_teams_handler/ms_teams_tables.py

@@ -33,10 +33,10 @@ class TeamsTable(APIResource):
             targets (List[str]): The list of target columns to return.
         """
         client: MSGraphAPITeamsDelegatedPermissionsClient = self.handler.connect()
-        teams = client.get_all_groups()
+        teams = client.get_teams()
 
         teams_df = pd.json_normalize(teams, sep="_")
-        teams_df = teams_df[self.get_columns()]
+        teams_df = teams_df.reindex(columns=self.get_columns(), fill_value=None)
 
         return teams_df
 
@@ -114,18 +114,7 @@ class ChannelsTable(APIResource):
 
                 condition.applied = True
 
-        if team_id:
-            if channel_ids:
-                channels = client.get_channels_in_group_by_ids(team_id, channel_ids)
-
-            else:
-                channels = client.get_all_channels_in_group(team_id)
-
-        elif channel_ids:
-            channels = client.get_channels_across_all_groups_by_ids(channel_ids)
-
-        else:
-            channels = client.get_all_channels_across_all_groups()
+        channels = client.get_channels(team_id, channel_ids)
 
         channels_df = pd.json_normalize(channels, sep="_")
         channels_df = channels_df[self.get_columns()]
@@ -218,11 +207,7 @@ class ChannelMessagesTable(APIResource):
         if not group_id or not channel_id:
             raise ValueError("The 'channelIdentity_teamId' and 'channelIdentity_channelId' columns are required.")
         
-        if message_ids:
-            messages = client.get_messages_in_channel_by_ids(group_id, channel_id, message_ids)
-
-        else:
-            messages = client.get_all_messages_in_channel(group_id, channel_id, limit)
+        messages = client.get_channel_messages(group_id, channel_id, message_ids)
 
         messages_df = pd.json_normalize(messages, sep="_")
         messages_df = messages_df[self.get_columns()]
@@ -304,11 +289,7 @@ class ChatsTable(APIResource):
 
                 condition.applied = True
 
-        if chat_ids:
-            chats = client.get_chats_by_ids(chat_ids)
-
-        else:
-            chats = client.get_all_chats(limit)
+        chats = client.get_chats(chat_ids)
 
         chats_df = pd.json_normalize(chats, sep="_")
         chats_df = chats_df[self.get_columns()]
@@ -387,11 +368,7 @@ class ChatMessagesTable(APIResource):
         if not chat_id:
             raise ValueError("The 'chatId' column is required.")
         
-        if message_ids:
-            messages = client.get_messages_in_chat_by_ids(chat_id, message_ids)
-
-        else:
-            messages = client.get_all_messages_in_chat(chat_id, limit)
+        messages = client.get_chat_messages(chat_id, message_ids)
 
         messages_df = pd.json_normalize(messages, sep="_")
         messages_df = messages_df[self.get_columns()]