gateway/modules/methods/methodOutlook.py

"""
Outlook method module.
Handles Outlook operations using the Outlook service.
"""

import logging
from typing import Dict, Any, List, Optional
from datetime import datetime

from modules.interfaces.interfaceOutlook import OutlookService
from modules.methods.methodBase import MethodBase, MethodResult, action

logger = logging.getLogger(__name__)

class MethodOutlook(MethodBase):
    """Outlook method implementation"""
    
    def __init__(self, serviceContainer):
        """Initialize the Outlook method"""
        super().__init__(serviceContainer)
        self.outlookService = OutlookService(serviceContainer)

    @action
    async def readMails(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Read emails from Outlook
        
        Args:
            parameters:
                folder: Folder to read from (default: inbox)
                query: Search query
                maxResults: Maximum number of results
                includeAttachments: Whether to include attachments
        """
        try:
            folder = parameters.get("folder", "inbox")
            query = parameters.get("query")
            maxResults = parameters.get("maxResults", 10)
            includeAttachments = parameters.get("includeAttachments", False)
            
            # Read emails
            emails = await self.outlookService.readEmails(
                folder=folder,
                query=query,
                maxResults=maxResults,
                includeAttachments=includeAttachments
            )
            
            return self._createResult(
                success=True,
                data={
                    "folder": folder,
                    "query": query,
                    "emails": emails
                }
            )
            
        except Exception as e:
            logger.error(f"Error reading emails: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def sendMail(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Send email using Outlook
        
        Args:
            parameters:
                to: List of recipient email addresses
                subject: Email subject
                body: Email body
                attachments: List of attachment file IDs
        """
        try:
            to = parameters["to"]
            subject = parameters["subject"]
            body = parameters["body"]
            attachments = parameters.get("attachments", [])
            
            # Send email
            messageId = await self.outlookService.sendEmail(
                to=to,
                subject=subject,
                body=body,
                attachments=attachments
            )
            
            return self._createResult(
                success=True,
                data={
                    "messageId": messageId,
                    "to": to,
                    "subject": subject
                }
            )
            
        except Exception as e:
            logger.error(f"Error sending email: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def createFolder(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Create folder in Outlook
        
        Args:
            parameters:
                name: Folder name
                parentFolder: Parent folder ID (optional)
        """
        try:
            name = parameters["name"]
            parentFolder = parameters.get("parentFolder")
            
            # Create folder
            folderId = await self.outlookService.createFolder(
                name=name,
                parentFolder=parentFolder
            )
            
            return self._createResult(
                success=True,
                data={
                    "folderId": folderId,
                    "name": name,
                    "parentFolder": parentFolder
                }
            )
            
        except Exception as e:
            logger.error(f"Error creating folder: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def moveMail(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Move email to different folder
        
        Args:
            parameters:
                messageId: ID of the message to move
                targetFolder: ID of the target folder
        """
        try:
            messageId = parameters["messageId"]
            targetFolder = parameters["targetFolder"]
            
            # Move email
            await self.outlookService.moveEmail(
                messageId=messageId,
                targetFolder=targetFolder
            )
            
            return self._createResult(
                success=True,
                data={
                    "messageId": messageId,
                    "targetFolder": targetFolder
                }
            )
            
        except Exception as e:
            logger.error(f"Error moving email: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )