MindsDB 25.3.3.0__py3-none-any.whl → 25.3.4.0__py3-none-any.whl

mindsdb/integrations/handlers/ms_teams_handler/ms_graph_api_teams_client.py

@@ -0,0 +1,278 @@
+from typing import Text, List, Dict, Optional
+
+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): 
+    """
+    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 check_connection(self) -> bool:
+        """
+        Check if the connection to Microsoft Teams is established.
+
+        Returns:
+            bool: True if the connection is established, False otherwise.
+        """
+        try:
+            self.fetch_data_json("me/joinedTeams")
+            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]:
+        """
+        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_all_group_ids(self) -> List[Text]:
+        """
+        Get all group IDs related to Microsoft Teams.
+
+        Returns:
+            List[Text]: The group IDs.
+        """
+        if not self._group_ids:
+            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:
+        """
+        Get a channel by its ID and the ID of the group that it belongs to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel.
+
+        Returns:
+            Dict: The channel data.
+        """
+        channel = self.fetch_data_json(f"teams/{group_id}/channels/{channel_id}")
+        # Add the group ID to the channel data.
+        channel.update({"teamId": group_id})
+
+        return channel
+    
+    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.
+
+        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.
+        """
+        channels = []
+        for channel_id in channel_ids:
+            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]:
+        """
+        Get all channels of a group by its ID.
+
+        Args:
+            group_id (Text): The ID of the group.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        channels = self.fetch_data_json(f"teams/{group_id}/channels")
+        for channel in channels:
+            channel["teamId"] = group_id
+
+        return channels
+    
+    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.
+
+        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)
+
+        return channels
+    
+    def get_channels_across_all_groups_by_ids(self, channel_ids: List[Text]) -> List[Dict]:
+        """
+        Get channels by their IDs.
+
+        Args:
+            channel_ids (List[Text]): The IDs of the channels.
+
+        Returns:
+            List[Dict]: The channels data.
+        """
+        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:
+        """
+        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.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel that the message belongs to.
+            message_id (Text): The ID of the message.
+
+        Returns:
+            Dict: The message data.
+        """
+        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]:
+        """
+        Get messages by their IDs, the ID of the group that they belong to, and the ID of the channel that they belong to.
+
+        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.
+        """
+        messages = []
+        for message_id in message_ids:
+            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]:
+        """
+        Get messages of a channel by its ID and the ID of the group that it belongs to.
+
+        Args:
+            group_id (Text): The ID of the group that the channel belongs to.
+            channel_id (Text): The ID of the channel.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for messages_batch in self.fetch_paginated_data(f"teams/{group_id}/channels/{channel_id}/messages"):
+            messages += messages_batch
+
+            if limit and len(messages) >= limit:
+                break
+
+        return messages[:limit]
+    
+    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_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_all_chats(self, limit: int = None) -> List[Dict]:
+        """
+        Get all chats of the signed in user.
+
+        Args:
+            limit (int): The maximum number of chats to return.
+
+        Returns:
+            List[Dict]: The chats data.
+        """
+        chats = []
+        for chat_batch in self.fetch_paginated_data("me/chats"):
+            chats += chat_batch
+
+            if limit and len(chats) >= limit:
+                break
+
+        return chats[:limit]
+    
+    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"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]:
+        """
+        Get messages of a chat by its ID.
+
+        Args:
+            chat_id (Text): The ID of the chat.
+
+        Returns:
+            List[Dict]: The messages data.
+        """
+        messages = []
+        for messages_batch in self.fetch_paginated_data(f"me/chats/{chat_id}/messages"):
+            messages += messages_batch
+
+            if limit and len(messages) >= limit:
+                break
+
+        return messages[:limit]
+

mindsdb/integrations/handlers/ms_teams_handler/ms_teams_handler.py

@@ -1,31 +1,48 @@
-from typing import Text, Dict, Callable
+from typing import Callable, Dict, Text, Callable, Union
 
 from botbuilder.schema import Activity, ActivityTypes
 from botbuilder.schema import ChannelAccount
 from botframework.connector import ConnectorClient
 from botframework.connector.auth import MicrosoftAppCredentials
-from mindsdb.utilities import log
-from mindsdb_sql_parser import parse_sql
+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_teams_tables import (
+    ChannelsTable, ChannelMessagesTable, ChatsTable, ChatMessagesTable, TeamsTable
+)
 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.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':
+            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
+
+
 class MSTeamsHandler(APIChatHandler):
     """
-    The Microsoft Teams handler implementation.
+    This handler handles the connection and execution of SQL statements on Microsoft Teams via the Microsoft Graph API.
+    It is also responsible for handling the chatbot functionality.
     """
 
     name = 'teams'
 
     def __init__(self, name: str, **kwargs):
         """
-        Initialize the handler.
+        Initializes the handler.
+
         Args:
             name (str): name of particular handler instance
             **kwargs: arbitrary keyword arguments.
@@ -34,6 +51,7 @@ class MSTeamsHandler(APIChatHandler):
 
         connection_data = kwargs.get("connection_data", {})
         self.connection_data = connection_data
+        self.handler_storage = kwargs['handler_storage']
         self.kwargs = kwargs
 
         self.connection = None
@@ -44,22 +62,57 @@ class MSTeamsHandler(APIChatHandler):
         self.bot_id = None
         self.conversation_id = None
 
-    def connect(self) -> MicrosoftAppCredentials:
+    def connect(self) -> Union[MicrosoftAppCredentials, MSGraphAPITeamsDelegatedPermissionsClient]:
         """
-        Set up the connection required by the handler.
+        Establishes a connection to the Microsoft Teams registered app or the Microsoft Graph API.
 
-        Returns
-        -------
-        MicrosoftAppCredentials
-            Client object for interacting with the Microsoft Teams app.
+        Returns:
+            Union[MicrosoftAppCredentials, MSGraphAPITeamsDelegatedPermissionsClient]: A connection object to the Microsoft Teams registered app or the Microsoft Graph API.
         """
         if self.is_connected:
             return self.connection
 
-        self.connection = MicrosoftAppCredentials(
-            app_id=self.connection_data["client_id"],
-            password=self.connection_data["client_secret"]
-        )
+        # 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:
+            # Initialize the token cache.
+            cache = msal.SerializableTokenCache()
+
+            # Load the cache from file if it exists.
+            cache_file = 'cache.bin'
+            try:
+                cache_content = self.handler_storage.file_get(cache_file)
+            except FileNotFoundError:
+                cache_content = None
+
+            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')
+            )
+
+            access_token = permissions_manager.get_access_token()
+
+            # Save the cache back to file if it has changed.
+            if cache.has_state_changed:
+                self.handler_storage.file_set(cache_file, cache.serialize().encode('utf-8'))
+
+            self.connection = MSGraphAPITeamsDelegatedPermissionsClient(access_token)
+
+            self._register_table('channels', ChannelsTable(self))
+            self._register_table('channel_messages', ChannelMessagesTable(self))
+            self._register_table('chats', ChatsTable(self))
+            self._register_table('chat_messages', ChatMessagesTable(self))
+            self._register_table('teams', TeamsTable(self))
 
         self.is_connected = True
 
@@ -67,54 +120,44 @@ class MSTeamsHandler(APIChatHandler):
 
     def check_connection(self) -> StatusResponse:
         """
-        Check connection to the handler.
+        Checks the status of the connection to Microsoft Teams.
 
-        Returns
-        -------
-        StatusResponse
-            Response object with the status of the connection.
+        Returns:
+            StatusResponse: An object containing the success status and an error message if an error occurs.
         """
         response = StatusResponse(False)
 
         try:
-            self.connect()
-            response.success = True
-        except Exception as e:
-            logger.error(f'Error connecting to Microsoft Teams: {e}!')
-            response.success = False
-            response.error_message = str(e)
+            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():
+                response.success = True
+                response.copy_storage = True
+            else:
+                raise RequestException("Connection check failed!")
+        except (ValueError, RequestException) as known_error:
+            logger.error(f'Connection check to Microsoft Teams failed, {known_error}!')
+            response.error_message = str(known_error)
+        except AuthException as error:
+            response.error_message = str(error)
+            response.redirect_url = error.auth_url
+            return response
+        except Exception as unknown_error:
+            logger.error(f'Connection check to Microsoft Teams failed due to an unknown error, {unknown_error}!')
+            response.error_message = str(unknown_error)
 
         self.is_connected = response.success
 
         return response
 
-    def native_query(self, query: Text) -> StatusResponse:
-        """
-        Receive and process a raw query.
-
-        Parameters
-        ----------
-        query: Text
-            Query in the native format.
-
-        Returns
-        -------
-        StatusResponse
-            Response object with the result of the query.
-        """
-        ast = parse_sql(query)
-
-        return self.query(ast)
-    
+    @chatbot_only
     def get_chat_config(self) -> Dict:
         """
-        Get the configuration for the chatbot.
+        Gets the configuration for the chatbot.
         This method is required for the implementation of the chatbot.
 
-        Returns
-        -------
-        Dict
-            Configuration for the chatbot.
+        Returns:
+            Dict: The configuration for the chatbot.
         """
         params = {
             'polling': {
@@ -123,30 +166,26 @@ class MSTeamsHandler(APIChatHandler):
         }
 
         return params
-    
+
+    @chatbot_only
     def get_my_user_name(self) -> Text:
         """
-        Get the name of the signed in user.
+        Gets the name of the signed in user.
         This method is required for the implementation of the chatbot.
 
-        Returns
-        -------
-        Text
-            Name of the signed in user.
+        Returns:
+            Text: The name of the signed in user.
         """
         return None
-    
+
+    @chatbot_only
     def on_webhook(self, request: Dict, callback: Callable) -> None:
         """
-        Handle a webhook request.
+        Handles a webhook request.
 
-        Parameters
-        ----------
-        request: Dict
-            The incoming webhook request.
-
-        callback: Callable
-            Callback function to call after parsing the request.
+        Args:
+            request (Dict): The request data.
+            callback (Callable): The callback function to call.
         """
         self.service_url = request["serviceUrl"]
         self.channel_id = request["channelId"]
@@ -164,15 +203,20 @@ class MSTeamsHandler(APIChatHandler):
             chat_id=request['conversation']['id'],
             message=chat_bot_message
         )    
-            
+
+    @chatbot_only
     def respond(self, message: ChatBotMessage) -> None:
         """
-        Send a response to the chatbot.
+        Sends a response to the chatbot.
+
+        Args:
+            message (ChatBotMessage): The message to send
+
+        Raises:
+            ValueError: If the chatbot message is not of type DIRECT.
 
-        Parameters
-        ----------
-        message: ChatBotMessage
-            The message to send.
+        Returns:
+            None
         """
         credentials = self.connect()