2357 lines
90 KiB
Python
2357 lines
90 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
aza_doku_vorlagen.py — Doku-Prompt-Fenster (AzA-Stil)
|
||
|
||
Zentrale Prompt-Verwaltung fuer medizinische Dokumente (UI: Doku-Prompt).
|
||
Interne Datei/IDs bleiben aus Kompatibilitaetsgruenden unveraendert.
|
||
|
||
Kernprinzipien:
|
||
- AzA-Grundvorlage ist Systemvorlage und wird nicht direkt ueberschrieben.
|
||
- Benutzer darf den Inhalt im Editor bearbeiten und als neue Vorlage speichern.
|
||
- Immer genau eine aktive Vorlage pro Dokumenttyp.
|
||
- Alle Daten lokal in aza_document_templates.json.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import shutil
|
||
import time
|
||
import tkinter as tk
|
||
from datetime import datetime, timezone
|
||
from tkinter import ttk
|
||
from typing import Any
|
||
|
||
from aza_ui_helpers import (
|
||
aza_askstring,
|
||
aza_askyesno,
|
||
aza_showerror,
|
||
aza_showinfo,
|
||
aza_showwarning,
|
||
make_modal_topmost,
|
||
release_modal_dialog,
|
||
)
|
||
|
||
SCHEMA_VERSION = 2
|
||
MAX_PROMPT_CHARS = 32000
|
||
|
||
# ── AzA-Designkonstanten (identisch mit KI-Guthaben-Fenster) ──────────────────
|
||
_BG = "#E8F4FA"
|
||
_HDR_BG = "#1A4D6D"
|
||
_HDR_FG = "#FFFFFF"
|
||
_SUB_BG = "#D0E8F5"
|
||
_CARD_BG = "#FFFFFF"
|
||
_CARD_BD = "#C8D8E8"
|
||
_ACCENT = "#5B8DB3"
|
||
_TEXT = "#1A3D55"
|
||
_TEXT_SUB = "#607890"
|
||
_BTN_BLUE = "#5B8DB3"
|
||
_BTN_ACT = "#5B8DB3" # Einheitlich AzA-Blau (wie Speichern/Als neue Vorlage)
|
||
_BTN_RESET = "#C04040" # Rot nur fuer destruktive Aktion "Zurücksetzen"
|
||
_BTN_CLOSE = "#5B8DB3" # Einheitlich AzA-Blau
|
||
_FF = "Segoe UI"
|
||
|
||
# ── Dokumenttypen (Reihenfolge exakt laut Spezifikation) ─────────────────────
|
||
DOC_TYPES = [
|
||
("kg", "Krankengeschichte"),
|
||
("verlauf", "Verlauf"),
|
||
("brief", "Brief"),
|
||
("rezept", "Rezept"),
|
||
("op_bericht", "OP-Bericht"),
|
||
("kogu", "KOGU"),
|
||
("arztzeugnis", "Arztzeugnis"),
|
||
("eigenes_dokument", "Eigenes Dokument"),
|
||
]
|
||
|
||
DOC_TYPE_KEYS = [dt for dt, _ in DOC_TYPES]
|
||
|
||
# Status-Label pro Dokumenttyp (für dynamische "Erstelle …"-Statusmeldung).
|
||
DOC_TYPE_STATUS_LABELS = {
|
||
"kg": "Krankengeschichte",
|
||
"verlauf": "Verlauf",
|
||
"brief": "Brief",
|
||
"rezept": "Rezept",
|
||
"op_bericht": "OP-Bericht",
|
||
"kogu": "KOGU",
|
||
"arztzeugnis": "Arztzeugnis",
|
||
"eigenes_dokument": "Eigenes Dokument",
|
||
}
|
||
|
||
|
||
def doc_type_status_label(doc_type: str) -> str:
|
||
"""Reines Mapping doc_type → Anzeigename für Statusmeldungen."""
|
||
return DOC_TYPE_STATUS_LABELS.get(doc_type or "kg", "Krankengeschichte")
|
||
|
||
|
||
def resolve_doc_generation_route(doc_type: str) -> str:
|
||
"""Reines Routing: welcher Generierungspfad gehört zum Dokumenttyp.
|
||
|
||
Rückgabe:
|
||
"kg" → Krankengeschichte-Generator (summarize_text)
|
||
"form" → Formularpfad (Arztzeugnis)
|
||
"generate" → generate_document_to_main_field(doc_type)
|
||
"""
|
||
dt = doc_type or "kg"
|
||
if dt == "kg":
|
||
return "kg"
|
||
if dt == "arztzeugnis":
|
||
return "form"
|
||
if dt in ("verlauf", "brief", "rezept", "op_bericht", "kogu", "eigenes_dokument"):
|
||
return "generate"
|
||
return "kg"
|
||
|
||
DOC_TYPE_CREATE_LABELS = {
|
||
"kg": "KG erstellen",
|
||
"verlauf": "Verlauf erstellen",
|
||
"brief": "Brief erstellen",
|
||
"rezept": "Rezept erstellen",
|
||
"op_bericht": "OP-Bericht erstellen",
|
||
"kogu": "KOGU erstellen",
|
||
"arztzeugnis": "Arztzeugnis erstellen",
|
||
"eigenes_dokument": "Dokument erstellen",
|
||
}
|
||
|
||
DOC_TYPE_COPY_LABELS = {
|
||
"kg": "KG kopieren",
|
||
"verlauf": "Verlauf kopieren",
|
||
"brief": "Brief kopieren",
|
||
"rezept": "Rezept kopieren",
|
||
"op_bericht": "OP-Bericht kopieren",
|
||
"kogu": "KOGU kopieren",
|
||
"arztzeugnis": "Arztzeugnis kopieren",
|
||
"eigenes_dokument": "Dokument kopieren",
|
||
}
|
||
|
||
# Kurzlabels fürs Hauptfenster (verhindern abgeschnittene Buttons bei langen Typen).
|
||
DOC_TYPE_CREATE_LABELS_SHORT = {
|
||
"kg": "KG erstellen",
|
||
"verlauf": "Verl. erst.",
|
||
"brief": "Brief erst.",
|
||
"rezept": "Rezept erst.",
|
||
"op_bericht": "OP erst.",
|
||
"kogu": "KOGU erst.",
|
||
"arztzeugnis": "Zeugnis",
|
||
"eigenes_dokument": "Eig. Dok. erst.",
|
||
}
|
||
|
||
DOC_TYPE_COPY_LABELS_SHORT = {
|
||
"kg": "KG kopieren",
|
||
"verlauf": "Verl. kop.",
|
||
"brief": "Brief kop.",
|
||
"rezept": "Rezept kop.",
|
||
"op_bericht": "OP kop.",
|
||
"kogu": "KOGU kop.",
|
||
"arztzeugnis": "Zeugnis kop.",
|
||
"eigenes_dokument": "Eig. Dok. kop.",
|
||
}
|
||
|
||
|
||
def save_local_publish_payload(payload: dict) -> None:
|
||
"""Bereitet eine Veröffentlichung lokal vor (Queue im Daten-Verzeichnis).
|
||
|
||
So geht beim fehlenden Server-Deploy nichts verloren und es entsteht keine
|
||
falsche Erfolgsmeldung.
|
||
"""
|
||
try:
|
||
import os
|
||
from aza_config import get_writable_data_dir
|
||
path = os.path.join(get_writable_data_dir(), "doku_prompt_publish_queue.json")
|
||
existing = []
|
||
if os.path.isfile(path):
|
||
try:
|
||
with open(path, encoding="utf-8") as fh:
|
||
existing = json.load(fh) or []
|
||
except Exception:
|
||
existing = []
|
||
if not isinstance(existing, list):
|
||
existing = []
|
||
existing.append(payload)
|
||
tmp = path + ".tmp"
|
||
with open(tmp, "w", encoding="utf-8") as fh:
|
||
json.dump(existing, fh, ensure_ascii=False, indent=2)
|
||
os.replace(tmp, path)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _publish_queue_path() -> str:
|
||
from aza_config import get_writable_data_dir
|
||
return os.path.join(get_writable_data_dir(), "doku_prompt_publish_queue.json")
|
||
|
||
|
||
def _read_publish_queue() -> list[dict[str, Any]]:
|
||
try:
|
||
path = _publish_queue_path()
|
||
if not os.path.isfile(path):
|
||
return []
|
||
with open(path, encoding="utf-8") as fh:
|
||
raw = json.load(fh) or []
|
||
return raw if isinstance(raw, list) else []
|
||
except Exception:
|
||
return []
|
||
|
||
|
||
def _write_publish_queue(items: list[dict[str, Any]]) -> None:
|
||
path = _publish_queue_path()
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
tmp = path + ".tmp"
|
||
with open(tmp, "w", encoding="utf-8") as fh:
|
||
json.dump(items, fh, ensure_ascii=False, indent=2)
|
||
os.replace(tmp, path)
|
||
|
||
|
||
def update_local_publish_queue_item(queue_index: int, updates: dict[str, Any]) -> bool:
|
||
"""Aktualisiert einen Eintrag der lokalen Publish-Queue (Metadaten-Bearbeitung)."""
|
||
try:
|
||
items = _read_publish_queue()
|
||
if queue_index < 0 or queue_index >= len(items):
|
||
return False
|
||
if not isinstance(items[queue_index], dict):
|
||
return False
|
||
items[queue_index].update(updates)
|
||
_write_publish_queue(items)
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def remove_local_publish_queue_item(queue_index: int) -> bool:
|
||
"""Entfernt einen Eintrag aus der lokalen Publish-Queue (eigene Veröffentlichung)."""
|
||
try:
|
||
items = _read_publish_queue()
|
||
if queue_index < 0 or queue_index >= len(items):
|
||
return False
|
||
del items[queue_index]
|
||
_write_publish_queue(items)
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def public_item_search_text(item: dict[str, Any]) -> str:
|
||
"""Suchtext für lokale Filterung öffentlicher Vorlagen."""
|
||
if not isinstance(item, dict):
|
||
return ""
|
||
parts = [
|
||
item.get("doc_type") or "",
|
||
doc_type_label(item.get("doc_type") or ""),
|
||
item.get("title") or "",
|
||
item.get("author_display") or item.get("author") or "",
|
||
item.get("location") or item.get("city") or "",
|
||
item.get("specialty") or "",
|
||
item.get("description") or "",
|
||
item.get("content") or "",
|
||
]
|
||
return " ".join(str(p) for p in parts).lower()
|
||
|
||
|
||
def filter_public_items(items: list[dict[str, Any]], query: str) -> list[dict[str, Any]]:
|
||
"""Filtert öffentliche Vorlagen lokal nach Metadaten und Prompttext."""
|
||
q = (query or "").strip().lower()
|
||
if not q:
|
||
return list(items)
|
||
return [it for it in items if isinstance(it, dict) and q in public_item_search_text(it)]
|
||
|
||
|
||
def load_local_prepared_public_items() -> list[dict[str, Any]]:
|
||
"""Lokale Publish-Queue als Platzhalter für öffentliche Vorlagen (kein Server-Deploy)."""
|
||
try:
|
||
raw = _read_publish_queue()
|
||
items: list[dict[str, Any]] = []
|
||
for idx, p in enumerate(raw):
|
||
if not isinstance(p, dict):
|
||
continue
|
||
dt = p.get("document_type_key") or ""
|
||
items.append({
|
||
"doc_type": dt,
|
||
"title": p.get("title") or "Ohne Titel",
|
||
"author_display": p.get("author_display_name") or "",
|
||
"author": p.get("author_display_name") or "",
|
||
"author_initials": p.get("author_initials") or "",
|
||
"author_user_id": p.get("author_user_id") or "",
|
||
"location": p.get("region") or "",
|
||
"city": p.get("region") or "",
|
||
"specialty": p.get("specialty") or "",
|
||
"description": p.get("description") or "",
|
||
"content": p.get("prompt_text") or "",
|
||
"id": p.get("source_template_id") or "",
|
||
"server_id": "",
|
||
"_local_prepared": True,
|
||
"_queue_index": idx,
|
||
})
|
||
return items
|
||
except Exception:
|
||
return []
|
||
|
||
|
||
def resolve_current_user_id(app: Any) -> str:
|
||
uid, _ = _app_user_practice_ids(app)
|
||
return uid
|
||
|
||
|
||
def is_own_public_item(app: Any, item: dict[str, Any]) -> bool:
|
||
"""Eigene Veröffentlichung erkennen (user_id oder Autoren-Fallback bei lokaler Queue)."""
|
||
if not isinstance(item, dict):
|
||
return False
|
||
uid = resolve_current_user_id(app)
|
||
item_uid = str(item.get("author_user_id") or "").strip()
|
||
if uid and item_uid:
|
||
return item_uid == uid
|
||
if item.get("_local_prepared"):
|
||
me = resolve_default_author_display(app).strip().lower()
|
||
theirs = str(item.get("author_display") or item.get("author") or "").strip().lower()
|
||
if me and theirs and me == theirs:
|
||
return True
|
||
return False
|
||
|
||
|
||
def format_rating_average_de(avg: float | None) -> str:
|
||
if avg is None:
|
||
return "—"
|
||
return f"{float(avg):.1f}".replace(".", ",")
|
||
|
||
|
||
def format_rating_count_label(count: int) -> str:
|
||
n = int(count or 0)
|
||
if n == 1:
|
||
return "1 Bewertung"
|
||
return f"{n} Bewertungen"
|
||
|
||
|
||
def render_star_unicode(avg: float | None) -> str:
|
||
if avg is None or float(avg) <= 0:
|
||
return "☆☆☆☆☆"
|
||
steps = max(0, min(10, int(round(float(avg) * 2))))
|
||
full = steps // 2
|
||
half = steps % 2 == 1
|
||
chars = "★" * full
|
||
if half:
|
||
chars += "½"
|
||
chars += "☆" * (5 - full - (1 if half else 0))
|
||
return chars
|
||
|
||
|
||
def format_public_rating_summary(avg: float | None, count: int) -> str:
|
||
n = int(count or 0)
|
||
if n <= 0:
|
||
return "Noch keine Bewertungen · 0 Bewertungen"
|
||
return f"{render_star_unicode(avg)} {format_rating_average_de(avg)} · {format_rating_count_label(n)}"
|
||
|
||
|
||
def format_public_rating_list_text(avg: float | None, count: int) -> str:
|
||
n = int(count or 0)
|
||
if n <= 0:
|
||
return "Noch keine Bewertungen"
|
||
return f"{render_star_unicode(avg)} {format_rating_average_de(avg)} ({format_rating_count_label(n)})"
|
||
|
||
|
||
def _apply_rating_fields_to_item(item: dict[str, Any], payload: dict[str, Any]) -> None:
|
||
if not isinstance(item, dict) or not isinstance(payload, dict):
|
||
return
|
||
for key in ("rating_average", "rating_count", "my_rating", "can_rate"):
|
||
if key in payload:
|
||
item[key] = payload[key]
|
||
|
||
|
||
def build_half_star_rating_bar(
|
||
parent: tk.Misc,
|
||
*,
|
||
bg: str = _SUB_BG,
|
||
on_save,
|
||
) -> dict[str, Any]:
|
||
"""Interaktive Halbstern-Leiste (Klick waehlt, Speichern sendet)."""
|
||
frame = tk.Frame(parent, bg=bg)
|
||
state: dict[str, Any] = {"value": 0.0, "enabled": True, "busy": False}
|
||
value_var = tk.StringVar(value="")
|
||
star_canvas = tk.Canvas(frame, width=118, height=26, bg=bg, highlightthickness=0, cursor="hand2")
|
||
star_canvas.pack(side="left")
|
||
btn_save = tk.Button(
|
||
frame, text="Speichern", font=(_FF, 8), bg=_BTN_BLUE, fg="white",
|
||
activebackground="#4A7A9B", relief="flat", padx=8, pady=2, cursor="hand2",
|
||
)
|
||
btn_save.pack(side="left", padx=(8, 0))
|
||
|
||
def _draw() -> None:
|
||
star_canvas.delete("all")
|
||
val = float(state.get("value") or 0)
|
||
for i in range(5):
|
||
x0 = i * 22 + 2
|
||
mid = x0 + 11
|
||
left_active = val >= (i + 0.5)
|
||
right_active = val >= (i + 1.0)
|
||
star_canvas.create_text(
|
||
mid - 5, 13, text="★" if left_active else "☆",
|
||
font=(_FF, 13), fill="#C8921A" if left_active else "#B0BEC5",
|
||
)
|
||
star_canvas.create_text(
|
||
mid + 5, 13, text="★" if right_active else "☆",
|
||
font=(_FF, 13), fill="#C8921A" if right_active else "#B0BEC5",
|
||
)
|
||
if val > 0:
|
||
value_var.set(f"{format_rating_average_de(val)} Sterne")
|
||
else:
|
||
value_var.set("Bitte Sterne wählen")
|
||
|
||
def _pick(event) -> None:
|
||
if not state.get("enabled") or state.get("busy"):
|
||
return
|
||
try:
|
||
x = max(0, min(109, int(event.x)))
|
||
except Exception:
|
||
return
|
||
step = int(x / 11) + 1
|
||
state["value"] = min(5.0, max(0.5, step * 0.5))
|
||
_draw()
|
||
|
||
def _save() -> None:
|
||
if not state.get("enabled") or state.get("busy"):
|
||
return
|
||
val = float(state.get("value") or 0)
|
||
if val <= 0:
|
||
return
|
||
state["busy"] = True
|
||
try:
|
||
btn_save.config(state="disabled")
|
||
except Exception:
|
||
pass
|
||
try:
|
||
on_save(val)
|
||
finally:
|
||
state["busy"] = False
|
||
try:
|
||
btn_save.config(state="normal" if state.get("enabled") else "disabled")
|
||
except Exception:
|
||
pass
|
||
|
||
star_canvas.bind("<Button-1>", _pick)
|
||
btn_save.config(command=_save)
|
||
|
||
def set_value(v: float | None) -> None:
|
||
state["value"] = float(v or 0)
|
||
_draw()
|
||
|
||
def set_enabled(enabled: bool) -> None:
|
||
state["enabled"] = bool(enabled)
|
||
try:
|
||
star_canvas.config(cursor="hand2" if enabled else "arrow")
|
||
btn_save.config(state="normal" if enabled else "disabled")
|
||
except Exception:
|
||
pass
|
||
|
||
_draw()
|
||
return {"frame": frame, "value_var": value_var, "set_value": set_value, "set_enabled": set_enabled}
|
||
|
||
|
||
def refresh_doku_prompt_window(app: Any, doc_type: str | None = None, tpl_id: str | None = None) -> None:
|
||
"""Aktualisiert das offene Doku-Prompt-Fenster (Dropdown nach Übernahme)."""
|
||
cb = getattr(app, "_doku_vorlage_refresh_cb", None)
|
||
if not callable(cb):
|
||
return
|
||
|
||
def _do_refresh():
|
||
try:
|
||
cb(doc_type, tpl_id)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
app.after(0, _do_refresh)
|
||
except Exception:
|
||
_do_refresh()
|
||
|
||
|
||
def adopt_public_template_to_own(app: Any, item: dict[str, Any], *, activate: bool = True) -> str | None:
|
||
"""Übernimmt öffentliche Vorlage in denselben Speicherpfad wie „Als neue Vorlage“."""
|
||
dt = (item.get("doc_type") or "kg").strip()
|
||
if dt not in DOC_TYPE_KEYS:
|
||
dt = "kg"
|
||
uid, pid = _app_user_practice_ids(app)
|
||
new_id = copy_public_template_as_own(
|
||
dt,
|
||
content=item.get("content") or "",
|
||
title=item.get("title") or "Übernommene Vorlage",
|
||
description=item.get("description") or "",
|
||
source_author=item.get("author_display") or item.get("author") or "",
|
||
source_server_id=item.get("id") or item.get("server_id") or "",
|
||
user_id=uid,
|
||
practice_id=pid,
|
||
activate=activate,
|
||
)
|
||
if new_id:
|
||
refresh_doku_prompt_window(app, doc_type=dt, tpl_id=new_id)
|
||
return new_id
|
||
|
||
VERLAUF_DEFAULT_PROMPT = (
|
||
"Erstelle aus dem Transkript einen präzisen medizinischen Verlaufsbericht. "
|
||
"Beschreibe die Entwicklung seit der letzten Konsultation, den aktuellen subjektiven Zustand, "
|
||
"relevante neue oder persistierende Beschwerden, objektive Befunde, relevante Resultate, "
|
||
"die Wirkung und Verträglichkeit der bisherigen Therapie, erfolgte Therapieanpassungen "
|
||
"sowie das weitere Vorgehen. Schreibe chronologisch, sachlich und knapp. "
|
||
"Wiederhole die vollständige Anamnese nicht unnötig. "
|
||
"Verwende ausschliesslich Angaben aus dem Transkript und dem vorhandenen Kontext. "
|
||
"Erfinde keine Diagnosen, Befunde, Medikamente oder Massnahmen. "
|
||
"Gliedere sinnvoll in Verlauf, Befunde, Beurteilung und weiteres Vorgehen, "
|
||
"sofern genügend Informationen vorhanden sind."
|
||
)
|
||
|
||
EIGENES_DOKUMENT_DEFAULT_PROMPT = (
|
||
"Erstelle aus dem Transkript ein medizinisches Dokument gemäss den untenstehenden "
|
||
"Anweisungen. Verwende ausschliesslich Informationen aus dem Transkript und dem "
|
||
"vorhandenen Kontext. Erfinde keine Diagnosen, Befunde, Medikamente oder Massnahmen. "
|
||
"Schreibe sachlich, professionell und in Schweizer medizinischer Schreibweise."
|
||
)
|
||
|
||
# ── AzA-Grundvorlagen (verständlich formuliert, für Ärzte) ────────────────────
|
||
AZA_DEFAULT_TEMPLATES: dict[str, str] = {
|
||
"kg": (
|
||
"Reihenfolge: 1. Diagnose, 2. Anamnese, 3. Befund, 4. Therapie, 5. Procedere\n\n"
|
||
"Schreibregeln:\n"
|
||
"- Aus der Transkription eine klare medizinische Krankengeschichte erstellen.\n"
|
||
"- Diagnosen nummerieren (1. 2. 3. ...). KEIN Bulletpoint vor der Nummer.\n"
|
||
" Richtig: 1. Diagnose Falsch: • 1. Diagnose\n"
|
||
"- Wenn 'Diagnosen gliedern' aktiv ist: Therapien möglichst direkt unter die\n"
|
||
" passende Diagnose schreiben, wenn eindeutig zuordenbar.\n"
|
||
"- Unklare Therapien separat unter 'Therapie' aufführen.\n"
|
||
"- Verlauf, Kontrollen und Wiedervorstellung unter 'Procedere', nicht unter 'Therapie'.\n"
|
||
"- Medikamente mit Wirkstoff in Klammern, wenn sicher bekannt:\n"
|
||
" Dermovate Creme (Clobetasol), Dafalgan (Paracetamol), Fucidin (Fusidinsäure).\n"
|
||
"- 'Status nach' als Standard verwenden, nicht 'Zustand nach'.\n"
|
||
"- ICD-Codes aus dem Input übernehmen, wenn vorhanden. Keine ICD-Codes erfinden.\n"
|
||
"- Keine Diagnosen, Therapien oder Daten erfinden.\n"
|
||
"- Keine genannten Diagnosen weglassen.\n"
|
||
"- Unterpunkte unter Diagnosen einrücken (Bindestrich).\n"
|
||
"- Schreibstil: medizinisch, professionell, kompakt.\n\n"
|
||
"Hinweis: Die Diagnose-/Therapie-Gliederung (Therapie direkt unter Diagnose,\n"
|
||
"Procedere getrennt) wird zusätzlich durch das Häkchen 'Diagnosen gliedern' gesteuert."
|
||
),
|
||
"brief": (
|
||
"Reihenfolge: 1. Diagnose, 2. Anlass, 3. Befunde, 4. Therapie, 5. Procedere/Empfehlung\n\n"
|
||
"Schreibregeln:\n"
|
||
"- Diagnosen nummerieren (1. 2. 3. ...).\n"
|
||
"- Wenn 'Diagnosen gliedern' aktiv ist: Therapien möglichst direkt\n"
|
||
" unter die passende Diagnose schreiben.\n"
|
||
"- Verlauf, Kontrollen und Wiedervorstellung unter Procedere,\n"
|
||
" nicht unter Therapie.\n"
|
||
"- Medikamente mit Wirkstoff in Klammern angeben, wenn sicher bekannt.\n"
|
||
" Beispiel: Dermovate Creme (Clobetasol), Dafalgan (Paracetamol).\n"
|
||
"- 'Status nach' als Standard verwenden, nicht 'Zustand nach'.\n"
|
||
"- ICD-Codes aus dem Input übernehmen, wenn vorhanden.\n"
|
||
"- Nichts erfinden. Medizinisch, professionell und kompakt schreiben.\n\n"
|
||
"Hinweis: Die Diagnose-/Therapie-Gliederung (Therapie direkt unter\n"
|
||
"Diagnose, Procedere getrennt) wird zusätzlich durch das Häkchen\n"
|
||
"'Diagnosen gliedern' gesteuert."
|
||
),
|
||
"rezept": (
|
||
"Rezeptvorlage – Schreibregeln:\n\n"
|
||
"- Nur Medikamente aufführen, die im Transkript genannt wurden.\n"
|
||
"- Dosierung nur aus dem Transkript übernehmen, nichts erfinden.\n"
|
||
"- Markenname mit Wirkstoff in Klammern angeben, wenn sicher bekannt.\n"
|
||
" Beispiel: Dermovate Creme (Clobetasol) 2x täglich.\n"
|
||
"- Generikum bevorzugen, wenn nur der Wirkstoff genannt wurde.\n"
|
||
"- Keine ICD-Codes erfinden, wenn nicht vorhanden."
|
||
),
|
||
"op_bericht": (
|
||
"OP-Bericht / Eingriffsbericht – Reihenfolge:\n\n"
|
||
"1. Diagnose (mit ICD-Code, falls vorhanden)\n"
|
||
"2. Indikation\n"
|
||
"3. Eingriff / Prozedur\n"
|
||
"4. Befund / Histologie\n"
|
||
"5. Verlauf / Procedere\n\n"
|
||
"Schreibregeln:\n"
|
||
"- 'Status nach' als Standard, nicht 'Zustand nach'.\n"
|
||
"- Keine Befunde oder Histologien erfinden.\n"
|
||
"- ICD-Codes nur übernehmen, wenn im Transkript genannt.\n"
|
||
"- Medizinisch korrekter Fachstil."
|
||
),
|
||
"kogu": (
|
||
"Kostengutsprache – Reihenfolge:\n\n"
|
||
"1. Patient / Versicherung\n"
|
||
"2. Diagnose (ICD-Code falls vorhanden)\n"
|
||
"3. Klinische Begründung / Notwendigkeit\n"
|
||
"4. Beantragte Massnahme / Behandlung\n"
|
||
"5. Kosten / Tarifpositionen (nur wenn im Transkript genannt)\n"
|
||
"6. Datum / Unterschrift\n\n"
|
||
"Schreibregeln:\n"
|
||
"- Kosten und Tarifpositionen nur aufnehmen, wenn genannt.\n"
|
||
"- Medizinische Begründung sachlich und klinisch formulieren.\n"
|
||
"- Keine Diagnosen oder Befunde erfinden."
|
||
),
|
||
"arztzeugnis": (
|
||
"Arztzeugnis – Reihenfolge:\n\n"
|
||
"1. Angaben Patient/in\n"
|
||
"2. Diagnose (ICD-Code falls vorhanden)\n"
|
||
"3. Behandlungszeitraum\n"
|
||
"4. Arbeitsfähigkeit / Arbeitsunfähigkeit\n"
|
||
"5. Besondere Anmerkungen (nur aus Transkript)\n"
|
||
"6. Datum, Arzt/Ärztin\n\n"
|
||
"Schreibregeln:\n"
|
||
"- Zeiträume nur aus Transkript übernehmen, nichts erfinden.\n"
|
||
"- Diagnose medizinisch korrekt, ICD-Code wenn vorhanden.\n"
|
||
"- Sachlicher, formeller Schreibstil."
|
||
),
|
||
"verlauf": VERLAUF_DEFAULT_PROMPT,
|
||
"eigenes_dokument": EIGENES_DOKUMENT_DEFAULT_PROMPT,
|
||
}
|
||
|
||
|
||
# ── Persistenz ────────────────────────────────────────────────────────────────
|
||
def _templates_json_path() -> str:
|
||
try:
|
||
from aza_config import get_writable_data_dir
|
||
return os.path.join(get_writable_data_dir(), "aza_document_templates.json")
|
||
except Exception:
|
||
return os.path.join(os.path.expanduser("~"), "AppData", "Roaming",
|
||
"AZA Desktop", "aza_document_templates.json")
|
||
|
||
|
||
def _utc_now() -> str:
|
||
return datetime.now(timezone.utc).isoformat()
|
||
|
||
|
||
def sanitize_prompt_text(text: str) -> str:
|
||
"""Plaintext only — keine HTML/Script-Injection."""
|
||
if not text:
|
||
return ""
|
||
s = str(text)
|
||
s = re.sub(r"(?is)<script[^>]*>.*?</script>", "", s)
|
||
s = re.sub(r"(?is)<style[^>]*>.*?</style>", "", s)
|
||
s = re.sub(r"<[^>]+>", "", s)
|
||
s = re.sub(r"(?i)javascript\s*:", "", s)
|
||
s = re.sub(r"(?i)data\s*:", "", s)
|
||
s = s.replace("\x00", "")
|
||
if len(s) > MAX_PROMPT_CHARS:
|
||
s = s[:MAX_PROMPT_CHARS]
|
||
return s.strip()
|
||
|
||
|
||
def _new_template_entry(doc_type: str, *, now: str | None = None) -> dict[str, Any]:
|
||
ts = now or _utc_now()
|
||
return {
|
||
"id": "aza_default",
|
||
"name": "AzA-Grundvorlage",
|
||
"is_system": True,
|
||
"content": AZA_DEFAULT_TEMPLATES.get(doc_type, ""),
|
||
"description": "",
|
||
"created_at": ts,
|
||
"updated_at": ts,
|
||
"revision": 1,
|
||
"user_id": "",
|
||
"practice_id": "",
|
||
"server_id": "",
|
||
"published": False,
|
||
"sync_updated_at": "",
|
||
"source_author": "",
|
||
"source_server_id": "",
|
||
}
|
||
|
||
|
||
def _ensure_template_fields(t: dict[str, Any]) -> dict[str, Any]:
|
||
if not isinstance(t, dict):
|
||
return _new_template_entry("kg")
|
||
t.setdefault("description", "")
|
||
t.setdefault("revision", 1)
|
||
t.setdefault("user_id", "")
|
||
t.setdefault("practice_id", "")
|
||
t.setdefault("server_id", "")
|
||
t.setdefault("published", False)
|
||
t.setdefault("sync_updated_at", "")
|
||
t.setdefault("source_author", "")
|
||
t.setdefault("source_server_id", "")
|
||
if "content" in t:
|
||
t["content"] = sanitize_prompt_text(t.get("content") or "")
|
||
return t
|
||
|
||
|
||
def _default_structure() -> dict[str, Any]:
|
||
now = _utc_now()
|
||
return {
|
||
"schema_version": SCHEMA_VERSION,
|
||
"active": {dt: "aza_default" for dt, _ in DOC_TYPES},
|
||
"templates": {
|
||
dt: [_new_template_entry(dt, now=now)]
|
||
for dt, _ in DOC_TYPES
|
||
},
|
||
"sync_meta": {"last_sync_at": "", "conflicts": []},
|
||
}
|
||
|
||
|
||
def _backup_json_before_migration(path: str) -> None:
|
||
if not os.path.isfile(path):
|
||
return
|
||
try:
|
||
stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
shutil.copy2(path, path + f".pre_migrate_{stamp}.bak")
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _migrate_data(d: dict[str, Any]) -> tuple[dict[str, Any], bool]:
|
||
"""Migration schema v1→v2: fehlende Typen ergänzen, Metadaten anreichern."""
|
||
changed = False
|
||
now = _utc_now()
|
||
sv = int(d.get("schema_version") or 1)
|
||
|
||
for dt, _ in DOC_TYPES:
|
||
if dt not in d.get("templates", {}):
|
||
d.setdefault("templates", {})[dt] = [_new_template_entry(dt, now=now)]
|
||
changed = True
|
||
if dt not in d.get("active", {}):
|
||
d.setdefault("active", {})[dt] = "aza_default"
|
||
changed = True
|
||
tpls = d.get("templates", {}).get(dt, [])
|
||
for i, t in enumerate(tpls):
|
||
if isinstance(t, dict):
|
||
before = json.dumps(t, sort_keys=True)
|
||
tpls[i] = _ensure_template_fields(t)
|
||
if json.dumps(tpls[i], sort_keys=True) != before:
|
||
changed = True
|
||
|
||
if "sync_meta" not in d:
|
||
d["sync_meta"] = {"last_sync_at": "", "conflicts": []}
|
||
changed = True
|
||
|
||
if sv < SCHEMA_VERSION:
|
||
d["schema_version"] = SCHEMA_VERSION
|
||
changed = True
|
||
|
||
return d, changed
|
||
|
||
|
||
def _load() -> dict[str, Any]:
|
||
path = _templates_json_path()
|
||
if os.path.isfile(path):
|
||
try:
|
||
with open(path, "r", encoding="utf-8") as f:
|
||
d = json.load(f)
|
||
if isinstance(d, dict) and d.get("schema_version") in (1, 2):
|
||
d, changed = _migrate_data(d)
|
||
if changed:
|
||
try:
|
||
_backup_json_before_migration(path)
|
||
_save(d)
|
||
except Exception:
|
||
pass
|
||
return d
|
||
except Exception:
|
||
pass
|
||
return _default_structure()
|
||
|
||
|
||
def _load_all_templates() -> dict[str, Any]:
|
||
"""Alias fuer externe Module (z. B. aza_text_windows_mixin)."""
|
||
return _load()
|
||
|
||
|
||
def _save(data: dict[str, Any]) -> None:
|
||
path = _templates_json_path()
|
||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||
tmp = path + ".tmp"
|
||
with open(tmp, "w", encoding="utf-8") as f:
|
||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||
os.replace(tmp, path)
|
||
|
||
|
||
def get_active_template_content(doc_type: str) -> str:
|
||
try:
|
||
data = _load()
|
||
aid = data.get("active", {}).get(doc_type, "aza_default")
|
||
for t in data.get("templates", {}).get(doc_type, []):
|
||
if isinstance(t, dict) and t.get("id") == aid:
|
||
return sanitize_prompt_text(t.get("content") or "")
|
||
except Exception:
|
||
pass
|
||
return AZA_DEFAULT_TEMPLATES.get(doc_type, "")
|
||
|
||
|
||
def get_active_template_id(doc_type: str) -> str:
|
||
try:
|
||
data = _load()
|
||
return str(data.get("active", {}).get(doc_type, "aza_default"))
|
||
except Exception:
|
||
return "aza_default"
|
||
|
||
|
||
def doc_type_label(doc_type: str) -> str:
|
||
for dt, label in DOC_TYPES:
|
||
if dt == doc_type:
|
||
return label
|
||
return doc_type
|
||
|
||
|
||
def copy_public_template_as_own(
|
||
doc_type: str,
|
||
*,
|
||
content: str,
|
||
title: str,
|
||
description: str = "",
|
||
source_author: str = "",
|
||
source_server_id: str = "",
|
||
user_id: str = "",
|
||
practice_id: str = "",
|
||
activate: bool = False,
|
||
) -> str | None:
|
||
"""Übernimmt eine öffentliche Vorlage als neue eigene Kopie (neue ID)."""
|
||
if doc_type not in DOC_TYPE_KEYS:
|
||
doc_type = "kg"
|
||
data = _load()
|
||
name = (title or "Übernommene Vorlage").strip()
|
||
new_id = f"user_{int(time.time())}_{doc_type}"
|
||
now = _utc_now()
|
||
new_tpl = {
|
||
"id": new_id,
|
||
"name": name,
|
||
"is_system": False,
|
||
"content": sanitize_prompt_text(content),
|
||
"description": (description or "").strip(),
|
||
"created_at": now,
|
||
"updated_at": now,
|
||
"revision": 1,
|
||
"user_id": (user_id or "").strip(),
|
||
"practice_id": (practice_id or "").strip(),
|
||
"server_id": "",
|
||
"published": False,
|
||
"sync_updated_at": "",
|
||
"source_author": (source_author or "").strip(),
|
||
"source_server_id": (source_server_id or "").strip(),
|
||
}
|
||
data.setdefault("templates", {}).setdefault(doc_type, []).append(new_tpl)
|
||
if activate:
|
||
data.setdefault("active", {})[doc_type] = new_id
|
||
_save(data)
|
||
return new_id
|
||
|
||
|
||
# ── Sync / Veröffentlichung (Client, kein Deploy in diesem Block) ─────────────
|
||
|
||
def _app_user_practice_ids(app: Any) -> tuple[str, str]:
|
||
user_id = ""
|
||
practice_id = ""
|
||
try:
|
||
practice_id = (app.get_practice_id() or "").strip()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
user_id = (getattr(app, "_empfang_self_user_id", lambda: "")() or "").strip()
|
||
except Exception:
|
||
user_id = ""
|
||
return user_id, practice_id
|
||
|
||
|
||
def sync_private_doku_prompts(app: Any) -> bool:
|
||
"""Synchronisiert private Benutzer-Prompts mit dem Server (falls erreichbar)."""
|
||
try:
|
||
from aza_doku_prompt_sync import sync_doku_prompts_with_server
|
||
return sync_doku_prompts_with_server(app)
|
||
except ImportError:
|
||
return False
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def publish_template_to_server(app: Any, doc_type: str, tpl: dict[str, Any],
|
||
title: str, description: str = "") -> tuple[bool, str]:
|
||
"""Veröffentlicht aktuelle Vorlage auf dem Server (nur wenn angemeldet)."""
|
||
try:
|
||
from aza_doku_prompt_sync import publish_doku_prompt
|
||
return publish_doku_prompt(app, doc_type, tpl, title, description)
|
||
except ImportError:
|
||
return False, "Sync-Modul nicht verfügbar."
|
||
except Exception as e:
|
||
return False, str(e)
|
||
|
||
|
||
def fetch_public_prompt_library(app: Any) -> list[dict[str, Any]]:
|
||
try:
|
||
from aza_doku_prompt_sync import fetch_public_doku_prompts
|
||
return fetch_public_doku_prompts(app)
|
||
except ImportError:
|
||
return []
|
||
except Exception:
|
||
return []
|
||
|
||
|
||
def fetch_public_prompt_library_result(app: Any) -> tuple[list[dict[str, Any]], str | None]:
|
||
try:
|
||
from aza_doku_prompt_sync import fetch_public_doku_prompts_result
|
||
return fetch_public_doku_prompts_result(app)
|
||
except ImportError:
|
||
return [], None
|
||
except Exception:
|
||
return [], "__CONN_ERROR__"
|
||
|
||
|
||
# ── Fenster-Hilfen (analog aza_bibliothek_ui) ─────────────────────────────────
|
||
_DOKU_WIN_W, _DOKU_WIN_H = 1080, 820
|
||
_DOKU_WIN_MIN_W, _DOKU_WIN_MIN_H = 980, 700
|
||
_PUBLIC_WIN_W, _PUBLIC_WIN_H = 1180, 860
|
||
_PUBLIC_WIN_MIN_W, _PUBLIC_WIN_MIN_H = 1050, 760
|
||
_PUBLISH_DLG_W, _PUBLISH_DLG_H = 720, 860
|
||
_PUBLISH_DLG_MIN_W, _PUBLISH_DLG_MIN_H = 650, 760
|
||
|
||
_PUBLISH_ROUTE_MSG = (
|
||
"Öffentliche Veröffentlichung ist lokal vorbereitet, "
|
||
"benötigt aber noch den Server-Deploy."
|
||
)
|
||
_PUBLIC_LIB_PLACEHOLDER = (
|
||
"Öffentliche Vorlagen sind lokal vorbereitet. "
|
||
"Die Live-Bibliothek benötigt noch den Server-Deploy."
|
||
)
|
||
|
||
|
||
def _doku_center_top(win: tk.Toplevel, w: int, h: int, *, parent=None) -> None:
|
||
from aza_ui_helpers import center_tool_window
|
||
center_tool_window(win, w, h, parent=parent, y_ratio=0.06)
|
||
|
||
|
||
def _doku_bring_to_front(win: tk.Toplevel) -> None:
|
||
from aza_ui_helpers import bring_tool_window_to_front
|
||
bring_tool_window_to_front(win)
|
||
|
||
|
||
def _apply_tool_window_geometry(
|
||
win: tk.Toplevel, w: int, h: int, min_w: int, min_h: int, *, parent=None,
|
||
) -> None:
|
||
"""AzA-Werkzeugfenster: zentriert, im Vordergrund, Höhe begrenzt (Action-Bar sichtbar)."""
|
||
try:
|
||
win.update_idletasks()
|
||
sh = win.winfo_screenheight()
|
||
h = min(h, max(min_h, sh - 80))
|
||
except Exception:
|
||
pass
|
||
win.minsize(min_w, min_h)
|
||
_doku_center_top(win, w, h, parent=parent)
|
||
_doku_bring_to_front(win)
|
||
|
||
|
||
def _profile_field(app: Any, keys: tuple[str, ...], default: str = "") -> str:
|
||
try:
|
||
prof = getattr(app, "_user_profile", {}) or {}
|
||
for k in keys:
|
||
v = str(prof.get(k) or "").strip()
|
||
if v:
|
||
return v
|
||
except Exception:
|
||
pass
|
||
return default
|
||
|
||
|
||
def _author_initials(name: str) -> str:
|
||
parts = [p for p in (name or "").split() if p]
|
||
if not parts:
|
||
return "?"
|
||
if len(parts) == 1:
|
||
return parts[0][:2].upper()
|
||
return f"{parts[0][0]}{parts[-1][0]}".upper()
|
||
|
||
|
||
def resolve_default_author_display(app: Any) -> str:
|
||
try:
|
||
from aza_doku_prompt_sync import resolve_author_display
|
||
return resolve_author_display(app)
|
||
except Exception:
|
||
return _profile_field(app, ("display_name", "name"))
|
||
|
||
|
||
def resolve_default_location(app: Any) -> str:
|
||
return _profile_field(
|
||
app,
|
||
("city", "location", "ort", "practice_city", "practice_location"),
|
||
"Winterthur",
|
||
)
|
||
|
||
|
||
def resolve_default_specialty(app: Any) -> str:
|
||
return _profile_field(
|
||
app,
|
||
("specialty", "fachrichtung", "specialisation", "fachgebiet"),
|
||
"Dermatologie",
|
||
)
|
||
|
||
|
||
def resolve_default_author_initials(app: Any) -> str:
|
||
author = resolve_default_author_display(app)
|
||
initials = _author_initials(author)
|
||
return initials if initials and initials != "?" else "A.S."
|
||
|
||
|
||
def _wire_text_dictation(
|
||
app: Any,
|
||
parent: tk.Misc,
|
||
text_widget: tk.Text,
|
||
status_var: tk.StringVar,
|
||
btn_rec: tk.Button,
|
||
) -> None:
|
||
"""Mini-Diktat in ein Textfeld — gleiches Muster wie Arztzeugnis-Fenster."""
|
||
recorder: list[Any] = [None]
|
||
is_recording = [False]
|
||
|
||
def _toggle():
|
||
if is_recording[0]:
|
||
is_recording[0] = False
|
||
btn_rec.configure(text="⏺ Diktieren", bg=_BTN_BLUE)
|
||
status_var.set("Transkribiere …")
|
||
rec = recorder[0]
|
||
|
||
def _worker():
|
||
try:
|
||
wav_path = rec.stop_and_save_wav() if rec else None
|
||
if not wav_path:
|
||
app.after(0, lambda: status_var.set("Aufnahme fehlgeschlagen."))
|
||
return
|
||
text = app.transcribe_wav(wav_path)
|
||
if not text:
|
||
app.after(0, lambda: status_var.set("Kein Text erkannt."))
|
||
return
|
||
|
||
def _insert():
|
||
cur = text_widget.get("1.0", "end-1c").strip()
|
||
if cur:
|
||
text_widget.insert("end", "\n" + text)
|
||
else:
|
||
text_widget.insert("1.0", text)
|
||
status_var.set("Diktat eingefügt.")
|
||
|
||
app.after(0, _insert)
|
||
except Exception as exc: # noqa: BLE001
|
||
app.after(0, lambda: status_var.set(f"Fehler: {exc}"))
|
||
|
||
import threading
|
||
threading.Thread(target=_worker, daemon=True).start()
|
||
return
|
||
|
||
mic_ok = True
|
||
try:
|
||
mic_ok = bool(app._ensure_microphone_ready())
|
||
except Exception:
|
||
pass
|
||
if not mic_ok:
|
||
status_var.set("Mikrofon nicht bereit.")
|
||
return
|
||
try:
|
||
from aza_audio import AudioRecorder
|
||
recorder[0] = AudioRecorder()
|
||
recorder[0].start()
|
||
except Exception as exc:
|
||
status_var.set(f"Fehler: {exc}")
|
||
return
|
||
is_recording[0] = True
|
||
btn_rec.configure(text="⏹ Stoppen", bg="#C03030")
|
||
status_var.set("Aufnahme läuft …")
|
||
|
||
btn_rec.configure(command=_toggle)
|
||
|
||
|
||
def open_doku_publish_dialog(
|
||
app: Any,
|
||
parent: tk.Misc,
|
||
*,
|
||
doc_type: str,
|
||
default_title: str,
|
||
on_confirm,
|
||
mode: str = "publish",
|
||
initial_values: dict[str, Any] | None = None,
|
||
confirm_label: str = "Veröffentlichen",
|
||
window_title: str = "Vorlage veröffentlichen",
|
||
) -> None:
|
||
"""AzA-Werkzeugfenster für Veröffentlichungs-Metadaten (kein simpledialog)."""
|
||
iv = initial_values or {}
|
||
start_dt = (iv.get("doc_type") or doc_type or "kg").strip()
|
||
if start_dt not in DOC_TYPE_KEYS:
|
||
start_dt = doc_type if doc_type in DOC_TYPE_KEYS else "kg"
|
||
|
||
dlg = tk.Toplevel(parent)
|
||
dlg.title(window_title)
|
||
dlg.configure(bg=_BG)
|
||
dlg.resizable(True, True)
|
||
_apply_tool_window_geometry(
|
||
dlg, _PUBLISH_DLG_W, _PUBLISH_DLG_H, _PUBLISH_DLG_MIN_W, _PUBLISH_DLG_MIN_H, parent=parent,
|
||
)
|
||
make_modal_topmost(dlg, parent)
|
||
|
||
hdr = tk.Frame(dlg, bg=_HDR_BG)
|
||
hdr.pack(side="top", fill="x")
|
||
tk.Label(hdr, text=window_title, font=(_FF, 12, "bold"),
|
||
bg=_HDR_BG, fg=_HDR_FG, padx=16, pady=10).pack(side="left")
|
||
|
||
btn_row = tk.Frame(dlg, bg="#E8F0F5", pady=10)
|
||
btn_row.pack(side="bottom", fill="x")
|
||
|
||
body = tk.Frame(dlg, bg=_BG, padx=16, pady=10)
|
||
body.pack(side="top", fill="both", expand=True)
|
||
body.columnconfigure(1, weight=1)
|
||
|
||
def _lbl(row, text):
|
||
tk.Label(body, text=text, font=(_FF, 9, "bold"),
|
||
bg=_BG, fg=_TEXT, anchor="w").grid(row=row, column=0, sticky="w", pady=(6, 2))
|
||
|
||
def _ent(row, value=""):
|
||
var = tk.StringVar(value=value)
|
||
ent = tk.Entry(body, textvariable=var, font=(_FF, 9), bg="#FFFFFF", fg=_TEXT,
|
||
relief="flat", highlightbackground=_CARD_BD, highlightthickness=1)
|
||
ent.grid(row=row, column=1, sticky="ew", pady=(6, 2), ipady=4)
|
||
return var
|
||
|
||
doc_labels = [lbl for _, lbl in DOC_TYPES]
|
||
doc_label_var = tk.StringVar(value=doc_type_label(start_dt))
|
||
_lbl(0, "Dokumenttyp:")
|
||
doc_combo = ttk.Combobox(
|
||
body, textvariable=doc_label_var, values=doc_labels,
|
||
state="readonly", font=(_FF, 9),
|
||
)
|
||
doc_combo.grid(row=0, column=1, sticky="ew", pady=(6, 2))
|
||
|
||
def _get_selected_doc_type() -> str:
|
||
lbl = doc_label_var.get()
|
||
for dt_key, dt_lbl in DOC_TYPES:
|
||
if dt_lbl == lbl:
|
||
return dt_key
|
||
return start_dt
|
||
|
||
_lbl(1, "Vorlagenname:")
|
||
title_var = _ent(1, iv.get("title") or default_title)
|
||
_lbl(2, "Verfasser:")
|
||
author_var = _ent(2, iv.get("author") or resolve_default_author_display(app))
|
||
_lbl(3, "Initialen:")
|
||
initials_var = _ent(3, iv.get("initials") or resolve_default_author_initials(app))
|
||
_lbl(4, "Ort:")
|
||
location_var = _ent(4, iv.get("location") or resolve_default_location(app))
|
||
_lbl(5, "Fachrichtung:")
|
||
specialty_var = _ent(5, iv.get("specialty") or resolve_default_specialty(app))
|
||
|
||
tk.Label(body, text="Beschreibung:", font=(_FF, 9, "bold"),
|
||
bg=_BG, fg=_TEXT, anchor="nw").grid(row=6, column=0, sticky="nw", pady=(10, 2))
|
||
desc_frame = tk.Frame(body, bg=_CARD_BG, highlightbackground=_CARD_BD, highlightthickness=1)
|
||
desc_frame.grid(row=6, column=1, sticky="nsew", pady=(10, 2))
|
||
body.rowconfigure(6, weight=1)
|
||
desc_vsb = tk.Scrollbar(desc_frame, orient="vertical")
|
||
desc_vsb.pack(side="right", fill="y")
|
||
desc_height = 7 if mode == "edit" else 9
|
||
desc_txt = tk.Text(desc_frame, font=(_FF, 9), bg="#FFFFFF", fg=_TEXT,
|
||
wrap="word", height=desc_height, yscrollcommand=desc_vsb.set,
|
||
padx=8, pady=8, relief="flat")
|
||
desc_txt.pack(side="left", fill="both", expand=True)
|
||
desc_vsb.config(command=desc_txt.yview)
|
||
desc_init = (iv.get("description") or "").strip()
|
||
if desc_init:
|
||
desc_txt.insert("1.0", desc_init)
|
||
|
||
dict_row = tk.Frame(body, bg=_BG)
|
||
dict_row.grid(row=7, column=1, sticky="w", pady=(4, 0))
|
||
dict_status = tk.StringVar(value="")
|
||
btn_dict = tk.Button(dict_row, text="⏺ Diktieren", font=(_FF, 9, "bold"),
|
||
bg=_BTN_BLUE, fg="#FFFFFF", relief="flat", bd=0,
|
||
padx=12, pady=4, cursor="hand2")
|
||
btn_dict.pack(side="left")
|
||
tk.Label(dict_row, textvariable=dict_status, font=(_FF, 8),
|
||
bg=_BG, fg=_TEXT_SUB).pack(side="left", padx=(8, 0))
|
||
_wire_text_dictation(app, dlg, desc_txt, dict_status, btn_dict)
|
||
|
||
if mode == "publish":
|
||
hint = tk.Label(
|
||
body,
|
||
text="Bitte prüfen: keine Patientendaten oder vertraulichen Praxisdaten.",
|
||
font=(_FF, 8), bg=_BG, fg=_TEXT_SUB, wraplength=480, justify="left",
|
||
)
|
||
hint.grid(row=8, column=0, columnspan=2, sticky="w", pady=(8, 0))
|
||
|
||
def _cancel():
|
||
release_modal_dialog(dlg, parent)
|
||
dlg.destroy()
|
||
|
||
def _confirm():
|
||
title = title_var.get().strip()
|
||
if not title:
|
||
aza_showinfo("Hinweis", "Bitte einen Vorlagennamen eingeben.", parent=dlg)
|
||
return
|
||
meta = {
|
||
"doc_type": _get_selected_doc_type(),
|
||
"title": title,
|
||
"description": desc_txt.get("1.0", "end-1c").strip(),
|
||
"author": author_var.get().strip(),
|
||
"initials": initials_var.get().strip(),
|
||
"location": location_var.get().strip(),
|
||
"specialty": specialty_var.get().strip(),
|
||
}
|
||
release_modal_dialog(dlg, parent)
|
||
dlg.destroy()
|
||
try:
|
||
on_confirm(meta)
|
||
except Exception:
|
||
pass
|
||
|
||
tk.Button(btn_row, text=confirm_label, command=_confirm,
|
||
font=(_FF, 9, "bold"), bg=_BTN_BLUE, fg="#FFFFFF",
|
||
relief="flat", bd=0, padx=14, pady=6, cursor="hand2").pack(side="left", padx=(16, 8))
|
||
tk.Button(btn_row, text="Abbrechen", command=_cancel,
|
||
font=(_FF, 9, "bold"), bg="#8AAFC8", fg="#FFFFFF",
|
||
relief="flat", bd=0, padx=14, pady=6, cursor="hand2").pack(side="left")
|
||
dlg.protocol("WM_DELETE_WINDOW", _cancel)
|
||
|
||
|
||
def open_public_doku_vorlagen_window(app: Any, parent: tk.Misc | None = None) -> None:
|
||
"""Öffentliche Vorlagen — separates Werkzeugfenster (lokal, kein Serverzwang)."""
|
||
existing = getattr(app, "_public_doku_vorlagen_win", None)
|
||
if existing is not None:
|
||
try:
|
||
if existing.winfo_exists():
|
||
existing.lift()
|
||
_doku_bring_to_front(existing)
|
||
return
|
||
except Exception:
|
||
pass
|
||
|
||
owner = parent or app
|
||
win = tk.Toplevel(owner)
|
||
app._public_doku_vorlagen_win = win
|
||
win.title("Öffentliche Vorlagen")
|
||
win.configure(bg=_BG)
|
||
win.resizable(True, True)
|
||
_apply_tool_window_geometry(
|
||
win, _PUBLIC_WIN_W, _PUBLIC_WIN_H, _PUBLIC_WIN_MIN_W, _PUBLIC_WIN_MIN_H, parent=owner,
|
||
)
|
||
|
||
if hasattr(app, "_register_window"):
|
||
try:
|
||
app._register_window(win)
|
||
except Exception:
|
||
pass
|
||
|
||
author = resolve_default_author_display(app)
|
||
initials = _author_initials(author)
|
||
location = resolve_default_location(app)
|
||
specialty = resolve_default_specialty(app)
|
||
|
||
hdr = tk.Frame(win, bg=_HDR_BG)
|
||
hdr.pack(fill="x")
|
||
tk.Label(hdr, text="Öffentliche Vorlagen", font=(_FF, 13, "bold"),
|
||
bg=_HDR_BG, fg=_HDR_FG, padx=18, pady=10).pack(side="left")
|
||
close_x = tk.Label(hdr, text="✕", font=(_FF, 11), bg=_HDR_BG, fg="#A0C4D8",
|
||
cursor="hand2", padx=14)
|
||
close_x.pack(side="right")
|
||
|
||
meta = tk.Frame(win, bg=_SUB_BG)
|
||
meta.pack(side="top", fill="x")
|
||
tk.Label(
|
||
meta,
|
||
text=(
|
||
f"Standard für Veröffentlichungen: Verfasser {author or initials} "
|
||
f"· Ort {location} · Fachrichtung {specialty}"
|
||
),
|
||
font=(_FF, 8), bg=_SUB_BG, fg=_TEXT_SUB, padx=18, pady=5, anchor="w",
|
||
).pack(fill="x")
|
||
|
||
action_bar = tk.Frame(win, bg="#E8F0F5", pady=8)
|
||
action_bar.pack(side="bottom", fill="x")
|
||
|
||
body = tk.Frame(win, bg=_BG)
|
||
body.pack(side="top", fill="both", expand=True, padx=12, pady=10)
|
||
body.rowconfigure(2, weight=3)
|
||
body.rowconfigure(3, weight=2)
|
||
body.columnconfigure(0, weight=1)
|
||
|
||
search_row = tk.Frame(body, bg=_BG)
|
||
search_row.grid(row=0, column=0, sticky="ew", pady=(0, 6))
|
||
search_row.columnconfigure(1, weight=1)
|
||
tk.Label(search_row, text="Suchen:", font=(_FF, 8, "bold"),
|
||
bg=_BG, fg=_TEXT).grid(row=0, column=0, sticky="w", padx=(0, 6))
|
||
search_var = tk.StringVar(value="")
|
||
search_entry = tk.Entry(search_row, textvariable=search_var, font=(_FF, 9),
|
||
bg="#FFFFFF", fg=_TEXT, relief="flat",
|
||
highlightbackground=_CARD_BD, highlightthickness=1)
|
||
search_entry.grid(row=0, column=1, sticky="ew", ipady=3)
|
||
|
||
status_var = tk.StringVar(value="Lade öffentliche Vorlagen …")
|
||
tk.Label(body, textvariable=status_var, font=(_FF, 8),
|
||
bg=_BG, fg=_TEXT_SUB, anchor="w").grid(row=1, column=0, sticky="ew", pady=(0, 6))
|
||
|
||
table_frame = tk.Frame(body, bg=_CARD_BG,
|
||
highlightbackground=_CARD_BD, highlightthickness=1)
|
||
table_frame.grid(row=2, column=0, sticky="nsew")
|
||
table_frame.rowconfigure(0, weight=1)
|
||
table_frame.columnconfigure(0, weight=1)
|
||
|
||
pub_style = ttk.Style(win)
|
||
pub_style.configure("Public.Treeview", font=(_FF, 8), rowheight=26)
|
||
pub_style.configure("Public.Treeview.Heading", font=(_FF, 8, "bold"))
|
||
|
||
cols = ("doc_type", "title", "rating", "author", "location", "specialty", "status")
|
||
tree = ttk.Treeview(
|
||
table_frame, columns=cols, show="headings", selectmode="browse",
|
||
height=12, style="Public.Treeview",
|
||
)
|
||
headings = {
|
||
"doc_type": "Dokumenttyp",
|
||
"title": "Vorlagenname",
|
||
"rating": "Bewertung",
|
||
"author": "Verfasser",
|
||
"location": "Ort",
|
||
"specialty": "Fachrichtung",
|
||
"status": "Status",
|
||
}
|
||
widths = {
|
||
"doc_type": 100, "title": 170, "rating": 150, "author": 120,
|
||
"location": 80, "specialty": 110, "status": 120,
|
||
}
|
||
for col in cols:
|
||
tree.heading(col, text=headings[col])
|
||
tree.column(col, width=widths[col], minwidth=60, stretch=(col == "title"))
|
||
vsb = ttk.Scrollbar(table_frame, orient="vertical", command=tree.yview)
|
||
tree.configure(yscrollcommand=vsb.set)
|
||
tree.grid(row=0, column=0, sticky="nsew", padx=6, pady=6)
|
||
vsb.grid(row=0, column=1, sticky="ns", pady=6)
|
||
|
||
detail_outer = tk.Frame(body, bg=_SUB_BG, highlightbackground=_CARD_BD, highlightthickness=1)
|
||
detail_outer.grid(row=3, column=0, sticky="nsew", pady=(8, 0))
|
||
detail_outer.rowconfigure(0, weight=1)
|
||
detail_outer.columnconfigure(0, weight=1)
|
||
detail_vsb = tk.Scrollbar(detail_outer, orient="vertical")
|
||
detail_vsb.grid(row=0, column=1, sticky="ns")
|
||
detail_canvas = tk.Canvas(detail_outer, bg=_SUB_BG, highlightthickness=0,
|
||
yscrollcommand=detail_vsb.set)
|
||
detail_canvas.grid(row=0, column=0, sticky="nsew")
|
||
detail_vsb.config(command=detail_canvas.yview)
|
||
detail_frame = tk.Frame(detail_canvas, bg=_SUB_BG)
|
||
detail_canvas_window = detail_canvas.create_window((0, 0), window=detail_frame, anchor="nw")
|
||
|
||
def _detail_scroll_update(_evt=None):
|
||
detail_canvas.configure(scrollregion=detail_canvas.bbox("all"))
|
||
try:
|
||
detail_canvas.itemconfig(detail_canvas_window, width=detail_canvas.winfo_width())
|
||
except Exception:
|
||
pass
|
||
|
||
detail_frame.bind("<Configure>", _detail_scroll_update)
|
||
detail_canvas.bind("<Configure>", _detail_scroll_update)
|
||
|
||
detail_vars: dict[str, tk.StringVar] = {}
|
||
detail_rows = [
|
||
("doc_type", "Dokumenttyp"),
|
||
("title", "Vorlagenname"),
|
||
("author", "Verfasser"),
|
||
("location", "Ort"),
|
||
("specialty", "Fachrichtung"),
|
||
]
|
||
for r, (key, label) in enumerate(detail_rows):
|
||
tk.Label(detail_frame, text=f"{label}:", font=(_FF, 8, "bold"),
|
||
bg=_SUB_BG, fg=_TEXT_SUB, anchor="w").grid(
|
||
row=r, column=0, sticky="w", padx=(10, 6), pady=2,
|
||
)
|
||
detail_vars[key] = tk.StringVar(value="—")
|
||
tk.Label(detail_frame, textvariable=detail_vars[key], font=(_FF, 8),
|
||
bg=_SUB_BG, fg=_TEXT, anchor="w").grid(
|
||
row=r, column=1, sticky="w", pady=2, padx=(0, 10),
|
||
)
|
||
desc_row = len(detail_rows)
|
||
tk.Label(detail_frame, text="Beschreibung:", font=(_FF, 8, "bold"),
|
||
bg=_SUB_BG, fg=_TEXT_SUB, anchor="nw").grid(
|
||
row=desc_row, column=0, sticky="nw", padx=(10, 6), pady=(4, 2),
|
||
)
|
||
detail_desc = tk.Text(
|
||
detail_frame, font=(_FF, 8), bg=_SUB_BG, fg=_TEXT,
|
||
wrap="word", height=3, relief="flat", bd=0, padx=0, pady=2,
|
||
)
|
||
detail_desc.grid(row=desc_row, column=1, sticky="ew", pady=(4, 2), padx=(0, 10))
|
||
detail_desc.config(state="disabled")
|
||
prompt_row = desc_row + 1
|
||
tk.Label(detail_frame, text="Prompt:", font=(_FF, 8, "bold"),
|
||
bg=_SUB_BG, fg=_TEXT_SUB, anchor="nw").grid(
|
||
row=prompt_row, column=0, sticky="nw", padx=(10, 6), pady=(4, 8),
|
||
)
|
||
detail_prompt = tk.Text(
|
||
detail_frame, font=(_FF, 8), bg=_SUB_BG, fg=_TEXT,
|
||
wrap="word", height=6, relief="flat", bd=0, padx=0, pady=2,
|
||
)
|
||
detail_prompt.grid(row=prompt_row, column=1, sticky="ew", pady=(4, 8), padx=(0, 10))
|
||
detail_prompt.config(state="disabled")
|
||
detail_frame.columnconfigure(1, weight=1)
|
||
|
||
rating_row = prompt_row + 1
|
||
tk.Label(detail_frame, text="Bewertung:", font=(_FF, 8, "bold"),
|
||
bg=_SUB_BG, fg=_TEXT_SUB, anchor="nw").grid(
|
||
row=rating_row, column=0, sticky="nw", padx=(10, 6), pady=(4, 8),
|
||
)
|
||
rating_block = tk.Frame(detail_frame, bg=_SUB_BG)
|
||
rating_block.grid(row=rating_row, column=1, sticky="ew", pady=(4, 8), padx=(0, 10))
|
||
rating_summary_var = tk.StringVar(value="Noch keine Bewertungen · 0 Bewertungen")
|
||
tk.Label(
|
||
rating_block, textvariable=rating_summary_var, font=(_FF, 8),
|
||
bg=_SUB_BG, fg=_TEXT, anchor="w", justify="left",
|
||
).pack(anchor="w")
|
||
rating_own_hint_var = tk.StringVar(value="")
|
||
tk.Label(
|
||
rating_block, textvariable=rating_own_hint_var, font=(_FF, 8),
|
||
bg=_SUB_BG, fg=_TEXT_SUB, anchor="w", justify="left",
|
||
).pack(anchor="w", pady=(2, 4))
|
||
rating_user_fr = tk.Frame(rating_block, bg=_SUB_BG)
|
||
rating_user_fr.pack(anchor="w", fill="x")
|
||
tk.Label(
|
||
rating_user_fr, text="Ihre Bewertung:", font=(_FF, 8, "bold"),
|
||
bg=_SUB_BG, fg=_TEXT_SUB,
|
||
).pack(side="left", padx=(0, 8))
|
||
rating_inflight = {"busy": False}
|
||
|
||
def _submit_rating(val: float) -> None:
|
||
item = _selected_item()
|
||
if not item or rating_inflight["busy"]:
|
||
return
|
||
pid = str(item.get("server_id") or item.get("id") or "").strip()
|
||
if not pid:
|
||
aza_showwarning("Hinweis", "Diese Vorlage kann noch nicht bewertet werden.", parent=win)
|
||
return
|
||
rating_inflight["busy"] = True
|
||
try:
|
||
from aza_doku_prompt_sync import rate_public_doku_prompt_result
|
||
ok, msg, payload = rate_public_doku_prompt_result(app, pid, val)
|
||
except Exception as exc: # noqa: BLE001
|
||
aza_showerror("Fehler", f"Bewertung fehlgeschlagen:\n{exc}", parent=win)
|
||
rating_inflight["busy"] = False
|
||
return
|
||
rating_inflight["busy"] = False
|
||
if not ok:
|
||
if msg == "__ROUTE_MISSING__":
|
||
aza_showinfo(
|
||
"Noch nicht live",
|
||
"Die Bewertungsfunktion ist auf dem Server noch nicht deployt.",
|
||
parent=win,
|
||
)
|
||
elif msg == "__CONN_ERROR__":
|
||
aza_showwarning(
|
||
"Server nicht erreichbar",
|
||
"Bitte später erneut versuchen.",
|
||
parent=win,
|
||
)
|
||
else:
|
||
aza_showwarning("Fehler", msg or "Bewertung nicht möglich.", parent=win)
|
||
return
|
||
_apply_rating_fields_to_item(item, payload)
|
||
for src in all_source_items:
|
||
if str(src.get("id") or src.get("server_id") or "") == pid:
|
||
_apply_rating_fields_to_item(src, payload)
|
||
_apply_search()
|
||
sel = tree.selection()
|
||
if sel:
|
||
_show_detail(tree_iid_to_item.get(sel[0]))
|
||
aza_showinfo("Gespeichert", "Bewertung wurde gespeichert.", parent=win)
|
||
|
||
rating_bar = build_half_star_rating_bar(
|
||
rating_user_fr, bg=_SUB_BG, on_save=_submit_rating,
|
||
)
|
||
rating_bar["frame"].pack(side="left")
|
||
tk.Label(
|
||
rating_user_fr, textvariable=rating_bar["value_var"], font=(_FF, 8),
|
||
bg=_SUB_BG, fg=_TEXT_SUB,
|
||
).pack(side="left", padx=(8, 0))
|
||
|
||
all_source_items: list[dict[str, Any]] = []
|
||
library_items: list[dict[str, Any]] = []
|
||
tree_iid_to_item: dict[str, dict[str, Any]] = {}
|
||
|
||
def _close():
|
||
try:
|
||
app._public_doku_vorlagen_win = None
|
||
except Exception:
|
||
pass
|
||
try:
|
||
win.destroy()
|
||
except Exception:
|
||
pass
|
||
|
||
def _selected_item() -> dict[str, Any] | None:
|
||
sel = tree.selection()
|
||
if not sel:
|
||
return None
|
||
return tree_iid_to_item.get(sel[0])
|
||
|
||
def _show_detail(item: dict[str, Any] | None) -> None:
|
||
if not item:
|
||
for v in detail_vars.values():
|
||
v.set("—")
|
||
detail_desc.config(state="normal")
|
||
detail_desc.delete("1.0", "end")
|
||
detail_desc.config(state="disabled")
|
||
detail_prompt.config(state="normal")
|
||
detail_prompt.delete("1.0", "end")
|
||
detail_prompt.config(state="disabled")
|
||
rating_summary_var.set("Noch keine Bewertungen · 0 Bewertungen")
|
||
rating_own_hint_var.set("")
|
||
rating_bar["set_value"](0)
|
||
rating_bar["set_enabled"](False)
|
||
_detail_scroll_update()
|
||
return
|
||
dt_lbl = doc_type_label(item.get("doc_type") or "")
|
||
detail_vars["doc_type"].set(dt_lbl)
|
||
detail_vars["title"].set(item.get("title") or "Ohne Titel")
|
||
detail_vars["author"].set(item.get("author_display") or item.get("author") or "—")
|
||
detail_vars["location"].set(item.get("location") or item.get("city") or location)
|
||
detail_vars["specialty"].set(item.get("specialty") or specialty)
|
||
desc = (item.get("description") or "").strip() or "—"
|
||
detail_desc.config(state="normal")
|
||
detail_desc.delete("1.0", "end")
|
||
detail_desc.insert("1.0", desc)
|
||
detail_desc.config(state="disabled")
|
||
prompt = (item.get("content") or "").strip() or "—"
|
||
detail_prompt.config(state="normal")
|
||
detail_prompt.delete("1.0", "end")
|
||
detail_prompt.insert("1.0", prompt)
|
||
detail_prompt.config(state="disabled")
|
||
avg = item.get("rating_average")
|
||
cnt = int(item.get("rating_count") or 0)
|
||
rating_summary_var.set(format_public_rating_summary(avg, cnt))
|
||
own = is_own_public_item(app, item)
|
||
can_rate = bool(item.get("can_rate")) and not own and not item.get("_local_prepared")
|
||
if own:
|
||
rating_own_hint_var.set("Die eigene Vorlage kann nicht bewertet werden.")
|
||
rating_bar["set_enabled"](False)
|
||
rating_bar["set_value"](item.get("my_rating") or 0)
|
||
elif can_rate:
|
||
rating_own_hint_var.set("")
|
||
rating_bar["set_enabled"](True)
|
||
rating_bar["set_value"](item.get("my_rating") or 0)
|
||
else:
|
||
rating_own_hint_var.set("")
|
||
rating_bar["set_enabled"](False)
|
||
rating_bar["set_value"](item.get("my_rating") or 0)
|
||
_detail_scroll_update()
|
||
|
||
def _update_btn_state(_evt=None):
|
||
item = _selected_item()
|
||
has_sel = item is not None
|
||
own = is_own_public_item(app, item) if item else False
|
||
from aza_ui_helpers import set_tool_action_button_enabled
|
||
set_tool_action_button_enabled(btn_adopt, has_sel)
|
||
set_tool_action_button_enabled(btn_edit, own)
|
||
set_tool_action_button_enabled(btn_delete, own)
|
||
|
||
def _render_tree(items: list[dict[str, Any]], *, status_note: str = "") -> None:
|
||
for row in tree.get_children():
|
||
tree.delete(row)
|
||
library_items.clear()
|
||
tree_iid_to_item.clear()
|
||
for item in items:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
dt = item.get("doc_type") or ""
|
||
library_items.append(item)
|
||
own = is_own_public_item(app, item)
|
||
iid = tree.insert(
|
||
"", "end",
|
||
values=(
|
||
doc_type_label(dt),
|
||
item.get("title") or "Ohne Titel",
|
||
format_public_rating_list_text(
|
||
item.get("rating_average"),
|
||
int(item.get("rating_count") or 0),
|
||
),
|
||
item.get("author_display") or item.get("author") or "—",
|
||
item.get("location") or item.get("city") or location,
|
||
item.get("specialty") or specialty,
|
||
"Eigene Veröffentlichung" if own else "",
|
||
),
|
||
)
|
||
tree_iid_to_item[iid] = item
|
||
if status_note:
|
||
status_var.set(status_note)
|
||
_show_detail(None)
|
||
_update_btn_state()
|
||
|
||
def _apply_search(*_evt) -> None:
|
||
filtered = filter_public_items(all_source_items, search_var.get())
|
||
total = len(all_source_items)
|
||
shown = len(filtered)
|
||
if total and shown != total:
|
||
note = f"{shown} von {total} Vorlage(n) (gefiltert)."
|
||
elif total:
|
||
note = f"{shown} öffentliche Vorlage(n)."
|
||
else:
|
||
note = status_var.get()
|
||
_render_tree(filtered, status_note=note)
|
||
|
||
def _set_source_items(items: list[dict[str, Any]]) -> None:
|
||
all_source_items.clear()
|
||
all_source_items.extend(items)
|
||
_apply_search()
|
||
|
||
def _populate(items: list[dict[str, Any]]) -> None:
|
||
merged = list(items) if items else []
|
||
if not merged:
|
||
local = load_local_prepared_public_items()
|
||
if local:
|
||
merged = local
|
||
_set_source_items(local)
|
||
status_var.set(
|
||
f"{len(local)} lokal vorbereitete Vorlage(n) "
|
||
f"(Live-Bibliothek benötigt noch Server-Deploy)."
|
||
)
|
||
else:
|
||
status_var.set(_PUBLIC_LIB_PLACEHOLDER)
|
||
_set_source_items([])
|
||
return
|
||
if any(it.get("_local_prepared") for it in merged):
|
||
status_var.set(f"{len(merged)} Vorlage(n) (teilweise lokal vorbereitet).")
|
||
else:
|
||
status_var.set(f"{len(merged)} öffentliche Vorlage(n) geladen.")
|
||
_set_source_items(merged)
|
||
|
||
def _adopt_selected():
|
||
item = _selected_item()
|
||
if not item:
|
||
aza_showinfo("Hinweis", "Bitte eine Vorlage auswählen.", parent=win)
|
||
return
|
||
content = (item.get("content") or "").strip()
|
||
if not content:
|
||
aza_showwarning(
|
||
"Hinweis",
|
||
"Diese Vorlage enthält keinen Prompttext und kann nicht übernommen werden.",
|
||
parent=win,
|
||
)
|
||
return
|
||
dt = (item.get("doc_type") or "kg").strip()
|
||
if dt not in DOC_TYPE_KEYS:
|
||
aza_showwarning(
|
||
"Hinweis",
|
||
f"Unbekannter Dokumenttyp '{dt}'. Übernahme nicht möglich.",
|
||
parent=win,
|
||
)
|
||
return
|
||
try:
|
||
new_id = adopt_public_template_to_own(app, item, activate=True)
|
||
except Exception as exc: # noqa: BLE001
|
||
aza_showerror(
|
||
"Fehler",
|
||
f"Übernahme fehlgeschlagen:\n{exc}",
|
||
parent=win,
|
||
)
|
||
return
|
||
if new_id:
|
||
dt_lbl = doc_type_label(dt)
|
||
aza_showinfo(
|
||
"Übernommen",
|
||
f"Vorlage wurde als eigene {dt_lbl}-Vorlage übernommen.\n"
|
||
"Sie erscheint im Doku-Prompt-Dropdown.",
|
||
parent=win,
|
||
)
|
||
else:
|
||
aza_showwarning(
|
||
"Fehler",
|
||
"Vorlage konnte nicht als eigene Vorlage gespeichert werden.",
|
||
parent=win,
|
||
)
|
||
|
||
def _delete_selected():
|
||
item = _selected_item()
|
||
if not item or not is_own_public_item(app, item):
|
||
return
|
||
qidx = item.get("_queue_index")
|
||
server_id = str(item.get("server_id") or item.get("id") or "").strip()
|
||
if qidx is None and server_id:
|
||
title = item.get("title") or "Ohne Titel"
|
||
if not aza_askyesno(
|
||
"Veröffentlichung zurückziehen?",
|
||
f"Veröffentlichung '{title}' vom Server entfernen?\n\n"
|
||
"Ihre private Vorlage (falls übernommen) bleibt erhalten.",
|
||
parent=win,
|
||
):
|
||
return
|
||
try:
|
||
from aza_doku_prompt_sync import unpublish_doku_prompt
|
||
ok, msg = unpublish_doku_prompt(app, server_id)
|
||
except Exception as exc: # noqa: BLE001
|
||
aza_showerror("Fehler", f"Entfernen fehlgeschlagen:\n{exc}", parent=win)
|
||
return
|
||
if ok:
|
||
aza_showinfo("Entfernt", "Veröffentlichung wurde zurückgezogen.", parent=win)
|
||
_load_async()
|
||
elif msg == "__ROUTE_MISSING__":
|
||
aza_showinfo(
|
||
"Noch nicht live",
|
||
"Die Server-Funktion zum Zurückziehen ist noch nicht deployt.\n"
|
||
"Lokal vorbereitete Veröffentlichungen können weiterhin entfernt werden.",
|
||
parent=win,
|
||
)
|
||
elif msg == "__CONN_ERROR__":
|
||
aza_showwarning(
|
||
"Server nicht erreichbar",
|
||
"Der Server ist derzeit nicht erreichbar. Bitte später erneut versuchen.",
|
||
parent=win,
|
||
)
|
||
else:
|
||
aza_showwarning("Fehler", msg or "Veröffentlichung konnte nicht entfernt werden.", parent=win)
|
||
return
|
||
if qidx is None:
|
||
aza_showinfo(
|
||
"Hinweis",
|
||
"Nur lokal vorbereitete eigene Veröffentlichungen können hier gelöscht werden.",
|
||
parent=win,
|
||
)
|
||
return
|
||
title = item.get("title") or "Ohne Titel"
|
||
if not aza_askyesno(
|
||
"Löschen?",
|
||
f"Veröffentlichung '{title}' aus der lokalen Queue entfernen?\n\n"
|
||
"Ihre private Vorlage (falls übernommen) bleibt erhalten.",
|
||
parent=win,
|
||
):
|
||
return
|
||
if remove_local_publish_queue_item(int(qidx)):
|
||
refreshed = load_local_prepared_public_items()
|
||
_set_source_items(refreshed)
|
||
status_var.set(f"{len(refreshed)} lokal vorbereitete Vorlage(n).")
|
||
aza_showinfo("Gelöscht", "Veröffentlichung wurde entfernt.", parent=win)
|
||
else:
|
||
aza_showwarning("Fehler", "Veröffentlichung konnte nicht gelöscht werden.", parent=win)
|
||
|
||
def _edit_selected():
|
||
item = _selected_item()
|
||
if not item or not is_own_public_item(app, item):
|
||
return
|
||
qidx = item.get("_queue_index")
|
||
server_id = str(item.get("server_id") or item.get("id") or "").strip()
|
||
|
||
def _on_edit_confirm(meta: dict[str, Any]):
|
||
pub_dt = meta.get("doc_type") or item.get("doc_type") or "kg"
|
||
updates = {
|
||
"document_type_key": pub_dt,
|
||
"document_type_label": doc_type_label(pub_dt),
|
||
"title": meta.get("title") or "",
|
||
"description": meta.get("description") or "",
|
||
"author_display_name": meta.get("author") or "",
|
||
"author_initials": meta.get("initials") or "",
|
||
"specialty": meta.get("specialty") or "",
|
||
"region": meta.get("location") or "",
|
||
}
|
||
if qidx is not None and update_local_publish_queue_item(int(qidx), updates):
|
||
refreshed = load_local_prepared_public_items()
|
||
_set_source_items(refreshed)
|
||
aza_showinfo("Gespeichert", "Metadaten aktualisiert.", parent=win)
|
||
return
|
||
if server_id and qidx is None:
|
||
tpl = {
|
||
"content": item.get("content") or "",
|
||
"server_id": server_id,
|
||
"specialty": meta.get("specialty") or item.get("specialty") or "",
|
||
"city": meta.get("location") or item.get("city") or "",
|
||
}
|
||
ok, msg = publish_template_to_server(
|
||
app, pub_dt, tpl,
|
||
meta.get("title") or item.get("title") or "",
|
||
meta.get("description") or item.get("description") or "",
|
||
)
|
||
if ok:
|
||
aza_showinfo("Gespeichert", "Veröffentlichung auf dem Server aktualisiert.", parent=win)
|
||
_load_async()
|
||
elif msg == "__ROUTE_MISSING__":
|
||
aza_showinfo(
|
||
"Noch nicht live",
|
||
"Die Server-Funktion zum Bearbeiten ist noch nicht deployt.",
|
||
parent=win,
|
||
)
|
||
elif msg == "__CONN_ERROR__":
|
||
aza_showwarning(
|
||
"Server nicht erreichbar",
|
||
"Der Server ist derzeit nicht erreichbar. Bitte später erneut versuchen.",
|
||
parent=win,
|
||
)
|
||
else:
|
||
aza_showwarning("Fehler", msg or "Metadaten konnten nicht gespeichert werden.", parent=win)
|
||
return
|
||
aza_showwarning("Fehler", "Metadaten konnten nicht gespeichert werden.", parent=win)
|
||
|
||
open_doku_publish_dialog(
|
||
app, win,
|
||
doc_type=item.get("doc_type") or "kg",
|
||
default_title=item.get("title") or "Ohne Titel",
|
||
on_confirm=_on_edit_confirm,
|
||
mode="edit",
|
||
initial_values={
|
||
"doc_type": item.get("doc_type") or "kg",
|
||
"title": item.get("title") or "",
|
||
"author": item.get("author_display") or item.get("author") or "",
|
||
"initials": item.get("author_initials") or "",
|
||
"location": item.get("location") or item.get("city") or "",
|
||
"specialty": item.get("specialty") or "",
|
||
"description": item.get("description") or "",
|
||
},
|
||
confirm_label="Speichern",
|
||
window_title="Metadaten bearbeiten",
|
||
)
|
||
|
||
def _on_tree_select(_evt=None):
|
||
_show_detail(_selected_item())
|
||
_update_btn_state()
|
||
|
||
def _on_double_click(_evt=None):
|
||
item = _selected_item()
|
||
if item and is_own_public_item(app, item):
|
||
_edit_selected()
|
||
|
||
tree.bind("<<TreeviewSelect>>", _on_tree_select)
|
||
tree.bind("<Double-Button-1>", _on_double_click)
|
||
search_var.trace_add("write", lambda *_: _apply_search())
|
||
|
||
def _load_async():
|
||
import threading
|
||
|
||
def _worker():
|
||
try:
|
||
items, err = fetch_public_prompt_library_result(app)
|
||
except Exception:
|
||
items, err = [], "__CONN_ERROR__"
|
||
if not items:
|
||
local = load_local_prepared_public_items()
|
||
if local:
|
||
note = (
|
||
f"{len(local)} lokal vorbereitete Vorlage(n) "
|
||
f"(Live-Bibliothek benötigt noch Server-Deploy)."
|
||
)
|
||
if err == "__CONN_ERROR__":
|
||
note = (
|
||
f"{len(local)} lokal vorbereitete Vorlage(n) "
|
||
f"(Server nicht erreichbar — lokaler Fallback)."
|
||
)
|
||
try:
|
||
app.after(0, lambda: _populate_local_fallback(local, note))
|
||
except Exception:
|
||
pass
|
||
return
|
||
if err == "__ROUTE_MISSING__":
|
||
note = _PUBLIC_LIB_PLACEHOLDER
|
||
elif err == "__CONN_ERROR__":
|
||
note = (
|
||
"Server nicht erreichbar. "
|
||
"Lokal vorbereitete Vorlagen werden angezeigt, sobald vorhanden."
|
||
)
|
||
else:
|
||
note = _PUBLIC_LIB_PLACEHOLDER
|
||
try:
|
||
app.after(0, lambda: _populate_empty(note))
|
||
except Exception:
|
||
pass
|
||
return
|
||
try:
|
||
app.after(0, lambda: _populate(items))
|
||
except Exception:
|
||
pass
|
||
|
||
def _populate_local_fallback(local_items, note):
|
||
_populate(local_items)
|
||
status_var.set(note)
|
||
|
||
def _populate_empty(note):
|
||
status_var.set(note)
|
||
_set_source_items([])
|
||
|
||
threading.Thread(target=_worker, daemon=True).start()
|
||
|
||
from aza_ui_helpers import create_tool_action_button, set_tool_action_button_enabled
|
||
|
||
btn_adopt = create_tool_action_button(
|
||
action_bar, "In eigene Vorlage übernehmen", _adopt_selected, kind="primary",
|
||
)
|
||
btn_adopt.pack(side="left", padx=(12, 4))
|
||
set_tool_action_button_enabled(btn_adopt, False)
|
||
btn_edit = create_tool_action_button(
|
||
action_bar, "Bearbeiten", _edit_selected, kind="secondary",
|
||
)
|
||
btn_edit.pack(side="left", padx=4)
|
||
set_tool_action_button_enabled(btn_edit, False)
|
||
btn_delete = create_tool_action_button(
|
||
action_bar, "Löschen", _delete_selected, kind="danger",
|
||
)
|
||
btn_delete.pack(side="left", padx=4)
|
||
set_tool_action_button_enabled(btn_delete, False)
|
||
create_tool_action_button(
|
||
action_bar, "Schliessen", _close, kind="close", width=10,
|
||
).pack(side="right", padx=(4, 12))
|
||
|
||
close_x.bind("<Button-1>", lambda e: _close())
|
||
win.protocol("WM_DELETE_WINDOW", _close)
|
||
_load_async()
|
||
|
||
|
||
# ── Fenster ───────────────────────────────────────────────────────────────────
|
||
def open_doku_vorlage_fenster(app: Any) -> None:
|
||
"""Oeffnet das Doku-Prompt-Fenster. Singleton."""
|
||
existing = getattr(app, "_doku_vorlage_win", None)
|
||
if existing is not None:
|
||
try:
|
||
if existing.winfo_exists():
|
||
existing.lift(); existing.focus_force(); return
|
||
except Exception:
|
||
pass
|
||
|
||
win = tk.Toplevel(app)
|
||
app._doku_vorlage_win = win
|
||
win.title("Doku-Prompt")
|
||
win.configure(bg=_BG)
|
||
win.resizable(True, True)
|
||
win.minsize(_DOKU_WIN_MIN_W, _DOKU_WIN_MIN_H)
|
||
_doku_center_top(win, _DOKU_WIN_W, _DOKU_WIN_H, parent=app)
|
||
|
||
if hasattr(app, "_register_window"):
|
||
try: app._register_window(win)
|
||
except Exception: pass
|
||
|
||
try:
|
||
import threading
|
||
threading.Thread(target=lambda: sync_private_doku_prompts(app), daemon=True).start()
|
||
except Exception:
|
||
pass
|
||
|
||
# ── Header ────────────────────────────────────────────────────────────────
|
||
hdr = tk.Frame(win, bg=_HDR_BG)
|
||
hdr.pack(fill="x")
|
||
tk.Label(hdr, text="📄 Doku-Prompt", font=(_FF, 13, "bold"),
|
||
bg=_HDR_BG, fg=_HDR_FG, padx=18, pady=10).pack(side="left")
|
||
close_x = tk.Label(hdr, text="✕", font=(_FF, 11), bg=_HDR_BG, fg="#A0C4D8",
|
||
cursor="hand2", padx=14)
|
||
close_x.pack(side="right")
|
||
|
||
sub = tk.Frame(win, bg=_SUB_BG)
|
||
sub.pack(fill="x")
|
||
tk.Label(sub,
|
||
text="Prompts für medizinische Dokumente anpassen. "
|
||
"Diagnose-/Therapie-Gliederung wird über das Häkchen 'Diagnosen gliedern' gesteuert.",
|
||
font=(_FF, 8), bg=_SUB_BG, fg=_TEXT_SUB,
|
||
padx=18, pady=5, wraplength=780, justify="left").pack(anchor="w")
|
||
|
||
# ── Hauptbereich ──────────────────────────────────────────────────────────
|
||
body = tk.Frame(win, bg=_BG)
|
||
body.pack(fill="both", expand=True, padx=10, pady=8)
|
||
body.columnconfigure(1, weight=1)
|
||
body.rowconfigure(0, weight=1)
|
||
|
||
# Linke Spalte — Dokumenttypen
|
||
left = tk.Frame(body, bg=_CARD_BG, bd=0,
|
||
highlightbackground=_CARD_BD, highlightthickness=1, width=140)
|
||
left.grid(row=0, column=0, sticky="nsew", padx=(0, 8))
|
||
left.grid_propagate(False)
|
||
|
||
tk.Label(left, text="Dokumenttyp", font=(_FF, 9, "bold"),
|
||
bg="#E0EEF7", fg=_TEXT, pady=6).pack(fill="x")
|
||
|
||
# Rechte Karte — Bearbeitungsfläche
|
||
right = tk.Frame(body, bg=_CARD_BG, bd=0,
|
||
highlightbackground=_CARD_BD, highlightthickness=1)
|
||
right.grid(row=0, column=1, sticky="nsew")
|
||
right.rowconfigure(2, weight=1)
|
||
right.columnconfigure(0, weight=1)
|
||
|
||
# ── State-Variablen ───────────────────────────────────────────────────────
|
||
_data: list[dict] = [_load()]
|
||
_cur_dt: list[str] = ["kg"]
|
||
_cur_tpl: list[dict] = [{}]
|
||
_dirty: list[bool] = [False]
|
||
|
||
combo_var = [None]
|
||
combo_widget = [None]
|
||
txt_content = [None]
|
||
lbl_doctype = [None]
|
||
lbl_active_info = [None]
|
||
lbl_mode = [None]
|
||
btn_save = [None]
|
||
btn_activate = [None]
|
||
|
||
def _tpls(dt): return _data[0].get("templates", {}).get(dt, [])
|
||
def _aid(dt): return _data[0].get("active", {}).get(dt, "aza_default")
|
||
def _by_id(dt, tid):
|
||
for t in _tpls(dt):
|
||
if isinstance(t, dict) and t.get("id") == tid: return t
|
||
return None
|
||
def _dname(t):
|
||
n = (t.get("name") or "Unbenannt").strip()
|
||
return f"★ {n}" if t.get("is_system") else n
|
||
|
||
def _refresh(dt: str, tpl_id: str | None = None):
|
||
templates = _tpls(dt)
|
||
active_id = _aid(dt)
|
||
target_id = tpl_id or active_id
|
||
tpl = _by_id(dt, target_id)
|
||
if tpl is None and templates:
|
||
tpl = templates[0]
|
||
if tpl is None:
|
||
tpl = {"id": "aza_default", "name": "AzA-Grundvorlage",
|
||
"is_system": True, "content": AZA_DEFAULT_TEMPLATES.get(dt, "")}
|
||
_cur_tpl[0] = tpl
|
||
|
||
# Combo
|
||
names = [_dname(t) for t in templates if isinstance(t, dict)]
|
||
if combo_widget[0]:
|
||
combo_widget[0]["values"] = names
|
||
combo_var[0].set(_dname(tpl))
|
||
|
||
# Label Dokumenttyp
|
||
_, dlabel = next((d for d in DOC_TYPES if d[0] == dt), (dt, dt))
|
||
if lbl_doctype[0]:
|
||
lbl_doctype[0].config(text=dlabel)
|
||
|
||
# Textfeld — IMMER beschreibbar, unabhaengig von Systemvorlage
|
||
if txt_content[0]:
|
||
txt_content[0].config(state="normal")
|
||
txt_content[0].delete("1.0", "end")
|
||
txt_content[0].insert("1.0", tpl.get("content") or "")
|
||
txt_content[0].config(state="normal", bg="#FFFFFF", fg=_TEXT)
|
||
|
||
# Aktive-Info
|
||
at = _by_id(dt, active_id)
|
||
aname = _dname(at) if at else active_id
|
||
if lbl_active_info[0]:
|
||
lbl_active_info[0].config(text=f"Aktive Vorlage: {aname}")
|
||
|
||
is_system = bool(tpl.get("is_system"))
|
||
is_active = (tpl.get("id") == active_id)
|
||
|
||
# Modus-Hinweis
|
||
if lbl_mode[0]:
|
||
if is_system:
|
||
lbl_mode[0].config(
|
||
text="Systemvorlage – 'Speichern' nicht direkt möglich → 'Als neue Vorlage speichern'",
|
||
fg="#B06000")
|
||
else:
|
||
lbl_mode[0].config(
|
||
text="Benutzervorlage – direkt bearbeitbar und speicherbar.",
|
||
fg="#2A7A4A")
|
||
|
||
# Buttons
|
||
if btn_activate[0]:
|
||
btn_activate[0].config(
|
||
text="Aktiv" if is_active else "Als aktiv setzen",
|
||
bg="#8AAFC8" if is_active else _BTN_ACT,
|
||
state="disabled" if is_active else "normal",
|
||
)
|
||
if btn_save[0]:
|
||
# Speichern bei Systemvorlage deaktivieren — klare Führung
|
||
btn_save[0].config(
|
||
state="disabled" if is_system else "normal",
|
||
bg="#8AAFC8" if is_system else _BTN_BLUE,
|
||
)
|
||
_dirty[0] = False
|
||
|
||
def _on_combo(evt=None):
|
||
dt = _cur_dt[0]
|
||
sel = combo_var[0].get() if combo_var[0] else ""
|
||
for t in _tpls(dt):
|
||
if isinstance(t, dict) and _dname(t) == sel:
|
||
_refresh(dt, t.get("id")); return
|
||
|
||
def _do_save():
|
||
tpl = _cur_tpl[0]
|
||
if tpl.get("is_system"):
|
||
aza_showinfo(
|
||
"Systemvorlage",
|
||
"Die AzA-Grundvorlage kann nicht direkt überschrieben werden.\n\n"
|
||
"Bitte verwenden Sie 'Als neue Vorlage speichern', um eine\n"
|
||
"eigene Variante zu erstellen.",
|
||
parent=win)
|
||
return
|
||
content = sanitize_prompt_text(txt_content[0].get("1.0", "end") if txt_content[0] else "")
|
||
tpl["content"] = content
|
||
tpl["updated_at"] = _utc_now()
|
||
tpl["revision"] = int(tpl.get("revision") or 0) + 1
|
||
try:
|
||
_save(_data[0])
|
||
except Exception as e:
|
||
aza_showerror("Fehler", str(e), parent=win); return
|
||
_dirty[0] = False
|
||
aza_showinfo("Gespeichert", "Vorlage gespeichert.", parent=win)
|
||
|
||
def _do_save_new():
|
||
dt = _cur_dt[0]
|
||
name = aza_askstring("Neue Vorlage", "Name der neuen Vorlage:", parent=win)
|
||
if not name or not name.strip(): return
|
||
content = sanitize_prompt_text(txt_content[0].get("1.0", "end") if txt_content[0] else "")
|
||
new_id = f"user_{int(time.time())}_{dt}"
|
||
uid, pid = _app_user_practice_ids(app)
|
||
new_tpl = {
|
||
"id": new_id, "name": name.strip(), "is_system": False,
|
||
"content": content, "description": "",
|
||
"created_at": _utc_now(), "updated_at": _utc_now(),
|
||
"revision": 1, "user_id": uid, "practice_id": pid,
|
||
"server_id": "", "published": False, "sync_updated_at": "",
|
||
"source_author": "", "source_server_id": "",
|
||
}
|
||
_data[0].setdefault("templates", {}).setdefault(dt, []).append(new_tpl)
|
||
activate = aza_askyesno("Aktivieren?",
|
||
f"Neue Vorlage '{name.strip()}' gespeichert.\nJetzt aktivieren?", parent=win)
|
||
if activate:
|
||
_data[0].setdefault("active", {})[dt] = new_id
|
||
try:
|
||
_save(_data[0])
|
||
except Exception as e:
|
||
aza_showerror("Fehler", str(e), parent=win); return
|
||
_refresh(dt, new_id if activate else _aid(dt))
|
||
|
||
def _do_activate():
|
||
dt = _cur_dt[0]; tpl = _cur_tpl[0]; tid = tpl.get("id", "")
|
||
if not tid: return
|
||
_data[0].setdefault("active", {})[dt] = tid
|
||
try: _save(_data[0])
|
||
except Exception as e:
|
||
aza_showerror("Fehler", str(e), parent=win); return
|
||
_refresh(dt, tid)
|
||
|
||
def _do_reset():
|
||
dt = _cur_dt[0]
|
||
_, dlabel = next((d for d in DOC_TYPES if d[0] == dt), (dt, dt))
|
||
if not aza_askyesno(
|
||
"Zurücksetzen?",
|
||
f"'{dlabel}' auf AzA-Grundvorlage zurücksetzen?\n\n"
|
||
"Die aktive Vorlage wird auf AzA-Grundvorlage gesetzt.\n"
|
||
"Ihre eigenen Varianten werden NICHT gelöscht.", parent=win):
|
||
return
|
||
templates = _tpls(dt)
|
||
has_default = any(isinstance(t, dict) and t.get("id") == "aza_default"
|
||
for t in templates)
|
||
if not has_default:
|
||
now = _utc_now()
|
||
_data[0].setdefault("templates", {}).setdefault(dt, []).insert(0, {
|
||
"id": "aza_default", "name": "AzA-Grundvorlage", "is_system": True,
|
||
"content": AZA_DEFAULT_TEMPLATES.get(dt, ""),
|
||
"created_at": now, "updated_at": now})
|
||
_data[0].setdefault("active", {})[dt] = "aza_default"
|
||
try: _save(_data[0])
|
||
except Exception as e:
|
||
aza_showerror("Fehler", str(e), parent=win); return
|
||
_refresh(dt, "aza_default")
|
||
|
||
def _do_delete():
|
||
dt = _cur_dt[0]
|
||
tpl = _cur_tpl[0]
|
||
if tpl.get("is_system"):
|
||
aza_showinfo("Systemvorlage", "AzA-Grundvorlage kann nicht gelöscht werden.", parent=win)
|
||
return
|
||
tid = tpl.get("id", "")
|
||
if not tid:
|
||
return
|
||
name = (tpl.get("name") or "Unbenannt").strip()
|
||
if not aza_askyesno("Löschen?", f"Vorlage '{name}' wirklich löschen?", parent=win):
|
||
return
|
||
templates = _tpls(dt)
|
||
_data[0]["templates"][dt] = [t for t in templates if not (isinstance(t, dict) and t.get("id") == tid)]
|
||
if _aid(dt) == tid:
|
||
_data[0].setdefault("active", {})[dt] = "aza_default"
|
||
try:
|
||
_save(_data[0])
|
||
except Exception as e:
|
||
aza_showerror("Fehler", str(e), parent=win)
|
||
return
|
||
_refresh(dt, _aid(dt))
|
||
|
||
def _do_publish():
|
||
dt = _cur_dt[0]
|
||
tpl = dict(_cur_tpl[0])
|
||
content = sanitize_prompt_text(txt_content[0].get("1.0", "end") if txt_content[0] else "")
|
||
if not content:
|
||
aza_showinfo("Hinweis", "Bitte zuerst einen Prompt-Inhalt eingeben.", parent=win)
|
||
return
|
||
tpl["content"] = content
|
||
default_title = (tpl.get("name") or doc_type_label(dt)).strip()
|
||
|
||
def _publish_done(ok: bool, msg: str):
|
||
try:
|
||
app.set_status("Bereit.")
|
||
except Exception:
|
||
pass
|
||
if ok:
|
||
tpl["published"] = True
|
||
tpl["updated_at"] = _utc_now()
|
||
_save(_data[0])
|
||
aza_showinfo(
|
||
"Veröffentlicht",
|
||
"Prompt wurde für andere angemeldete Ärzte veröffentlicht.",
|
||
parent=win,
|
||
)
|
||
return
|
||
if msg == "__ROUTE_MISSING__" or (msg or "").strip().lower() in ("not found", "notfound"):
|
||
aza_showinfo("Veröffentlichung vorbereitet", _PUBLISH_ROUTE_MSG, parent=win)
|
||
return
|
||
if msg == "__CONN_ERROR__":
|
||
aza_showwarning(
|
||
"Server nicht erreichbar",
|
||
"Der Server ist derzeit nicht erreichbar.\n\n"
|
||
"Die Veröffentlichung wurde lokal vorbereitet und geht nicht verloren. "
|
||
"Bitte später erneut versuchen.",
|
||
parent=win,
|
||
)
|
||
return
|
||
aza_showwarning(
|
||
"Veröffentlichung",
|
||
(msg or "Veröffentlichung nicht möglich.") +
|
||
"\n\n(Die Vorlage wurde lokal vorbereitet.)",
|
||
parent=win,
|
||
)
|
||
|
||
def _on_publish_confirm(meta: dict[str, Any]):
|
||
title = meta.get("title") or ""
|
||
desc = meta.get("description") or ""
|
||
author_display = meta.get("author") or ""
|
||
pub_dt = meta.get("doc_type") or dt
|
||
uid, _ = _app_user_practice_ids(app)
|
||
try:
|
||
save_local_publish_payload({
|
||
"document_type_key": pub_dt,
|
||
"document_type_label": doc_type_label(pub_dt),
|
||
"title": title,
|
||
"description": desc,
|
||
"prompt_text": content,
|
||
"author_display_name": author_display,
|
||
"author_initials": meta.get("initials") or "",
|
||
"author_user_id": uid,
|
||
"specialty": meta.get("specialty") or "",
|
||
"language": "de",
|
||
"region": meta.get("location") or "",
|
||
"status": "prepared",
|
||
"created_at": _utc_now(),
|
||
"revision": int(tpl.get("revision") or 1),
|
||
"source_template_id": tpl.get("id") or "",
|
||
})
|
||
except Exception:
|
||
pass
|
||
|
||
app.set_status("Veröffentliche Prompt …")
|
||
|
||
def _worker():
|
||
try:
|
||
ok, msg = publish_template_to_server(app, pub_dt, tpl, title, desc)
|
||
except Exception as e: # noqa: BLE001
|
||
ok, msg = False, str(e)
|
||
app.after(0, lambda: _publish_done(ok, msg))
|
||
|
||
import threading
|
||
threading.Thread(target=_worker, daemon=True).start()
|
||
|
||
open_doku_publish_dialog(
|
||
app, win, doc_type=dt, default_title=default_title, on_confirm=_on_publish_confirm,
|
||
)
|
||
|
||
def _external_refresh(dt=None, tpl_id=None):
|
||
_data[0] = _load()
|
||
target_dt = dt or _cur_dt[0]
|
||
if target_dt != _cur_dt[0]:
|
||
_sel_dt(target_dt)
|
||
else:
|
||
_refresh(target_dt, tpl_id or _aid(target_dt))
|
||
|
||
try:
|
||
app._doku_vorlage_refresh_cb = _external_refresh
|
||
except Exception:
|
||
pass
|
||
|
||
def _close():
|
||
try: app._doku_vorlage_win = None
|
||
except Exception: pass
|
||
try: app._doku_vorlage_refresh_cb = None
|
||
except Exception: pass
|
||
try: win.destroy()
|
||
except Exception: pass
|
||
|
||
close_x.bind("<Button-1>", lambda e: _close())
|
||
win.protocol("WM_DELETE_WINDOW", _close)
|
||
|
||
# ── Linke Buttons (Dokumenttypen) ─────────────────────────────────────────
|
||
_dt_btns: dict[str, tk.Label] = {}
|
||
|
||
def _sel_dt(dt: str):
|
||
_cur_dt[0] = dt
|
||
for k, b in _dt_btns.items():
|
||
b.config(bg=_ACCENT if k == dt else _CARD_BG,
|
||
fg="#FFFFFF" if k == dt else _TEXT)
|
||
_refresh(dt)
|
||
|
||
for dt_key, dt_label in DOC_TYPES:
|
||
b = tk.Label(left, text=dt_label, font=(_FF, 9),
|
||
bg=_CARD_BG, fg=_TEXT, cursor="hand2",
|
||
pady=9, anchor="w", padx=12)
|
||
b.pack(fill="x")
|
||
b.bind("<Button-1>", lambda e, dk=dt_key: _sel_dt(dk))
|
||
_dt_btns[dt_key] = b
|
||
|
||
tk.Frame(left, bg=_CARD_BD, height=1).pack(fill="x", padx=10, pady=(10, 6))
|
||
btn_public_left = tk.Button(
|
||
left, text="Öffentliche Vorlagen",
|
||
command=lambda: open_public_doku_vorlagen_window(app, parent=win),
|
||
font=(_FF, 8, "bold"), bg="#3A6F8F", fg="#FFFFFF",
|
||
relief="flat", bd=0, padx=8, pady=8, cursor="hand2",
|
||
activebackground="#2E5F7A",
|
||
)
|
||
btn_public_left.pack(fill="x", padx=10, pady=(0, 10))
|
||
|
||
# ── Rechte Karte ──────────────────────────────────────────────────────────
|
||
# Zeile 0: Header (Dokumenttyp + aktive Vorlage)
|
||
top_bar = tk.Frame(right, bg="#E0EEF7")
|
||
top_bar.grid(row=0, column=0, sticky="ew")
|
||
|
||
lbl_doctype[0] = tk.Label(top_bar, text="Krankengeschichte", font=(_FF, 10, "bold"),
|
||
bg="#E0EEF7", fg=_TEXT, padx=12, pady=6)
|
||
lbl_doctype[0].pack(side="left")
|
||
lbl_active_info[0] = tk.Label(top_bar, text="Aktive Vorlage: AzA-Grundvorlage",
|
||
font=(_FF, 8), bg="#E0EEF7", fg=_TEXT_SUB, padx=8)
|
||
lbl_active_info[0].pack(side="left")
|
||
|
||
# Zeile 1: Vorlage-Auswahl + Modus-Hinweis
|
||
sel_bar = tk.Frame(right, bg=_CARD_BG)
|
||
sel_bar.grid(row=1, column=0, sticky="ew", padx=10, pady=(6, 2))
|
||
|
||
tk.Label(sel_bar, text="Vorlage:", font=(_FF, 8),
|
||
bg=_CARD_BG, fg=_TEXT_SUB).pack(side="left")
|
||
combo_var[0] = tk.StringVar()
|
||
combo_widget[0] = ttk.Combobox(sel_bar, textvariable=combo_var[0],
|
||
state="readonly", width=32, font=(_FF, 9))
|
||
combo_widget[0].pack(side="left", padx=(4, 12))
|
||
combo_widget[0].bind("<<ComboboxSelected>>", _on_combo)
|
||
|
||
lbl_mode[0] = tk.Label(sel_bar, text="", font=(_FF, 7),
|
||
bg=_CARD_BG, fg="#B06000", padx=4)
|
||
lbl_mode[0].pack(side="left")
|
||
|
||
# Zeile 2: Textfeld (expandierend)
|
||
txt_frame = tk.Frame(right, bg=_CARD_BG)
|
||
txt_frame.grid(row=2, column=0, sticky="nsew", padx=10, pady=(2, 4))
|
||
txt_frame.rowconfigure(0, weight=1)
|
||
txt_frame.columnconfigure(0, weight=1)
|
||
|
||
vsb = tk.Scrollbar(txt_frame, orient="vertical")
|
||
vsb.grid(row=0, column=1, sticky="ns")
|
||
txt_content[0] = tk.Text(txt_frame, font=(_FF, 9),
|
||
bg="#FFFFFF", fg=_TEXT,
|
||
relief="flat", bd=0, wrap="word",
|
||
yscrollcommand=vsb.set,
|
||
highlightbackground=_CARD_BD, highlightthickness=1,
|
||
padx=8, pady=8)
|
||
txt_content[0].grid(row=0, column=0, sticky="nsew")
|
||
vsb.config(command=txt_content[0].yview)
|
||
txt_content[0].bind("<KeyRelease>", lambda e: _dirty.__setitem__(0, True))
|
||
|
||
# Zeile 3: Button-Leiste (feste Höhe, nie abgeschnitten)
|
||
btn_row = tk.Frame(right, bg="#E8F0F5", pady=8)
|
||
btn_row.grid(row=3, column=0, sticky="ew", padx=0)
|
||
|
||
def _mk(parent, text, cmd, bg, fg="#FFFFFF", width=16):
|
||
return tk.Button(parent, text=text, command=cmd,
|
||
font=(_FF, 8, "bold"), bg=bg, fg=fg,
|
||
relief="flat", bd=0, padx=10, pady=5,
|
||
cursor="hand2", width=width,
|
||
activebackground=bg)
|
||
|
||
btn_save[0] = _mk(btn_row, "Speichern", _do_save, _BTN_BLUE, width=12)
|
||
btn_save[0].pack(side="left", padx=(10, 4))
|
||
_mk(btn_row, "Als neue Vorlage", _do_save_new, _BTN_BLUE, width=16).pack(side="left", padx=4)
|
||
btn_activate[0] = _mk(btn_row, "Als aktiv setzen", _do_activate, _BTN_ACT, width=15)
|
||
btn_activate[0].pack(side="left", padx=4)
|
||
_mk(btn_row, "Löschen", _do_delete, _BTN_RESET, width=10).pack(side="left", padx=4)
|
||
btn_publish = _mk(
|
||
btn_row, "Veröffentlichen", _do_publish, _BTN_BLUE, width=14,
|
||
)
|
||
btn_publish.pack(side="left", padx=4)
|
||
try:
|
||
from aza_ui_helpers import add_tooltip
|
||
add_tooltip(btn_publish, "Aktuellen Prompt für andere angemeldete Ärzte freigeben.")
|
||
except Exception:
|
||
pass
|
||
_mk(btn_row, "Schließen", _close, _BTN_CLOSE, width=10).pack(side="right", padx=(4, 10))
|
||
_mk(btn_row, "↩ Auf Grundvorlage", _do_reset, _BTN_RESET, width=18).pack(side="right", padx=4)
|
||
|
||
# Initialer Zustand — immer Krankengeschichte
|
||
_sel_dt("kg")
|