gateway/modules/methods/methodPowerpoint.py

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

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

from modules.interfaces.interfacePowerpoint import PowerpointService
from modules.methods.methodBase import MethodBase, MethodResult, action

logger = logging.getLogger(__name__)

class MethodPowerpoint(MethodBase):
    """PowerPoint method implementation"""
    
    def __init__(self, serviceContainer):
        """Initialize the PowerPoint method"""
        super().__init__(serviceContainer)
        self.powerpointService = PowerpointService(serviceContainer)

    @action
    async def read(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Read PowerPoint presentation
        
        Args:
            parameters:
                fileId: ID of the PowerPoint file
                includeSlides: Whether to include slide content
        """
        try:
            fileId = parameters["fileId"]
            includeSlides = parameters.get("includeSlides", True)
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Read presentation
            presentation = await self.powerpointService.readPresentation(file, includeSlides)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "presentation": presentation
                }
            )
            
        except Exception as e:
            logger.error(f"Error reading PowerPoint: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def write(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Write PowerPoint presentation
        
        Args:
            parameters:
                fileId: ID of the PowerPoint file
                slides: List of slide configurations
        """
        try:
            fileId = parameters["fileId"]
            slides = parameters["slides"]
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Write presentation
            await self.powerpointService.writePresentation(file, slides)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "slideCount": len(slides)
                }
            )
            
        except Exception as e:
            logger.error(f"Error writing PowerPoint: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def convert(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Convert PowerPoint to other format
        
        Args:
            parameters:
                fileId: ID of the PowerPoint file
                format: Target format (pdf, png, etc.)
        """
        try:
            fileId = parameters["fileId"]
            format = parameters["format"]
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Convert presentation
            convertedFile = await self.powerpointService.convertPresentation(file, format)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "format": format,
                    "convertedFileId": convertedFile.id
                }
            )
            
        except Exception as e:
            logger.error(f"Error converting PowerPoint: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def createPresentation(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Create new PowerPoint presentation
        
        Args:
            parameters:
                fileName: Name of the new file
                template: Template ID (optional)
        """
        try:
            fileName = parameters["fileName"]
            template = parameters.get("template")
            
            # Create presentation
            file = await self.powerpointService.createPresentation(fileName, template)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": file.id,
                    "fileName": fileName,
                    "template": template
                }
            )
            
        except Exception as e:
            logger.error(f"Error creating PowerPoint: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def addSlide(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Add slide to presentation
        
        Args:
            parameters:
                fileId: ID of the PowerPoint file
                layout: Slide layout
                content: Slide content
        """
        try:
            fileId = parameters["fileId"]
            layout = parameters.get("layout", "title")
            content = parameters.get("content", {})
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Add slide
            slideId = await self.powerpointService.addSlide(file, layout, content)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "slideId": slideId,
                    "layout": layout
                }
            )
            
        except Exception as e:
            logger.error(f"Error adding slide: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def addContent(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Add content to slide
        
        Args:
            parameters:
                fileId: ID of the PowerPoint file
                slideId: ID of the slide
                content: Content to add
        """
        try:
            fileId = parameters["fileId"]
            slideId = parameters["slideId"]
            content = parameters["content"]
            
            # Get file from service
            file = await self.service.interfaceComponent.getFile(fileId)
            if not file:
                return self._createResult(
                    success=False,
                    data={"error": f"File not found: {fileId}"}
                )
            
            # Add content
            await self.powerpointService.addContent(file, slideId, content)
            
            return self._createResult(
                success=True,
                data={
                    "fileId": fileId,
                    "slideId": slideId
                }
            )
            
        except Exception as e:
            logger.error(f"Error adding content: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )