gateway/modules/methods/methodSharepoint.py

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

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

from modules.interfaces.interfaceSharepoint import SharepointService
from modules.methods.methodBase import MethodBase, MethodResult, action

logger = logging.getLogger(__name__)

class MethodSharepoint(MethodBase):
    """SharePoint method implementation"""
    
    def __init__(self, serviceContainer):
        """Initialize the SharePoint method"""
        super().__init__(serviceContainer)
        self.sharepointService = SharepointService(serviceContainer)

    @action
    async def search(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Search SharePoint content
        
        Args:
            parameters:
                query: Search query
                siteId: Site ID to search in
                contentType: Content type to search for
                maxResults: Maximum number of results
        """
        try:
            query = parameters["query"]
            siteId = parameters.get("siteId")
            contentType = parameters.get("contentType")
            maxResults = parameters.get("maxResults", 10)
            
            # Search content
            results = await self.sharepointService.searchContent(
                query=query,
                siteId=siteId,
                contentType=contentType,
                maxResults=maxResults
            )
            
            return self._createResult(
                success=True,
                data={
                    "query": query,
                    "siteId": siteId,
                    "contentType": contentType,
                    "results": results
                }
            )
            
        except Exception as e:
            logger.error(f"Error searching SharePoint: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def read(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Read SharePoint item
        
        Args:
            parameters:
                itemId: ID of the item to read
                siteId: Site ID containing the item
                listId: List ID containing the item
        """
        try:
            itemId = parameters["itemId"]
            siteId = parameters.get("siteId")
            listId = parameters.get("listId")
            
            # Read item
            item = await self.sharepointService.readItem(
                itemId=itemId,
                siteId=siteId,
                listId=listId
            )
            
            return self._createResult(
                success=True,
                data={
                    "itemId": itemId,
                    "siteId": siteId,
                    "listId": listId,
                    "item": item
                }
            )
            
        except Exception as e:
            logger.error(f"Error reading SharePoint item: {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 SharePoint item
        
        Args:
            parameters:
                siteId: Site ID to write to
                listId: List ID to write to
                item: Item data to write
        """
        try:
            siteId = parameters["siteId"]
            listId = parameters["listId"]
            item = parameters["item"]
            
            # Write item
            itemId = await self.sharepointService.writeItem(
                siteId=siteId,
                listId=listId,
                item=item
            )
            
            return self._createResult(
                success=True,
                data={
                    "siteId": siteId,
                    "listId": listId,
                    "itemId": itemId
                }
            )
            
        except Exception as e:
            logger.error(f"Error writing SharePoint item: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def readList(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Read SharePoint list
        
        Args:
            parameters:
                listId: ID of the list to read
                siteId: Site ID containing the list
                query: Query to filter items
                maxResults: Maximum number of results
        """
        try:
            listId = parameters["listId"]
            siteId = parameters.get("siteId")
            query = parameters.get("query")
            maxResults = parameters.get("maxResults", 100)
            
            # Read list
            items = await self.sharepointService.readList(
                listId=listId,
                siteId=siteId,
                query=query,
                maxResults=maxResults
            )
            
            return self._createResult(
                success=True,
                data={
                    "listId": listId,
                    "siteId": siteId,
                    "items": items
                }
            )
            
        except Exception as e:
            logger.error(f"Error reading SharePoint list: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def writeList(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Write multiple items to SharePoint list
        
        Args:
            parameters:
                siteId: Site ID to write to
                listId: List ID to write to
                items: List of item data to write
        """
        try:
            siteId = parameters["siteId"]
            listId = parameters["listId"]
            items = parameters["items"]
            
            # Write items
            itemIds = await self.sharepointService.writeList(
                siteId=siteId,
                listId=listId,
                items=items
            )
            
            return self._createResult(
                success=True,
                data={
                    "siteId": siteId,
                    "listId": listId,
                    "itemIds": itemIds
                }
            )
            
        except Exception as e:
            logger.error(f"Error writing SharePoint list: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )

    @action
    async def createList(self, parameters: Dict[str, Any], authData: Optional[Dict[str, Any]] = None) -> MethodResult:
        """
        Create SharePoint list
        
        Args:
            parameters:
                siteId: Site ID to create list in
                name: Name of the list
                description: List description
                template: List template
                fields: List field definitions
        """
        try:
            siteId = parameters["siteId"]
            name = parameters["name"]
            description = parameters.get("description")
            template = parameters.get("template", "genericList")
            fields = parameters.get("fields", [])
            
            # Create list
            listId = await self.sharepointService.createList(
                siteId=siteId,
                name=name,
                description=description,
                template=template,
                fields=fields
            )
            
            return self._createResult(
                success=True,
                data={
                    "siteId": siteId,
                    "listId": listId,
                    "name": name
                }
            )
            
        except Exception as e:
            logger.error(f"Error creating SharePoint list: {str(e)}")
            return self._createResult(
                success=False,
                data={"error": str(e)}
            )