12b0d3d36e
Fix 1 -- Opening-Prompt: processSessionOpening in serviceCommcoach.py prüft jetzt ob es die erste Session ist (isFirstSession) und gibt der AI einen expliziten Prompt, der das Erfinden von Kontext verbietet.
Fix 2 -- Stabiler Transcript: onresult in CommcoachCoachingView.tsx nutzt jetzt processedResultIndexRef um nur neue Results zu verarbeiten. Finalisierte Teile werden stabil akkumuliert, kein Flackern mehr.
Fix 3 -- Hintergrundgeräusche-Timeout: Neuer silenceTimerRef mit 5s Timeout. Wenn nach onspeechstart kein Text kommt, wird isUserSpeaking automatisch zurückgesetzt.
Fix 4 -- Stop-Button: "Stop" Button erscheint im Session-Header wenn TTS läuft (via isTtsPlaying State, synchronisiert per 200ms Interval mit isTtsPlayingRef).
Fix 5 -- Weitersprechen-Button: lastTtsAudioRef speichert das zuletzt gespielte Audio. stopTts setzt wasInterrupted = true. "Weitersprechen" Button erscheint nach Unterbrechung und spielt das Audio erneut ab.
Fix 6 -- Paralleles TTS: Neue _generateAndEmitTts() Hilfsfunktion. In processMessage und processSessionOpening wird TTS als asyncio.create_task parallel zu _emitChunkedResponse gestartet.
Fix 7 -- JSON-Response: Die AI antwortet jetzt als JSON mit text, speech, documents. Neuer Prompt-Block wird in buildCoachingSystemPrompt angehängt. _parseAiJsonResponse() und _saveGeneratedDocument() im Backend. processMessage und processSessionOpening nutzen die neue Struktur.
Fix 8 -- Loading-States: Neuer actionLoading State in useCommcoach. Alle async Funktionen setzen setActionLoading('key') vor dem Await und null im finally. Buttons zeigen Loading-Text und werden disabled.
Fix 9 -- Umlaute: Alle deutschen Strings in allen CommCoach-Dateien (Backend + Frontend) korrigiert: ae->ä, oe->ö, ue->ü.
288 lines
11 KiB
Python
288 lines
11 KiB
Python
# Copyright (c) 2025 Patrick Motsch
|
|
# All rights reserved.
|
|
"""
|
|
CommCoach Export Service.
|
|
Generates Markdown and PDF exports for dossiers and sessions.
|
|
"""
|
|
|
|
import logging
|
|
import json
|
|
from typing import Dict, Any, List, Optional
|
|
from datetime import datetime
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def buildDossierMarkdown(context: Dict[str, Any], sessions: List[Dict[str, Any]],
|
|
tasks: List[Dict[str, Any]], scores: List[Dict[str, Any]]) -> str:
|
|
"""Build a Markdown export of a full coaching dossier (context)."""
|
|
title = context.get("title", "Coaching Dossier")
|
|
description = context.get("description", "")
|
|
category = context.get("category", "custom")
|
|
createdAt = _formatDate(context.get("createdAt"))
|
|
|
|
lines = [
|
|
f"# {title}",
|
|
"",
|
|
f"**Kategorie:** {category} ",
|
|
f"**Erstellt:** {createdAt} ",
|
|
]
|
|
if description:
|
|
lines.append(f"**Beschreibung:** {description} ")
|
|
|
|
goalsRaw = context.get("goals")
|
|
goals = _parseJson(goalsRaw, [])
|
|
if goals:
|
|
lines += ["", "## Ziele", ""]
|
|
for g in goals:
|
|
text = g.get("text", g) if isinstance(g, dict) else str(g)
|
|
status = g.get("status", "open") if isinstance(g, dict) else "open"
|
|
marker = "[x]" if status in ("done", "completed") else "[ ]"
|
|
lines.append(f"- {marker} {text}")
|
|
|
|
insightsRaw = context.get("insights")
|
|
insights = _parseJson(insightsRaw, [])
|
|
if insights:
|
|
lines += ["", "## Erkenntnisse", ""]
|
|
for ins in insights:
|
|
text = ins.get("text", ins) if isinstance(ins, dict) else str(ins)
|
|
lines.append(f"- {text}")
|
|
|
|
completedSessions = [s for s in sessions if s.get("status") == "completed"]
|
|
completedSessions.sort(key=lambda s: s.get("startedAt") or s.get("createdAt") or "")
|
|
if completedSessions:
|
|
lines += ["", "## Sessions", ""]
|
|
for i, s in enumerate(completedSessions, 1):
|
|
dateStr = _formatDate(s.get("startedAt") or s.get("createdAt"))
|
|
duration = s.get("durationSeconds", 0)
|
|
durationMin = duration // 60 if duration else 0
|
|
score = s.get("competenceScore")
|
|
persona = s.get("personaId") or "Coach"
|
|
lines.append(f"### Session {i} -- {dateStr}")
|
|
lines.append("")
|
|
lines.append(f"**Dauer:** {durationMin} Min. | **Score:** {score or '--'} | **Persona:** {persona} ")
|
|
summary = s.get("summary")
|
|
if summary:
|
|
lines.append(f"\n{summary}")
|
|
lines.append("")
|
|
|
|
if tasks:
|
|
openTasks = [t for t in tasks if t.get("status") in ("open", "inProgress")]
|
|
doneTasks = [t for t in tasks if t.get("status") == "done"]
|
|
lines += ["", "## Aufgaben", ""]
|
|
if openTasks:
|
|
lines.append("**Offen:**")
|
|
for t in openTasks:
|
|
lines.append(f"- [ ] {t.get('title')} ({t.get('priority', 'medium')})")
|
|
lines.append("")
|
|
if doneTasks:
|
|
lines.append("**Erledigt:**")
|
|
for t in doneTasks:
|
|
lines.append(f"- [x] {t.get('title')}")
|
|
lines.append("")
|
|
|
|
if scores:
|
|
lines += ["", "## Kompetenz-Scores", ""]
|
|
dimScores = _groupScoresByDimension(scores)
|
|
for dim, entries in dimScores.items():
|
|
latest = entries[-1]
|
|
lines.append(f"- **{dim}**: {latest.get('score', '--')} ({latest.get('trend', 'stable')})")
|
|
|
|
lines += ["", "---", f"*Exportiert am {_formatDate(None)}*", ""]
|
|
return "\n".join(lines)
|
|
|
|
|
|
def buildSessionMarkdown(session: Dict[str, Any], messages: List[Dict[str, Any]],
|
|
tasks: List[Dict[str, Any]], scores: List[Dict[str, Any]]) -> str:
|
|
"""Build a Markdown export of a single session."""
|
|
dateStr = _formatDate(session.get("startedAt") or session.get("createdAt"))
|
|
duration = session.get("durationSeconds", 0)
|
|
durationMin = duration // 60 if duration else 0
|
|
score = session.get("competenceScore")
|
|
persona = session.get("personaId") or "Coach"
|
|
|
|
lines = [
|
|
f"# Coaching Session -- {dateStr}",
|
|
"",
|
|
f"**Dauer:** {durationMin} Min. | **Score:** {score or '--'} | **Persona:** {persona} ",
|
|
]
|
|
|
|
summary = session.get("summary")
|
|
if summary:
|
|
lines += ["", "## Zusammenfassung", "", summary]
|
|
|
|
if messages:
|
|
lines += ["", "## Gesprächsverlauf", ""]
|
|
for msg in messages:
|
|
role = "Du" if msg.get("role") == "user" else "Coach"
|
|
content = msg.get("content", "")
|
|
lines.append(f"**{role}:** {content}")
|
|
lines.append("")
|
|
|
|
sessionTasks = [t for t in tasks if t.get("sessionId") == session.get("id")]
|
|
if sessionTasks:
|
|
lines += ["## Aufgaben", ""]
|
|
for t in sessionTasks:
|
|
marker = "[x]" if t.get("status") == "done" else "[ ]"
|
|
lines.append(f"- {marker} {t.get('title')}")
|
|
lines.append("")
|
|
|
|
sessionScores = [s for s in scores if s.get("sessionId") == session.get("id")]
|
|
if sessionScores:
|
|
lines += ["## Scores", ""]
|
|
for s in sessionScores:
|
|
lines.append(f"- **{s.get('dimension')}**: {s.get('score')} ({s.get('trend', 'stable')})")
|
|
if s.get("evidence"):
|
|
lines.append(f" _{s.get('evidence')}_")
|
|
lines.append("")
|
|
|
|
lines += ["---", f"*Exportiert am {_formatDate(None)}*", ""]
|
|
return "\n".join(lines)
|
|
|
|
|
|
async def renderDossierPdf(context: Dict[str, Any], sessions: List[Dict[str, Any]],
|
|
tasks: List[Dict[str, Any]], scores: List[Dict[str, Any]],
|
|
aiService=None) -> Optional[bytes]:
|
|
"""Render a dossier as PDF using the existing RendererPdf."""
|
|
try:
|
|
from modules.services.serviceGeneration.renderers.rendererPdf import RendererPdf
|
|
extractedContent = _buildPdfContent(context, sessions, tasks, scores, isDossier=True)
|
|
renderer = RendererPdf()
|
|
docs = await renderer.render(extractedContent=extractedContent, title=context.get("title", "Dossier"), aiService=aiService)
|
|
if docs and len(docs) > 0:
|
|
return docs[0].documentData
|
|
except ImportError:
|
|
logger.warning("RendererPdf not available, falling back to markdown-based PDF")
|
|
except Exception as e:
|
|
logger.warning(f"PDF rendering failed: {e}")
|
|
return None
|
|
|
|
|
|
async def renderSessionPdf(session: Dict[str, Any], messages: List[Dict[str, Any]],
|
|
tasks: List[Dict[str, Any]], scores: List[Dict[str, Any]],
|
|
aiService=None) -> Optional[bytes]:
|
|
"""Render a session as PDF."""
|
|
try:
|
|
from modules.services.serviceGeneration.renderers.rendererPdf import RendererPdf
|
|
title = f"Session {_formatDate(session.get('startedAt'))}"
|
|
extractedContent = _buildPdfContent({"title": title}, [session], tasks, scores, isDossier=False, messages=messages)
|
|
renderer = RendererPdf()
|
|
docs = await renderer.render(extractedContent=extractedContent, title=title, aiService=aiService)
|
|
if docs and len(docs) > 0:
|
|
return docs[0].documentData
|
|
except ImportError:
|
|
logger.warning("RendererPdf not available")
|
|
except Exception as e:
|
|
logger.warning(f"Session PDF rendering failed: {e}")
|
|
return None
|
|
|
|
|
|
def _buildPdfContent(context, sessions, tasks, scores, isDossier=True, messages=None) -> Dict[str, Any]:
|
|
"""Convert dossier/session data into the extractedContent format expected by RendererPdf."""
|
|
title = context.get("title", "Export")
|
|
sections = []
|
|
|
|
sections.append({
|
|
"id": "header",
|
|
"content_type": "heading",
|
|
"elements": [{"text": title, "level": 1}],
|
|
})
|
|
|
|
if isDossier and context.get("description"):
|
|
sections.append({
|
|
"id": "desc",
|
|
"content_type": "paragraph",
|
|
"elements": [{"text": context.get("description")}],
|
|
})
|
|
|
|
completedSessions = [s for s in sessions if s.get("status") == "completed"] if isDossier else sessions
|
|
if completedSessions:
|
|
sessionRows = []
|
|
for s in completedSessions:
|
|
sessionRows.append({
|
|
"cells": [
|
|
_formatDate(s.get("startedAt") or s.get("createdAt")),
|
|
str(s.get("competenceScore") or "--"),
|
|
s.get("summary", "")[:200] if s.get("summary") else "",
|
|
]
|
|
})
|
|
sections.append({
|
|
"id": "sessions",
|
|
"content_type": "heading",
|
|
"elements": [{"text": "Sessions", "level": 2}],
|
|
})
|
|
sections.append({
|
|
"id": "sessions_table",
|
|
"content_type": "table",
|
|
"elements": [{
|
|
"headers": ["Datum", "Score", "Zusammenfassung"],
|
|
"rows": sessionRows,
|
|
}],
|
|
})
|
|
|
|
if messages:
|
|
chatElements = []
|
|
for msg in messages:
|
|
role = "Du" if msg.get("role") == "user" else "Coach"
|
|
chatElements.append({"text": f"{role}: {msg.get('content', '')}"})
|
|
sections.append({
|
|
"id": "chat",
|
|
"content_type": "heading",
|
|
"elements": [{"text": "Gesprächsverlauf", "level": 2}],
|
|
})
|
|
sections.append({
|
|
"id": "chat_content",
|
|
"content_type": "paragraph",
|
|
"elements": chatElements,
|
|
})
|
|
|
|
if tasks:
|
|
taskItems = [{"text": f"{'[x]' if t.get('status') == 'done' else '[ ]'} {t.get('title')}"} for t in tasks]
|
|
sections.append({
|
|
"id": "tasks",
|
|
"content_type": "heading",
|
|
"elements": [{"text": "Aufgaben", "level": 2}],
|
|
})
|
|
sections.append({
|
|
"id": "task_list",
|
|
"content_type": "bullet_list",
|
|
"elements": taskItems,
|
|
})
|
|
|
|
return {
|
|
"metadata": {"title": title},
|
|
"documents": [{"id": "main", "title": title, "sections": sections}],
|
|
}
|
|
|
|
|
|
def _formatDate(isoStr: Optional[str]) -> str:
|
|
if not isoStr:
|
|
return datetime.now().strftime("%d.%m.%Y")
|
|
try:
|
|
dt = datetime.fromisoformat(str(isoStr).replace("Z", "+00:00"))
|
|
return dt.strftime("%d.%m.%Y")
|
|
except Exception:
|
|
return isoStr
|
|
|
|
|
|
def _parseJson(value, fallback):
|
|
if not value:
|
|
return fallback
|
|
if isinstance(value, (list, dict)):
|
|
return value
|
|
try:
|
|
return json.loads(value)
|
|
except (json.JSONDecodeError, TypeError):
|
|
return fallback
|
|
|
|
|
|
def _groupScoresByDimension(scores: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
|
|
groups: Dict[str, List[Dict[str, Any]]] = {}
|
|
for s in scores:
|
|
dim = s.get("dimension", "unknown")
|
|
if dim not in groups:
|
|
groups[dim] = []
|
|
groups[dim].append(s)
|
|
for dim in groups:
|
|
groups[dim].sort(key=lambda x: x.get("createdAt") or "")
|
|
return groups
|