209 lines
No EOL
8.4 KiB
Python
209 lines
No EOL
8.4 KiB
Python
"""
|
|
Sharepoint-Agent für die Interaktion mit Sharepoint-Ressourcen und Dokumenten.
|
|
Angepasst für das refaktorisierte Core-Modul.
|
|
"""
|
|
|
|
import logging
|
|
import traceback
|
|
from typing import List, Dict, Any, Optional, Union
|
|
from datetime import datetime
|
|
import uuid
|
|
|
|
from modules.agentservice_base import BaseAgent
|
|
from modules.agentservice_utils import WorkflowUtils, MessageUtils, LoggingUtils
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class SharepointAgent(BaseAgent):
|
|
"""Agent für den Zugriff auf und die Arbeit mit SharePoint-Ressourcen"""
|
|
|
|
def __init__(self):
|
|
"""Initialisiert den SharePoint-Agenten"""
|
|
super().__init__()
|
|
self.id = "sharepoint"
|
|
self.name = "SharePoint-Agent"
|
|
self.type = "sharepoint"
|
|
self.description = "Zugriff auf und Arbeit mit SharePoint-Ressourcen"
|
|
self.capabilities = "document_search,metadata_extraction,content_integration,sharepoint_interaction"
|
|
self.instructions = """
|
|
Du bist der SharePoint-Agent, ein Spezialist für die Interaktion mit Microsoft SharePoint. Deine Aufgabe ist es:
|
|
|
|
1. SharePoint-Dokumente und -Ressourcen zu durchsuchen und abzurufen
|
|
2. Metadaten aus SharePoint-Dokumenten zu extrahieren und zu analysieren
|
|
3. Strukturierte Informationen aus SharePoint-Bibliotheken zu sammeln
|
|
4. Dokumente basierend auf Metadaten zu filtern und zu organisieren
|
|
5. Inhalte aus verschiedenen SharePoint-Quellen zu integrieren und zusammenzuführen
|
|
6. Informationen aus SharePoint-Listen und -Dokumentbibliotheken zu extrahieren
|
|
7. Zusammenfassungen und Analysen von SharePoint-Inhalten zu erstellen
|
|
|
|
Bei der Darstellung deiner Ergebnisse:
|
|
- Strukturiere die Informationen klar und übersichtlich
|
|
- Gib den Ursprung und die Metadaten der Dokumente an
|
|
- Zeige Beziehungen zwischen verschiedenen Dokumenten und Ressourcen auf
|
|
- Hebe wichtige Erkenntnisse und Muster hervor
|
|
- Biete Kontext und Relevanz für die gefundenen Informationen
|
|
"""
|
|
self.result_format = "DocumentList"
|
|
|
|
# Utility-Klassen initialisieren
|
|
self.message_utils = MessageUtils()
|
|
|
|
def get_agent_info(self) -> Dict[str, Any]:
|
|
"""Get agent information for agent registry"""
|
|
return {
|
|
"id": self.id,
|
|
"type": self.type,
|
|
"name": self.name,
|
|
"description": self.description,
|
|
"capabilities": self.capabilities,
|
|
"result_format": self.result_format
|
|
}
|
|
|
|
def get_prompt(self, message_context: Dict[str, Any]) -> str:
|
|
"""
|
|
Generiert einen angepassten Prompt für den SharePoint-Agenten.
|
|
|
|
Args:
|
|
message_context: Kontext der Nachricht
|
|
|
|
Returns:
|
|
Formatierter Prompt für den SharePoint-Agenten
|
|
"""
|
|
# Basis-Prompt vom BaseAgent holen
|
|
base_prompt = super().get_prompt(message_context)
|
|
|
|
# Zusätzliche Anweisungen für SharePoint-Interaktion
|
|
sharepoint_instructions = """
|
|
SHAREPOINT-INTERAKTIONS-RICHTLINIEN:
|
|
|
|
1. Präzisiere die Suchkriterien für SharePoint-Ressourcen
|
|
2. Identifiziere relevante Bibliotheken, Listen und Standorte
|
|
3. Definiere benötigte Metadaten und Inhalte
|
|
4. Berücksichtige Berechtigungsanforderungen
|
|
5. Priorisiere aktuelle und relevante Dokumente
|
|
6. Stelle eine strukturierte Darstellung der Ergebnisse sicher
|
|
|
|
Für eine gute SharePoint-Integration:
|
|
- Gib detaillierte Pfade und Standorte an
|
|
- Berücksichtige verschiedene Dokumenttypen und Formate
|
|
- Zeige Metadaten und Dokumenteigenschaften
|
|
- Biete Kontext zu den gefundenen Ressourcen
|
|
- Berücksichtige Versionsinformationen
|
|
"""
|
|
|
|
# Task aus dem Kontext extrahieren
|
|
task = message_context.get("task", "")
|
|
task_instructions = f"\nSHAREPOINT-AUFTRAG:\n{task}\n" if task else ""
|
|
|
|
# Vollständigen Prompt zusammenbauen
|
|
complete_prompt = f"{base_prompt}\n\n{sharepoint_instructions}\n{task_instructions}"
|
|
|
|
return complete_prompt.strip()
|
|
|
|
async def process_message(self, message: Dict[str, Any],
|
|
workflow: Dict[str, Any],
|
|
context: Dict[str, Any] = None,
|
|
log_func=None) -> Dict[str, Any]:
|
|
"""
|
|
Verarbeitet eine Nachricht und interagiert mit SharePoint.
|
|
|
|
Args:
|
|
message: Die zu verarbeitende Nachricht
|
|
workflow: Der aktuelle Workflow
|
|
context: Zusätzlicher Kontext
|
|
log_func: Funktion für Workflow-Logging
|
|
|
|
Returns:
|
|
Die generierte Antwort mit SharePoint-Inhalten
|
|
"""
|
|
# Initialize logging
|
|
workflow_id = workflow.get("id", "unknown")
|
|
logging_utils = LoggingUtils(workflow_id, log_func)
|
|
logging_utils.info(f"SharePointAgent startet SharePoint-Interaktion", "agents")
|
|
|
|
# Create response message
|
|
response = self.message_utils.create_message(workflow_id, role="assistant")
|
|
response["agent_type"] = self.type
|
|
response["agent_name"] = self.name
|
|
response["parent_message_id"] = message.get("id")
|
|
|
|
try:
|
|
# Hier würde die tatsächliche Interaktion mit SharePoint stattfinden
|
|
# In der finalen Implementierung würde ein SharePoint-Connector verwendet werden
|
|
|
|
# Als Beispiel generieren wir eine Standardantwort
|
|
logging_utils.info("SharePoint-Suche wird simuliert", "agents")
|
|
|
|
sharepoint_content = f"""Ich habe als {self.name} die SharePoint-Ressourcen durchsucht und folgende Ergebnisse gefunden:
|
|
|
|
## SharePoint-Suchergebnisse
|
|
|
|
Basierend auf deiner Anfrage habe ich folgende relevante Dokumente identifiziert:
|
|
|
|
### Dokumente
|
|
1. **Projektplan_2025.docx** (Letzte Änderung: 15.03.2025)
|
|
- Standort: Projekte/Strategische Planung
|
|
- Autor: Maria Schmidt
|
|
- Schlüsselinhalt: Zeitplan für Q2-Q4 2025, Ressourcenplanung, Meilensteine
|
|
|
|
2. **Marktanalyse_Q1_2025.pptx** (Letzte Änderung: 22.02.2025)
|
|
- Standort: Marketing/Marktforschung
|
|
- Autor: Thomas Müller
|
|
- Schlüsselinhalt: Aktuelle Markttrends, Wettbewerbsanalyse, Chancen und Risiken
|
|
|
|
3. **Budgetplanung_2025.xlsx** (Letzte Änderung: 01.03.2025)
|
|
- Standort: Finanzen/Planung
|
|
- Autor: Sarah Weber
|
|
- Schlüsselinhalt: Detaillierte Budgetaufschlüsselung nach Abteilungen und Quartalen
|
|
|
|
### SharePoint-Listen
|
|
1. **Projektstatusliste**
|
|
- 12 Einträge mit relevanten Projektstatusinformationen
|
|
- Letzte Aktualisierung: 25.03.2025
|
|
|
|
## Zusammenfassung der Inhalte
|
|
|
|
Die gefundenen Dokumente zeigen übereinstimmend, dass:
|
|
- Der Fokus im Jahr 2025 auf der Expansion in neue Märkte liegt
|
|
- Das Budget für Forschung und Entwicklung um 15% erhöht wurde
|
|
- Drei neue Hauptprojekte im zweiten Quartal starten werden
|
|
|
|
## Empfehlungen
|
|
|
|
Basierend auf den gefundenen Informationen empfehle ich:
|
|
1. Die Projektpläne für Q2 mit besonderem Fokus auf die neuen Hauptprojekte zu prüfen
|
|
2. Die Ressourcenzuweisung entsprechend der Budgeterhöhung anzupassen
|
|
3. Die Marktanalyse als Grundlage für die Expansionsstrategie zu verwenden
|
|
|
|
Die Dokumente sind alle aktuell und wurden von den verantwortlichen Fachabteilungen erstellt."""
|
|
|
|
logging_utils.info("SharePoint-Ergebnisse zusammengestellt", "agents")
|
|
|
|
# Set the content in the response
|
|
response["content"] = sharepoint_content
|
|
|
|
# Finalize the message
|
|
self.message_utils.finalize_message(response)
|
|
response["result_format"] = self.result_format
|
|
|
|
return response
|
|
|
|
except Exception as e:
|
|
error_msg = f"Fehler bei der SharePoint-Interaktion: {str(e)}"
|
|
logging_utils.error(error_msg, "error")
|
|
|
|
# Create error response
|
|
response["content"] = f"## Fehler bei der SharePoint-Interaktion\n\n{error_msg}\n\n```\n{traceback.format_exc()}\n```"
|
|
self.message_utils.finalize_message(response)
|
|
|
|
return response
|
|
|
|
# Singleton-Instanz
|
|
_sharepoint_agent = None
|
|
|
|
def get_sharepoint_agent():
|
|
"""Gibt eine Singleton-Instanz des SharePoint-Agenten zurück"""
|
|
global _sharepoint_agent
|
|
if _sharepoint_agent is None:
|
|
_sharepoint_agent = SharepointAgent()
|
|
return _sharepoint_agent |