flowtask 5.8.4__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/interfaces/O365Client.py

@@ -0,0 +1,220 @@
+from abc import abstractmethod
+from typing import Any
+from collections.abc import Callable
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import msal
+from office365.graph_client import GraphClient
+from office365.sharepoint.client_context import ClientContext
+from office365.runtime.auth.user_credential import UserCredential
+from office365.runtime.auth.client_credential import ClientCredential
+from navconfig.logging import logging
+from ..conf import (
+    SHAREPOINT_TENANT_NAME,
+    O365_CLIENT_ID,
+    O365_CLIENT_SECRET,
+    O365_TENANT_ID,
+)
+from .credentials import CredentialsInterface
+
+
+logging.getLogger('msal').setLevel(logging.INFO)
+
+
+class O365Client(CredentialsInterface):
+    """
+    O365Client
+
+    Overview
+
+        The O365Client class is an abstract base class for managing connections to Office 365 services.
+        It handles authentication, credential processing, and provides a method for obtaining the
+        Office 365 context. It uses the Office 365 Python SDK for authentication and context management.
+
+    .. table:: Properties
+    :widths: auto
+
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | Name             | Required | Description                                                                                      |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | url              |   No     | The base URL for the Office 365 service.                                                         |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | tenant           |   Yes    | The tenant ID for the Office 365 service.                                                        |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | site             |   No     | The site URL for the Office 365 service.                                                         |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | auth_context     |   Yes    | The authentication context for Office 365.                                                       |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | context          |   Yes    | The context object for Office 365 operations.                                                    |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+        | credentials      |   Yes    | A dictionary containing the credentials for authentication.                                      |
+        +------------------+----------+--------------------------------------------------------------------------------------------------+
+
+    Return
+
+        The methods in this class manage the authentication and connection setup for Office 365 services,
+        providing an abstract base for subclasses to implement specific service interactions.
+
+    """  # noqa
+    _credentials: dict = {
+        "username": str,
+        "password": str,
+        "client_id": str,
+        "client_secret": str,
+        "tenant": str,
+        "site": str,
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        self.url: str = None
+        self.tenant_id: str = None
+        self.auth_context: Any = None
+        self.context: Any = None
+        self._access_token: str = None
+        self._graph_client: Callable = None
+        self._logger = logging.getLogger(__name__)
+        self._executor = ThreadPoolExecutor()
+        # Default credentials
+        self._default_tenant_id = O365_TENANT_ID
+        self._default_client_id = O365_CLIENT_ID
+        self._default_client_secret = O365_CLIENT_SECRET
+        self._default_tenant_name = SHAREPOINT_TENANT_NAME
+        super(O365Client, self).__init__(*args, **kwargs)
+
+    @abstractmethod
+    def get_context(self, url: str, *args):
+        pass
+
+    @abstractmethod
+    async def _start_(self, **kwargs):
+        pass
+
+    async def run_in_executor(self, fn, *args, **kwargs):
+        """
+        Calling any blocking process in an executor.
+        """
+        return await asyncio.get_event_loop().run_in_executor(
+            self._executor, fn, *args, **kwargs
+        )
+
+    def processing_credentials(self):
+        super().processing_credentials()
+        ## getting Tenant and Site from credentials:
+        try:
+            self.tenant = self.credentials.get('tenant', None)
+            if not self.tenant:
+                self.tenant = self._default_tenant_name
+            self.site = self.credentials.get('site', None)
+        except KeyError as e:
+            raise RuntimeError(
+                f"Office365: Missing Tenant or Site Configuration: {e}."
+            ) from e
+
+    def connection(self):
+        # calling before run:
+        self._start_()
+        # Processing The Credentials:
+        if hasattr(self, "credentials"):
+            username = self.credentials.get("username")
+            password = self.credentials.get("password")
+            client_id = self.credentials.get("client_id")
+            if not client_id:
+                client_id = self._default_client_id
+            client_secret = self.credentials.get("client_secret")
+            if not client_secret:
+                client_secret = self._default_client_secret
+        else:
+            # Maybe getting from default credentials?
+            client_id = getattr(self, 'client_id', self._default_client_id)
+            client_secret = getattr(self, 'client_secret', self._default_client_secret)
+            if not client_id or client_secret:
+                logging.error(
+                    "Office365: Wrong Credentials or missing Credentials")
+                raise RuntimeError(
+                    "Office365: Wrong Credentials or missing Credentials"
+                )
+        try:
+            if username is not None:
+                self.context = ClientContext(self.url).with_credentials(
+                    UserCredential(username, password)
+                )
+                try:
+                    token = self.user_auth(username, password)
+                    self._access_token = token.get('access_token')
+                except Exception as err:
+                    self._logger.warning(
+                        f"Office365: Authentication Error: {err}"
+                    )
+            else:
+                self.auth_context = ClientCredential(client_id, client_secret)
+                self.context = self.get_context(self.url).with_credentials(
+                    self.auth_context
+                )
+                token = self.acquire_token()
+                self._access_token = token.get('access_token')
+            # Create Graph client
+            self._graph_client = GraphClient(
+                acquire_token_callback=lambda: self.access_token
+            )
+            logging.debug("Office365: Authentication success")
+        except Exception as err:
+            logging.error(f"Office365: Authentication Error: {err}")
+            raise RuntimeError(f"Office365: Authentication Error: {err}") from err
+        return self
+
+    def user_auth(self, username: str, password: str, scopes: list = None) -> dict:
+        tenant_id = self.credentials.get('tenant_id', self._default_tenant_id)
+        authority_url = f'https://login.microsoftonline.com/{tenant_id}'
+        client_id = self.credentials.get("client_id")
+        if not client_id:
+            client_id = self._default_client_id
+
+        if not scopes:
+            scopes = ["https://graph.microsoft.com/.default"]
+        app = msal.PublicClientApplication(
+            authority=authority_url,
+            client_id=client_id,
+            client_credential=None
+        )
+        result = app.acquire_token_by_username_password(
+            username,
+            password,
+            scopes=scopes
+        )
+        if "access_token" not in result:
+            error_message = result.get('error_description', 'Unknown error')
+            error_code = result.get('error', 'Unknown error code')
+            raise RuntimeError(
+                f"Failed to obtain access token: {error_code} - {error_message}"
+            )
+        return result
+
+    def acquire_token(self, scopes: list = None) -> dict:
+        """
+        Acquire a Token via MSAL.
+        """
+        client_id = self.credentials.get("client_id")
+        if not client_id:
+            client_id = self._default_client_id
+        client_secret = self.credentials.get("client_secret")
+        if not client_secret:
+            client_secret = self._default_client_secret
+        tenant_id = self.credentials.get('tenant_id', self._default_tenant_id)
+        if not scopes:
+            scopes = ["https://graph.microsoft.com/.default"]
+        authority_url = f'https://login.microsoftonline.com/{tenant_id}'
+        app = msal.ConfidentialClientApplication(
+            authority=authority_url,
+            client_id=client_id,
+            client_credential=client_secret
+        )
+        result = app.acquire_token_for_client(
+            scopes=scopes
+        )
+        if "access_token" not in result:
+            error_message = result.get('error_description', 'Unknown error')
+            error_code = result.get('error', 'Unknown error code')
+            raise RuntimeError(
+                f"Failed to obtain access token: {error_code} - {error_message}"
+            )
+        return result

flowtask/interfaces/OneDrive.py

@@ -0,0 +1,284 @@
+import os
+from typing import List
+from collections.abc import Callable
+from pathlib import Path
+import pandas as pd
+from io import BytesIO
+from office365.graph_client import GraphClient
+from office365.onedrive.driveitems.driveItem import DriveItem
+from office365.onedrive.drives.drive import Drive
+from ..exceptions import FileError, FileNotFound
+from .O365Client import O365Client
+
+
+class OneDriveClient(O365Client):
+    """
+    OneDrive Client.
+
+    Interface for Managing connections to OneDrive resources.
+
+    Methods:
+        file_list: Lists files in a specified OneDrive folder.
+        file_search: Searches for files matching a query.
+        file_download: Downloads a single file by its item ID.
+        download_files: Downloads multiple files provided as a list of dictionaries containing file info.
+        folder_download: Downloads a folder and its contents recursively.
+        file_delete: Deletes a file or folder by its item ID.
+        upload_files: Uploads multiple files to a specified OneDrive folder.
+        upload_file: Uploads a single file to OneDrive.
+        upload_folder: Uploads a local folder and its contents to OneDrive recursively.
+
+    """
+
+    def get_context(self, url: str, *args) -> Callable:
+        # For OneDrive, we primarily use GraphClient
+        if not self._graph_client:
+            self._graph_client = GraphClient(acquire_token=lambda: self.access_token)
+        return self._graph_client
+
+    def _start_(self, **kwargs):
+        return True
+
+    async def download_excel_file(
+        self,
+        item_id: str,
+        destination: Path = None,
+        as_pandas: bool = False
+    ):
+        """
+        Download an Excel file from OneDrive by item ID.
+        If `as_pandas` is True, return as a pandas DataFrame.
+        If `as_pandas` is False, save to the destination path.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            file_item = drive.items[item_id]
+
+            if as_pandas:
+                bytes_buffer = BytesIO()
+                file_item.download(bytes_buffer).execute_query()
+                bytes_buffer.seek(0)
+                df = pd.read_excel(bytes_buffer)
+                return df
+            else:
+                if not destination:
+                    raise ValueError("Destination path must be provided when `as_pandas` is False.")
+                with open(destination, "wb") as local_file:
+                    file_item.download(local_file).execute_query()
+                return str(destination)
+        except Exception as err:
+            self._logger.error(f"Error downloading Excel file {item_id}: {err}")
+            raise FileError(f"Error downloading Excel file {item_id}: {err}") from err
+
+    async def upload_dataframe_as_excel(
+        self,
+        df: pd.DataFrame,
+        file_name: str,
+        destination_folder: str = None
+    ):
+        """
+        Upload a pandas DataFrame as an Excel file to OneDrive.
+        """
+        try:
+            output = BytesIO()
+            df.to_excel(output, index=False)
+            output.seek(0)
+            drive = self._graph_client.me.drive
+            if destination_folder:
+                item_path = f"{destination_folder}/{file_name}"
+            else:
+                item_path = file_name
+            target_item = drive.root.item_with_path(item_path)
+            target_item.upload(output).execute_query()
+            return {
+                "name": file_name,
+                "webUrl": target_item.web_url
+            }
+        except Exception as err:
+            self._logger.error(f"Error uploading DataFrame as Excel file {file_name}: {err}")
+            raise FileError(f"Error uploading DataFrame as Excel file {file_name}: {err}") from err
+
+    async def file_list(self, folder_path: str = None) -> List[dict]:
+        """
+        List files in a given OneDrive folder.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            if folder_path:
+                folder_item = drive.root.get_by_path(folder_path)
+            else:
+                folder_item = drive.root
+
+            items = folder_item.children.get().execute_query()
+            file_list = []
+            for item in items:
+                file_info = {
+                    "name": item.name,
+                    "id": item.id,
+                    "webUrl": item.web_url,
+                    "isFolder": item.folder is not None
+                }
+                file_list.append(file_info)
+            return file_list
+        except Exception as err:
+            self._logger.error(f"Error listing files: {err}")
+            raise FileError(f"Error listing files: {err}") from err
+
+    async def file_search(self, search_query: str) -> List[dict]:
+        """
+        Search for files in OneDrive matching the search query.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            items = drive.root.search(search_query).get().execute_query()
+            search_results = []
+            for item in items:
+                file_info = {
+                    "name": item.name,
+                    "id": item.id,
+                    "webUrl": item.web_url,
+                    "path": item.parent_reference.path,
+                    "isFolder": item.folder is not None
+                }
+                search_results.append(file_info)
+            return search_results
+        except Exception as err:
+            self._logger.error(f"Error searching files: {err}")
+            raise FileError(f"Error searching files: {err}") from err
+
+    async def file_download(self, item_id: str, destination: Path):
+        """
+        Download a file from OneDrive by item ID.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            file_item = drive.items[item_id]
+            with open(destination, "wb") as local_file:
+                file_item.download(local_file).execute_query()
+            return str(destination)
+        except Exception as err:
+            self._logger.error(f"Error downloading file {item_id}: {err}")
+            raise FileError(f"Error downloading file {item_id}: {err}") from err
+
+    async def download_files(self, items: List[dict], destination_folder: Path):
+        """
+        Download multiple files from OneDrive.
+        """
+        downloaded_files = []
+        for item in items:
+            item_id = item.get("id")
+            file_name = item.get("name")
+            destination = destination_folder / file_name
+            await self.file_download(item_id, destination)
+            downloaded_files.append(str(destination))
+        return downloaded_files
+
+    async def folder_download(self, folder_id: str, destination_folder: Path):
+        """
+        Download a folder and its contents from OneDrive.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            folder_item = drive.items[folder_id]
+            await self._download_folder_recursive(folder_item, destination_folder)
+            return True
+        except Exception as err:
+            self._logger.error(f"Error downloading folder {folder_id}: {err}")
+            raise FileError(f"Error downloading folder {folder_id}: {err}") from err
+
+    async def _download_folder_recursive(self, folder_item: DriveItem, local_path: Path):
+        """
+        Recursively download a folder's contents.
+        """
+        if not local_path.exists():
+            local_path.mkdir(parents=True)
+        items = folder_item.children.get().execute_query()
+        for item in items:
+            item_path = local_path / item.name
+            if item.folder:
+                await self._download_folder_recursive(item, item_path)
+            else:
+                await self.file_download(item.id, item_path)
+
+    async def file_delete(self, item_id: str):
+        """
+        Delete a file or folder in OneDrive by item ID.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            item = drive.items[item_id]
+            item.delete_object().execute_query()
+            return True
+        except Exception as err:
+            self._logger.error(f"Error deleting item {item_id}: {err}")
+            raise FileError(f"Error deleting item {item_id}: {err}") from err
+
+    async def upload_files(self, files: List[Path], destination_folder: str = None):
+        """
+        Upload multiple files to OneDrive.
+        """
+        uploaded_files = []
+        for file_path in files:
+            file_name = file_path.name
+            uploaded_item = await self.upload_file(file_path, destination_folder)
+            uploaded_files.append(uploaded_item)
+        return uploaded_files
+
+    async def upload_file(self, file_path: Path, destination_folder: str = None):
+        """
+        Upload a single file to OneDrive.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            if destination_folder:
+                target_folder = drive.root.get_by_path(destination_folder)
+            else:
+                target_folder = drive.root
+            with open(file_path, "rb") as content_file:
+                file_content = content_file.read()
+                uploaded_item = target_folder.children[file_path.name].upload(file_content).execute_query()
+            return {
+                "name": uploaded_item.name,
+                "id": uploaded_item.id,
+                "webUrl": uploaded_item.web_url
+            }
+        except Exception as err:
+            self._logger.error(f"Error uploading file {file_path}: {err}")
+            raise FileError(f"Error uploading file {file_path}: {err}") from err
+
+    async def upload_folder(self, local_folder: Path, destination_folder: str = None):
+        """
+        Upload a local folder and its contents to OneDrive.
+        """
+        uploaded_items = []
+        for root, dirs, files in os.walk(local_folder):
+            relative_path = Path(root).relative_to(local_folder)
+            one_drive_path = f"{destination_folder}/{relative_path}".strip("/") if destination_folder else str(relative_path)  # noqa
+            # Create folder in OneDrive if it doesn't exist
+            await self._create_onedrive_folder(one_drive_path)
+            for file_name in files:
+                file_path = Path(root) / file_name
+                destination_path = f"{one_drive_path}/{file_name}".strip("/")
+                uploaded_item = await self.upload_file(file_path, destination_path)
+                uploaded_items.append(uploaded_item)
+        return uploaded_items
+
+    async def _create_onedrive_folder(self, folder_path: str):
+        """
+        Create a folder in OneDrive if it doesn't exist.
+        """
+        try:
+            drive = self._graph_client.me.drive
+            # Try to get the folder; if it doesn't exist, create it
+            folder_item = drive.root.get_by_path(folder_path)
+            folder_item.get().execute_query()
+        except Exception:
+            # Folder does not exist; create it
+            parent_path = "/".join(folder_path.split("/")[:-1])
+            folder_name = folder_path.split("/")[-1]
+            if parent_path:
+                parent_folder = drive.root.get_by_path(parent_path)
+            else:
+                parent_folder = drive.root
+            new_folder = parent_folder.children.add_folder(folder_name).execute_query()
+            self._logger.info(f"Created folder: {new_folder.web_url}")

flowtask/interfaces/Outlook.py

@@ -0,0 +1,155 @@
+import asyncio
+from typing import List, Optional
+from office365.graph_client import GraphClient
+from office365.outlook.mail.attachments.attachment import Attachment
+from office365.outlook.mail.folders.folder import MailFolder
+from office365.outlook.user import OutlookUser
+from pathlib import Path
+from ..exceptions import FileError
+from .O365Client import O365Client
+
+
+class OutlookClient(O365Client):
+    """
+    Outlook Client.
+
+    Managing connections to Outlook Mail API.
+    """
+
+    def get_context(self, url: str = None, *args) -> GraphClient:
+        # For Outlook, we primarily use GraphClient
+        if not self._graph_client:
+            self._graph_client = GraphClient(acquire_token=lambda: self.access_token)
+        return self._graph_client
+
+    def _start_(self, **kwargs):
+        return True
+
+    async def list_messages(
+        self,
+        folder: str = "Inbox",
+        top: int = 10,
+        filter_query: str = None,
+        select_fields: List[str] = None,
+    ) -> List[dict]:
+        """
+        List messages in a specified folder.
+        """
+        try:
+            messages = []
+            mail_folder = self._graph_client.me.mail_folders[folder]
+            query = mail_folder.messages.top(top)
+            if filter_query:
+                query = query.filter(filter_query)
+            if select_fields:
+                query = query.select(select_fields)
+            msg_pages = query.get_paged()
+            while True:
+                for message in msg_pages:
+                    messages.append({
+                        "id": message.id,
+                        "subject": message.subject,
+                        "sender": message.sender.email_address.address,
+                        "receivedDateTime": message.received_date_time,
+                    })
+                if not msg_pages.has_next:
+                    break
+                msg_pages = msg_pages.get_next()
+            return messages
+        except Exception as err:
+            self._logger.error(f"Error listing messages: {err}")
+            raise FileError(f"Error listing messages: {err}") from err
+
+    async def download_message(self, message_id: str, destination: Path):
+        """
+        Download a message by its ID.
+        """
+        try:
+            message = self._graph_client.me.messages[message_id].get().execute_query()
+            eml_content = message.mime_content
+            with open(destination, "wb") as file:
+                file.write(eml_content)
+            return str(destination)
+        except Exception as err:
+            self._logger.error(f"Error downloading message {message_id}: {err}")
+            raise FileError(f"Error downloading message {message_id}: {err}") from err
+
+    async def move_message(self, message_id: str, destination_folder_id: str):
+        """
+        Move a message to a different folder.
+        """
+        try:
+            message = self._graph_client.me.messages[message_id]
+            moved_message = message.move(destination_folder_id).execute_query()
+            return {
+                "id": moved_message.id,
+                "subject": moved_message.subject,
+                "folderId": destination_folder_id,
+            }
+        except Exception as err:
+            self._logger.error(f"Error moving message {message_id}: {err}")
+            raise FileError(f"Error moving message {message_id}: {err}") from err
+
+    async def search_messages(self, search_query: str, top: int = 10) -> List[dict]:
+        """
+        Search for messages matching the search query.
+        """
+        try:
+            messages = []
+            query = self._graph_client.me.messages.search(search_query).top(top)
+            msg_pages = query.get_paged()
+            while True:
+                for message in msg_pages:
+                    messages.append({
+                        "id": message.id,
+                        "subject": message.subject,
+                        "sender": message.sender.email_address.address,
+                        "receivedDateTime": message.received_date_time,
+                    })
+                if not msg_pages.has_next:
+                    break
+                msg_pages = msg_pages.get_next()
+            return messages
+        except Exception as err:
+            self._logger.error(f"Error searching messages: {err}")
+            raise FileError(f"Error searching messages: {err}") from err
+
+    async def send_message(
+        self,
+        subject: str,
+        body: str,
+        to_recipients: List[str],
+        cc_recipients: Optional[List[str]] = None,
+        bcc_recipients: Optional[List[str]] = None,
+        attachments: Optional[List[Path]] = None,
+        from_address: Optional[str] = None,
+    ):
+        """
+        Send a message with optional attachments and optional 'on behalf of' another user.
+        """
+        try:
+            message = self._graph_client.me.messages.new()
+            message.subject = subject
+            message.body = {
+                "contentType": "HTML",
+                "content": body
+            }
+            message.to_recipients = [{"emailAddress": {"address": addr}} for addr in to_recipients]
+            if cc_recipients:
+                message.cc_recipients = [{"emailAddress": {"address": addr}} for addr in cc_recipients]
+            if bcc_recipients:
+                message.bcc_recipients = [{"emailAddress": {"address": addr}} for addr in bcc_recipients]
+            if attachments:
+                for attachment_path in attachments:
+                    attachment = message.attachments.add_file_attachment(attachment_path.name)
+                    with open(attachment_path, "rb") as file:
+                        attachment.content_bytes = file.read()
+            if from_address:
+                # Set the 'from' address
+                message.from_ = {"emailAddress": {"address": from_address}}
+            # Send the message
+            message.send().execute_query()
+            return True
+        except Exception as err:
+            self._logger.error(f"Error sending message: {err}")
+            raise FileError(f"Error sending message: {err}") from err